Skip to content

Instantly share code, notes, and snippets.

@geohot

geohot/hip.py

Created November 25, 2023 23:28
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save geohot/6232fb00527de161a5c8ce8a635dd4f3 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save geohot/6232fb00527de161a5c8ce8a635dd4f3 to your computer and use it in GitHub Desktop.
Download ZIP
Wrapper for HIP
Raw
hip.py
# -*- coding: utf-8 -*-
#
# TARGET arch is: ['-D__HIP_PLATFORM_AMD__', '-I/opt/rocm/include']
# WORD_SIZE is: 8
# POINTER_SIZE is: 8
# LONGDOUBLE_SIZE is: 16
#
import ctypes
class AsDictMixin:
@classmethod
def as_dict(cls, self):
result = {}
if not isinstance(self, AsDictMixin):
# not a structure, assume it's already a python object
return self
if not hasattr(cls, "_fields_"):
return result
# sys.version_info >= (3, 5)
# for (field, *_) in cls._fields_: # noqa
for field_tuple in cls._fields_: # noqa
field = field_tuple[0]
if field.startswith('PADDING_'):
continue
value = getattr(self, field)
type_ = type(value)
if hasattr(value, "_length_") and hasattr(value, "_type_"):
# array
if not hasattr(type_, "as_dict"):
value = [v for v in value]
else:
type_ = type_._type_
value = [type_.as_dict(v) for v in value]
elif hasattr(value, "contents") and hasattr(value, "_type_"):
# pointer
try:
if not hasattr(type_, "as_dict"):
value = value.contents
else:
type_ = type_._type_
value = type_.as_dict(value.contents)
except ValueError:
# nullptr
value = None
elif isinstance(value, AsDictMixin):
# other structure
value = type_.as_dict(value)
result[field] = value
return result
class Structure(ctypes.Structure, AsDictMixin):
def __init__(self, *args, **kwds):
# We don't want to use positional arguments fill PADDING_* fields
args = dict(zip(self.__class__._field_names_(), args))
args.update(kwds)
super(Structure, self).__init__(**args)
@classmethod
def _field_names_(cls):
if hasattr(cls, '_fields_'):
return (f[0] for f in cls._fields_ if not f[0].startswith('PADDING'))
else:
return ()
@classmethod
def get_type(cls, field):
for f in cls._fields_:
if f[0] == field:
return f[1]
return None
@classmethod
def bind(cls, bound_fields):
fields = {}
for name, type_ in cls._fields_:
if hasattr(type_, "restype"):
if name in bound_fields:
if bound_fields[name] is None:
fields[name] = type_()
else:
# use a closure to capture the callback from the loop scope
fields[name] = (
type_((lambda callback: lambda *args: callback(*args))(
bound_fields[name]))
)
del bound_fields[name]
else:
# default callback implementation (does nothing)
try:
default_ = type_(0).restype().value
except TypeError:
default_ = None
fields[name] = type_((
lambda default_: lambda *args: default_)(default_))
else:
# not a callback function, use default initialization
if name in bound_fields:
fields[name] = bound_fields[name]
del bound_fields[name]
else:
fields[name] = type_()
if len(bound_fields) != 0:
raise ValueError(
"Cannot bind the following unknown callback(s) {}.{}".format(
cls.__name__, bound_fields.keys()
))
return cls(**fields)
class Union(ctypes.Union, AsDictMixin):
pass
_libraries = {}
_libraries['libhiprtc.so'] = ctypes.CDLL('/opt/rocm/lib/libhiprtc.so')
def string_cast(char_pointer, encoding='utf-8', errors='strict'):
value = ctypes.cast(char_pointer, ctypes.c_char_p).value
if value is not None and encoding is not None:
value = value.decode(encoding, errors=errors)
return value
def char_pointer_cast(string, encoding='utf-8'):
if encoding is not None:
try:
string = string.encode(encoding)
except AttributeError:
# In Python3, bytes has no encode attribute
pass
string = ctypes.c_char_p(string)
return ctypes.cast(string, ctypes.POINTER(ctypes.c_char))
c_int128 = ctypes.c_ubyte*16
c_uint128 = c_int128
void = None
if ctypes.sizeof(ctypes.c_longdouble) == 16:
c_long_double_t = ctypes.c_longdouble
else:
c_long_double_t = ctypes.c_ubyte*16
class FunctionFactoryStub:
def __getattr__(self, _):
return ctypes.CFUNCTYPE(lambda y:y)
# libraries['FIXME_STUB'] explanation
# As you did not list (-l libraryname.so) a library that exports this function
# This is a non-working stub instead.
# You can either re-run clan2py with -l /path/to/library.so
# Or manually fix this by comment the ctypes.CDLL loading
_libraries['FIXME_STUB'] = FunctionFactoryStub() # ctypes.CDLL('FIXME_STUB')
_libraries['libamdhip64.so'] = ctypes.CDLL('/opt/rocm/lib/libamdhip64.so')
# values for enumeration 'hiprtcResult'
hiprtcResult__enumvalues = {
0: 'HIPRTC_SUCCESS',
1: 'HIPRTC_ERROR_OUT_OF_MEMORY',
2: 'HIPRTC_ERROR_PROGRAM_CREATION_FAILURE',
3: 'HIPRTC_ERROR_INVALID_INPUT',
4: 'HIPRTC_ERROR_INVALID_PROGRAM',
5: 'HIPRTC_ERROR_INVALID_OPTION',
6: 'HIPRTC_ERROR_COMPILATION',
7: 'HIPRTC_ERROR_BUILTIN_OPERATION_FAILURE',
8: 'HIPRTC_ERROR_NO_NAME_EXPRESSIONS_AFTER_COMPILATION',
9: 'HIPRTC_ERROR_NO_LOWERED_NAMES_BEFORE_COMPILATION',
10: 'HIPRTC_ERROR_NAME_EXPRESSION_NOT_VALID',
11: 'HIPRTC_ERROR_INTERNAL_ERROR',
100: 'HIPRTC_ERROR_LINKING',
}
HIPRTC_SUCCESS = 0
HIPRTC_ERROR_OUT_OF_MEMORY = 1
HIPRTC_ERROR_PROGRAM_CREATION_FAILURE = 2
HIPRTC_ERROR_INVALID_INPUT = 3
HIPRTC_ERROR_INVALID_PROGRAM = 4
HIPRTC_ERROR_INVALID_OPTION = 5
HIPRTC_ERROR_COMPILATION = 6
HIPRTC_ERROR_BUILTIN_OPERATION_FAILURE = 7
HIPRTC_ERROR_NO_NAME_EXPRESSIONS_AFTER_COMPILATION = 8
HIPRTC_ERROR_NO_LOWERED_NAMES_BEFORE_COMPILATION = 9
HIPRTC_ERROR_NAME_EXPRESSION_NOT_VALID = 10
HIPRTC_ERROR_INTERNAL_ERROR = 11
HIPRTC_ERROR_LINKING = 100
hiprtcResult = ctypes.c_uint32 # enum
# values for enumeration 'hiprtcJIT_option'
hiprtcJIT_option__enumvalues = {
0: 'HIPRTC_JIT_MAX_REGISTERS',
1: 'HIPRTC_JIT_THREADS_PER_BLOCK',
2: 'HIPRTC_JIT_WALL_TIME',
3: 'HIPRTC_JIT_INFO_LOG_BUFFER',
4: 'HIPRTC_JIT_INFO_LOG_BUFFER_SIZE_BYTES',
5: 'HIPRTC_JIT_ERROR_LOG_BUFFER',
6: 'HIPRTC_JIT_ERROR_LOG_BUFFER_SIZE_BYTES',
7: 'HIPRTC_JIT_OPTIMIZATION_LEVEL',
8: 'HIPRTC_JIT_TARGET_FROM_HIPCONTEXT',
9: 'HIPRTC_JIT_TARGET',
10: 'HIPRTC_JIT_FALLBACK_STRATEGY',
11: 'HIPRTC_JIT_GENERATE_DEBUG_INFO',
12: 'HIPRTC_JIT_LOG_VERBOSE',
13: 'HIPRTC_JIT_GENERATE_LINE_INFO',
14: 'HIPRTC_JIT_CACHE_MODE',
15: 'HIPRTC_JIT_NEW_SM3X_OPT',
16: 'HIPRTC_JIT_FAST_COMPILE',
17: 'HIPRTC_JIT_GLOBAL_SYMBOL_NAMES',
18: 'HIPRTC_JIT_GLOBAL_SYMBOL_ADDRESS',
19: 'HIPRTC_JIT_GLOBAL_SYMBOL_COUNT',
20: 'HIPRTC_JIT_LTO',
21: 'HIPRTC_JIT_FTZ',
22: 'HIPRTC_JIT_PREC_DIV',
23: 'HIPRTC_JIT_PREC_SQRT',
24: 'HIPRTC_JIT_FMA',
25: 'HIPRTC_JIT_NUM_OPTIONS',
10000: 'HIPRTC_JIT_IR_TO_ISA_OPT_EXT',
10001: 'HIPRTC_JIT_IR_TO_ISA_OPT_COUNT_EXT',
}
HIPRTC_JIT_MAX_REGISTERS = 0
HIPRTC_JIT_THREADS_PER_BLOCK = 1
HIPRTC_JIT_WALL_TIME = 2
HIPRTC_JIT_INFO_LOG_BUFFER = 3
HIPRTC_JIT_INFO_LOG_BUFFER_SIZE_BYTES = 4
HIPRTC_JIT_ERROR_LOG_BUFFER = 5
HIPRTC_JIT_ERROR_LOG_BUFFER_SIZE_BYTES = 6
HIPRTC_JIT_OPTIMIZATION_LEVEL = 7
HIPRTC_JIT_TARGET_FROM_HIPCONTEXT = 8
HIPRTC_JIT_TARGET = 9
HIPRTC_JIT_FALLBACK_STRATEGY = 10
HIPRTC_JIT_GENERATE_DEBUG_INFO = 11
HIPRTC_JIT_LOG_VERBOSE = 12
HIPRTC_JIT_GENERATE_LINE_INFO = 13
HIPRTC_JIT_CACHE_MODE = 14
HIPRTC_JIT_NEW_SM3X_OPT = 15
HIPRTC_JIT_FAST_COMPILE = 16
HIPRTC_JIT_GLOBAL_SYMBOL_NAMES = 17
HIPRTC_JIT_GLOBAL_SYMBOL_ADDRESS = 18
HIPRTC_JIT_GLOBAL_SYMBOL_COUNT = 19
HIPRTC_JIT_LTO = 20
HIPRTC_JIT_FTZ = 21
HIPRTC_JIT_PREC_DIV = 22
HIPRTC_JIT_PREC_SQRT = 23
HIPRTC_JIT_FMA = 24
HIPRTC_JIT_NUM_OPTIONS = 25
HIPRTC_JIT_IR_TO_ISA_OPT_EXT = 10000
HIPRTC_JIT_IR_TO_ISA_OPT_COUNT_EXT = 10001
hiprtcJIT_option = ctypes.c_uint32 # enum
# values for enumeration 'hiprtcJITInputType'
hiprtcJITInputType__enumvalues = {
0: 'HIPRTC_JIT_INPUT_CUBIN',
1: 'HIPRTC_JIT_INPUT_PTX',
2: 'HIPRTC_JIT_INPUT_FATBINARY',
3: 'HIPRTC_JIT_INPUT_OBJECT',
4: 'HIPRTC_JIT_INPUT_LIBRARY',
5: 'HIPRTC_JIT_INPUT_NVVM',
6: 'HIPRTC_JIT_NUM_LEGACY_INPUT_TYPES',
100: 'HIPRTC_JIT_INPUT_LLVM_BITCODE',
101: 'HIPRTC_JIT_INPUT_LLVM_BUNDLED_BITCODE',
102: 'HIPRTC_JIT_INPUT_LLVM_ARCHIVES_OF_BUNDLED_BITCODE',
9: 'HIPRTC_JIT_NUM_INPUT_TYPES',
}
HIPRTC_JIT_INPUT_CUBIN = 0
HIPRTC_JIT_INPUT_PTX = 1
HIPRTC_JIT_INPUT_FATBINARY = 2
HIPRTC_JIT_INPUT_OBJECT = 3
HIPRTC_JIT_INPUT_LIBRARY = 4
HIPRTC_JIT_INPUT_NVVM = 5
HIPRTC_JIT_NUM_LEGACY_INPUT_TYPES = 6
HIPRTC_JIT_INPUT_LLVM_BITCODE = 100
HIPRTC_JIT_INPUT_LLVM_BUNDLED_BITCODE = 101
HIPRTC_JIT_INPUT_LLVM_ARCHIVES_OF_BUNDLED_BITCODE = 102
HIPRTC_JIT_NUM_INPUT_TYPES = 9
hiprtcJITInputType = ctypes.c_uint32 # enum
class struct_ihiprtcLinkState(Structure):
pass
hiprtcLinkState = ctypes.POINTER(struct_ihiprtcLinkState)
hiprtcGetErrorString = _libraries['libhiprtc.so'].hiprtcGetErrorString
hiprtcGetErrorString.restype = ctypes.POINTER(ctypes.c_char)
hiprtcGetErrorString.argtypes = [hiprtcResult]
hiprtcVersion = _libraries['libhiprtc.so'].hiprtcVersion
hiprtcVersion.restype = hiprtcResult
hiprtcVersion.argtypes = [ctypes.POINTER(ctypes.c_int32), ctypes.POINTER(ctypes.c_int32)]
class struct__hiprtcProgram(Structure):
pass
hiprtcProgram = ctypes.POINTER(struct__hiprtcProgram)
hiprtcAddNameExpression = _libraries['libhiprtc.so'].hiprtcAddNameExpression
hiprtcAddNameExpression.restype = hiprtcResult
hiprtcAddNameExpression.argtypes = [hiprtcProgram, ctypes.POINTER(ctypes.c_char)]
hiprtcCompileProgram = _libraries['libhiprtc.so'].hiprtcCompileProgram
hiprtcCompileProgram.restype = hiprtcResult
hiprtcCompileProgram.argtypes = [hiprtcProgram, ctypes.c_int32, ctypes.POINTER(ctypes.POINTER(ctypes.c_char))]
hiprtcCreateProgram = _libraries['libhiprtc.so'].hiprtcCreateProgram
hiprtcCreateProgram.restype = hiprtcResult
hiprtcCreateProgram.argtypes = [ctypes.POINTER(ctypes.POINTER(struct__hiprtcProgram)), ctypes.POINTER(ctypes.c_char), ctypes.POINTER(ctypes.c_char), ctypes.c_int32, ctypes.POINTER(ctypes.POINTER(ctypes.c_char)), ctypes.POINTER(ctypes.POINTER(ctypes.c_char))]
hiprtcDestroyProgram = _libraries['libhiprtc.so'].hiprtcDestroyProgram
hiprtcDestroyProgram.restype = hiprtcResult
hiprtcDestroyProgram.argtypes = [ctypes.POINTER(ctypes.POINTER(struct__hiprtcProgram))]
hiprtcGetLoweredName = _libraries['libhiprtc.so'].hiprtcGetLoweredName
hiprtcGetLoweredName.restype = hiprtcResult
hiprtcGetLoweredName.argtypes = [hiprtcProgram, ctypes.POINTER(ctypes.c_char), ctypes.POINTER(ctypes.POINTER(ctypes.c_char))]
hiprtcGetProgramLog = _libraries['libhiprtc.so'].hiprtcGetProgramLog
hiprtcGetProgramLog.restype = hiprtcResult
hiprtcGetProgramLog.argtypes = [hiprtcProgram, ctypes.POINTER(ctypes.c_char)]
hiprtcGetProgramLogSize = _libraries['libhiprtc.so'].hiprtcGetProgramLogSize
hiprtcGetProgramLogSize.restype = hiprtcResult
hiprtcGetProgramLogSize.argtypes = [hiprtcProgram, ctypes.POINTER(ctypes.c_uint64)]
hiprtcGetCode = _libraries['libhiprtc.so'].hiprtcGetCode
hiprtcGetCode.restype = hiprtcResult
hiprtcGetCode.argtypes = [hiprtcProgram, ctypes.POINTER(ctypes.c_char)]
hiprtcGetCodeSize = _libraries['libhiprtc.so'].hiprtcGetCodeSize
hiprtcGetCodeSize.restype = hiprtcResult
hiprtcGetCodeSize.argtypes = [hiprtcProgram, ctypes.POINTER(ctypes.c_uint64)]
hiprtcGetBitcode = _libraries['libhiprtc.so'].hiprtcGetBitcode
hiprtcGetBitcode.restype = hiprtcResult
hiprtcGetBitcode.argtypes = [hiprtcProgram, ctypes.POINTER(ctypes.c_char)]
hiprtcGetBitcodeSize = _libraries['libhiprtc.so'].hiprtcGetBitcodeSize
hiprtcGetBitcodeSize.restype = hiprtcResult
hiprtcGetBitcodeSize.argtypes = [hiprtcProgram, ctypes.POINTER(ctypes.c_uint64)]
hiprtcLinkCreate = _libraries['libhiprtc.so'].hiprtcLinkCreate
hiprtcLinkCreate.restype = hiprtcResult
hiprtcLinkCreate.argtypes = [ctypes.c_uint32, ctypes.POINTER(hiprtcJIT_option), ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(ctypes.POINTER(struct_ihiprtcLinkState))]
hiprtcLinkAddFile = _libraries['libhiprtc.so'].hiprtcLinkAddFile
hiprtcLinkAddFile.restype = hiprtcResult
hiprtcLinkAddFile.argtypes = [hiprtcLinkState, hiprtcJITInputType, ctypes.POINTER(ctypes.c_char), ctypes.c_uint32, ctypes.POINTER(hiprtcJIT_option), ctypes.POINTER(ctypes.POINTER(None))]
size_t = ctypes.c_uint64
hiprtcLinkAddData = _libraries['libhiprtc.so'].hiprtcLinkAddData
hiprtcLinkAddData.restype = hiprtcResult
hiprtcLinkAddData.argtypes = [hiprtcLinkState, hiprtcJITInputType, ctypes.POINTER(None), size_t, ctypes.POINTER(ctypes.c_char), ctypes.c_uint32, ctypes.POINTER(hiprtcJIT_option), ctypes.POINTER(ctypes.POINTER(None))]
hiprtcLinkComplete = _libraries['libhiprtc.so'].hiprtcLinkComplete
hiprtcLinkComplete.restype = hiprtcResult
hiprtcLinkComplete.argtypes = [hiprtcLinkState, ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(ctypes.c_uint64)]
hiprtcLinkDestroy = _libraries['libhiprtc.so'].hiprtcLinkDestroy
hiprtcLinkDestroy.restype = hiprtcResult
hiprtcLinkDestroy.argtypes = [hiprtcLinkState]
# values for enumeration 'c__Ea_HIP_SUCCESS'
c__Ea_HIP_SUCCESS__enumvalues = {
0: 'HIP_SUCCESS',
1: 'HIP_ERROR_INVALID_VALUE',
2: 'HIP_ERROR_NOT_INITIALIZED',
3: 'HIP_ERROR_LAUNCH_OUT_OF_RESOURCES',
}
HIP_SUCCESS = 0
HIP_ERROR_INVALID_VALUE = 1
HIP_ERROR_NOT_INITIALIZED = 2
HIP_ERROR_LAUNCH_OUT_OF_RESOURCES = 3
c__Ea_HIP_SUCCESS = ctypes.c_uint32 # enum
class struct_c__SA_hipDeviceArch_t(Structure):
pass
struct_c__SA_hipDeviceArch_t._pack_ = 1 # source:False
struct_c__SA_hipDeviceArch_t._fields_ = [
('hasGlobalInt32Atomics', ctypes.c_uint32, 1),
('hasGlobalFloatAtomicExch', ctypes.c_uint32, 1),
('hasSharedInt32Atomics', ctypes.c_uint32, 1),
('hasSharedFloatAtomicExch', ctypes.c_uint32, 1),
('hasFloatAtomicAdd', ctypes.c_uint32, 1),
('hasGlobalInt64Atomics', ctypes.c_uint32, 1),
('hasSharedInt64Atomics', ctypes.c_uint32, 1),
('hasDoubles', ctypes.c_uint32, 1),
('hasWarpVote', ctypes.c_uint32, 1),
('hasWarpBallot', ctypes.c_uint32, 1),
('hasWarpShuffle', ctypes.c_uint32, 1),
('hasFunnelShift', ctypes.c_uint32, 1),
('hasThreadFenceSystem', ctypes.c_uint32, 1),
('hasSyncThreadsExt', ctypes.c_uint32, 1),
('hasSurfaceFuncs', ctypes.c_uint32, 1),
('has3dGrid', ctypes.c_uint32, 1),
('hasDynamicParallelism', ctypes.c_uint32, 1),
('PADDING_0', ctypes.c_uint16, 15),
]
hipDeviceArch_t = struct_c__SA_hipDeviceArch_t
class struct_hipUUID_t(Structure):
pass
struct_hipUUID_t._pack_ = 1 # source:False
struct_hipUUID_t._fields_ = [
('bytes', ctypes.c_char * 16),
]
hipUUID = struct_hipUUID_t
class struct_hipDeviceProp_t(Structure):
pass
struct_hipDeviceProp_t._pack_ = 1 # source:False
struct_hipDeviceProp_t._fields_ = [
('name', ctypes.c_char * 256),
('totalGlobalMem', ctypes.c_uint64),
('sharedMemPerBlock', ctypes.c_uint64),
('regsPerBlock', ctypes.c_int32),
('warpSize', ctypes.c_int32),
('maxThreadsPerBlock', ctypes.c_int32),
('maxThreadsDim', ctypes.c_int32 * 3),
('maxGridSize', ctypes.c_int32 * 3),
('clockRate', ctypes.c_int32),
('memoryClockRate', ctypes.c_int32),
('memoryBusWidth', ctypes.c_int32),
('totalConstMem', ctypes.c_uint64),
('major', ctypes.c_int32),
('minor', ctypes.c_int32),
('multiProcessorCount', ctypes.c_int32),
('l2CacheSize', ctypes.c_int32),
('maxThreadsPerMultiProcessor', ctypes.c_int32),
('computeMode', ctypes.c_int32),
('clockInstructionRate', ctypes.c_int32),
('arch', hipDeviceArch_t),
('concurrentKernels', ctypes.c_int32),
('pciDomainID', ctypes.c_int32),
('pciBusID', ctypes.c_int32),
('pciDeviceID', ctypes.c_int32),
('maxSharedMemoryPerMultiProcessor', ctypes.c_uint64),
('isMultiGpuBoard', ctypes.c_int32),
('canMapHostMemory', ctypes.c_int32),
('gcnArch', ctypes.c_int32),
('gcnArchName', ctypes.c_char * 256),
('integrated', ctypes.c_int32),
('cooperativeLaunch', ctypes.c_int32),
('cooperativeMultiDeviceLaunch', ctypes.c_int32),
('maxTexture1DLinear', ctypes.c_int32),
('maxTexture1D', ctypes.c_int32),
('maxTexture2D', ctypes.c_int32 * 2),
('maxTexture3D', ctypes.c_int32 * 3),
('PADDING_0', ctypes.c_ubyte * 4),
('hdpMemFlushCntl', ctypes.POINTER(ctypes.c_uint32)),
('hdpRegFlushCntl', ctypes.POINTER(ctypes.c_uint32)),
('memPitch', ctypes.c_uint64),
('textureAlignment', ctypes.c_uint64),
('texturePitchAlignment', ctypes.c_uint64),
('kernelExecTimeoutEnabled', ctypes.c_int32),
('ECCEnabled', ctypes.c_int32),
('tccDriver', ctypes.c_int32),
('cooperativeMultiDeviceUnmatchedFunc', ctypes.c_int32),
('cooperativeMultiDeviceUnmatchedGridDim', ctypes.c_int32),
('cooperativeMultiDeviceUnmatchedBlockDim', ctypes.c_int32),
('cooperativeMultiDeviceUnmatchedSharedMem', ctypes.c_int32),
('isLargeBar', ctypes.c_int32),
('asicRevision', ctypes.c_int32),
('managedMemory', ctypes.c_int32),
('directManagedMemAccessFromHost', ctypes.c_int32),
('concurrentManagedAccess', ctypes.c_int32),
('pageableMemoryAccess', ctypes.c_int32),
('pageableMemoryAccessUsesHostPageTables', ctypes.c_int32),
]
hipDeviceProp_t = struct_hipDeviceProp_t
# values for enumeration 'hipMemoryType'
hipMemoryType__enumvalues = {
0: 'hipMemoryTypeHost',
1: 'hipMemoryTypeDevice',
2: 'hipMemoryTypeArray',
3: 'hipMemoryTypeUnified',
4: 'hipMemoryTypeManaged',
}
hipMemoryTypeHost = 0
hipMemoryTypeDevice = 1
hipMemoryTypeArray = 2
hipMemoryTypeUnified = 3
hipMemoryTypeManaged = 4
hipMemoryType = ctypes.c_uint32 # enum
class struct_hipPointerAttribute_t(Structure):
pass
class union_hipPointerAttribute_t_0(Union):
_pack_ = 1 # source:False
_fields_ = [
('memoryType', hipMemoryType),
('type', hipMemoryType),
]
struct_hipPointerAttribute_t._pack_ = 1 # source:False
struct_hipPointerAttribute_t._anonymous_ = ('_0',)
struct_hipPointerAttribute_t._fields_ = [
('_0', union_hipPointerAttribute_t_0),
('device', ctypes.c_int32),
('devicePointer', ctypes.POINTER(None)),
('hostPointer', ctypes.POINTER(None)),
('isManaged', ctypes.c_int32),
('allocationFlags', ctypes.c_uint32),
]
hipPointerAttribute_t = struct_hipPointerAttribute_t
# values for enumeration 'hipError_t'
hipError_t__enumvalues = {
0: 'hipSuccess',
1: 'hipErrorInvalidValue',
2: 'hipErrorOutOfMemory',
2: 'hipErrorMemoryAllocation',
3: 'hipErrorNotInitialized',
3: 'hipErrorInitializationError',
4: 'hipErrorDeinitialized',
5: 'hipErrorProfilerDisabled',
6: 'hipErrorProfilerNotInitialized',
7: 'hipErrorProfilerAlreadyStarted',
8: 'hipErrorProfilerAlreadyStopped',
9: 'hipErrorInvalidConfiguration',
12: 'hipErrorInvalidPitchValue',
13: 'hipErrorInvalidSymbol',
17: 'hipErrorInvalidDevicePointer',
21: 'hipErrorInvalidMemcpyDirection',
35: 'hipErrorInsufficientDriver',
52: 'hipErrorMissingConfiguration',
53: 'hipErrorPriorLaunchFailure',
98: 'hipErrorInvalidDeviceFunction',
100: 'hipErrorNoDevice',
101: 'hipErrorInvalidDevice',
200: 'hipErrorInvalidImage',
201: 'hipErrorInvalidContext',
202: 'hipErrorContextAlreadyCurrent',
205: 'hipErrorMapFailed',
205: 'hipErrorMapBufferObjectFailed',
206: 'hipErrorUnmapFailed',
207: 'hipErrorArrayIsMapped',
208: 'hipErrorAlreadyMapped',
209: 'hipErrorNoBinaryForGpu',
210: 'hipErrorAlreadyAcquired',
211: 'hipErrorNotMapped',
212: 'hipErrorNotMappedAsArray',
213: 'hipErrorNotMappedAsPointer',
214: 'hipErrorECCNotCorrectable',
215: 'hipErrorUnsupportedLimit',
216: 'hipErrorContextAlreadyInUse',
217: 'hipErrorPeerAccessUnsupported',
218: 'hipErrorInvalidKernelFile',
219: 'hipErrorInvalidGraphicsContext',
300: 'hipErrorInvalidSource',
301: 'hipErrorFileNotFound',
302: 'hipErrorSharedObjectSymbolNotFound',
303: 'hipErrorSharedObjectInitFailed',
304: 'hipErrorOperatingSystem',
400: 'hipErrorInvalidHandle',
400: 'hipErrorInvalidResourceHandle',
401: 'hipErrorIllegalState',
500: 'hipErrorNotFound',
600: 'hipErrorNotReady',
700: 'hipErrorIllegalAddress',
701: 'hipErrorLaunchOutOfResources',
702: 'hipErrorLaunchTimeOut',
704: 'hipErrorPeerAccessAlreadyEnabled',
705: 'hipErrorPeerAccessNotEnabled',
708: 'hipErrorSetOnActiveProcess',
709: 'hipErrorContextIsDestroyed',
710: 'hipErrorAssert',
712: 'hipErrorHostMemoryAlreadyRegistered',
713: 'hipErrorHostMemoryNotRegistered',
719: 'hipErrorLaunchFailure',
720: 'hipErrorCooperativeLaunchTooLarge',
801: 'hipErrorNotSupported',
900: 'hipErrorStreamCaptureUnsupported',
901: 'hipErrorStreamCaptureInvalidated',
902: 'hipErrorStreamCaptureMerge',
903: 'hipErrorStreamCaptureUnmatched',
904: 'hipErrorStreamCaptureUnjoined',
905: 'hipErrorStreamCaptureIsolation',
906: 'hipErrorStreamCaptureImplicit',
907: 'hipErrorCapturedEvent',
908: 'hipErrorStreamCaptureWrongThread',
910: 'hipErrorGraphExecUpdateFailure',
999: 'hipErrorUnknown',
1052: 'hipErrorRuntimeMemory',
1053: 'hipErrorRuntimeOther',
1054: 'hipErrorTbd',
}
hipSuccess = 0
hipErrorInvalidValue = 1
hipErrorOutOfMemory = 2
hipErrorMemoryAllocation = 2
hipErrorNotInitialized = 3
hipErrorInitializationError = 3
hipErrorDeinitialized = 4
hipErrorProfilerDisabled = 5
hipErrorProfilerNotInitialized = 6
hipErrorProfilerAlreadyStarted = 7
hipErrorProfilerAlreadyStopped = 8
hipErrorInvalidConfiguration = 9
hipErrorInvalidPitchValue = 12
hipErrorInvalidSymbol = 13
hipErrorInvalidDevicePointer = 17
hipErrorInvalidMemcpyDirection = 21
hipErrorInsufficientDriver = 35
hipErrorMissingConfiguration = 52
hipErrorPriorLaunchFailure = 53
hipErrorInvalidDeviceFunction = 98
hipErrorNoDevice = 100
hipErrorInvalidDevice = 101
hipErrorInvalidImage = 200
hipErrorInvalidContext = 201
hipErrorContextAlreadyCurrent = 202
hipErrorMapFailed = 205
hipErrorMapBufferObjectFailed = 205
hipErrorUnmapFailed = 206
hipErrorArrayIsMapped = 207
hipErrorAlreadyMapped = 208
hipErrorNoBinaryForGpu = 209
hipErrorAlreadyAcquired = 210
hipErrorNotMapped = 211
hipErrorNotMappedAsArray = 212
hipErrorNotMappedAsPointer = 213
hipErrorECCNotCorrectable = 214
hipErrorUnsupportedLimit = 215
hipErrorContextAlreadyInUse = 216
hipErrorPeerAccessUnsupported = 217
hipErrorInvalidKernelFile = 218
hipErrorInvalidGraphicsContext = 219
hipErrorInvalidSource = 300
hipErrorFileNotFound = 301
hipErrorSharedObjectSymbolNotFound = 302
hipErrorSharedObjectInitFailed = 303
hipErrorOperatingSystem = 304
hipErrorInvalidHandle = 400
hipErrorInvalidResourceHandle = 400
hipErrorIllegalState = 401
hipErrorNotFound = 500
hipErrorNotReady = 600
hipErrorIllegalAddress = 700
hipErrorLaunchOutOfResources = 701
hipErrorLaunchTimeOut = 702
hipErrorPeerAccessAlreadyEnabled = 704
hipErrorPeerAccessNotEnabled = 705
hipErrorSetOnActiveProcess = 708
hipErrorContextIsDestroyed = 709
hipErrorAssert = 710
hipErrorHostMemoryAlreadyRegistered = 712
hipErrorHostMemoryNotRegistered = 713
hipErrorLaunchFailure = 719
hipErrorCooperativeLaunchTooLarge = 720
hipErrorNotSupported = 801
hipErrorStreamCaptureUnsupported = 900
hipErrorStreamCaptureInvalidated = 901
hipErrorStreamCaptureMerge = 902
hipErrorStreamCaptureUnmatched = 903
hipErrorStreamCaptureUnjoined = 904
hipErrorStreamCaptureIsolation = 905
hipErrorStreamCaptureImplicit = 906
hipErrorCapturedEvent = 907
hipErrorStreamCaptureWrongThread = 908
hipErrorGraphExecUpdateFailure = 910
hipErrorUnknown = 999
hipErrorRuntimeMemory = 1052
hipErrorRuntimeOther = 1053
hipErrorTbd = 1054
hipError_t = ctypes.c_uint32 # enum
# values for enumeration 'hipDeviceAttribute_t'
hipDeviceAttribute_t__enumvalues = {
0: 'hipDeviceAttributeCudaCompatibleBegin',
0: 'hipDeviceAttributeEccEnabled',
1: 'hipDeviceAttributeAccessPolicyMaxWindowSize',
2: 'hipDeviceAttributeAsyncEngineCount',
3: 'hipDeviceAttributeCanMapHostMemory',
4: 'hipDeviceAttributeCanUseHostPointerForRegisteredMem',
5: 'hipDeviceAttributeClockRate',
6: 'hipDeviceAttributeComputeMode',
7: 'hipDeviceAttributeComputePreemptionSupported',
8: 'hipDeviceAttributeConcurrentKernels',
9: 'hipDeviceAttributeConcurrentManagedAccess',
10: 'hipDeviceAttributeCooperativeLaunch',
11: 'hipDeviceAttributeCooperativeMultiDeviceLaunch',
12: 'hipDeviceAttributeDeviceOverlap',
13: 'hipDeviceAttributeDirectManagedMemAccessFromHost',
14: 'hipDeviceAttributeGlobalL1CacheSupported',
15: 'hipDeviceAttributeHostNativeAtomicSupported',
16: 'hipDeviceAttributeIntegrated',
17: 'hipDeviceAttributeIsMultiGpuBoard',
18: 'hipDeviceAttributeKernelExecTimeout',
19: 'hipDeviceAttributeL2CacheSize',
20: 'hipDeviceAttributeLocalL1CacheSupported',
21: 'hipDeviceAttributeLuid',
22: 'hipDeviceAttributeLuidDeviceNodeMask',
23: 'hipDeviceAttributeComputeCapabilityMajor',
24: 'hipDeviceAttributeManagedMemory',
25: 'hipDeviceAttributeMaxBlocksPerMultiProcessor',
26: 'hipDeviceAttributeMaxBlockDimX',
27: 'hipDeviceAttributeMaxBlockDimY',
28: 'hipDeviceAttributeMaxBlockDimZ',
29: 'hipDeviceAttributeMaxGridDimX',
30: 'hipDeviceAttributeMaxGridDimY',
31: 'hipDeviceAttributeMaxGridDimZ',
32: 'hipDeviceAttributeMaxSurface1D',
33: 'hipDeviceAttributeMaxSurface1DLayered',
34: 'hipDeviceAttributeMaxSurface2D',
35: 'hipDeviceAttributeMaxSurface2DLayered',
36: 'hipDeviceAttributeMaxSurface3D',
37: 'hipDeviceAttributeMaxSurfaceCubemap',
38: 'hipDeviceAttributeMaxSurfaceCubemapLayered',
39: 'hipDeviceAttributeMaxTexture1DWidth',
40: 'hipDeviceAttributeMaxTexture1DLayered',
41: 'hipDeviceAttributeMaxTexture1DLinear',
42: 'hipDeviceAttributeMaxTexture1DMipmap',
43: 'hipDeviceAttributeMaxTexture2DWidth',
44: 'hipDeviceAttributeMaxTexture2DHeight',
45: 'hipDeviceAttributeMaxTexture2DGather',
46: 'hipDeviceAttributeMaxTexture2DLayered',
47: 'hipDeviceAttributeMaxTexture2DLinear',
48: 'hipDeviceAttributeMaxTexture2DMipmap',
49: 'hipDeviceAttributeMaxTexture3DWidth',
50: 'hipDeviceAttributeMaxTexture3DHeight',
51: 'hipDeviceAttributeMaxTexture3DDepth',
52: 'hipDeviceAttributeMaxTexture3DAlt',
53: 'hipDeviceAttributeMaxTextureCubemap',
54: 'hipDeviceAttributeMaxTextureCubemapLayered',
55: 'hipDeviceAttributeMaxThreadsDim',
56: 'hipDeviceAttributeMaxThreadsPerBlock',
57: 'hipDeviceAttributeMaxThreadsPerMultiProcessor',
58: 'hipDeviceAttributeMaxPitch',
59: 'hipDeviceAttributeMemoryBusWidth',
60: 'hipDeviceAttributeMemoryClockRate',
61: 'hipDeviceAttributeComputeCapabilityMinor',
62: 'hipDeviceAttributeMultiGpuBoardGroupID',
63: 'hipDeviceAttributeMultiprocessorCount',
64: 'hipDeviceAttributeName',
65: 'hipDeviceAttributePageableMemoryAccess',
66: 'hipDeviceAttributePageableMemoryAccessUsesHostPageTables',
67: 'hipDeviceAttributePciBusId',
68: 'hipDeviceAttributePciDeviceId',
69: 'hipDeviceAttributePciDomainID',
70: 'hipDeviceAttributePersistingL2CacheMaxSize',
71: 'hipDeviceAttributeMaxRegistersPerBlock',
72: 'hipDeviceAttributeMaxRegistersPerMultiprocessor',
73: 'hipDeviceAttributeReservedSharedMemPerBlock',
74: 'hipDeviceAttributeMaxSharedMemoryPerBlock',
75: 'hipDeviceAttributeSharedMemPerBlockOptin',
76: 'hipDeviceAttributeSharedMemPerMultiprocessor',
77: 'hipDeviceAttributeSingleToDoublePrecisionPerfRatio',
78: 'hipDeviceAttributeStreamPrioritiesSupported',
79: 'hipDeviceAttributeSurfaceAlignment',
80: 'hipDeviceAttributeTccDriver',
81: 'hipDeviceAttributeTextureAlignment',
82: 'hipDeviceAttributeTexturePitchAlignment',
83: 'hipDeviceAttributeTotalConstantMemory',
84: 'hipDeviceAttributeTotalGlobalMem',
85: 'hipDeviceAttributeUnifiedAddressing',
86: 'hipDeviceAttributeUuid',
87: 'hipDeviceAttributeWarpSize',
88: 'hipDeviceAttributeMemoryPoolsSupported',
89: 'hipDeviceAttributeVirtualMemoryManagementSupported',
9999: 'hipDeviceAttributeCudaCompatibleEnd',
10000: 'hipDeviceAttributeAmdSpecificBegin',
10000: 'hipDeviceAttributeClockInstructionRate',
10001: 'hipDeviceAttributeArch',
10002: 'hipDeviceAttributeMaxSharedMemoryPerMultiprocessor',
10003: 'hipDeviceAttributeGcnArch',
10004: 'hipDeviceAttributeGcnArchName',
10005: 'hipDeviceAttributeHdpMemFlushCntl',
10006: 'hipDeviceAttributeHdpRegFlushCntl',
10007: 'hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc',
10008: 'hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim',
10009: 'hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim',
10010: 'hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem',
10011: 'hipDeviceAttributeIsLargeBar',
10012: 'hipDeviceAttributeAsicRevision',
10013: 'hipDeviceAttributeCanUseStreamWaitValue',
10014: 'hipDeviceAttributeImageSupport',
10015: 'hipDeviceAttributePhysicalMultiProcessorCount',
10016: 'hipDeviceAttributeFineGrainSupport',
10017: 'hipDeviceAttributeWallClockRate',
19999: 'hipDeviceAttributeAmdSpecificEnd',
20000: 'hipDeviceAttributeVendorSpecificBegin',
}
hipDeviceAttributeCudaCompatibleBegin = 0
hipDeviceAttributeEccEnabled = 0
hipDeviceAttributeAccessPolicyMaxWindowSize = 1
hipDeviceAttributeAsyncEngineCount = 2
hipDeviceAttributeCanMapHostMemory = 3
hipDeviceAttributeCanUseHostPointerForRegisteredMem = 4
hipDeviceAttributeClockRate = 5
hipDeviceAttributeComputeMode = 6
hipDeviceAttributeComputePreemptionSupported = 7
hipDeviceAttributeConcurrentKernels = 8
hipDeviceAttributeConcurrentManagedAccess = 9
hipDeviceAttributeCooperativeLaunch = 10
hipDeviceAttributeCooperativeMultiDeviceLaunch = 11
hipDeviceAttributeDeviceOverlap = 12
hipDeviceAttributeDirectManagedMemAccessFromHost = 13
hipDeviceAttributeGlobalL1CacheSupported = 14
hipDeviceAttributeHostNativeAtomicSupported = 15
hipDeviceAttributeIntegrated = 16
hipDeviceAttributeIsMultiGpuBoard = 17
hipDeviceAttributeKernelExecTimeout = 18
hipDeviceAttributeL2CacheSize = 19
hipDeviceAttributeLocalL1CacheSupported = 20
hipDeviceAttributeLuid = 21
hipDeviceAttributeLuidDeviceNodeMask = 22
hipDeviceAttributeComputeCapabilityMajor = 23
hipDeviceAttributeManagedMemory = 24
hipDeviceAttributeMaxBlocksPerMultiProcessor = 25
hipDeviceAttributeMaxBlockDimX = 26
hipDeviceAttributeMaxBlockDimY = 27
hipDeviceAttributeMaxBlockDimZ = 28
hipDeviceAttributeMaxGridDimX = 29
hipDeviceAttributeMaxGridDimY = 30
hipDeviceAttributeMaxGridDimZ = 31
hipDeviceAttributeMaxSurface1D = 32
hipDeviceAttributeMaxSurface1DLayered = 33
hipDeviceAttributeMaxSurface2D = 34
hipDeviceAttributeMaxSurface2DLayered = 35
hipDeviceAttributeMaxSurface3D = 36
hipDeviceAttributeMaxSurfaceCubemap = 37
hipDeviceAttributeMaxSurfaceCubemapLayered = 38
hipDeviceAttributeMaxTexture1DWidth = 39
hipDeviceAttributeMaxTexture1DLayered = 40
hipDeviceAttributeMaxTexture1DLinear = 41
hipDeviceAttributeMaxTexture1DMipmap = 42
hipDeviceAttributeMaxTexture2DWidth = 43
hipDeviceAttributeMaxTexture2DHeight = 44
hipDeviceAttributeMaxTexture2DGather = 45
hipDeviceAttributeMaxTexture2DLayered = 46
hipDeviceAttributeMaxTexture2DLinear = 47
hipDeviceAttributeMaxTexture2DMipmap = 48
hipDeviceAttributeMaxTexture3DWidth = 49
hipDeviceAttributeMaxTexture3DHeight = 50
hipDeviceAttributeMaxTexture3DDepth = 51
hipDeviceAttributeMaxTexture3DAlt = 52
hipDeviceAttributeMaxTextureCubemap = 53
hipDeviceAttributeMaxTextureCubemapLayered = 54
hipDeviceAttributeMaxThreadsDim = 55
hipDeviceAttributeMaxThreadsPerBlock = 56
hipDeviceAttributeMaxThreadsPerMultiProcessor = 57
hipDeviceAttributeMaxPitch = 58
hipDeviceAttributeMemoryBusWidth = 59
hipDeviceAttributeMemoryClockRate = 60
hipDeviceAttributeComputeCapabilityMinor = 61
hipDeviceAttributeMultiGpuBoardGroupID = 62
hipDeviceAttributeMultiprocessorCount = 63
hipDeviceAttributeName = 64
hipDeviceAttributePageableMemoryAccess = 65
hipDeviceAttributePageableMemoryAccessUsesHostPageTables = 66
hipDeviceAttributePciBusId = 67
hipDeviceAttributePciDeviceId = 68
hipDeviceAttributePciDomainID = 69
hipDeviceAttributePersistingL2CacheMaxSize = 70
hipDeviceAttributeMaxRegistersPerBlock = 71
hipDeviceAttributeMaxRegistersPerMultiprocessor = 72
hipDeviceAttributeReservedSharedMemPerBlock = 73
hipDeviceAttributeMaxSharedMemoryPerBlock = 74
hipDeviceAttributeSharedMemPerBlockOptin = 75
hipDeviceAttributeSharedMemPerMultiprocessor = 76
hipDeviceAttributeSingleToDoublePrecisionPerfRatio = 77
hipDeviceAttributeStreamPrioritiesSupported = 78
hipDeviceAttributeSurfaceAlignment = 79
hipDeviceAttributeTccDriver = 80
hipDeviceAttributeTextureAlignment = 81
hipDeviceAttributeTexturePitchAlignment = 82
hipDeviceAttributeTotalConstantMemory = 83
hipDeviceAttributeTotalGlobalMem = 84
hipDeviceAttributeUnifiedAddressing = 85
hipDeviceAttributeUuid = 86
hipDeviceAttributeWarpSize = 87
hipDeviceAttributeMemoryPoolsSupported = 88
hipDeviceAttributeVirtualMemoryManagementSupported = 89
hipDeviceAttributeCudaCompatibleEnd = 9999
hipDeviceAttributeAmdSpecificBegin = 10000
hipDeviceAttributeClockInstructionRate = 10000
hipDeviceAttributeArch = 10001
hipDeviceAttributeMaxSharedMemoryPerMultiprocessor = 10002
hipDeviceAttributeGcnArch = 10003
hipDeviceAttributeGcnArchName = 10004
hipDeviceAttributeHdpMemFlushCntl = 10005
hipDeviceAttributeHdpRegFlushCntl = 10006
hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc = 10007
hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim = 10008
hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim = 10009
hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem = 10010
hipDeviceAttributeIsLargeBar = 10011
hipDeviceAttributeAsicRevision = 10012
hipDeviceAttributeCanUseStreamWaitValue = 10013
hipDeviceAttributeImageSupport = 10014
hipDeviceAttributePhysicalMultiProcessorCount = 10015
hipDeviceAttributeFineGrainSupport = 10016
hipDeviceAttributeWallClockRate = 10017
hipDeviceAttributeAmdSpecificEnd = 19999
hipDeviceAttributeVendorSpecificBegin = 20000
hipDeviceAttribute_t = ctypes.c_uint32 # enum
# values for enumeration 'hipComputeMode'
hipComputeMode__enumvalues = {
0: 'hipComputeModeDefault',
1: 'hipComputeModeExclusive',
2: 'hipComputeModeProhibited',
3: 'hipComputeModeExclusiveProcess',
}
hipComputeModeDefault = 0
hipComputeModeExclusive = 1
hipComputeModeProhibited = 2
hipComputeModeExclusiveProcess = 3
hipComputeMode = ctypes.c_uint32 # enum
hipDeviceptr_t = ctypes.POINTER(None)
# values for enumeration 'hipChannelFormatKind'
hipChannelFormatKind__enumvalues = {
0: 'hipChannelFormatKindSigned',
1: 'hipChannelFormatKindUnsigned',
2: 'hipChannelFormatKindFloat',
3: 'hipChannelFormatKindNone',
}
hipChannelFormatKindSigned = 0
hipChannelFormatKindUnsigned = 1
hipChannelFormatKindFloat = 2
hipChannelFormatKindNone = 3
hipChannelFormatKind = ctypes.c_uint32 # enum
class struct_hipChannelFormatDesc(Structure):
pass
struct_hipChannelFormatDesc._pack_ = 1 # source:False
struct_hipChannelFormatDesc._fields_ = [
('x', ctypes.c_int32),
('y', ctypes.c_int32),
('z', ctypes.c_int32),
('w', ctypes.c_int32),
('f', hipChannelFormatKind),
]
hipChannelFormatDesc = struct_hipChannelFormatDesc
# values for enumeration 'hipArray_Format'
hipArray_Format__enumvalues = {
1: 'HIP_AD_FORMAT_UNSIGNED_INT8',
2: 'HIP_AD_FORMAT_UNSIGNED_INT16',
3: 'HIP_AD_FORMAT_UNSIGNED_INT32',
8: 'HIP_AD_FORMAT_SIGNED_INT8',
9: 'HIP_AD_FORMAT_SIGNED_INT16',
10: 'HIP_AD_FORMAT_SIGNED_INT32',
16: 'HIP_AD_FORMAT_HALF',
32: 'HIP_AD_FORMAT_FLOAT',
}
HIP_AD_FORMAT_UNSIGNED_INT8 = 1
HIP_AD_FORMAT_UNSIGNED_INT16 = 2
HIP_AD_FORMAT_UNSIGNED_INT32 = 3
HIP_AD_FORMAT_SIGNED_INT8 = 8
HIP_AD_FORMAT_SIGNED_INT16 = 9
HIP_AD_FORMAT_SIGNED_INT32 = 10
HIP_AD_FORMAT_HALF = 16
HIP_AD_FORMAT_FLOAT = 32
hipArray_Format = ctypes.c_uint32 # enum
class struct_HIP_ARRAY_DESCRIPTOR(Structure):
pass
struct_HIP_ARRAY_DESCRIPTOR._pack_ = 1 # source:False
struct_HIP_ARRAY_DESCRIPTOR._fields_ = [
('Width', ctypes.c_uint64),
('Height', ctypes.c_uint64),
('Format', hipArray_Format),
('NumChannels', ctypes.c_uint32),
]
HIP_ARRAY_DESCRIPTOR = struct_HIP_ARRAY_DESCRIPTOR
class struct_HIP_ARRAY3D_DESCRIPTOR(Structure):
pass
struct_HIP_ARRAY3D_DESCRIPTOR._pack_ = 1 # source:False
struct_HIP_ARRAY3D_DESCRIPTOR._fields_ = [
('Width', ctypes.c_uint64),
('Height', ctypes.c_uint64),
('Depth', ctypes.c_uint64),
('Format', hipArray_Format),
('NumChannels', ctypes.c_uint32),
('Flags', ctypes.c_uint32),
('PADDING_0', ctypes.c_ubyte * 4),
]
HIP_ARRAY3D_DESCRIPTOR = struct_HIP_ARRAY3D_DESCRIPTOR
class struct_hipArray(Structure):
pass
struct_hipArray._pack_ = 1 # source:False
struct_hipArray._fields_ = [
('data', ctypes.POINTER(None)),
('desc', struct_hipChannelFormatDesc),
('type', ctypes.c_uint32),
('width', ctypes.c_uint32),
('height', ctypes.c_uint32),
('depth', ctypes.c_uint32),
('Format', hipArray_Format),
('NumChannels', ctypes.c_uint32),
('isDrv', ctypes.c_bool),
('PADDING_0', ctypes.c_ubyte * 3),
('textureType', ctypes.c_uint32),
('flags', ctypes.c_uint32),
]
hipArray = struct_hipArray
class struct_hip_Memcpy2D(Structure):
pass
struct_hip_Memcpy2D._pack_ = 1 # source:False
struct_hip_Memcpy2D._fields_ = [
('srcXInBytes', ctypes.c_uint64),
('srcY', ctypes.c_uint64),
('srcMemoryType', hipMemoryType),
('PADDING_0', ctypes.c_ubyte * 4),
('srcHost', ctypes.POINTER(None)),
('srcDevice', ctypes.POINTER(None)),
('srcArray', ctypes.POINTER(struct_hipArray)),
('srcPitch', ctypes.c_uint64),
('dstXInBytes', ctypes.c_uint64),
('dstY', ctypes.c_uint64),
('dstMemoryType', hipMemoryType),
('PADDING_1', ctypes.c_ubyte * 4),
('dstHost', ctypes.POINTER(None)),
('dstDevice', ctypes.POINTER(None)),
('dstArray', ctypes.POINTER(struct_hipArray)),
('dstPitch', ctypes.c_uint64),
('WidthInBytes', ctypes.c_uint64),
('Height', ctypes.c_uint64),
]
hip_Memcpy2D = struct_hip_Memcpy2D
hipArray_t = ctypes.POINTER(struct_hipArray)
hiparray = ctypes.POINTER(struct_hipArray)
hipArray_const_t = ctypes.POINTER(struct_hipArray)
class struct_hipMipmappedArray(Structure):
pass
struct_hipMipmappedArray._pack_ = 1 # source:False
struct_hipMipmappedArray._fields_ = [
('data', ctypes.POINTER(None)),
('desc', struct_hipChannelFormatDesc),
('type', ctypes.c_uint32),
('width', ctypes.c_uint32),
('height', ctypes.c_uint32),
('depth', ctypes.c_uint32),
('min_mipmap_level', ctypes.c_uint32),
('max_mipmap_level', ctypes.c_uint32),
('flags', ctypes.c_uint32),
('format', hipArray_Format),
('num_channels', ctypes.c_uint32),
]
hipMipmappedArray = struct_hipMipmappedArray
hipMipmappedArray_t = ctypes.POINTER(struct_hipMipmappedArray)
hipmipmappedArray = ctypes.POINTER(struct_hipMipmappedArray)
hipMipmappedArray_const_t = ctypes.POINTER(struct_hipMipmappedArray)
# values for enumeration 'hipResourceType'
hipResourceType__enumvalues = {
0: 'hipResourceTypeArray',
1: 'hipResourceTypeMipmappedArray',
2: 'hipResourceTypeLinear',
3: 'hipResourceTypePitch2D',
}
hipResourceTypeArray = 0
hipResourceTypeMipmappedArray = 1
hipResourceTypeLinear = 2
hipResourceTypePitch2D = 3
hipResourceType = ctypes.c_uint32 # enum
# values for enumeration 'HIPresourcetype_enum'
HIPresourcetype_enum__enumvalues = {
0: 'HIP_RESOURCE_TYPE_ARRAY',
1: 'HIP_RESOURCE_TYPE_MIPMAPPED_ARRAY',
2: 'HIP_RESOURCE_TYPE_LINEAR',
3: 'HIP_RESOURCE_TYPE_PITCH2D',
}
HIP_RESOURCE_TYPE_ARRAY = 0
HIP_RESOURCE_TYPE_MIPMAPPED_ARRAY = 1
HIP_RESOURCE_TYPE_LINEAR = 2
HIP_RESOURCE_TYPE_PITCH2D = 3
HIPresourcetype_enum = ctypes.c_uint32 # enum
HIPresourcetype = HIPresourcetype_enum
HIPresourcetype__enumvalues = HIPresourcetype_enum__enumvalues
hipResourcetype = HIPresourcetype_enum
hipResourcetype__enumvalues = HIPresourcetype_enum__enumvalues
# values for enumeration 'HIPaddress_mode_enum'
HIPaddress_mode_enum__enumvalues = {
0: 'HIP_TR_ADDRESS_MODE_WRAP',
1: 'HIP_TR_ADDRESS_MODE_CLAMP',
2: 'HIP_TR_ADDRESS_MODE_MIRROR',
3: 'HIP_TR_ADDRESS_MODE_BORDER',
}
HIP_TR_ADDRESS_MODE_WRAP = 0
HIP_TR_ADDRESS_MODE_CLAMP = 1
HIP_TR_ADDRESS_MODE_MIRROR = 2
HIP_TR_ADDRESS_MODE_BORDER = 3
HIPaddress_mode_enum = ctypes.c_uint32 # enum
HIPaddress_mode = HIPaddress_mode_enum
HIPaddress_mode__enumvalues = HIPaddress_mode_enum__enumvalues
# values for enumeration 'HIPfilter_mode_enum'
HIPfilter_mode_enum__enumvalues = {
0: 'HIP_TR_FILTER_MODE_POINT',
1: 'HIP_TR_FILTER_MODE_LINEAR',
}
HIP_TR_FILTER_MODE_POINT = 0
HIP_TR_FILTER_MODE_LINEAR = 1
HIPfilter_mode_enum = ctypes.c_uint32 # enum
HIPfilter_mode = HIPfilter_mode_enum
HIPfilter_mode__enumvalues = HIPfilter_mode_enum__enumvalues
class struct_HIP_TEXTURE_DESC_st(Structure):
pass
struct_HIP_TEXTURE_DESC_st._pack_ = 1 # source:False
struct_HIP_TEXTURE_DESC_st._fields_ = [
('addressMode', HIPaddress_mode_enum * 3),
('filterMode', HIPfilter_mode),
('flags', ctypes.c_uint32),
('maxAnisotropy', ctypes.c_uint32),
('mipmapFilterMode', HIPfilter_mode),
('mipmapLevelBias', ctypes.c_float),
('minMipmapLevelClamp', ctypes.c_float),
('maxMipmapLevelClamp', ctypes.c_float),
('borderColor', ctypes.c_float * 4),
('reserved', ctypes.c_int32 * 12),
]
HIP_TEXTURE_DESC = struct_HIP_TEXTURE_DESC_st
# values for enumeration 'hipResourceViewFormat'
hipResourceViewFormat__enumvalues = {
0: 'hipResViewFormatNone',
1: 'hipResViewFormatUnsignedChar1',
2: 'hipResViewFormatUnsignedChar2',
3: 'hipResViewFormatUnsignedChar4',
4: 'hipResViewFormatSignedChar1',
5: 'hipResViewFormatSignedChar2',
6: 'hipResViewFormatSignedChar4',
7: 'hipResViewFormatUnsignedShort1',
8: 'hipResViewFormatUnsignedShort2',
9: 'hipResViewFormatUnsignedShort4',
10: 'hipResViewFormatSignedShort1',
11: 'hipResViewFormatSignedShort2',
12: 'hipResViewFormatSignedShort4',
13: 'hipResViewFormatUnsignedInt1',
14: 'hipResViewFormatUnsignedInt2',
15: 'hipResViewFormatUnsignedInt4',
16: 'hipResViewFormatSignedInt1',
17: 'hipResViewFormatSignedInt2',
18: 'hipResViewFormatSignedInt4',
19: 'hipResViewFormatHalf1',
20: 'hipResViewFormatHalf2',
21: 'hipResViewFormatHalf4',
22: 'hipResViewFormatFloat1',
23: 'hipResViewFormatFloat2',
24: 'hipResViewFormatFloat4',
25: 'hipResViewFormatUnsignedBlockCompressed1',
26: 'hipResViewFormatUnsignedBlockCompressed2',
27: 'hipResViewFormatUnsignedBlockCompressed3',
28: 'hipResViewFormatUnsignedBlockCompressed4',
29: 'hipResViewFormatSignedBlockCompressed4',
30: 'hipResViewFormatUnsignedBlockCompressed5',
31: 'hipResViewFormatSignedBlockCompressed5',
32: 'hipResViewFormatUnsignedBlockCompressed6H',
33: 'hipResViewFormatSignedBlockCompressed6H',
34: 'hipResViewFormatUnsignedBlockCompressed7',
}
hipResViewFormatNone = 0
hipResViewFormatUnsignedChar1 = 1
hipResViewFormatUnsignedChar2 = 2
hipResViewFormatUnsignedChar4 = 3
hipResViewFormatSignedChar1 = 4
hipResViewFormatSignedChar2 = 5
hipResViewFormatSignedChar4 = 6
hipResViewFormatUnsignedShort1 = 7
hipResViewFormatUnsignedShort2 = 8
hipResViewFormatUnsignedShort4 = 9
hipResViewFormatSignedShort1 = 10
hipResViewFormatSignedShort2 = 11
hipResViewFormatSignedShort4 = 12
hipResViewFormatUnsignedInt1 = 13
hipResViewFormatUnsignedInt2 = 14
hipResViewFormatUnsignedInt4 = 15
hipResViewFormatSignedInt1 = 16
hipResViewFormatSignedInt2 = 17
hipResViewFormatSignedInt4 = 18
hipResViewFormatHalf1 = 19
hipResViewFormatHalf2 = 20
hipResViewFormatHalf4 = 21
hipResViewFormatFloat1 = 22
hipResViewFormatFloat2 = 23
hipResViewFormatFloat4 = 24
hipResViewFormatUnsignedBlockCompressed1 = 25
hipResViewFormatUnsignedBlockCompressed2 = 26
hipResViewFormatUnsignedBlockCompressed3 = 27
hipResViewFormatUnsignedBlockCompressed4 = 28
hipResViewFormatSignedBlockCompressed4 = 29
hipResViewFormatUnsignedBlockCompressed5 = 30
hipResViewFormatSignedBlockCompressed5 = 31
hipResViewFormatUnsignedBlockCompressed6H = 32
hipResViewFormatSignedBlockCompressed6H = 33
hipResViewFormatUnsignedBlockCompressed7 = 34
hipResourceViewFormat = ctypes.c_uint32 # enum
# values for enumeration 'HIPresourceViewFormat_enum'
HIPresourceViewFormat_enum__enumvalues = {
0: 'HIP_RES_VIEW_FORMAT_NONE',
1: 'HIP_RES_VIEW_FORMAT_UINT_1X8',
2: 'HIP_RES_VIEW_FORMAT_UINT_2X8',
3: 'HIP_RES_VIEW_FORMAT_UINT_4X8',
4: 'HIP_RES_VIEW_FORMAT_SINT_1X8',
5: 'HIP_RES_VIEW_FORMAT_SINT_2X8',
6: 'HIP_RES_VIEW_FORMAT_SINT_4X8',
7: 'HIP_RES_VIEW_FORMAT_UINT_1X16',
8: 'HIP_RES_VIEW_FORMAT_UINT_2X16',
9: 'HIP_RES_VIEW_FORMAT_UINT_4X16',
10: 'HIP_RES_VIEW_FORMAT_SINT_1X16',
11: 'HIP_RES_VIEW_FORMAT_SINT_2X16',
12: 'HIP_RES_VIEW_FORMAT_SINT_4X16',
13: 'HIP_RES_VIEW_FORMAT_UINT_1X32',
14: 'HIP_RES_VIEW_FORMAT_UINT_2X32',
15: 'HIP_RES_VIEW_FORMAT_UINT_4X32',
16: 'HIP_RES_VIEW_FORMAT_SINT_1X32',
17: 'HIP_RES_VIEW_FORMAT_SINT_2X32',
18: 'HIP_RES_VIEW_FORMAT_SINT_4X32',
19: 'HIP_RES_VIEW_FORMAT_FLOAT_1X16',
20: 'HIP_RES_VIEW_FORMAT_FLOAT_2X16',
21: 'HIP_RES_VIEW_FORMAT_FLOAT_4X16',
22: 'HIP_RES_VIEW_FORMAT_FLOAT_1X32',
23: 'HIP_RES_VIEW_FORMAT_FLOAT_2X32',
24: 'HIP_RES_VIEW_FORMAT_FLOAT_4X32',
25: 'HIP_RES_VIEW_FORMAT_UNSIGNED_BC1',
26: 'HIP_RES_VIEW_FORMAT_UNSIGNED_BC2',
27: 'HIP_RES_VIEW_FORMAT_UNSIGNED_BC3',
28: 'HIP_RES_VIEW_FORMAT_UNSIGNED_BC4',
29: 'HIP_RES_VIEW_FORMAT_SIGNED_BC4',
30: 'HIP_RES_VIEW_FORMAT_UNSIGNED_BC5',
31: 'HIP_RES_VIEW_FORMAT_SIGNED_BC5',
32: 'HIP_RES_VIEW_FORMAT_UNSIGNED_BC6H',
33: 'HIP_RES_VIEW_FORMAT_SIGNED_BC6H',
34: 'HIP_RES_VIEW_FORMAT_UNSIGNED_BC7',
}
HIP_RES_VIEW_FORMAT_NONE = 0
HIP_RES_VIEW_FORMAT_UINT_1X8 = 1
HIP_RES_VIEW_FORMAT_UINT_2X8 = 2
HIP_RES_VIEW_FORMAT_UINT_4X8 = 3
HIP_RES_VIEW_FORMAT_SINT_1X8 = 4
HIP_RES_VIEW_FORMAT_SINT_2X8 = 5
HIP_RES_VIEW_FORMAT_SINT_4X8 = 6
HIP_RES_VIEW_FORMAT_UINT_1X16 = 7
HIP_RES_VIEW_FORMAT_UINT_2X16 = 8
HIP_RES_VIEW_FORMAT_UINT_4X16 = 9
HIP_RES_VIEW_FORMAT_SINT_1X16 = 10
HIP_RES_VIEW_FORMAT_SINT_2X16 = 11
HIP_RES_VIEW_FORMAT_SINT_4X16 = 12
HIP_RES_VIEW_FORMAT_UINT_1X32 = 13
HIP_RES_VIEW_FORMAT_UINT_2X32 = 14
HIP_RES_VIEW_FORMAT_UINT_4X32 = 15
HIP_RES_VIEW_FORMAT_SINT_1X32 = 16
HIP_RES_VIEW_FORMAT_SINT_2X32 = 17
HIP_RES_VIEW_FORMAT_SINT_4X32 = 18
HIP_RES_VIEW_FORMAT_FLOAT_1X16 = 19
HIP_RES_VIEW_FORMAT_FLOAT_2X16 = 20
HIP_RES_VIEW_FORMAT_FLOAT_4X16 = 21
HIP_RES_VIEW_FORMAT_FLOAT_1X32 = 22
HIP_RES_VIEW_FORMAT_FLOAT_2X32 = 23
HIP_RES_VIEW_FORMAT_FLOAT_4X32 = 24
HIP_RES_VIEW_FORMAT_UNSIGNED_BC1 = 25
HIP_RES_VIEW_FORMAT_UNSIGNED_BC2 = 26
HIP_RES_VIEW_FORMAT_UNSIGNED_BC3 = 27
HIP_RES_VIEW_FORMAT_UNSIGNED_BC4 = 28
HIP_RES_VIEW_FORMAT_SIGNED_BC4 = 29
HIP_RES_VIEW_FORMAT_UNSIGNED_BC5 = 30
HIP_RES_VIEW_FORMAT_SIGNED_BC5 = 31
HIP_RES_VIEW_FORMAT_UNSIGNED_BC6H = 32
HIP_RES_VIEW_FORMAT_SIGNED_BC6H = 33
HIP_RES_VIEW_FORMAT_UNSIGNED_BC7 = 34
HIPresourceViewFormat_enum = ctypes.c_uint32 # enum
HIPresourceViewFormat = HIPresourceViewFormat_enum
HIPresourceViewFormat__enumvalues = HIPresourceViewFormat_enum__enumvalues
class struct_hipResourceDesc(Structure):
pass
class union_hipResourceDesc_res(Union):
pass
class struct_hipResourceDesc_0_pitch2D(Structure):
pass
struct_hipResourceDesc_0_pitch2D._pack_ = 1 # source:False
struct_hipResourceDesc_0_pitch2D._fields_ = [
('devPtr', ctypes.POINTER(None)),
('desc', struct_hipChannelFormatDesc),
('PADDING_0', ctypes.c_ubyte * 4),
('width', ctypes.c_uint64),
('height', ctypes.c_uint64),
('pitchInBytes', ctypes.c_uint64),
]
class struct_hipResourceDesc_0_mipmap(Structure):
pass
struct_hipResourceDesc_0_mipmap._pack_ = 1 # source:False
struct_hipResourceDesc_0_mipmap._fields_ = [
('mipmap', ctypes.POINTER(struct_hipMipmappedArray)),
]
class struct_hipResourceDesc_0_array(Structure):
pass
struct_hipResourceDesc_0_array._pack_ = 1 # source:False
struct_hipResourceDesc_0_array._fields_ = [
('array', ctypes.POINTER(struct_hipArray)),
]
class struct_hipResourceDesc_0_linear(Structure):
pass
struct_hipResourceDesc_0_linear._pack_ = 1 # source:False
struct_hipResourceDesc_0_linear._fields_ = [
('devPtr', ctypes.POINTER(None)),
('desc', struct_hipChannelFormatDesc),
('PADDING_0', ctypes.c_ubyte * 4),
('sizeInBytes', ctypes.c_uint64),
]
union_hipResourceDesc_res._pack_ = 1 # source:False
union_hipResourceDesc_res._fields_ = [
('array', struct_hipResourceDesc_0_array),
('mipmap', struct_hipResourceDesc_0_mipmap),
('linear', struct_hipResourceDesc_0_linear),
('pitch2D', struct_hipResourceDesc_0_pitch2D),
]
struct_hipResourceDesc._pack_ = 1 # source:False
struct_hipResourceDesc._fields_ = [
('resType', hipResourceType),
('PADDING_0', ctypes.c_ubyte * 4),
('res', union_hipResourceDesc_res),
]
hipResourceDesc = struct_hipResourceDesc
class struct_HIP_RESOURCE_DESC_st(Structure):
pass
class union_HIP_RESOURCE_DESC_st_res(Union):
pass
class struct_HIP_RESOURCE_DESC_st_0_mipmap(Structure):
pass
struct_HIP_RESOURCE_DESC_st_0_mipmap._pack_ = 1 # source:False
struct_HIP_RESOURCE_DESC_st_0_mipmap._fields_ = [
('hMipmappedArray', ctypes.POINTER(struct_hipMipmappedArray)),
]
class struct_HIP_RESOURCE_DESC_st_0_array(Structure):
pass
struct_HIP_RESOURCE_DESC_st_0_array._pack_ = 1 # source:False
struct_HIP_RESOURCE_DESC_st_0_array._fields_ = [
('hArray', ctypes.POINTER(struct_hipArray)),
]
class struct_HIP_RESOURCE_DESC_st_0_linear(Structure):
pass
struct_HIP_RESOURCE_DESC_st_0_linear._pack_ = 1 # source:False
struct_HIP_RESOURCE_DESC_st_0_linear._fields_ = [
('devPtr', ctypes.POINTER(None)),
('format', hipArray_Format),
('numChannels', ctypes.c_uint32),
('sizeInBytes', ctypes.c_uint64),
]
class struct_HIP_RESOURCE_DESC_st_0_pitch2D(Structure):
pass
struct_HIP_RESOURCE_DESC_st_0_pitch2D._pack_ = 1 # source:False
struct_HIP_RESOURCE_DESC_st_0_pitch2D._fields_ = [
('devPtr', ctypes.POINTER(None)),
('format', hipArray_Format),
('numChannels', ctypes.c_uint32),
('width', ctypes.c_uint64),
('height', ctypes.c_uint64),
('pitchInBytes', ctypes.c_uint64),
]
class struct_HIP_RESOURCE_DESC_st_0_reserved(Structure):
pass
struct_HIP_RESOURCE_DESC_st_0_reserved._pack_ = 1 # source:False
struct_HIP_RESOURCE_DESC_st_0_reserved._fields_ = [
('reserved', ctypes.c_int32 * 32),
]
union_HIP_RESOURCE_DESC_st_res._pack_ = 1 # source:False
union_HIP_RESOURCE_DESC_st_res._fields_ = [
('array', struct_HIP_RESOURCE_DESC_st_0_array),
('mipmap', struct_HIP_RESOURCE_DESC_st_0_mipmap),
('linear', struct_HIP_RESOURCE_DESC_st_0_linear),
('pitch2D', struct_HIP_RESOURCE_DESC_st_0_pitch2D),
('reserved', struct_HIP_RESOURCE_DESC_st_0_reserved),
]
struct_HIP_RESOURCE_DESC_st._pack_ = 1 # source:False
struct_HIP_RESOURCE_DESC_st._fields_ = [
('resType', HIPresourcetype),
('PADDING_0', ctypes.c_ubyte * 4),
('res', union_HIP_RESOURCE_DESC_st_res),
('flags', ctypes.c_uint32),
('PADDING_1', ctypes.c_ubyte * 4),
]
HIP_RESOURCE_DESC = struct_HIP_RESOURCE_DESC_st
class struct_hipResourceViewDesc(Structure):
pass
struct_hipResourceViewDesc._pack_ = 1 # source:False
struct_hipResourceViewDesc._fields_ = [
('format', hipResourceViewFormat),
('PADDING_0', ctypes.c_ubyte * 4),
('width', ctypes.c_uint64),
('height', ctypes.c_uint64),
('depth', ctypes.c_uint64),
('firstMipmapLevel', ctypes.c_uint32),
('lastMipmapLevel', ctypes.c_uint32),
('firstLayer', ctypes.c_uint32),
('lastLayer', ctypes.c_uint32),
]
class struct_HIP_RESOURCE_VIEW_DESC_st(Structure):
pass
struct_HIP_RESOURCE_VIEW_DESC_st._pack_ = 1 # source:False
struct_HIP_RESOURCE_VIEW_DESC_st._fields_ = [
('format', HIPresourceViewFormat),
('PADDING_0', ctypes.c_ubyte * 4),
('width', ctypes.c_uint64),
('height', ctypes.c_uint64),
('depth', ctypes.c_uint64),
('firstMipmapLevel', ctypes.c_uint32),
('lastMipmapLevel', ctypes.c_uint32),
('firstLayer', ctypes.c_uint32),
('lastLayer', ctypes.c_uint32),
('reserved', ctypes.c_uint32 * 16),
]
HIP_RESOURCE_VIEW_DESC = struct_HIP_RESOURCE_VIEW_DESC_st
# values for enumeration 'hipMemcpyKind'
hipMemcpyKind__enumvalues = {
0: 'hipMemcpyHostToHost',
1: 'hipMemcpyHostToDevice',
2: 'hipMemcpyDeviceToHost',
3: 'hipMemcpyDeviceToDevice',
4: 'hipMemcpyDefault',
}
hipMemcpyHostToHost = 0
hipMemcpyHostToDevice = 1
hipMemcpyDeviceToHost = 2
hipMemcpyDeviceToDevice = 3
hipMemcpyDefault = 4
hipMemcpyKind = ctypes.c_uint32 # enum
class struct_hipPitchedPtr(Structure):
pass
struct_hipPitchedPtr._pack_ = 1 # source:False
struct_hipPitchedPtr._fields_ = [
('ptr', ctypes.POINTER(None)),
('pitch', ctypes.c_uint64),
('xsize', ctypes.c_uint64),
('ysize', ctypes.c_uint64),
]
hipPitchedPtr = struct_hipPitchedPtr
class struct_hipExtent(Structure):
pass
struct_hipExtent._pack_ = 1 # source:False
struct_hipExtent._fields_ = [
('width', ctypes.c_uint64),
('height', ctypes.c_uint64),
('depth', ctypes.c_uint64),
]
hipExtent = struct_hipExtent
class struct_hipPos(Structure):
pass
struct_hipPos._pack_ = 1 # source:False
struct_hipPos._fields_ = [
('x', ctypes.c_uint64),
('y', ctypes.c_uint64),
('z', ctypes.c_uint64),
]
hipPos = struct_hipPos
class struct_hipMemcpy3DParms(Structure):
pass
struct_hipMemcpy3DParms._pack_ = 1 # source:False
struct_hipMemcpy3DParms._fields_ = [
('srcArray', ctypes.POINTER(struct_hipArray)),
('srcPos', struct_hipPos),
('srcPtr', struct_hipPitchedPtr),
('dstArray', ctypes.POINTER(struct_hipArray)),
('dstPos', struct_hipPos),
('dstPtr', struct_hipPitchedPtr),
('extent', struct_hipExtent),
('kind', hipMemcpyKind),
('PADDING_0', ctypes.c_ubyte * 4),
]
hipMemcpy3DParms = struct_hipMemcpy3DParms
class struct_HIP_MEMCPY3D(Structure):
pass
struct_HIP_MEMCPY3D._pack_ = 1 # source:False
struct_HIP_MEMCPY3D._fields_ = [
('srcXInBytes', ctypes.c_uint32),
('srcY', ctypes.c_uint32),
('srcZ', ctypes.c_uint32),
('srcLOD', ctypes.c_uint32),
('srcMemoryType', hipMemoryType),
('PADDING_0', ctypes.c_ubyte * 4),
('srcHost', ctypes.POINTER(None)),
('srcDevice', ctypes.POINTER(None)),
('srcArray', ctypes.POINTER(struct_hipArray)),
('srcPitch', ctypes.c_uint32),
('srcHeight', ctypes.c_uint32),
('dstXInBytes', ctypes.c_uint32),
('dstY', ctypes.c_uint32),
('dstZ', ctypes.c_uint32),
('dstLOD', ctypes.c_uint32),
('dstMemoryType', hipMemoryType),
('PADDING_1', ctypes.c_ubyte * 4),
('dstHost', ctypes.POINTER(None)),
('dstDevice', ctypes.POINTER(None)),
('dstArray', ctypes.POINTER(struct_hipArray)),
('dstPitch', ctypes.c_uint32),
('dstHeight', ctypes.c_uint32),
('WidthInBytes', ctypes.c_uint32),
('Height', ctypes.c_uint32),
('Depth', ctypes.c_uint32),
('PADDING_2', ctypes.c_ubyte * 4),
]
HIP_MEMCPY3D = struct_HIP_MEMCPY3D
make_hipPitchedPtr = _libraries['FIXME_STUB'].make_hipPitchedPtr
make_hipPitchedPtr.restype = struct_hipPitchedPtr
make_hipPitchedPtr.argtypes = [ctypes.POINTER(None), size_t, size_t, size_t]
make_hipPos = _libraries['FIXME_STUB'].make_hipPos
make_hipPos.restype = struct_hipPos
make_hipPos.argtypes = [size_t, size_t, size_t]
make_hipExtent = _libraries['FIXME_STUB'].make_hipExtent
make_hipExtent.restype = struct_hipExtent
make_hipExtent.argtypes = [size_t, size_t, size_t]
# values for enumeration 'hipFunction_attribute'
hipFunction_attribute__enumvalues = {
0: 'HIP_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK',
1: 'HIP_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES',
2: 'HIP_FUNC_ATTRIBUTE_CONST_SIZE_BYTES',
3: 'HIP_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES',
4: 'HIP_FUNC_ATTRIBUTE_NUM_REGS',
5: 'HIP_FUNC_ATTRIBUTE_PTX_VERSION',
6: 'HIP_FUNC_ATTRIBUTE_BINARY_VERSION',
7: 'HIP_FUNC_ATTRIBUTE_CACHE_MODE_CA',
8: 'HIP_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES',
9: 'HIP_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT',
10: 'HIP_FUNC_ATTRIBUTE_MAX',
}
HIP_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK = 0
HIP_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES = 1
HIP_FUNC_ATTRIBUTE_CONST_SIZE_BYTES = 2
HIP_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES = 3
HIP_FUNC_ATTRIBUTE_NUM_REGS = 4
HIP_FUNC_ATTRIBUTE_PTX_VERSION = 5
HIP_FUNC_ATTRIBUTE_BINARY_VERSION = 6
HIP_FUNC_ATTRIBUTE_CACHE_MODE_CA = 7
HIP_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES = 8
HIP_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT = 9
HIP_FUNC_ATTRIBUTE_MAX = 10
hipFunction_attribute = ctypes.c_uint32 # enum
# values for enumeration 'hipPointer_attribute'
hipPointer_attribute__enumvalues = {
1: 'HIP_POINTER_ATTRIBUTE_CONTEXT',
2: 'HIP_POINTER_ATTRIBUTE_MEMORY_TYPE',
3: 'HIP_POINTER_ATTRIBUTE_DEVICE_POINTER',
4: 'HIP_POINTER_ATTRIBUTE_HOST_POINTER',
5: 'HIP_POINTER_ATTRIBUTE_P2P_TOKENS',
6: 'HIP_POINTER_ATTRIBUTE_SYNC_MEMOPS',
7: 'HIP_POINTER_ATTRIBUTE_BUFFER_ID',
8: 'HIP_POINTER_ATTRIBUTE_IS_MANAGED',
9: 'HIP_POINTER_ATTRIBUTE_DEVICE_ORDINAL',
10: 'HIP_POINTER_ATTRIBUTE_IS_LEGACY_HIP_IPC_CAPABLE',
11: 'HIP_POINTER_ATTRIBUTE_RANGE_START_ADDR',
12: 'HIP_POINTER_ATTRIBUTE_RANGE_SIZE',
13: 'HIP_POINTER_ATTRIBUTE_MAPPED',
14: 'HIP_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES',
15: 'HIP_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE',
16: 'HIP_POINTER_ATTRIBUTE_ACCESS_FLAGS',
17: 'HIP_POINTER_ATTRIBUTE_MEMPOOL_HANDLE',
}
HIP_POINTER_ATTRIBUTE_CONTEXT = 1
HIP_POINTER_ATTRIBUTE_MEMORY_TYPE = 2
HIP_POINTER_ATTRIBUTE_DEVICE_POINTER = 3
HIP_POINTER_ATTRIBUTE_HOST_POINTER = 4
HIP_POINTER_ATTRIBUTE_P2P_TOKENS = 5
HIP_POINTER_ATTRIBUTE_SYNC_MEMOPS = 6
HIP_POINTER_ATTRIBUTE_BUFFER_ID = 7
HIP_POINTER_ATTRIBUTE_IS_MANAGED = 8
HIP_POINTER_ATTRIBUTE_DEVICE_ORDINAL = 9
HIP_POINTER_ATTRIBUTE_IS_LEGACY_HIP_IPC_CAPABLE = 10
HIP_POINTER_ATTRIBUTE_RANGE_START_ADDR = 11
HIP_POINTER_ATTRIBUTE_RANGE_SIZE = 12
HIP_POINTER_ATTRIBUTE_MAPPED = 13
HIP_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES = 14
HIP_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE = 15
HIP_POINTER_ATTRIBUTE_ACCESS_FLAGS = 16
HIP_POINTER_ATTRIBUTE_MEMPOOL_HANDLE = 17
hipPointer_attribute = ctypes.c_uint32 # enum
class struct_ihipCtx_t(Structure):
pass
hipCtx_t = ctypes.POINTER(struct_ihipCtx_t)
hipDevice_t = ctypes.c_int32
# values for enumeration 'hipDeviceP2PAttr'
hipDeviceP2PAttr__enumvalues = {
0: 'hipDevP2PAttrPerformanceRank',
1: 'hipDevP2PAttrAccessSupported',
2: 'hipDevP2PAttrNativeAtomicSupported',
3: 'hipDevP2PAttrHipArrayAccessSupported',
}
hipDevP2PAttrPerformanceRank = 0
hipDevP2PAttrAccessSupported = 1
hipDevP2PAttrNativeAtomicSupported = 2
hipDevP2PAttrHipArrayAccessSupported = 3
hipDeviceP2PAttr = ctypes.c_uint32 # enum
class struct_ihipStream_t(Structure):
pass
hipStream_t = ctypes.POINTER(struct_ihipStream_t)
class struct_hipIpcMemHandle_st(Structure):
pass
struct_hipIpcMemHandle_st._pack_ = 1 # source:False
struct_hipIpcMemHandle_st._fields_ = [
('reserved', ctypes.c_char * 64),
]
hipIpcMemHandle_t = struct_hipIpcMemHandle_st
class struct_hipIpcEventHandle_st(Structure):
pass
struct_hipIpcEventHandle_st._pack_ = 1 # source:False
struct_hipIpcEventHandle_st._fields_ = [
('reserved', ctypes.c_char * 64),
]
hipIpcEventHandle_t = struct_hipIpcEventHandle_st
class struct_ihipModule_t(Structure):
pass
hipModule_t = ctypes.POINTER(struct_ihipModule_t)
class struct_ihipModuleSymbol_t(Structure):
pass
hipFunction_t = ctypes.POINTER(struct_ihipModuleSymbol_t)
class struct_ihipMemPoolHandle_t(Structure):
pass
hipMemPool_t = ctypes.POINTER(struct_ihipMemPoolHandle_t)
class struct_hipFuncAttributes(Structure):
pass
struct_hipFuncAttributes._pack_ = 1 # source:False
struct_hipFuncAttributes._fields_ = [
('binaryVersion', ctypes.c_int32),
('cacheModeCA', ctypes.c_int32),
('constSizeBytes', ctypes.c_uint64),
('localSizeBytes', ctypes.c_uint64),
('maxDynamicSharedSizeBytes', ctypes.c_int32),
('maxThreadsPerBlock', ctypes.c_int32),
('numRegs', ctypes.c_int32),
('preferredShmemCarveout', ctypes.c_int32),
('ptxVersion', ctypes.c_int32),
('PADDING_0', ctypes.c_ubyte * 4),
('sharedSizeBytes', ctypes.c_uint64),
]
hipFuncAttributes = struct_hipFuncAttributes
class struct_ihipEvent_t(Structure):
pass
hipEvent_t = ctypes.POINTER(struct_ihipEvent_t)
# values for enumeration 'hipLimit_t'
hipLimit_t__enumvalues = {
0: 'hipLimitStackSize',
1: 'hipLimitPrintfFifoSize',
2: 'hipLimitMallocHeapSize',
3: 'hipLimitRange',
}
hipLimitStackSize = 0
hipLimitPrintfFifoSize = 1
hipLimitMallocHeapSize = 2
hipLimitRange = 3
hipLimit_t = ctypes.c_uint32 # enum
# values for enumeration 'hipMemoryAdvise'
hipMemoryAdvise__enumvalues = {
1: 'hipMemAdviseSetReadMostly',
2: 'hipMemAdviseUnsetReadMostly',
3: 'hipMemAdviseSetPreferredLocation',
4: 'hipMemAdviseUnsetPreferredLocation',
5: 'hipMemAdviseSetAccessedBy',
6: 'hipMemAdviseUnsetAccessedBy',
100: 'hipMemAdviseSetCoarseGrain',
101: 'hipMemAdviseUnsetCoarseGrain',
}
hipMemAdviseSetReadMostly = 1
hipMemAdviseUnsetReadMostly = 2
hipMemAdviseSetPreferredLocation = 3
hipMemAdviseUnsetPreferredLocation = 4
hipMemAdviseSetAccessedBy = 5
hipMemAdviseUnsetAccessedBy = 6
hipMemAdviseSetCoarseGrain = 100
hipMemAdviseUnsetCoarseGrain = 101
hipMemoryAdvise = ctypes.c_uint32 # enum
# values for enumeration 'hipMemRangeCoherencyMode'
hipMemRangeCoherencyMode__enumvalues = {
0: 'hipMemRangeCoherencyModeFineGrain',
1: 'hipMemRangeCoherencyModeCoarseGrain',
2: 'hipMemRangeCoherencyModeIndeterminate',
}
hipMemRangeCoherencyModeFineGrain = 0
hipMemRangeCoherencyModeCoarseGrain = 1
hipMemRangeCoherencyModeIndeterminate = 2
hipMemRangeCoherencyMode = ctypes.c_uint32 # enum
# values for enumeration 'hipMemRangeAttribute'
hipMemRangeAttribute__enumvalues = {
1: 'hipMemRangeAttributeReadMostly',
2: 'hipMemRangeAttributePreferredLocation',
3: 'hipMemRangeAttributeAccessedBy',
4: 'hipMemRangeAttributeLastPrefetchLocation',
100: 'hipMemRangeAttributeCoherencyMode',
}
hipMemRangeAttributeReadMostly = 1
hipMemRangeAttributePreferredLocation = 2
hipMemRangeAttributeAccessedBy = 3
hipMemRangeAttributeLastPrefetchLocation = 4
hipMemRangeAttributeCoherencyMode = 100
hipMemRangeAttribute = ctypes.c_uint32 # enum
# values for enumeration 'hipMemPoolAttr'
hipMemPoolAttr__enumvalues = {
1: 'hipMemPoolReuseFollowEventDependencies',
2: 'hipMemPoolReuseAllowOpportunistic',
3: 'hipMemPoolReuseAllowInternalDependencies',
4: 'hipMemPoolAttrReleaseThreshold',
5: 'hipMemPoolAttrReservedMemCurrent',
6: 'hipMemPoolAttrReservedMemHigh',
7: 'hipMemPoolAttrUsedMemCurrent',
8: 'hipMemPoolAttrUsedMemHigh',
}
hipMemPoolReuseFollowEventDependencies = 1
hipMemPoolReuseAllowOpportunistic = 2
hipMemPoolReuseAllowInternalDependencies = 3
hipMemPoolAttrReleaseThreshold = 4
hipMemPoolAttrReservedMemCurrent = 5
hipMemPoolAttrReservedMemHigh = 6
hipMemPoolAttrUsedMemCurrent = 7
hipMemPoolAttrUsedMemHigh = 8
hipMemPoolAttr = ctypes.c_uint32 # enum
# values for enumeration 'hipMemLocationType'
hipMemLocationType__enumvalues = {
0: 'hipMemLocationTypeInvalid',
1: 'hipMemLocationTypeDevice',
}
hipMemLocationTypeInvalid = 0
hipMemLocationTypeDevice = 1
hipMemLocationType = ctypes.c_uint32 # enum
class struct_hipMemLocation(Structure):
pass
struct_hipMemLocation._pack_ = 1 # source:False
struct_hipMemLocation._fields_ = [
('type', hipMemLocationType),
('id', ctypes.c_int32),
]
hipMemLocation = struct_hipMemLocation
# values for enumeration 'hipMemAccessFlags'
hipMemAccessFlags__enumvalues = {
0: 'hipMemAccessFlagsProtNone',
1: 'hipMemAccessFlagsProtRead',
3: 'hipMemAccessFlagsProtReadWrite',
}
hipMemAccessFlagsProtNone = 0
hipMemAccessFlagsProtRead = 1
hipMemAccessFlagsProtReadWrite = 3
hipMemAccessFlags = ctypes.c_uint32 # enum
class struct_hipMemAccessDesc(Structure):
_pack_ = 1 # source:False
_fields_ = [
('location', hipMemLocation),
('flags', hipMemAccessFlags),
]
hipMemAccessDesc = struct_hipMemAccessDesc
# values for enumeration 'hipMemAllocationType'
hipMemAllocationType__enumvalues = {
0: 'hipMemAllocationTypeInvalid',
1: 'hipMemAllocationTypePinned',
2147483647: 'hipMemAllocationTypeMax',
}
hipMemAllocationTypeInvalid = 0
hipMemAllocationTypePinned = 1
hipMemAllocationTypeMax = 2147483647
hipMemAllocationType = ctypes.c_uint32 # enum
# values for enumeration 'hipMemAllocationHandleType'
hipMemAllocationHandleType__enumvalues = {
0: 'hipMemHandleTypeNone',
1: 'hipMemHandleTypePosixFileDescriptor',
2: 'hipMemHandleTypeWin32',
4: 'hipMemHandleTypeWin32Kmt',
}
hipMemHandleTypeNone = 0
hipMemHandleTypePosixFileDescriptor = 1
hipMemHandleTypeWin32 = 2
hipMemHandleTypeWin32Kmt = 4
hipMemAllocationHandleType = ctypes.c_uint32 # enum
class struct_hipMemPoolProps(Structure):
pass
struct_hipMemPoolProps._pack_ = 1 # source:False
struct_hipMemPoolProps._fields_ = [
('allocType', hipMemAllocationType),
('handleTypes', hipMemAllocationHandleType),
('location', hipMemLocation),
('win32SecurityAttributes', ctypes.POINTER(None)),
('reserved', ctypes.c_ubyte * 64),
]
hipMemPoolProps = struct_hipMemPoolProps
class struct_hipMemPoolPtrExportData(Structure):
pass
struct_hipMemPoolPtrExportData._pack_ = 1 # source:False
struct_hipMemPoolPtrExportData._fields_ = [
('reserved', ctypes.c_ubyte * 64),
]
hipMemPoolPtrExportData = struct_hipMemPoolPtrExportData
# values for enumeration 'hipJitOption'
hipJitOption__enumvalues = {
0: 'hipJitOptionMaxRegisters',
1: 'hipJitOptionThreadsPerBlock',
2: 'hipJitOptionWallTime',
3: 'hipJitOptionInfoLogBuffer',
4: 'hipJitOptionInfoLogBufferSizeBytes',
5: 'hipJitOptionErrorLogBuffer',
6: 'hipJitOptionErrorLogBufferSizeBytes',
7: 'hipJitOptionOptimizationLevel',
8: 'hipJitOptionTargetFromContext',
9: 'hipJitOptionTarget',
10: 'hipJitOptionFallbackStrategy',
11: 'hipJitOptionGenerateDebugInfo',
12: 'hipJitOptionLogVerbose',
13: 'hipJitOptionGenerateLineInfo',
14: 'hipJitOptionCacheMode',
15: 'hipJitOptionSm3xOpt',
16: 'hipJitOptionFastCompile',
17: 'hipJitOptionNumOptions',
}
hipJitOptionMaxRegisters = 0
hipJitOptionThreadsPerBlock = 1
hipJitOptionWallTime = 2
hipJitOptionInfoLogBuffer = 3
hipJitOptionInfoLogBufferSizeBytes = 4
hipJitOptionErrorLogBuffer = 5
hipJitOptionErrorLogBufferSizeBytes = 6
hipJitOptionOptimizationLevel = 7
hipJitOptionTargetFromContext = 8
hipJitOptionTarget = 9
hipJitOptionFallbackStrategy = 10
hipJitOptionGenerateDebugInfo = 11
hipJitOptionLogVerbose = 12
hipJitOptionGenerateLineInfo = 13
hipJitOptionCacheMode = 14
hipJitOptionSm3xOpt = 15
hipJitOptionFastCompile = 16
hipJitOptionNumOptions = 17
hipJitOption = ctypes.c_uint32 # enum
# values for enumeration 'hipFuncAttribute'
hipFuncAttribute__enumvalues = {
8: 'hipFuncAttributeMaxDynamicSharedMemorySize',
9: 'hipFuncAttributePreferredSharedMemoryCarveout',
10: 'hipFuncAttributeMax',
}
hipFuncAttributeMaxDynamicSharedMemorySize = 8
hipFuncAttributePreferredSharedMemoryCarveout = 9
hipFuncAttributeMax = 10
hipFuncAttribute = ctypes.c_uint32 # enum
# values for enumeration 'hipFuncCache_t'
hipFuncCache_t__enumvalues = {
0: 'hipFuncCachePreferNone',
1: 'hipFuncCachePreferShared',
2: 'hipFuncCachePreferL1',
3: 'hipFuncCachePreferEqual',
}
hipFuncCachePreferNone = 0
hipFuncCachePreferShared = 1
hipFuncCachePreferL1 = 2
hipFuncCachePreferEqual = 3
hipFuncCache_t = ctypes.c_uint32 # enum
# values for enumeration 'hipSharedMemConfig'
hipSharedMemConfig__enumvalues = {
0: 'hipSharedMemBankSizeDefault',
1: 'hipSharedMemBankSizeFourByte',
2: 'hipSharedMemBankSizeEightByte',
}
hipSharedMemBankSizeDefault = 0
hipSharedMemBankSizeFourByte = 1
hipSharedMemBankSizeEightByte = 2
hipSharedMemConfig = ctypes.c_uint32 # enum
class struct_dim3(Structure):
pass
struct_dim3._pack_ = 1 # source:False
struct_dim3._fields_ = [
('x', ctypes.c_uint32),
('y', ctypes.c_uint32),
('z', ctypes.c_uint32),
]
dim3 = struct_dim3
class struct_hipLaunchParams_t(Structure):
pass
struct_hipLaunchParams_t._pack_ = 1 # source:False
struct_hipLaunchParams_t._fields_ = [
('func', ctypes.POINTER(None)),
('gridDim', dim3),
('blockDim', dim3),
('args', ctypes.POINTER(ctypes.POINTER(None))),
('sharedMem', ctypes.c_uint64),
('stream', ctypes.POINTER(struct_ihipStream_t)),
]
hipLaunchParams = struct_hipLaunchParams_t
class struct_hipFunctionLaunchParams_t(Structure):
pass
struct_hipFunctionLaunchParams_t._pack_ = 1 # source:False
struct_hipFunctionLaunchParams_t._fields_ = [
('function', ctypes.POINTER(struct_ihipModuleSymbol_t)),
('gridDimX', ctypes.c_uint32),
('gridDimY', ctypes.c_uint32),
('gridDimZ', ctypes.c_uint32),
('blockDimX', ctypes.c_uint32),
('blockDimY', ctypes.c_uint32),
('blockDimZ', ctypes.c_uint32),
('sharedMemBytes', ctypes.c_uint32),
('PADDING_0', ctypes.c_ubyte * 4),
('hStream', ctypes.POINTER(struct_ihipStream_t)),
('kernelParams', ctypes.POINTER(ctypes.POINTER(None))),
]
hipFunctionLaunchParams = struct_hipFunctionLaunchParams_t
# values for enumeration 'hipExternalMemoryHandleType_enum'
hipExternalMemoryHandleType_enum__enumvalues = {
1: 'hipExternalMemoryHandleTypeOpaqueFd',
2: 'hipExternalMemoryHandleTypeOpaqueWin32',
3: 'hipExternalMemoryHandleTypeOpaqueWin32Kmt',
4: 'hipExternalMemoryHandleTypeD3D12Heap',
5: 'hipExternalMemoryHandleTypeD3D12Resource',
6: 'hipExternalMemoryHandleTypeD3D11Resource',
7: 'hipExternalMemoryHandleTypeD3D11ResourceKmt',
}
hipExternalMemoryHandleTypeOpaqueFd = 1
hipExternalMemoryHandleTypeOpaqueWin32 = 2
hipExternalMemoryHandleTypeOpaqueWin32Kmt = 3
hipExternalMemoryHandleTypeD3D12Heap = 4
hipExternalMemoryHandleTypeD3D12Resource = 5
hipExternalMemoryHandleTypeD3D11Resource = 6
hipExternalMemoryHandleTypeD3D11ResourceKmt = 7
hipExternalMemoryHandleType_enum = ctypes.c_uint32 # enum
hipExternalMemoryHandleType = hipExternalMemoryHandleType_enum
hipExternalMemoryHandleType__enumvalues = hipExternalMemoryHandleType_enum__enumvalues
class struct_hipExternalMemoryHandleDesc_st(Structure):
pass
class union_hipExternalMemoryHandleDesc_st_handle(Union):
pass
class struct_hipExternalMemoryHandleDesc_st_0_win32(Structure):
pass
struct_hipExternalMemoryHandleDesc_st_0_win32._pack_ = 1 # source:False
struct_hipExternalMemoryHandleDesc_st_0_win32._fields_ = [
('handle', ctypes.POINTER(None)),
('name', ctypes.POINTER(None)),
]
union_hipExternalMemoryHandleDesc_st_handle._pack_ = 1 # source:False
union_hipExternalMemoryHandleDesc_st_handle._fields_ = [
('fd', ctypes.c_int32),
('win32', struct_hipExternalMemoryHandleDesc_st_0_win32),
]
struct_hipExternalMemoryHandleDesc_st._pack_ = 1 # source:False
struct_hipExternalMemoryHandleDesc_st._fields_ = [
('type', hipExternalMemoryHandleType),
('PADDING_0', ctypes.c_ubyte * 4),
('handle', union_hipExternalMemoryHandleDesc_st_handle),
('size', ctypes.c_uint64),
('flags', ctypes.c_uint32),
('PADDING_1', ctypes.c_ubyte * 4),
]
hipExternalMemoryHandleDesc = struct_hipExternalMemoryHandleDesc_st
class struct_hipExternalMemoryBufferDesc_st(Structure):
pass
struct_hipExternalMemoryBufferDesc_st._pack_ = 1 # source:False
struct_hipExternalMemoryBufferDesc_st._fields_ = [
('offset', ctypes.c_uint64),
('size', ctypes.c_uint64),
('flags', ctypes.c_uint32),
('PADDING_0', ctypes.c_ubyte * 4),
]
hipExternalMemoryBufferDesc = struct_hipExternalMemoryBufferDesc_st
hipExternalMemory_t = ctypes.POINTER(None)
# values for enumeration 'hipExternalSemaphoreHandleType_enum'
hipExternalSemaphoreHandleType_enum__enumvalues = {
1: 'hipExternalSemaphoreHandleTypeOpaqueFd',
2: 'hipExternalSemaphoreHandleTypeOpaqueWin32',
3: 'hipExternalSemaphoreHandleTypeOpaqueWin32Kmt',
4: 'hipExternalSemaphoreHandleTypeD3D12Fence',
}
hipExternalSemaphoreHandleTypeOpaqueFd = 1
hipExternalSemaphoreHandleTypeOpaqueWin32 = 2
hipExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3
hipExternalSemaphoreHandleTypeD3D12Fence = 4
hipExternalSemaphoreHandleType_enum = ctypes.c_uint32 # enum
hipExternalSemaphoreHandleType = hipExternalSemaphoreHandleType_enum
hipExternalSemaphoreHandleType__enumvalues = hipExternalSemaphoreHandleType_enum__enumvalues
class struct_hipExternalSemaphoreHandleDesc_st(Structure):
pass
class union_hipExternalSemaphoreHandleDesc_st_handle(Union):
pass
class struct_hipExternalSemaphoreHandleDesc_st_0_win32(Structure):
pass
struct_hipExternalSemaphoreHandleDesc_st_0_win32._pack_ = 1 # source:False
struct_hipExternalSemaphoreHandleDesc_st_0_win32._fields_ = [
('handle', ctypes.POINTER(None)),
('name', ctypes.POINTER(None)),
]
union_hipExternalSemaphoreHandleDesc_st_handle._pack_ = 1 # source:False
union_hipExternalSemaphoreHandleDesc_st_handle._fields_ = [
('fd', ctypes.c_int32),
('win32', struct_hipExternalSemaphoreHandleDesc_st_0_win32),
]
struct_hipExternalSemaphoreHandleDesc_st._pack_ = 1 # source:False
struct_hipExternalSemaphoreHandleDesc_st._fields_ = [
('type', hipExternalSemaphoreHandleType),
('PADDING_0', ctypes.c_ubyte * 4),
('handle', union_hipExternalSemaphoreHandleDesc_st_handle),
('flags', ctypes.c_uint32),
('PADDING_1', ctypes.c_ubyte * 4),
]
hipExternalSemaphoreHandleDesc = struct_hipExternalSemaphoreHandleDesc_st
hipExternalSemaphore_t = ctypes.POINTER(None)
class struct_hipExternalSemaphoreSignalParams_st(Structure):
pass
class struct_hipExternalSemaphoreSignalParams_st_params(Structure):
pass
class struct_hipExternalSemaphoreSignalParams_st_0_fence(Structure):
pass
struct_hipExternalSemaphoreSignalParams_st_0_fence._pack_ = 1 # source:False
struct_hipExternalSemaphoreSignalParams_st_0_fence._fields_ = [
('value', ctypes.c_uint64),
]
class struct_hipExternalSemaphoreSignalParams_st_0_keyedMutex(Structure):
pass
struct_hipExternalSemaphoreSignalParams_st_0_keyedMutex._pack_ = 1 # source:False
struct_hipExternalSemaphoreSignalParams_st_0_keyedMutex._fields_ = [
('key', ctypes.c_uint64),
]
struct_hipExternalSemaphoreSignalParams_st_params._pack_ = 1 # source:False
struct_hipExternalSemaphoreSignalParams_st_params._fields_ = [
('fence', struct_hipExternalSemaphoreSignalParams_st_0_fence),
('keyedMutex', struct_hipExternalSemaphoreSignalParams_st_0_keyedMutex),
('reserved', ctypes.c_uint32 * 12),
]
struct_hipExternalSemaphoreSignalParams_st._pack_ = 1 # source:False
struct_hipExternalSemaphoreSignalParams_st._fields_ = [
('params', struct_hipExternalSemaphoreSignalParams_st_params),
('flags', ctypes.c_uint32),
('reserved', ctypes.c_uint32 * 16),
('PADDING_0', ctypes.c_ubyte * 4),
]
hipExternalSemaphoreSignalParams = struct_hipExternalSemaphoreSignalParams_st
class struct_hipExternalSemaphoreWaitParams_st(Structure):
pass
class struct_hipExternalSemaphoreWaitParams_st_params(Structure):
pass
class struct_hipExternalSemaphoreWaitParams_st_0_keyedMutex(Structure):
pass
struct_hipExternalSemaphoreWaitParams_st_0_keyedMutex._pack_ = 1 # source:False
struct_hipExternalSemaphoreWaitParams_st_0_keyedMutex._fields_ = [
('key', ctypes.c_uint64),
('timeoutMs', ctypes.c_uint32),
('PADDING_0', ctypes.c_ubyte * 4),
]
class struct_hipExternalSemaphoreWaitParams_st_0_fence(Structure):
pass
struct_hipExternalSemaphoreWaitParams_st_0_fence._pack_ = 1 # source:False
struct_hipExternalSemaphoreWaitParams_st_0_fence._fields_ = [
('value', ctypes.c_uint64),
]
struct_hipExternalSemaphoreWaitParams_st_params._pack_ = 1 # source:False
struct_hipExternalSemaphoreWaitParams_st_params._fields_ = [
('fence', struct_hipExternalSemaphoreWaitParams_st_0_fence),
('keyedMutex', struct_hipExternalSemaphoreWaitParams_st_0_keyedMutex),
('reserved', ctypes.c_uint32 * 10),
]
struct_hipExternalSemaphoreWaitParams_st._pack_ = 1 # source:False
struct_hipExternalSemaphoreWaitParams_st._fields_ = [
('params', struct_hipExternalSemaphoreWaitParams_st_params),
('flags', ctypes.c_uint32),
('reserved', ctypes.c_uint32 * 16),
('PADDING_0', ctypes.c_ubyte * 4),
]
hipExternalSemaphoreWaitParams = struct_hipExternalSemaphoreWaitParams_st
__hipGetPCH = _libraries['libamdhip64.so'].__hipGetPCH
__hipGetPCH.restype = None
__hipGetPCH.argtypes = [ctypes.POINTER(ctypes.POINTER(ctypes.c_char)), ctypes.POINTER(ctypes.c_uint32)]
# values for enumeration 'hipGLDeviceList'
hipGLDeviceList__enumvalues = {
1: 'hipGLDeviceListAll',
2: 'hipGLDeviceListCurrentFrame',
3: 'hipGLDeviceListNextFrame',
}
hipGLDeviceListAll = 1
hipGLDeviceListCurrentFrame = 2
hipGLDeviceListNextFrame = 3
hipGLDeviceList = ctypes.c_uint32 # enum
# values for enumeration 'hipGraphicsRegisterFlags'
hipGraphicsRegisterFlags__enumvalues = {
0: 'hipGraphicsRegisterFlagsNone',
1: 'hipGraphicsRegisterFlagsReadOnly',
2: 'hipGraphicsRegisterFlagsWriteDiscard',
4: 'hipGraphicsRegisterFlagsSurfaceLoadStore',
8: 'hipGraphicsRegisterFlagsTextureGather',
}
hipGraphicsRegisterFlagsNone = 0
hipGraphicsRegisterFlagsReadOnly = 1
hipGraphicsRegisterFlagsWriteDiscard = 2
hipGraphicsRegisterFlagsSurfaceLoadStore = 4
hipGraphicsRegisterFlagsTextureGather = 8
hipGraphicsRegisterFlags = ctypes.c_uint32 # enum
class struct__hipGraphicsResource(Structure):
pass
hipGraphicsResource = struct__hipGraphicsResource
hipGraphicsResource_t = ctypes.POINTER(struct__hipGraphicsResource)
class struct_ihipGraph(Structure):
pass
hipGraph_t = ctypes.POINTER(struct_ihipGraph)
class struct_hipGraphNode(Structure):
pass
hipGraphNode_t = ctypes.POINTER(struct_hipGraphNode)
class struct_hipGraphExec(Structure):
pass
hipGraphExec_t = ctypes.POINTER(struct_hipGraphExec)
class struct_hipUserObject(Structure):
pass
hipUserObject_t = ctypes.POINTER(struct_hipUserObject)
# values for enumeration 'hipGraphNodeType'
hipGraphNodeType__enumvalues = {
0: 'hipGraphNodeTypeKernel',
1: 'hipGraphNodeTypeMemcpy',
2: 'hipGraphNodeTypeMemset',
3: 'hipGraphNodeTypeHost',
4: 'hipGraphNodeTypeGraph',
5: 'hipGraphNodeTypeEmpty',
6: 'hipGraphNodeTypeWaitEvent',
7: 'hipGraphNodeTypeEventRecord',
8: 'hipGraphNodeTypeExtSemaphoreSignal',
9: 'hipGraphNodeTypeExtSemaphoreWait',
10: 'hipGraphNodeTypeMemAlloc',
11: 'hipGraphNodeTypeMemFree',
12: 'hipGraphNodeTypeMemcpyFromSymbol',
13: 'hipGraphNodeTypeMemcpyToSymbol',
14: 'hipGraphNodeTypeCount',
}
hipGraphNodeTypeKernel = 0
hipGraphNodeTypeMemcpy = 1
hipGraphNodeTypeMemset = 2
hipGraphNodeTypeHost = 3
hipGraphNodeTypeGraph = 4
hipGraphNodeTypeEmpty = 5
hipGraphNodeTypeWaitEvent = 6
hipGraphNodeTypeEventRecord = 7
hipGraphNodeTypeExtSemaphoreSignal = 8
hipGraphNodeTypeExtSemaphoreWait = 9
hipGraphNodeTypeMemAlloc = 10
hipGraphNodeTypeMemFree = 11
hipGraphNodeTypeMemcpyFromSymbol = 12
hipGraphNodeTypeMemcpyToSymbol = 13
hipGraphNodeTypeCount = 14
hipGraphNodeType = ctypes.c_uint32 # enum
hipHostFn_t = ctypes.CFUNCTYPE(None, ctypes.POINTER(None))
class struct_hipHostNodeParams(Structure):
pass
struct_hipHostNodeParams._pack_ = 1 # source:False
struct_hipHostNodeParams._fields_ = [
('fn', ctypes.CFUNCTYPE(None, ctypes.POINTER(None))),
('userData', ctypes.POINTER(None)),
]
hipHostNodeParams = struct_hipHostNodeParams
class struct_hipKernelNodeParams(Structure):
pass
struct_hipKernelNodeParams._pack_ = 1 # source:False
struct_hipKernelNodeParams._fields_ = [
('blockDim', dim3),
('PADDING_0', ctypes.c_ubyte * 4),
('extra', ctypes.POINTER(ctypes.POINTER(None))),
('func', ctypes.POINTER(None)),
('gridDim', dim3),
('PADDING_1', ctypes.c_ubyte * 4),
('kernelParams', ctypes.POINTER(ctypes.POINTER(None))),
('sharedMemBytes', ctypes.c_uint32),
('PADDING_2', ctypes.c_ubyte * 4),
]
hipKernelNodeParams = struct_hipKernelNodeParams
class struct_hipMemsetParams(Structure):
pass
struct_hipMemsetParams._pack_ = 1 # source:False
struct_hipMemsetParams._fields_ = [
('dst', ctypes.POINTER(None)),
('elementSize', ctypes.c_uint32),
('PADDING_0', ctypes.c_ubyte * 4),
('height', ctypes.c_uint64),
('pitch', ctypes.c_uint64),
('value', ctypes.c_uint32),
('PADDING_1', ctypes.c_ubyte * 4),
('width', ctypes.c_uint64),
]
hipMemsetParams = struct_hipMemsetParams
class struct_hipMemAllocNodeParams(Structure):
pass
struct_hipMemAllocNodeParams._pack_ = 1 # source:False
struct_hipMemAllocNodeParams._fields_ = [
('poolProps', hipMemPoolProps),
('accessDescs', ctypes.POINTER(struct_hipMemAccessDesc)),
('accessDescCount', ctypes.c_uint64),
('bytesize', ctypes.c_uint64),
('dptr', ctypes.POINTER(None)),
]
hipMemAllocNodeParams = struct_hipMemAllocNodeParams
# values for enumeration 'hipKernelNodeAttrID'
hipKernelNodeAttrID__enumvalues = {
1: 'hipKernelNodeAttributeAccessPolicyWindow',
2: 'hipKernelNodeAttributeCooperative',
}
hipKernelNodeAttributeAccessPolicyWindow = 1
hipKernelNodeAttributeCooperative = 2
hipKernelNodeAttrID = ctypes.c_uint32 # enum
# values for enumeration 'hipAccessProperty'
hipAccessProperty__enumvalues = {
0: 'hipAccessPropertyNormal',
1: 'hipAccessPropertyStreaming',
2: 'hipAccessPropertyPersisting',
}
hipAccessPropertyNormal = 0
hipAccessPropertyStreaming = 1
hipAccessPropertyPersisting = 2
hipAccessProperty = ctypes.c_uint32 # enum
class struct_hipAccessPolicyWindow(Structure):
pass
struct_hipAccessPolicyWindow._pack_ = 1 # source:False
struct_hipAccessPolicyWindow._fields_ = [
('base_ptr', ctypes.POINTER(None)),
('hitProp', hipAccessProperty),
('hitRatio', ctypes.c_float),
('missProp', hipAccessProperty),
('PADDING_0', ctypes.c_ubyte * 4),
('num_bytes', ctypes.c_uint64),
]
hipAccessPolicyWindow = struct_hipAccessPolicyWindow
class union_hipKernelNodeAttrValue(Union):
pass
union_hipKernelNodeAttrValue._pack_ = 1 # source:False
union_hipKernelNodeAttrValue._fields_ = [
('accessPolicyWindow', hipAccessPolicyWindow),
('cooperative', ctypes.c_int32),
('PADDING_0', ctypes.c_ubyte * 28),
]
hipKernelNodeAttrValue = union_hipKernelNodeAttrValue
# values for enumeration 'hipGraphExecUpdateResult'
hipGraphExecUpdateResult__enumvalues = {
0: 'hipGraphExecUpdateSuccess',
1: 'hipGraphExecUpdateError',
2: 'hipGraphExecUpdateErrorTopologyChanged',
3: 'hipGraphExecUpdateErrorNodeTypeChanged',
4: 'hipGraphExecUpdateErrorFunctionChanged',
5: 'hipGraphExecUpdateErrorParametersChanged',
6: 'hipGraphExecUpdateErrorNotSupported',
7: 'hipGraphExecUpdateErrorUnsupportedFunctionChange',
}
hipGraphExecUpdateSuccess = 0
hipGraphExecUpdateError = 1
hipGraphExecUpdateErrorTopologyChanged = 2
hipGraphExecUpdateErrorNodeTypeChanged = 3
hipGraphExecUpdateErrorFunctionChanged = 4
hipGraphExecUpdateErrorParametersChanged = 5
hipGraphExecUpdateErrorNotSupported = 6
hipGraphExecUpdateErrorUnsupportedFunctionChange = 7
hipGraphExecUpdateResult = ctypes.c_uint32 # enum
# values for enumeration 'hipStreamCaptureMode'
hipStreamCaptureMode__enumvalues = {
0: 'hipStreamCaptureModeGlobal',
1: 'hipStreamCaptureModeThreadLocal',
2: 'hipStreamCaptureModeRelaxed',
}
hipStreamCaptureModeGlobal = 0
hipStreamCaptureModeThreadLocal = 1
hipStreamCaptureModeRelaxed = 2
hipStreamCaptureMode = ctypes.c_uint32 # enum
# values for enumeration 'hipStreamCaptureStatus'
hipStreamCaptureStatus__enumvalues = {
0: 'hipStreamCaptureStatusNone',
1: 'hipStreamCaptureStatusActive',
2: 'hipStreamCaptureStatusInvalidated',
}
hipStreamCaptureStatusNone = 0
hipStreamCaptureStatusActive = 1
hipStreamCaptureStatusInvalidated = 2
hipStreamCaptureStatus = ctypes.c_uint32 # enum
# values for enumeration 'hipStreamUpdateCaptureDependenciesFlags'
hipStreamUpdateCaptureDependenciesFlags__enumvalues = {
0: 'hipStreamAddCaptureDependencies',
1: 'hipStreamSetCaptureDependencies',
}
hipStreamAddCaptureDependencies = 0
hipStreamSetCaptureDependencies = 1
hipStreamUpdateCaptureDependenciesFlags = ctypes.c_uint32 # enum
# values for enumeration 'hipGraphMemAttributeType'
hipGraphMemAttributeType__enumvalues = {
0: 'hipGraphMemAttrUsedMemCurrent',
1: 'hipGraphMemAttrUsedMemHigh',
2: 'hipGraphMemAttrReservedMemCurrent',
3: 'hipGraphMemAttrReservedMemHigh',
}
hipGraphMemAttrUsedMemCurrent = 0
hipGraphMemAttrUsedMemHigh = 1
hipGraphMemAttrReservedMemCurrent = 2
hipGraphMemAttrReservedMemHigh = 3
hipGraphMemAttributeType = ctypes.c_uint32 # enum
# values for enumeration 'hipUserObjectFlags'
hipUserObjectFlags__enumvalues = {
1: 'hipUserObjectNoDestructorSync',
}
hipUserObjectNoDestructorSync = 1
hipUserObjectFlags = ctypes.c_uint32 # enum
# values for enumeration 'hipUserObjectRetainFlags'
hipUserObjectRetainFlags__enumvalues = {
1: 'hipGraphUserObjectMove',
}
hipGraphUserObjectMove = 1
hipUserObjectRetainFlags = ctypes.c_uint32 # enum
# values for enumeration 'hipGraphInstantiateFlags'
hipGraphInstantiateFlags__enumvalues = {
1: 'hipGraphInstantiateFlagAutoFreeOnLaunch',
2: 'hipGraphInstantiateFlagUpload',
4: 'hipGraphInstantiateFlagDeviceLaunch',
8: 'hipGraphInstantiateFlagUseNodePriority',
}
hipGraphInstantiateFlagAutoFreeOnLaunch = 1
hipGraphInstantiateFlagUpload = 2
hipGraphInstantiateFlagDeviceLaunch = 4
hipGraphInstantiateFlagUseNodePriority = 8
hipGraphInstantiateFlags = ctypes.c_uint32 # enum
# values for enumeration 'hipGraphDebugDotFlags'
hipGraphDebugDotFlags__enumvalues = {
1: 'hipGraphDebugDotFlagsVerbose',
4: 'hipGraphDebugDotFlagsKernelNodeParams',
8: 'hipGraphDebugDotFlagsMemcpyNodeParams',
16: 'hipGraphDebugDotFlagsMemsetNodeParams',
32: 'hipGraphDebugDotFlagsHostNodeParams',
64: 'hipGraphDebugDotFlagsEventNodeParams',
128: 'hipGraphDebugDotFlagsExtSemasSignalNodeParams',
256: 'hipGraphDebugDotFlagsExtSemasWaitNodeParams',
512: 'hipGraphDebugDotFlagsKernelNodeAttributes',
1024: 'hipGraphDebugDotFlagsHandles',
}
hipGraphDebugDotFlagsVerbose = 1
hipGraphDebugDotFlagsKernelNodeParams = 4
hipGraphDebugDotFlagsMemcpyNodeParams = 8
hipGraphDebugDotFlagsMemsetNodeParams = 16
hipGraphDebugDotFlagsHostNodeParams = 32
hipGraphDebugDotFlagsEventNodeParams = 64
hipGraphDebugDotFlagsExtSemasSignalNodeParams = 128
hipGraphDebugDotFlagsExtSemasWaitNodeParams = 256
hipGraphDebugDotFlagsKernelNodeAttributes = 512
hipGraphDebugDotFlagsHandles = 1024
hipGraphDebugDotFlags = ctypes.c_uint32 # enum
class struct_hipMemAllocationProp(Structure):
pass
class struct_hipMemAllocationProp_allocFlags(Structure):
pass
struct_hipMemAllocationProp_allocFlags._pack_ = 1 # source:False
struct_hipMemAllocationProp_allocFlags._fields_ = [
('compressionType', ctypes.c_ubyte),
('gpuDirectRDMACapable', ctypes.c_ubyte),
('usage', ctypes.c_uint16),
]
struct_hipMemAllocationProp._pack_ = 1 # source:False
struct_hipMemAllocationProp._fields_ = [
('type', hipMemAllocationType),
('requestedHandleType', hipMemAllocationHandleType),
('location', hipMemLocation),
('win32HandleMetaData', ctypes.POINTER(None)),
('allocFlags', struct_hipMemAllocationProp_allocFlags),
('PADDING_0', ctypes.c_ubyte * 4),
]
hipMemAllocationProp = struct_hipMemAllocationProp
class struct_hipExternalSemaphoreSignalNodeParams(Structure):
pass
struct_hipExternalSemaphoreSignalNodeParams._pack_ = 1 # source:False
struct_hipExternalSemaphoreSignalNodeParams._fields_ = [
('extSemArray', ctypes.POINTER(ctypes.POINTER(None))),
('paramsArray', ctypes.POINTER(struct_hipExternalSemaphoreSignalParams_st)),
('numExtSems', ctypes.c_uint32),
('PADDING_0', ctypes.c_ubyte * 4),
]
hipExternalSemaphoreSignalNodeParams = struct_hipExternalSemaphoreSignalNodeParams
class struct_hipExternalSemaphoreWaitNodeParams(Structure):
pass
struct_hipExternalSemaphoreWaitNodeParams._pack_ = 1 # source:False
struct_hipExternalSemaphoreWaitNodeParams._fields_ = [
('extSemArray', ctypes.POINTER(ctypes.POINTER(None))),
('paramsArray', ctypes.POINTER(struct_hipExternalSemaphoreWaitParams_st)),
('numExtSems', ctypes.c_uint32),
('PADDING_0', ctypes.c_ubyte * 4),
]
hipExternalSemaphoreWaitNodeParams = struct_hipExternalSemaphoreWaitNodeParams
class struct_ihipMemGenericAllocationHandle(Structure):
pass
hipMemGenericAllocationHandle_t = ctypes.POINTER(struct_ihipMemGenericAllocationHandle)
# values for enumeration 'hipMemAllocationGranularity_flags'
hipMemAllocationGranularity_flags__enumvalues = {
0: 'hipMemAllocationGranularityMinimum',
1: 'hipMemAllocationGranularityRecommended',
}
hipMemAllocationGranularityMinimum = 0
hipMemAllocationGranularityRecommended = 1
hipMemAllocationGranularity_flags = ctypes.c_uint32 # enum
# values for enumeration 'hipMemHandleType'
hipMemHandleType__enumvalues = {
0: 'hipMemHandleTypeGeneric',
}
hipMemHandleTypeGeneric = 0
hipMemHandleType = ctypes.c_uint32 # enum
# values for enumeration 'hipMemOperationType'
hipMemOperationType__enumvalues = {
1: 'hipMemOperationTypeMap',
2: 'hipMemOperationTypeUnmap',
}
hipMemOperationTypeMap = 1
hipMemOperationTypeUnmap = 2
hipMemOperationType = ctypes.c_uint32 # enum
# values for enumeration 'hipArraySparseSubresourceType'
hipArraySparseSubresourceType__enumvalues = {
0: 'hipArraySparseSubresourceTypeSparseLevel',
1: 'hipArraySparseSubresourceTypeMiptail',
}
hipArraySparseSubresourceTypeSparseLevel = 0
hipArraySparseSubresourceTypeMiptail = 1
hipArraySparseSubresourceType = ctypes.c_uint32 # enum
class struct_hipArrayMapInfo(Structure):
pass
class union_hipArrayMapInfo_resource(Union):
pass
union_hipArrayMapInfo_resource._pack_ = 1 # source:False
union_hipArrayMapInfo_resource._fields_ = [
('mipmap', hipMipmappedArray),
('array', ctypes.POINTER(struct_hipArray)),
('PADDING_0', ctypes.c_ubyte * 56),
]
class union_hipArrayMapInfo_subresource(Union):
pass
class struct_hipArrayMapInfo_1_sparseLevel(Structure):
pass
struct_hipArrayMapInfo_1_sparseLevel._pack_ = 1 # source:False
struct_hipArrayMapInfo_1_sparseLevel._fields_ = [
('level', ctypes.c_uint32),
('layer', ctypes.c_uint32),
('offsetX', ctypes.c_uint32),
('offsetY', ctypes.c_uint32),
('offsetZ', ctypes.c_uint32),
('extentWidth', ctypes.c_uint32),
('extentHeight', ctypes.c_uint32),
('extentDepth', ctypes.c_uint32),
]
class struct_hipArrayMapInfo_1_miptail(Structure):
pass
struct_hipArrayMapInfo_1_miptail._pack_ = 1 # source:False
struct_hipArrayMapInfo_1_miptail._fields_ = [
('layer', ctypes.c_uint32),
('PADDING_0', ctypes.c_ubyte * 4),
('offset', ctypes.c_uint64),
('size', ctypes.c_uint64),
]
union_hipArrayMapInfo_subresource._pack_ = 1 # source:False
union_hipArrayMapInfo_subresource._fields_ = [
('sparseLevel', struct_hipArrayMapInfo_1_sparseLevel),
('miptail', struct_hipArrayMapInfo_1_miptail),
('PADDING_0', ctypes.c_ubyte * 8),
]
class union_hipArrayMapInfo_memHandle(Union):
pass
union_hipArrayMapInfo_memHandle._pack_ = 1 # source:False
union_hipArrayMapInfo_memHandle._fields_ = [
('memHandle', ctypes.POINTER(struct_ihipMemGenericAllocationHandle)),
]
struct_hipArrayMapInfo._pack_ = 1 # source:False
struct_hipArrayMapInfo._fields_ = [
('resourceType', hipResourceType),
('PADDING_0', ctypes.c_ubyte * 4),
('resource', union_hipArrayMapInfo_resource),
('subresourceType', hipArraySparseSubresourceType),
('PADDING_1', ctypes.c_ubyte * 4),
('subresource', union_hipArrayMapInfo_subresource),
('memOperationType', hipMemOperationType),
('memHandleType', hipMemHandleType),
('memHandle', union_hipArrayMapInfo_memHandle),
('offset', ctypes.c_uint64),
('deviceBitMask', ctypes.c_uint32),
('flags', ctypes.c_uint32),
('reserved', ctypes.c_uint32 * 2),
]
hipArrayMapInfo = struct_hipArrayMapInfo
hipInit = _libraries['libamdhip64.so'].hipInit
hipInit.restype = hipError_t
hipInit.argtypes = [ctypes.c_uint32]
hipDriverGetVersion = _libraries['libamdhip64.so'].hipDriverGetVersion
hipDriverGetVersion.restype = hipError_t
hipDriverGetVersion.argtypes = [ctypes.POINTER(ctypes.c_int32)]
hipRuntimeGetVersion = _libraries['libamdhip64.so'].hipRuntimeGetVersion
hipRuntimeGetVersion.restype = hipError_t
hipRuntimeGetVersion.argtypes = [ctypes.POINTER(ctypes.c_int32)]
hipDeviceGet = _libraries['libamdhip64.so'].hipDeviceGet
hipDeviceGet.restype = hipError_t
hipDeviceGet.argtypes = [ctypes.POINTER(ctypes.c_int32), ctypes.c_int32]
hipDeviceComputeCapability = _libraries['libamdhip64.so'].hipDeviceComputeCapability
hipDeviceComputeCapability.restype = hipError_t
hipDeviceComputeCapability.argtypes = [ctypes.POINTER(ctypes.c_int32), ctypes.POINTER(ctypes.c_int32), hipDevice_t]
hipDeviceGetName = _libraries['libamdhip64.so'].hipDeviceGetName
hipDeviceGetName.restype = hipError_t
hipDeviceGetName.argtypes = [ctypes.POINTER(ctypes.c_char), ctypes.c_int32, hipDevice_t]
hipDeviceGetUuid = _libraries['libamdhip64.so'].hipDeviceGetUuid
hipDeviceGetUuid.restype = hipError_t
hipDeviceGetUuid.argtypes = [ctypes.POINTER(struct_hipUUID_t), hipDevice_t]
hipDeviceGetP2PAttribute = _libraries['libamdhip64.so'].hipDeviceGetP2PAttribute
hipDeviceGetP2PAttribute.restype = hipError_t
hipDeviceGetP2PAttribute.argtypes = [ctypes.POINTER(ctypes.c_int32), hipDeviceP2PAttr, ctypes.c_int32, ctypes.c_int32]
hipDeviceGetPCIBusId = _libraries['libamdhip64.so'].hipDeviceGetPCIBusId
hipDeviceGetPCIBusId.restype = hipError_t
hipDeviceGetPCIBusId.argtypes = [ctypes.POINTER(ctypes.c_char), ctypes.c_int32, ctypes.c_int32]
hipDeviceGetByPCIBusId = _libraries['libamdhip64.so'].hipDeviceGetByPCIBusId
hipDeviceGetByPCIBusId.restype = hipError_t
hipDeviceGetByPCIBusId.argtypes = [ctypes.POINTER(ctypes.c_int32), ctypes.POINTER(ctypes.c_char)]
hipDeviceTotalMem = _libraries['libamdhip64.so'].hipDeviceTotalMem
hipDeviceTotalMem.restype = hipError_t
hipDeviceTotalMem.argtypes = [ctypes.POINTER(ctypes.c_uint64), hipDevice_t]
hipDeviceSynchronize = _libraries['libamdhip64.so'].hipDeviceSynchronize
hipDeviceSynchronize.restype = hipError_t
hipDeviceSynchronize.argtypes = []
hipDeviceReset = _libraries['libamdhip64.so'].hipDeviceReset
hipDeviceReset.restype = hipError_t
hipDeviceReset.argtypes = []
hipSetDevice = _libraries['libamdhip64.so'].hipSetDevice
hipSetDevice.restype = hipError_t
hipSetDevice.argtypes = [ctypes.c_int32]
hipGetDevice = _libraries['libamdhip64.so'].hipGetDevice
hipGetDevice.restype = hipError_t
hipGetDevice.argtypes = [ctypes.POINTER(ctypes.c_int32)]
hipGetDeviceCount = _libraries['libamdhip64.so'].hipGetDeviceCount
hipGetDeviceCount.restype = hipError_t
hipGetDeviceCount.argtypes = [ctypes.POINTER(ctypes.c_int32)]
hipDeviceGetAttribute = _libraries['libamdhip64.so'].hipDeviceGetAttribute
hipDeviceGetAttribute.restype = hipError_t
hipDeviceGetAttribute.argtypes = [ctypes.POINTER(ctypes.c_int32), hipDeviceAttribute_t, ctypes.c_int32]
hipDeviceGetDefaultMemPool = _libraries['libamdhip64.so'].hipDeviceGetDefaultMemPool
hipDeviceGetDefaultMemPool.restype = hipError_t
hipDeviceGetDefaultMemPool.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipMemPoolHandle_t)), ctypes.c_int32]
hipDeviceSetMemPool = _libraries['libamdhip64.so'].hipDeviceSetMemPool
hipDeviceSetMemPool.restype = hipError_t
hipDeviceSetMemPool.argtypes = [ctypes.c_int32, hipMemPool_t]
hipDeviceGetMemPool = _libraries['libamdhip64.so'].hipDeviceGetMemPool
hipDeviceGetMemPool.restype = hipError_t
hipDeviceGetMemPool.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipMemPoolHandle_t)), ctypes.c_int32]
hipGetDeviceProperties = _libraries['libamdhip64.so'].hipGetDeviceProperties
hipGetDeviceProperties.restype = hipError_t
hipGetDeviceProperties.argtypes = [ctypes.POINTER(struct_hipDeviceProp_t), ctypes.c_int32]
hipDeviceSetCacheConfig = _libraries['libamdhip64.so'].hipDeviceSetCacheConfig
hipDeviceSetCacheConfig.restype = hipError_t
hipDeviceSetCacheConfig.argtypes = [hipFuncCache_t]
hipDeviceGetCacheConfig = _libraries['libamdhip64.so'].hipDeviceGetCacheConfig
hipDeviceGetCacheConfig.restype = hipError_t
hipDeviceGetCacheConfig.argtypes = [ctypes.POINTER(hipFuncCache_t)]
hipDeviceGetLimit = _libraries['libamdhip64.so'].hipDeviceGetLimit
hipDeviceGetLimit.restype = hipError_t
hipDeviceGetLimit.argtypes = [ctypes.POINTER(ctypes.c_uint64), hipLimit_t]
hipDeviceSetLimit = _libraries['libamdhip64.so'].hipDeviceSetLimit
hipDeviceSetLimit.restype = hipError_t
hipDeviceSetLimit.argtypes = [hipLimit_t, size_t]
hipDeviceGetSharedMemConfig = _libraries['libamdhip64.so'].hipDeviceGetSharedMemConfig
hipDeviceGetSharedMemConfig.restype = hipError_t
hipDeviceGetSharedMemConfig.argtypes = [ctypes.POINTER(hipSharedMemConfig)]
hipGetDeviceFlags = _libraries['libamdhip64.so'].hipGetDeviceFlags
hipGetDeviceFlags.restype = hipError_t
hipGetDeviceFlags.argtypes = [ctypes.POINTER(ctypes.c_uint32)]
hipDeviceSetSharedMemConfig = _libraries['libamdhip64.so'].hipDeviceSetSharedMemConfig
hipDeviceSetSharedMemConfig.restype = hipError_t
hipDeviceSetSharedMemConfig.argtypes = [hipSharedMemConfig]
hipSetDeviceFlags = _libraries['libamdhip64.so'].hipSetDeviceFlags
hipSetDeviceFlags.restype = hipError_t
hipSetDeviceFlags.argtypes = [ctypes.c_uint32]
hipChooseDevice = _libraries['libamdhip64.so'].hipChooseDevice
hipChooseDevice.restype = hipError_t
hipChooseDevice.argtypes = [ctypes.POINTER(ctypes.c_int32), ctypes.POINTER(struct_hipDeviceProp_t)]
hipExtGetLinkTypeAndHopCount = _libraries['libamdhip64.so'].hipExtGetLinkTypeAndHopCount
hipExtGetLinkTypeAndHopCount.restype = hipError_t
hipExtGetLinkTypeAndHopCount.argtypes = [ctypes.c_int32, ctypes.c_int32, ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_uint32)]
hipIpcGetMemHandle = _libraries['libamdhip64.so'].hipIpcGetMemHandle
hipIpcGetMemHandle.restype = hipError_t
hipIpcGetMemHandle.argtypes = [ctypes.POINTER(struct_hipIpcMemHandle_st), ctypes.POINTER(None)]
hipIpcOpenMemHandle = _libraries['libamdhip64.so'].hipIpcOpenMemHandle
hipIpcOpenMemHandle.restype = hipError_t
hipIpcOpenMemHandle.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), hipIpcMemHandle_t, ctypes.c_uint32]
hipIpcCloseMemHandle = _libraries['libamdhip64.so'].hipIpcCloseMemHandle
hipIpcCloseMemHandle.restype = hipError_t
hipIpcCloseMemHandle.argtypes = [ctypes.POINTER(None)]
hipIpcGetEventHandle = _libraries['libamdhip64.so'].hipIpcGetEventHandle
hipIpcGetEventHandle.restype = hipError_t
hipIpcGetEventHandle.argtypes = [ctypes.POINTER(struct_hipIpcEventHandle_st), hipEvent_t]
hipIpcOpenEventHandle = _libraries['libamdhip64.so'].hipIpcOpenEventHandle
hipIpcOpenEventHandle.restype = hipError_t
hipIpcOpenEventHandle.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipEvent_t)), hipIpcEventHandle_t]
hipFuncSetAttribute = _libraries['libamdhip64.so'].hipFuncSetAttribute
hipFuncSetAttribute.restype = hipError_t
hipFuncSetAttribute.argtypes = [ctypes.POINTER(None), hipFuncAttribute, ctypes.c_int32]
hipFuncSetCacheConfig = _libraries['libamdhip64.so'].hipFuncSetCacheConfig
hipFuncSetCacheConfig.restype = hipError_t
hipFuncSetCacheConfig.argtypes = [ctypes.POINTER(None), hipFuncCache_t]
hipFuncSetSharedMemConfig = _libraries['libamdhip64.so'].hipFuncSetSharedMemConfig
hipFuncSetSharedMemConfig.restype = hipError_t
hipFuncSetSharedMemConfig.argtypes = [ctypes.POINTER(None), hipSharedMemConfig]
hipGetLastError = _libraries['libamdhip64.so'].hipGetLastError
hipGetLastError.restype = hipError_t
hipGetLastError.argtypes = []
hipPeekAtLastError = _libraries['libamdhip64.so'].hipPeekAtLastError
hipPeekAtLastError.restype = hipError_t
hipPeekAtLastError.argtypes = []
hipGetErrorName = _libraries['libamdhip64.so'].hipGetErrorName
hipGetErrorName.restype = ctypes.POINTER(ctypes.c_char)
hipGetErrorName.argtypes = [hipError_t]
hipGetErrorString = _libraries['libamdhip64.so'].hipGetErrorString
hipGetErrorString.restype = ctypes.POINTER(ctypes.c_char)
hipGetErrorString.argtypes = [hipError_t]
hipDrvGetErrorName = _libraries['libamdhip64.so'].hipDrvGetErrorName
hipDrvGetErrorName.restype = hipError_t
hipDrvGetErrorName.argtypes = [hipError_t, ctypes.POINTER(ctypes.POINTER(ctypes.c_char))]
hipDrvGetErrorString = _libraries['libamdhip64.so'].hipDrvGetErrorString
hipDrvGetErrorString.restype = hipError_t
hipDrvGetErrorString.argtypes = [hipError_t, ctypes.POINTER(ctypes.POINTER(ctypes.c_char))]
hipStreamCreate = _libraries['libamdhip64.so'].hipStreamCreate
hipStreamCreate.restype = hipError_t
hipStreamCreate.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipStream_t))]
hipStreamCreateWithFlags = _libraries['libamdhip64.so'].hipStreamCreateWithFlags
hipStreamCreateWithFlags.restype = hipError_t
hipStreamCreateWithFlags.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipStream_t)), ctypes.c_uint32]
hipStreamCreateWithPriority = _libraries['libamdhip64.so'].hipStreamCreateWithPriority
hipStreamCreateWithPriority.restype = hipError_t
hipStreamCreateWithPriority.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipStream_t)), ctypes.c_uint32, ctypes.c_int32]
hipDeviceGetStreamPriorityRange = _libraries['libamdhip64.so'].hipDeviceGetStreamPriorityRange
hipDeviceGetStreamPriorityRange.restype = hipError_t
hipDeviceGetStreamPriorityRange.argtypes = [ctypes.POINTER(ctypes.c_int32), ctypes.POINTER(ctypes.c_int32)]
hipStreamDestroy = _libraries['libamdhip64.so'].hipStreamDestroy
hipStreamDestroy.restype = hipError_t
hipStreamDestroy.argtypes = [hipStream_t]
hipStreamQuery = _libraries['libamdhip64.so'].hipStreamQuery
hipStreamQuery.restype = hipError_t
hipStreamQuery.argtypes = [hipStream_t]
hipStreamSynchronize = _libraries['libamdhip64.so'].hipStreamSynchronize
hipStreamSynchronize.restype = hipError_t
hipStreamSynchronize.argtypes = [hipStream_t]
hipStreamWaitEvent = _libraries['libamdhip64.so'].hipStreamWaitEvent
hipStreamWaitEvent.restype = hipError_t
hipStreamWaitEvent.argtypes = [hipStream_t, hipEvent_t, ctypes.c_uint32]
hipStreamGetFlags = _libraries['libamdhip64.so'].hipStreamGetFlags
hipStreamGetFlags.restype = hipError_t
hipStreamGetFlags.argtypes = [hipStream_t, ctypes.POINTER(ctypes.c_uint32)]
hipStreamGetPriority = _libraries['libamdhip64.so'].hipStreamGetPriority
hipStreamGetPriority.restype = hipError_t
hipStreamGetPriority.argtypes = [hipStream_t, ctypes.POINTER(ctypes.c_int32)]
hipStreamGetDevice = _libraries['libamdhip64.so'].hipStreamGetDevice
hipStreamGetDevice.restype = hipError_t
hipStreamGetDevice.argtypes = [hipStream_t, ctypes.POINTER(ctypes.c_int32)]
uint32_t = ctypes.c_uint32
hipExtStreamCreateWithCUMask = _libraries['libamdhip64.so'].hipExtStreamCreateWithCUMask
hipExtStreamCreateWithCUMask.restype = hipError_t
hipExtStreamCreateWithCUMask.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipStream_t)), uint32_t, ctypes.POINTER(ctypes.c_uint32)]
hipExtStreamGetCUMask = _libraries['libamdhip64.so'].hipExtStreamGetCUMask
hipExtStreamGetCUMask.restype = hipError_t
hipExtStreamGetCUMask.argtypes = [hipStream_t, uint32_t, ctypes.POINTER(ctypes.c_uint32)]
hipStreamCallback_t = ctypes.CFUNCTYPE(None, ctypes.POINTER(struct_ihipStream_t), hipError_t, ctypes.POINTER(None))
hipStreamAddCallback = _libraries['libamdhip64.so'].hipStreamAddCallback
hipStreamAddCallback.restype = hipError_t
hipStreamAddCallback.argtypes = [hipStream_t, hipStreamCallback_t, ctypes.POINTER(None), ctypes.c_uint32]
hipStreamWaitValue32 = _libraries['libamdhip64.so'].hipStreamWaitValue32
hipStreamWaitValue32.restype = hipError_t
hipStreamWaitValue32.argtypes = [hipStream_t, ctypes.POINTER(None), uint32_t, ctypes.c_uint32, uint32_t]
uint64_t = ctypes.c_uint64
hipStreamWaitValue64 = _libraries['libamdhip64.so'].hipStreamWaitValue64
hipStreamWaitValue64.restype = hipError_t
hipStreamWaitValue64.argtypes = [hipStream_t, ctypes.POINTER(None), uint64_t, ctypes.c_uint32, uint64_t]
hipStreamWriteValue32 = _libraries['libamdhip64.so'].hipStreamWriteValue32
hipStreamWriteValue32.restype = hipError_t
hipStreamWriteValue32.argtypes = [hipStream_t, ctypes.POINTER(None), uint32_t, ctypes.c_uint32]
hipStreamWriteValue64 = _libraries['libamdhip64.so'].hipStreamWriteValue64
hipStreamWriteValue64.restype = hipError_t
hipStreamWriteValue64.argtypes = [hipStream_t, ctypes.POINTER(None), uint64_t, ctypes.c_uint32]
hipEventCreateWithFlags = _libraries['libamdhip64.so'].hipEventCreateWithFlags
hipEventCreateWithFlags.restype = hipError_t
hipEventCreateWithFlags.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipEvent_t)), ctypes.c_uint32]
hipEventCreate = _libraries['libamdhip64.so'].hipEventCreate
hipEventCreate.restype = hipError_t
hipEventCreate.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipEvent_t))]
hipEventRecord = _libraries['libamdhip64.so'].hipEventRecord
hipEventRecord.restype = hipError_t
hipEventRecord.argtypes = [hipEvent_t, hipStream_t]
hipEventDestroy = _libraries['libamdhip64.so'].hipEventDestroy
hipEventDestroy.restype = hipError_t
hipEventDestroy.argtypes = [hipEvent_t]
hipEventSynchronize = _libraries['libamdhip64.so'].hipEventSynchronize
hipEventSynchronize.restype = hipError_t
hipEventSynchronize.argtypes = [hipEvent_t]
hipEventElapsedTime = _libraries['libamdhip64.so'].hipEventElapsedTime
hipEventElapsedTime.restype = hipError_t
hipEventElapsedTime.argtypes = [ctypes.POINTER(ctypes.c_float), hipEvent_t, hipEvent_t]
hipEventQuery = _libraries['libamdhip64.so'].hipEventQuery
hipEventQuery.restype = hipError_t
hipEventQuery.argtypes = [hipEvent_t]
hipPointerSetAttribute = _libraries['libamdhip64.so'].hipPointerSetAttribute
hipPointerSetAttribute.restype = hipError_t
hipPointerSetAttribute.argtypes = [ctypes.POINTER(None), hipPointer_attribute, hipDeviceptr_t]
hipPointerGetAttributes = _libraries['libamdhip64.so'].hipPointerGetAttributes
hipPointerGetAttributes.restype = hipError_t
hipPointerGetAttributes.argtypes = [ctypes.POINTER(struct_hipPointerAttribute_t), ctypes.POINTER(None)]
hipPointerGetAttribute = _libraries['libamdhip64.so'].hipPointerGetAttribute
hipPointerGetAttribute.restype = hipError_t
hipPointerGetAttribute.argtypes = [ctypes.POINTER(None), hipPointer_attribute, hipDeviceptr_t]
hipDrvPointerGetAttributes = _libraries['libamdhip64.so'].hipDrvPointerGetAttributes
hipDrvPointerGetAttributes.restype = hipError_t
hipDrvPointerGetAttributes.argtypes = [ctypes.c_uint32, ctypes.POINTER(hipPointer_attribute), ctypes.POINTER(ctypes.POINTER(None)), hipDeviceptr_t]
hipImportExternalSemaphore = _libraries['libamdhip64.so'].hipImportExternalSemaphore
hipImportExternalSemaphore.restype = hipError_t
hipImportExternalSemaphore.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(struct_hipExternalSemaphoreHandleDesc_st)]
hipSignalExternalSemaphoresAsync = _libraries['libamdhip64.so'].hipSignalExternalSemaphoresAsync
hipSignalExternalSemaphoresAsync.restype = hipError_t
hipSignalExternalSemaphoresAsync.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(struct_hipExternalSemaphoreSignalParams_st), ctypes.c_uint32, hipStream_t]
hipWaitExternalSemaphoresAsync = _libraries['libamdhip64.so'].hipWaitExternalSemaphoresAsync
hipWaitExternalSemaphoresAsync.restype = hipError_t
hipWaitExternalSemaphoresAsync.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(struct_hipExternalSemaphoreWaitParams_st), ctypes.c_uint32, hipStream_t]
hipDestroyExternalSemaphore = _libraries['libamdhip64.so'].hipDestroyExternalSemaphore
hipDestroyExternalSemaphore.restype = hipError_t
hipDestroyExternalSemaphore.argtypes = [hipExternalSemaphore_t]
hipImportExternalMemory = _libraries['libamdhip64.so'].hipImportExternalMemory
hipImportExternalMemory.restype = hipError_t
hipImportExternalMemory.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(struct_hipExternalMemoryHandleDesc_st)]
hipExternalMemoryGetMappedBuffer = _libraries['libamdhip64.so'].hipExternalMemoryGetMappedBuffer
hipExternalMemoryGetMappedBuffer.restype = hipError_t
hipExternalMemoryGetMappedBuffer.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), hipExternalMemory_t, ctypes.POINTER(struct_hipExternalMemoryBufferDesc_st)]
hipDestroyExternalMemory = _libraries['libamdhip64.so'].hipDestroyExternalMemory
hipDestroyExternalMemory.restype = hipError_t
hipDestroyExternalMemory.argtypes = [hipExternalMemory_t]
hipMalloc = _libraries['libamdhip64.so'].hipMalloc
hipMalloc.restype = hipError_t
hipMalloc.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), size_t]
hipExtMallocWithFlags = _libraries['libamdhip64.so'].hipExtMallocWithFlags
hipExtMallocWithFlags.restype = hipError_t
hipExtMallocWithFlags.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), size_t, ctypes.c_uint32]
hipMallocHost = _libraries['libamdhip64.so'].hipMallocHost
hipMallocHost.restype = hipError_t
hipMallocHost.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), size_t]
hipMemAllocHost = _libraries['libamdhip64.so'].hipMemAllocHost
hipMemAllocHost.restype = hipError_t
hipMemAllocHost.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), size_t]
hipHostMalloc = _libraries['libamdhip64.so'].hipHostMalloc
hipHostMalloc.restype = hipError_t
hipHostMalloc.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), size_t, ctypes.c_uint32]
hipMallocManaged = _libraries['libamdhip64.so'].hipMallocManaged
hipMallocManaged.restype = hipError_t
hipMallocManaged.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), size_t, ctypes.c_uint32]
hipMemPrefetchAsync = _libraries['libamdhip64.so'].hipMemPrefetchAsync
hipMemPrefetchAsync.restype = hipError_t
hipMemPrefetchAsync.argtypes = [ctypes.POINTER(None), size_t, ctypes.c_int32, hipStream_t]
hipMemAdvise = _libraries['libamdhip64.so'].hipMemAdvise
hipMemAdvise.restype = hipError_t
hipMemAdvise.argtypes = [ctypes.POINTER(None), size_t, hipMemoryAdvise, ctypes.c_int32]
hipMemRangeGetAttribute = _libraries['libamdhip64.so'].hipMemRangeGetAttribute
hipMemRangeGetAttribute.restype = hipError_t
hipMemRangeGetAttribute.argtypes = [ctypes.POINTER(None), size_t, hipMemRangeAttribute, ctypes.POINTER(None), size_t]
hipMemRangeGetAttributes = _libraries['libamdhip64.so'].hipMemRangeGetAttributes
hipMemRangeGetAttributes.restype = hipError_t
hipMemRangeGetAttributes.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(hipMemRangeAttribute), size_t, ctypes.POINTER(None), size_t]
hipStreamAttachMemAsync = _libraries['libamdhip64.so'].hipStreamAttachMemAsync
hipStreamAttachMemAsync.restype = hipError_t
hipStreamAttachMemAsync.argtypes = [hipStream_t, ctypes.POINTER(None), size_t, ctypes.c_uint32]
hipMallocAsync = _libraries['libamdhip64.so'].hipMallocAsync
hipMallocAsync.restype = hipError_t
hipMallocAsync.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), size_t, hipStream_t]
hipFreeAsync = _libraries['libamdhip64.so'].hipFreeAsync
hipFreeAsync.restype = hipError_t
hipFreeAsync.argtypes = [ctypes.POINTER(None), hipStream_t]
hipMemPoolTrimTo = _libraries['libamdhip64.so'].hipMemPoolTrimTo
hipMemPoolTrimTo.restype = hipError_t
hipMemPoolTrimTo.argtypes = [hipMemPool_t, size_t]
hipMemPoolSetAttribute = _libraries['libamdhip64.so'].hipMemPoolSetAttribute
hipMemPoolSetAttribute.restype = hipError_t
hipMemPoolSetAttribute.argtypes = [hipMemPool_t, hipMemPoolAttr, ctypes.POINTER(None)]
hipMemPoolGetAttribute = _libraries['libamdhip64.so'].hipMemPoolGetAttribute
hipMemPoolGetAttribute.restype = hipError_t
hipMemPoolGetAttribute.argtypes = [hipMemPool_t, hipMemPoolAttr, ctypes.POINTER(None)]
hipMemPoolSetAccess = _libraries['libamdhip64.so'].hipMemPoolSetAccess
hipMemPoolSetAccess.restype = hipError_t
hipMemPoolSetAccess.argtypes = [hipMemPool_t, ctypes.POINTER(struct_hipMemAccessDesc), size_t]
hipMemPoolGetAccess = _libraries['libamdhip64.so'].hipMemPoolGetAccess
hipMemPoolGetAccess.restype = hipError_t
hipMemPoolGetAccess.argtypes = [ctypes.POINTER(hipMemAccessFlags), hipMemPool_t, ctypes.POINTER(struct_hipMemLocation)]
hipMemPoolCreate = _libraries['libamdhip64.so'].hipMemPoolCreate
hipMemPoolCreate.restype = hipError_t
hipMemPoolCreate.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipMemPoolHandle_t)), ctypes.POINTER(struct_hipMemPoolProps)]
hipMemPoolDestroy = _libraries['libamdhip64.so'].hipMemPoolDestroy
hipMemPoolDestroy.restype = hipError_t
hipMemPoolDestroy.argtypes = [hipMemPool_t]
hipMallocFromPoolAsync = _libraries['libamdhip64.so'].hipMallocFromPoolAsync
hipMallocFromPoolAsync.restype = hipError_t
hipMallocFromPoolAsync.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), size_t, hipMemPool_t, hipStream_t]
hipMemPoolExportToShareableHandle = _libraries['libamdhip64.so'].hipMemPoolExportToShareableHandle
hipMemPoolExportToShareableHandle.restype = hipError_t
hipMemPoolExportToShareableHandle.argtypes = [ctypes.POINTER(None), hipMemPool_t, hipMemAllocationHandleType, ctypes.c_uint32]
hipMemPoolImportFromShareableHandle = _libraries['libamdhip64.so'].hipMemPoolImportFromShareableHandle
hipMemPoolImportFromShareableHandle.restype = hipError_t
hipMemPoolImportFromShareableHandle.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipMemPoolHandle_t)), ctypes.POINTER(None), hipMemAllocationHandleType, ctypes.c_uint32]
hipMemPoolExportPointer = _libraries['libamdhip64.so'].hipMemPoolExportPointer
hipMemPoolExportPointer.restype = hipError_t
hipMemPoolExportPointer.argtypes = [ctypes.POINTER(struct_hipMemPoolPtrExportData), ctypes.POINTER(None)]
hipMemPoolImportPointer = _libraries['libamdhip64.so'].hipMemPoolImportPointer
hipMemPoolImportPointer.restype = hipError_t
hipMemPoolImportPointer.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), hipMemPool_t, ctypes.POINTER(struct_hipMemPoolPtrExportData)]
hipHostAlloc = _libraries['libamdhip64.so'].hipHostAlloc
hipHostAlloc.restype = hipError_t
hipHostAlloc.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), size_t, ctypes.c_uint32]
hipHostGetDevicePointer = _libraries['libamdhip64.so'].hipHostGetDevicePointer
hipHostGetDevicePointer.restype = hipError_t
hipHostGetDevicePointer.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(None), ctypes.c_uint32]
hipHostGetFlags = _libraries['libamdhip64.so'].hipHostGetFlags
hipHostGetFlags.restype = hipError_t
hipHostGetFlags.argtypes = [ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(None)]
hipHostRegister = _libraries['libamdhip64.so'].hipHostRegister
hipHostRegister.restype = hipError_t
hipHostRegister.argtypes = [ctypes.POINTER(None), size_t, ctypes.c_uint32]
hipHostUnregister = _libraries['libamdhip64.so'].hipHostUnregister
hipHostUnregister.restype = hipError_t
hipHostUnregister.argtypes = [ctypes.POINTER(None)]
hipMallocPitch = _libraries['libamdhip64.so'].hipMallocPitch
hipMallocPitch.restype = hipError_t
hipMallocPitch.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(ctypes.c_uint64), size_t, size_t]
hipMemAllocPitch = _libraries['libamdhip64.so'].hipMemAllocPitch
hipMemAllocPitch.restype = hipError_t
hipMemAllocPitch.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(ctypes.c_uint64), size_t, size_t, ctypes.c_uint32]
hipFree = _libraries['libamdhip64.so'].hipFree
hipFree.restype = hipError_t
hipFree.argtypes = [ctypes.POINTER(None)]
hipFreeHost = _libraries['libamdhip64.so'].hipFreeHost
hipFreeHost.restype = hipError_t
hipFreeHost.argtypes = [ctypes.POINTER(None)]
hipHostFree = _libraries['libamdhip64.so'].hipHostFree
hipHostFree.restype = hipError_t
hipHostFree.argtypes = [ctypes.POINTER(None)]
hipMemcpy = _libraries['libamdhip64.so'].hipMemcpy
hipMemcpy.restype = hipError_t
hipMemcpy.argtypes = [ctypes.POINTER(None), ctypes.POINTER(None), size_t, hipMemcpyKind]
hipMemcpyWithStream = _libraries['libamdhip64.so'].hipMemcpyWithStream
hipMemcpyWithStream.restype = hipError_t
hipMemcpyWithStream.argtypes = [ctypes.POINTER(None), ctypes.POINTER(None), size_t, hipMemcpyKind, hipStream_t]
hipMemcpyHtoD = _libraries['libamdhip64.so'].hipMemcpyHtoD
hipMemcpyHtoD.restype = hipError_t
hipMemcpyHtoD.argtypes = [hipDeviceptr_t, ctypes.POINTER(None), size_t]
hipMemcpyDtoH = _libraries['libamdhip64.so'].hipMemcpyDtoH
hipMemcpyDtoH.restype = hipError_t
hipMemcpyDtoH.argtypes = [ctypes.POINTER(None), hipDeviceptr_t, size_t]
hipMemcpyDtoD = _libraries['libamdhip64.so'].hipMemcpyDtoD
hipMemcpyDtoD.restype = hipError_t
hipMemcpyDtoD.argtypes = [hipDeviceptr_t, hipDeviceptr_t, size_t]
hipMemcpyHtoDAsync = _libraries['libamdhip64.so'].hipMemcpyHtoDAsync
hipMemcpyHtoDAsync.restype = hipError_t
hipMemcpyHtoDAsync.argtypes = [hipDeviceptr_t, ctypes.POINTER(None), size_t, hipStream_t]
hipMemcpyDtoHAsync = _libraries['libamdhip64.so'].hipMemcpyDtoHAsync
hipMemcpyDtoHAsync.restype = hipError_t
hipMemcpyDtoHAsync.argtypes = [ctypes.POINTER(None), hipDeviceptr_t, size_t, hipStream_t]
hipMemcpyDtoDAsync = _libraries['libamdhip64.so'].hipMemcpyDtoDAsync
hipMemcpyDtoDAsync.restype = hipError_t
hipMemcpyDtoDAsync.argtypes = [hipDeviceptr_t, hipDeviceptr_t, size_t, hipStream_t]
hipModuleGetGlobal = _libraries['libamdhip64.so'].hipModuleGetGlobal
hipModuleGetGlobal.restype = hipError_t
hipModuleGetGlobal.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(ctypes.c_uint64), hipModule_t, ctypes.POINTER(ctypes.c_char)]
hipGetSymbolAddress = _libraries['libamdhip64.so'].hipGetSymbolAddress
hipGetSymbolAddress.restype = hipError_t
hipGetSymbolAddress.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(None)]
hipGetSymbolSize = _libraries['libamdhip64.so'].hipGetSymbolSize
hipGetSymbolSize.restype = hipError_t
hipGetSymbolSize.argtypes = [ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(None)]
hipMemcpyToSymbol = _libraries['libamdhip64.so'].hipMemcpyToSymbol
hipMemcpyToSymbol.restype = hipError_t
hipMemcpyToSymbol.argtypes = [ctypes.POINTER(None), ctypes.POINTER(None), size_t, size_t, hipMemcpyKind]
hipMemcpyToSymbolAsync = _libraries['libamdhip64.so'].hipMemcpyToSymbolAsync
hipMemcpyToSymbolAsync.restype = hipError_t
hipMemcpyToSymbolAsync.argtypes = [ctypes.POINTER(None), ctypes.POINTER(None), size_t, size_t, hipMemcpyKind, hipStream_t]
hipMemcpyFromSymbol = _libraries['libamdhip64.so'].hipMemcpyFromSymbol
hipMemcpyFromSymbol.restype = hipError_t
hipMemcpyFromSymbol.argtypes = [ctypes.POINTER(None), ctypes.POINTER(None), size_t, size_t, hipMemcpyKind]
hipMemcpyFromSymbolAsync = _libraries['libamdhip64.so'].hipMemcpyFromSymbolAsync
hipMemcpyFromSymbolAsync.restype = hipError_t
hipMemcpyFromSymbolAsync.argtypes = [ctypes.POINTER(None), ctypes.POINTER(None), size_t, size_t, hipMemcpyKind, hipStream_t]
hipMemcpyAsync = _libraries['libamdhip64.so'].hipMemcpyAsync
hipMemcpyAsync.restype = hipError_t
hipMemcpyAsync.argtypes = [ctypes.POINTER(None), ctypes.POINTER(None), size_t, hipMemcpyKind, hipStream_t]
hipMemset = _libraries['libamdhip64.so'].hipMemset
hipMemset.restype = hipError_t
hipMemset.argtypes = [ctypes.POINTER(None), ctypes.c_int32, size_t]
hipMemsetD8 = _libraries['libamdhip64.so'].hipMemsetD8
hipMemsetD8.restype = hipError_t
hipMemsetD8.argtypes = [hipDeviceptr_t, ctypes.c_ubyte, size_t]
hipMemsetD8Async = _libraries['libamdhip64.so'].hipMemsetD8Async
hipMemsetD8Async.restype = hipError_t
hipMemsetD8Async.argtypes = [hipDeviceptr_t, ctypes.c_ubyte, size_t, hipStream_t]
hipMemsetD16 = _libraries['libamdhip64.so'].hipMemsetD16
hipMemsetD16.restype = hipError_t
hipMemsetD16.argtypes = [hipDeviceptr_t, ctypes.c_uint16, size_t]
hipMemsetD16Async = _libraries['libamdhip64.so'].hipMemsetD16Async
hipMemsetD16Async.restype = hipError_t
hipMemsetD16Async.argtypes = [hipDeviceptr_t, ctypes.c_uint16, size_t, hipStream_t]
hipMemsetD32 = _libraries['libamdhip64.so'].hipMemsetD32
hipMemsetD32.restype = hipError_t
hipMemsetD32.argtypes = [hipDeviceptr_t, ctypes.c_int32, size_t]
hipMemsetAsync = _libraries['libamdhip64.so'].hipMemsetAsync
hipMemsetAsync.restype = hipError_t
hipMemsetAsync.argtypes = [ctypes.POINTER(None), ctypes.c_int32, size_t, hipStream_t]
hipMemsetD32Async = _libraries['libamdhip64.so'].hipMemsetD32Async
hipMemsetD32Async.restype = hipError_t
hipMemsetD32Async.argtypes = [hipDeviceptr_t, ctypes.c_int32, size_t, hipStream_t]
hipMemset2D = _libraries['libamdhip64.so'].hipMemset2D
hipMemset2D.restype = hipError_t
hipMemset2D.argtypes = [ctypes.POINTER(None), size_t, ctypes.c_int32, size_t, size_t]
hipMemset2DAsync = _libraries['libamdhip64.so'].hipMemset2DAsync
hipMemset2DAsync.restype = hipError_t
hipMemset2DAsync.argtypes = [ctypes.POINTER(None), size_t, ctypes.c_int32, size_t, size_t, hipStream_t]
hipMemset3D = _libraries['libamdhip64.so'].hipMemset3D
hipMemset3D.restype = hipError_t
hipMemset3D.argtypes = [hipPitchedPtr, ctypes.c_int32, hipExtent]
hipMemset3DAsync = _libraries['libamdhip64.so'].hipMemset3DAsync
hipMemset3DAsync.restype = hipError_t
hipMemset3DAsync.argtypes = [hipPitchedPtr, ctypes.c_int32, hipExtent, hipStream_t]
hipMemGetInfo = _libraries['libamdhip64.so'].hipMemGetInfo
hipMemGetInfo.restype = hipError_t
hipMemGetInfo.argtypes = [ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.c_uint64)]
hipMemPtrGetInfo = _libraries['libamdhip64.so'].hipMemPtrGetInfo
hipMemPtrGetInfo.restype = hipError_t
hipMemPtrGetInfo.argtypes = [ctypes.POINTER(None), ctypes.POINTER(ctypes.c_uint64)]
hipMallocArray = _libraries['libamdhip64.so'].hipMallocArray
hipMallocArray.restype = hipError_t
hipMallocArray.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipArray)), ctypes.POINTER(struct_hipChannelFormatDesc), size_t, size_t, ctypes.c_uint32]
hipArrayCreate = _libraries['libamdhip64.so'].hipArrayCreate
hipArrayCreate.restype = hipError_t
hipArrayCreate.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipArray)), ctypes.POINTER(struct_HIP_ARRAY_DESCRIPTOR)]
hipArrayDestroy = _libraries['libamdhip64.so'].hipArrayDestroy
hipArrayDestroy.restype = hipError_t
hipArrayDestroy.argtypes = [ctypes.POINTER(struct_hipArray)]
hipArray3DCreate = _libraries['libamdhip64.so'].hipArray3DCreate
hipArray3DCreate.restype = hipError_t
hipArray3DCreate.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipArray)), ctypes.POINTER(struct_HIP_ARRAY3D_DESCRIPTOR)]
hipMalloc3D = _libraries['libamdhip64.so'].hipMalloc3D
hipMalloc3D.restype = hipError_t
hipMalloc3D.argtypes = [ctypes.POINTER(struct_hipPitchedPtr), hipExtent]
hipFreeArray = _libraries['libamdhip64.so'].hipFreeArray
hipFreeArray.restype = hipError_t
hipFreeArray.argtypes = [ctypes.POINTER(struct_hipArray)]
hipMalloc3DArray = _libraries['libamdhip64.so'].hipMalloc3DArray
hipMalloc3DArray.restype = hipError_t
hipMalloc3DArray.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipArray)), ctypes.POINTER(struct_hipChannelFormatDesc), struct_hipExtent, ctypes.c_uint32]
hipArrayGetInfo = _libraries['libamdhip64.so'].hipArrayGetInfo
hipArrayGetInfo.restype = hipError_t
hipArrayGetInfo.argtypes = [ctypes.POINTER(struct_hipChannelFormatDesc), ctypes.POINTER(struct_hipExtent), ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(struct_hipArray)]
hipArrayGetDescriptor = _libraries['libamdhip64.so'].hipArrayGetDescriptor
hipArrayGetDescriptor.restype = hipError_t
hipArrayGetDescriptor.argtypes = [ctypes.POINTER(struct_HIP_ARRAY_DESCRIPTOR), ctypes.POINTER(struct_hipArray)]
hipArray3DGetDescriptor = _libraries['libamdhip64.so'].hipArray3DGetDescriptor
hipArray3DGetDescriptor.restype = hipError_t
hipArray3DGetDescriptor.argtypes = [ctypes.POINTER(struct_HIP_ARRAY3D_DESCRIPTOR), ctypes.POINTER(struct_hipArray)]
hipMemcpy2D = _libraries['libamdhip64.so'].hipMemcpy2D
hipMemcpy2D.restype = hipError_t
hipMemcpy2D.argtypes = [ctypes.POINTER(None), size_t, ctypes.POINTER(None), size_t, size_t, size_t, hipMemcpyKind]
hipMemcpyParam2D = _libraries['libamdhip64.so'].hipMemcpyParam2D
hipMemcpyParam2D.restype = hipError_t
hipMemcpyParam2D.argtypes = [ctypes.POINTER(struct_hip_Memcpy2D)]
hipMemcpyParam2DAsync = _libraries['libamdhip64.so'].hipMemcpyParam2DAsync
hipMemcpyParam2DAsync.restype = hipError_t
hipMemcpyParam2DAsync.argtypes = [ctypes.POINTER(struct_hip_Memcpy2D), hipStream_t]
hipMemcpy2DAsync = _libraries['libamdhip64.so'].hipMemcpy2DAsync
hipMemcpy2DAsync.restype = hipError_t
hipMemcpy2DAsync.argtypes = [ctypes.POINTER(None), size_t, ctypes.POINTER(None), size_t, size_t, size_t, hipMemcpyKind, hipStream_t]
hipMemcpy2DToArray = _libraries['libamdhip64.so'].hipMemcpy2DToArray
hipMemcpy2DToArray.restype = hipError_t
hipMemcpy2DToArray.argtypes = [ctypes.POINTER(struct_hipArray), size_t, size_t, ctypes.POINTER(None), size_t, size_t, size_t, hipMemcpyKind]
hipMemcpy2DToArrayAsync = _libraries['libamdhip64.so'].hipMemcpy2DToArrayAsync
hipMemcpy2DToArrayAsync.restype = hipError_t
hipMemcpy2DToArrayAsync.argtypes = [ctypes.POINTER(struct_hipArray), size_t, size_t, ctypes.POINTER(None), size_t, size_t, size_t, hipMemcpyKind, hipStream_t]
hipMemcpyToArray = _libraries['libamdhip64.so'].hipMemcpyToArray
hipMemcpyToArray.restype = hipError_t
hipMemcpyToArray.argtypes = [ctypes.POINTER(struct_hipArray), size_t, size_t, ctypes.POINTER(None), size_t, hipMemcpyKind]
hipMemcpyFromArray = _libraries['libamdhip64.so'].hipMemcpyFromArray
hipMemcpyFromArray.restype = hipError_t
hipMemcpyFromArray.argtypes = [ctypes.POINTER(None), hipArray_const_t, size_t, size_t, size_t, hipMemcpyKind]
hipMemcpy2DFromArray = _libraries['libamdhip64.so'].hipMemcpy2DFromArray
hipMemcpy2DFromArray.restype = hipError_t
hipMemcpy2DFromArray.argtypes = [ctypes.POINTER(None), size_t, hipArray_const_t, size_t, size_t, size_t, size_t, hipMemcpyKind]
hipMemcpy2DFromArrayAsync = _libraries['libamdhip64.so'].hipMemcpy2DFromArrayAsync
hipMemcpy2DFromArrayAsync.restype = hipError_t
hipMemcpy2DFromArrayAsync.argtypes = [ctypes.POINTER(None), size_t, hipArray_const_t, size_t, size_t, size_t, size_t, hipMemcpyKind, hipStream_t]
hipMemcpyAtoH = _libraries['libamdhip64.so'].hipMemcpyAtoH
hipMemcpyAtoH.restype = hipError_t
hipMemcpyAtoH.argtypes = [ctypes.POINTER(None), ctypes.POINTER(struct_hipArray), size_t, size_t]
hipMemcpyHtoA = _libraries['libamdhip64.so'].hipMemcpyHtoA
hipMemcpyHtoA.restype = hipError_t
hipMemcpyHtoA.argtypes = [ctypes.POINTER(struct_hipArray), size_t, ctypes.POINTER(None), size_t]
hipMemcpy3D = _libraries['libamdhip64.so'].hipMemcpy3D
hipMemcpy3D.restype = hipError_t
hipMemcpy3D.argtypes = [ctypes.POINTER(struct_hipMemcpy3DParms)]
hipMemcpy3DAsync = _libraries['libamdhip64.so'].hipMemcpy3DAsync
hipMemcpy3DAsync.restype = hipError_t
hipMemcpy3DAsync.argtypes = [ctypes.POINTER(struct_hipMemcpy3DParms), hipStream_t]
hipDrvMemcpy3D = _libraries['libamdhip64.so'].hipDrvMemcpy3D
hipDrvMemcpy3D.restype = hipError_t
hipDrvMemcpy3D.argtypes = [ctypes.POINTER(struct_HIP_MEMCPY3D)]
hipDrvMemcpy3DAsync = _libraries['libamdhip64.so'].hipDrvMemcpy3DAsync
hipDrvMemcpy3DAsync.restype = hipError_t
hipDrvMemcpy3DAsync.argtypes = [ctypes.POINTER(struct_HIP_MEMCPY3D), hipStream_t]
hipDeviceCanAccessPeer = _libraries['libamdhip64.so'].hipDeviceCanAccessPeer
hipDeviceCanAccessPeer.restype = hipError_t
hipDeviceCanAccessPeer.argtypes = [ctypes.POINTER(ctypes.c_int32), ctypes.c_int32, ctypes.c_int32]
hipDeviceEnablePeerAccess = _libraries['libamdhip64.so'].hipDeviceEnablePeerAccess
hipDeviceEnablePeerAccess.restype = hipError_t
hipDeviceEnablePeerAccess.argtypes = [ctypes.c_int32, ctypes.c_uint32]
hipDeviceDisablePeerAccess = _libraries['libamdhip64.so'].hipDeviceDisablePeerAccess
hipDeviceDisablePeerAccess.restype = hipError_t
hipDeviceDisablePeerAccess.argtypes = [ctypes.c_int32]
hipMemGetAddressRange = _libraries['libamdhip64.so'].hipMemGetAddressRange
hipMemGetAddressRange.restype = hipError_t
hipMemGetAddressRange.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(ctypes.c_uint64), hipDeviceptr_t]
hipMemcpyPeer = _libraries['libamdhip64.so'].hipMemcpyPeer
hipMemcpyPeer.restype = hipError_t
hipMemcpyPeer.argtypes = [ctypes.POINTER(None), ctypes.c_int32, ctypes.POINTER(None), ctypes.c_int32, size_t]
hipMemcpyPeerAsync = _libraries['libamdhip64.so'].hipMemcpyPeerAsync
hipMemcpyPeerAsync.restype = hipError_t
hipMemcpyPeerAsync.argtypes = [ctypes.POINTER(None), ctypes.c_int32, ctypes.POINTER(None), ctypes.c_int32, size_t, hipStream_t]
hipCtxCreate = _libraries['libamdhip64.so'].hipCtxCreate
hipCtxCreate.restype = hipError_t
hipCtxCreate.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipCtx_t)), ctypes.c_uint32, hipDevice_t]
hipCtxDestroy = _libraries['libamdhip64.so'].hipCtxDestroy
hipCtxDestroy.restype = hipError_t
hipCtxDestroy.argtypes = [hipCtx_t]
hipCtxPopCurrent = _libraries['libamdhip64.so'].hipCtxPopCurrent
hipCtxPopCurrent.restype = hipError_t
hipCtxPopCurrent.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipCtx_t))]
hipCtxPushCurrent = _libraries['libamdhip64.so'].hipCtxPushCurrent
hipCtxPushCurrent.restype = hipError_t
hipCtxPushCurrent.argtypes = [hipCtx_t]
hipCtxSetCurrent = _libraries['libamdhip64.so'].hipCtxSetCurrent
hipCtxSetCurrent.restype = hipError_t
hipCtxSetCurrent.argtypes = [hipCtx_t]
hipCtxGetCurrent = _libraries['libamdhip64.so'].hipCtxGetCurrent
hipCtxGetCurrent.restype = hipError_t
hipCtxGetCurrent.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipCtx_t))]
hipCtxGetDevice = _libraries['libamdhip64.so'].hipCtxGetDevice
hipCtxGetDevice.restype = hipError_t
hipCtxGetDevice.argtypes = [ctypes.POINTER(ctypes.c_int32)]
hipCtxGetApiVersion = _libraries['libamdhip64.so'].hipCtxGetApiVersion
hipCtxGetApiVersion.restype = hipError_t
hipCtxGetApiVersion.argtypes = [hipCtx_t, ctypes.POINTER(ctypes.c_int32)]
hipCtxGetCacheConfig = _libraries['libamdhip64.so'].hipCtxGetCacheConfig
hipCtxGetCacheConfig.restype = hipError_t
hipCtxGetCacheConfig.argtypes = [ctypes.POINTER(hipFuncCache_t)]
hipCtxSetCacheConfig = _libraries['libamdhip64.so'].hipCtxSetCacheConfig
hipCtxSetCacheConfig.restype = hipError_t
hipCtxSetCacheConfig.argtypes = [hipFuncCache_t]
hipCtxSetSharedMemConfig = _libraries['libamdhip64.so'].hipCtxSetSharedMemConfig
hipCtxSetSharedMemConfig.restype = hipError_t
hipCtxSetSharedMemConfig.argtypes = [hipSharedMemConfig]
hipCtxGetSharedMemConfig = _libraries['libamdhip64.so'].hipCtxGetSharedMemConfig
hipCtxGetSharedMemConfig.restype = hipError_t
hipCtxGetSharedMemConfig.argtypes = [ctypes.POINTER(hipSharedMemConfig)]
hipCtxSynchronize = _libraries['libamdhip64.so'].hipCtxSynchronize
hipCtxSynchronize.restype = hipError_t
hipCtxSynchronize.argtypes = []
hipCtxGetFlags = _libraries['libamdhip64.so'].hipCtxGetFlags
hipCtxGetFlags.restype = hipError_t
hipCtxGetFlags.argtypes = [ctypes.POINTER(ctypes.c_uint32)]
hipCtxEnablePeerAccess = _libraries['libamdhip64.so'].hipCtxEnablePeerAccess
hipCtxEnablePeerAccess.restype = hipError_t
hipCtxEnablePeerAccess.argtypes = [hipCtx_t, ctypes.c_uint32]
hipCtxDisablePeerAccess = _libraries['libamdhip64.so'].hipCtxDisablePeerAccess
hipCtxDisablePeerAccess.restype = hipError_t
hipCtxDisablePeerAccess.argtypes = [hipCtx_t]
hipDevicePrimaryCtxGetState = _libraries['libamdhip64.so'].hipDevicePrimaryCtxGetState
hipDevicePrimaryCtxGetState.restype = hipError_t
hipDevicePrimaryCtxGetState.argtypes = [hipDevice_t, ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_int32)]
hipDevicePrimaryCtxRelease = _libraries['libamdhip64.so'].hipDevicePrimaryCtxRelease
hipDevicePrimaryCtxRelease.restype = hipError_t
hipDevicePrimaryCtxRelease.argtypes = [hipDevice_t]
hipDevicePrimaryCtxRetain = _libraries['libamdhip64.so'].hipDevicePrimaryCtxRetain
hipDevicePrimaryCtxRetain.restype = hipError_t
hipDevicePrimaryCtxRetain.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipCtx_t)), hipDevice_t]
hipDevicePrimaryCtxReset = _libraries['libamdhip64.so'].hipDevicePrimaryCtxReset
hipDevicePrimaryCtxReset.restype = hipError_t
hipDevicePrimaryCtxReset.argtypes = [hipDevice_t]
hipDevicePrimaryCtxSetFlags = _libraries['libamdhip64.so'].hipDevicePrimaryCtxSetFlags
hipDevicePrimaryCtxSetFlags.restype = hipError_t
hipDevicePrimaryCtxSetFlags.argtypes = [hipDevice_t, ctypes.c_uint32]
hipModuleLoad = _libraries['libamdhip64.so'].hipModuleLoad
hipModuleLoad.restype = hipError_t
hipModuleLoad.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipModule_t)), ctypes.POINTER(ctypes.c_char)]
hipModuleUnload = _libraries['libamdhip64.so'].hipModuleUnload
hipModuleUnload.restype = hipError_t
hipModuleUnload.argtypes = [hipModule_t]
hipModuleGetFunction = _libraries['libamdhip64.so'].hipModuleGetFunction
hipModuleGetFunction.restype = hipError_t
hipModuleGetFunction.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipModuleSymbol_t)), hipModule_t, ctypes.POINTER(ctypes.c_char)]
hipFuncGetAttributes = _libraries['libamdhip64.so'].hipFuncGetAttributes
hipFuncGetAttributes.restype = hipError_t
hipFuncGetAttributes.argtypes = [ctypes.POINTER(struct_hipFuncAttributes), ctypes.POINTER(None)]
hipFuncGetAttribute = _libraries['libamdhip64.so'].hipFuncGetAttribute
hipFuncGetAttribute.restype = hipError_t
hipFuncGetAttribute.argtypes = [ctypes.POINTER(ctypes.c_int32), hipFunction_attribute, hipFunction_t]
class struct_textureReference(Structure):
pass
class struct___hip_texture(Structure):
pass
# values for enumeration 'hipTextureAddressMode'
hipTextureAddressMode__enumvalues = {
0: 'hipAddressModeWrap',
1: 'hipAddressModeClamp',
2: 'hipAddressModeMirror',
3: 'hipAddressModeBorder',
}
hipAddressModeWrap = 0
hipAddressModeClamp = 1
hipAddressModeMirror = 2
hipAddressModeBorder = 3
hipTextureAddressMode = ctypes.c_uint32 # enum
# values for enumeration 'hipTextureReadMode'
hipTextureReadMode__enumvalues = {
0: 'hipReadModeElementType',
1: 'hipReadModeNormalizedFloat',
}
hipReadModeElementType = 0
hipReadModeNormalizedFloat = 1
hipTextureReadMode = ctypes.c_uint32 # enum
# values for enumeration 'hipTextureFilterMode'
hipTextureFilterMode__enumvalues = {
0: 'hipFilterModePoint',
1: 'hipFilterModeLinear',
}
hipFilterModePoint = 0
hipFilterModeLinear = 1
hipTextureFilterMode = ctypes.c_uint32 # enum
struct_textureReference._pack_ = 1 # source:False
struct_textureReference._fields_ = [
('normalized', ctypes.c_int32),
('readMode', hipTextureReadMode),
('filterMode', hipTextureFilterMode),
('addressMode', hipTextureAddressMode * 3),
('channelDesc', struct_hipChannelFormatDesc),
('sRGB', ctypes.c_int32),
('maxAnisotropy', ctypes.c_uint32),
('mipmapFilterMode', hipTextureFilterMode),
('mipmapLevelBias', ctypes.c_float),
('minMipmapLevelClamp', ctypes.c_float),
('maxMipmapLevelClamp', ctypes.c_float),
('PADDING_0', ctypes.c_ubyte * 4),
('textureObject', ctypes.POINTER(struct___hip_texture)),
('numChannels', ctypes.c_int32),
('format', hipArray_Format),
]
hipModuleGetTexRef = _libraries['libamdhip64.so'].hipModuleGetTexRef
hipModuleGetTexRef.restype = hipError_t
hipModuleGetTexRef.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_textureReference)), hipModule_t, ctypes.POINTER(ctypes.c_char)]
hipModuleLoadData = _libraries['libamdhip64.so'].hipModuleLoadData
hipModuleLoadData.restype = hipError_t
hipModuleLoadData.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipModule_t)), ctypes.POINTER(None)]
hipModuleLoadDataEx = _libraries['libamdhip64.so'].hipModuleLoadDataEx
hipModuleLoadDataEx.restype = hipError_t
hipModuleLoadDataEx.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipModule_t)), ctypes.POINTER(None), ctypes.c_uint32, ctypes.POINTER(hipJitOption), ctypes.POINTER(ctypes.POINTER(None))]
hipModuleLaunchKernel = _libraries['libamdhip64.so'].hipModuleLaunchKernel
hipModuleLaunchKernel.restype = hipError_t
hipModuleLaunchKernel.argtypes = [hipFunction_t, ctypes.c_uint32, ctypes.c_uint32, ctypes.c_uint32, ctypes.c_uint32, ctypes.c_uint32, ctypes.c_uint32, ctypes.c_uint32, hipStream_t, ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(ctypes.POINTER(None))]
hipModuleLaunchCooperativeKernel = _libraries['libamdhip64.so'].hipModuleLaunchCooperativeKernel
hipModuleLaunchCooperativeKernel.restype = hipError_t
hipModuleLaunchCooperativeKernel.argtypes = [hipFunction_t, ctypes.c_uint32, ctypes.c_uint32, ctypes.c_uint32, ctypes.c_uint32, ctypes.c_uint32, ctypes.c_uint32, ctypes.c_uint32, hipStream_t, ctypes.POINTER(ctypes.POINTER(None))]
hipModuleLaunchCooperativeKernelMultiDevice = _libraries['libamdhip64.so'].hipModuleLaunchCooperativeKernelMultiDevice
hipModuleLaunchCooperativeKernelMultiDevice.restype = hipError_t
hipModuleLaunchCooperativeKernelMultiDevice.argtypes = [ctypes.POINTER(struct_hipFunctionLaunchParams_t), ctypes.c_uint32, ctypes.c_uint32]
hipLaunchCooperativeKernel = _libraries['libamdhip64.so'].hipLaunchCooperativeKernel
hipLaunchCooperativeKernel.restype = hipError_t
hipLaunchCooperativeKernel.argtypes = [ctypes.POINTER(None), dim3, dim3, ctypes.POINTER(ctypes.POINTER(None)), ctypes.c_uint32, hipStream_t]
hipLaunchCooperativeKernelMultiDevice = _libraries['libamdhip64.so'].hipLaunchCooperativeKernelMultiDevice
hipLaunchCooperativeKernelMultiDevice.restype = hipError_t
hipLaunchCooperativeKernelMultiDevice.argtypes = [ctypes.POINTER(struct_hipLaunchParams_t), ctypes.c_int32, ctypes.c_uint32]
hipExtLaunchMultiKernelMultiDevice = _libraries['libamdhip64.so'].hipExtLaunchMultiKernelMultiDevice
hipExtLaunchMultiKernelMultiDevice.restype = hipError_t
hipExtLaunchMultiKernelMultiDevice.argtypes = [ctypes.POINTER(struct_hipLaunchParams_t), ctypes.c_int32, ctypes.c_uint32]
hipModuleOccupancyMaxPotentialBlockSize = _libraries['libamdhip64.so'].hipModuleOccupancyMaxPotentialBlockSize
hipModuleOccupancyMaxPotentialBlockSize.restype = hipError_t
hipModuleOccupancyMaxPotentialBlockSize.argtypes = [ctypes.POINTER(ctypes.c_int32), ctypes.POINTER(ctypes.c_int32), hipFunction_t, size_t, ctypes.c_int32]
hipModuleOccupancyMaxPotentialBlockSizeWithFlags = _libraries['libamdhip64.so'].hipModuleOccupancyMaxPotentialBlockSizeWithFlags
hipModuleOccupancyMaxPotentialBlockSizeWithFlags.restype = hipError_t
hipModuleOccupancyMaxPotentialBlockSizeWithFlags.argtypes = [ctypes.POINTER(ctypes.c_int32), ctypes.POINTER(ctypes.c_int32), hipFunction_t, size_t, ctypes.c_int32, ctypes.c_uint32]
hipModuleOccupancyMaxActiveBlocksPerMultiprocessor = _libraries['libamdhip64.so'].hipModuleOccupancyMaxActiveBlocksPerMultiprocessor
hipModuleOccupancyMaxActiveBlocksPerMultiprocessor.restype = hipError_t
hipModuleOccupancyMaxActiveBlocksPerMultiprocessor.argtypes = [ctypes.POINTER(ctypes.c_int32), hipFunction_t, ctypes.c_int32, size_t]
hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags = _libraries['libamdhip64.so'].hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags
hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.restype = hipError_t
hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.argtypes = [ctypes.POINTER(ctypes.c_int32), hipFunction_t, ctypes.c_int32, size_t, ctypes.c_uint32]
hipOccupancyMaxActiveBlocksPerMultiprocessor = _libraries['libamdhip64.so'].hipOccupancyMaxActiveBlocksPerMultiprocessor
hipOccupancyMaxActiveBlocksPerMultiprocessor.restype = hipError_t
hipOccupancyMaxActiveBlocksPerMultiprocessor.argtypes = [ctypes.POINTER(ctypes.c_int32), ctypes.POINTER(None), ctypes.c_int32, size_t]
hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags = _libraries['libamdhip64.so'].hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags
hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.restype = hipError_t
hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags.argtypes = [ctypes.POINTER(ctypes.c_int32), ctypes.POINTER(None), ctypes.c_int32, size_t, ctypes.c_uint32]
hipOccupancyMaxPotentialBlockSize = _libraries['libamdhip64.so'].hipOccupancyMaxPotentialBlockSize
hipOccupancyMaxPotentialBlockSize.restype = hipError_t
hipOccupancyMaxPotentialBlockSize.argtypes = [ctypes.POINTER(ctypes.c_int32), ctypes.POINTER(ctypes.c_int32), ctypes.POINTER(None), size_t, ctypes.c_int32]
hipProfilerStart = _libraries['libamdhip64.so'].hipProfilerStart
hipProfilerStart.restype = hipError_t
hipProfilerStart.argtypes = []
hipProfilerStop = _libraries['libamdhip64.so'].hipProfilerStop
hipProfilerStop.restype = hipError_t
hipProfilerStop.argtypes = []
hipConfigureCall = _libraries['libamdhip64.so'].hipConfigureCall
hipConfigureCall.restype = hipError_t
hipConfigureCall.argtypes = [dim3, dim3, size_t, hipStream_t]
hipSetupArgument = _libraries['libamdhip64.so'].hipSetupArgument
hipSetupArgument.restype = hipError_t
hipSetupArgument.argtypes = [ctypes.POINTER(None), size_t, size_t]
hipLaunchByPtr = _libraries['libamdhip64.so'].hipLaunchByPtr
hipLaunchByPtr.restype = hipError_t
hipLaunchByPtr.argtypes = [ctypes.POINTER(None)]
__hipPushCallConfiguration = _libraries['libamdhip64.so'].__hipPushCallConfiguration
__hipPushCallConfiguration.restype = hipError_t
__hipPushCallConfiguration.argtypes = [dim3, dim3, size_t, hipStream_t]
__hipPopCallConfiguration = _libraries['libamdhip64.so'].__hipPopCallConfiguration
__hipPopCallConfiguration.restype = hipError_t
__hipPopCallConfiguration.argtypes = [ctypes.POINTER(struct_dim3), ctypes.POINTER(struct_dim3), ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.POINTER(struct_ihipStream_t))]
hipLaunchKernel = _libraries['libamdhip64.so'].hipLaunchKernel
hipLaunchKernel.restype = hipError_t
hipLaunchKernel.argtypes = [ctypes.POINTER(None), dim3, dim3, ctypes.POINTER(ctypes.POINTER(None)), size_t, hipStream_t]
hipLaunchHostFunc = _libraries['libamdhip64.so'].hipLaunchHostFunc
hipLaunchHostFunc.restype = hipError_t
hipLaunchHostFunc.argtypes = [hipStream_t, hipHostFn_t, ctypes.POINTER(None)]
hipDrvMemcpy2DUnaligned = _libraries['libamdhip64.so'].hipDrvMemcpy2DUnaligned
hipDrvMemcpy2DUnaligned.restype = hipError_t
hipDrvMemcpy2DUnaligned.argtypes = [ctypes.POINTER(struct_hip_Memcpy2D)]
hipExtLaunchKernel = _libraries['libamdhip64.so'].hipExtLaunchKernel
hipExtLaunchKernel.restype = hipError_t
hipExtLaunchKernel.argtypes = [ctypes.POINTER(None), dim3, dim3, ctypes.POINTER(ctypes.POINTER(None)), size_t, hipStream_t, hipEvent_t, hipEvent_t, ctypes.c_int32]
class struct_hipTextureDesc(Structure):
pass
struct_hipTextureDesc._pack_ = 1 # source:False
struct_hipTextureDesc._fields_ = [
('addressMode', hipTextureAddressMode * 3),
('filterMode', hipTextureFilterMode),
('readMode', hipTextureReadMode),
('sRGB', ctypes.c_int32),
('borderColor', ctypes.c_float * 4),
('normalizedCoords', ctypes.c_int32),
('maxAnisotropy', ctypes.c_uint32),
('mipmapFilterMode', hipTextureFilterMode),
('mipmapLevelBias', ctypes.c_float),
('minMipmapLevelClamp', ctypes.c_float),
('maxMipmapLevelClamp', ctypes.c_float),
]
hipCreateTextureObject = _libraries['libamdhip64.so'].hipCreateTextureObject
hipCreateTextureObject.restype = hipError_t
hipCreateTextureObject.argtypes = [ctypes.POINTER(ctypes.POINTER(struct___hip_texture)), ctypes.POINTER(struct_hipResourceDesc), ctypes.POINTER(struct_hipTextureDesc), ctypes.POINTER(struct_hipResourceViewDesc)]
hipTextureObject_t = ctypes.POINTER(struct___hip_texture)
hipDestroyTextureObject = _libraries['libamdhip64.so'].hipDestroyTextureObject
hipDestroyTextureObject.restype = hipError_t
hipDestroyTextureObject.argtypes = [hipTextureObject_t]
hipGetChannelDesc = _libraries['libamdhip64.so'].hipGetChannelDesc
hipGetChannelDesc.restype = hipError_t
hipGetChannelDesc.argtypes = [ctypes.POINTER(struct_hipChannelFormatDesc), hipArray_const_t]
hipGetTextureObjectResourceDesc = _libraries['libamdhip64.so'].hipGetTextureObjectResourceDesc
hipGetTextureObjectResourceDesc.restype = hipError_t
hipGetTextureObjectResourceDesc.argtypes = [ctypes.POINTER(struct_hipResourceDesc), hipTextureObject_t]
hipGetTextureObjectResourceViewDesc = _libraries['libamdhip64.so'].hipGetTextureObjectResourceViewDesc
hipGetTextureObjectResourceViewDesc.restype = hipError_t
hipGetTextureObjectResourceViewDesc.argtypes = [ctypes.POINTER(struct_hipResourceViewDesc), hipTextureObject_t]
hipGetTextureObjectTextureDesc = _libraries['libamdhip64.so'].hipGetTextureObjectTextureDesc
hipGetTextureObjectTextureDesc.restype = hipError_t
hipGetTextureObjectTextureDesc.argtypes = [ctypes.POINTER(struct_hipTextureDesc), hipTextureObject_t]
hipTexObjectCreate = _libraries['libamdhip64.so'].hipTexObjectCreate
hipTexObjectCreate.restype = hipError_t
hipTexObjectCreate.argtypes = [ctypes.POINTER(ctypes.POINTER(struct___hip_texture)), ctypes.POINTER(struct_HIP_RESOURCE_DESC_st), ctypes.POINTER(struct_HIP_TEXTURE_DESC_st), ctypes.POINTER(struct_HIP_RESOURCE_VIEW_DESC_st)]
hipTexObjectDestroy = _libraries['libamdhip64.so'].hipTexObjectDestroy
hipTexObjectDestroy.restype = hipError_t
hipTexObjectDestroy.argtypes = [hipTextureObject_t]
hipTexObjectGetResourceDesc = _libraries['libamdhip64.so'].hipTexObjectGetResourceDesc
hipTexObjectGetResourceDesc.restype = hipError_t
hipTexObjectGetResourceDesc.argtypes = [ctypes.POINTER(struct_HIP_RESOURCE_DESC_st), hipTextureObject_t]
hipTexObjectGetResourceViewDesc = _libraries['libamdhip64.so'].hipTexObjectGetResourceViewDesc
hipTexObjectGetResourceViewDesc.restype = hipError_t
hipTexObjectGetResourceViewDesc.argtypes = [ctypes.POINTER(struct_HIP_RESOURCE_VIEW_DESC_st), hipTextureObject_t]
hipTexObjectGetTextureDesc = _libraries['libamdhip64.so'].hipTexObjectGetTextureDesc
hipTexObjectGetTextureDesc.restype = hipError_t
hipTexObjectGetTextureDesc.argtypes = [ctypes.POINTER(struct_HIP_TEXTURE_DESC_st), hipTextureObject_t]
hipMallocMipmappedArray = _libraries['libamdhip64.so'].hipMallocMipmappedArray
hipMallocMipmappedArray.restype = hipError_t
hipMallocMipmappedArray.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipMipmappedArray)), ctypes.POINTER(struct_hipChannelFormatDesc), struct_hipExtent, ctypes.c_uint32, ctypes.c_uint32]
hipFreeMipmappedArray = _libraries['libamdhip64.so'].hipFreeMipmappedArray
hipFreeMipmappedArray.restype = hipError_t
hipFreeMipmappedArray.argtypes = [hipMipmappedArray_t]
hipGetMipmappedArrayLevel = _libraries['libamdhip64.so'].hipGetMipmappedArrayLevel
hipGetMipmappedArrayLevel.restype = hipError_t
hipGetMipmappedArrayLevel.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipArray)), hipMipmappedArray_const_t, ctypes.c_uint32]
hipMipmappedArrayCreate = _libraries['libamdhip64.so'].hipMipmappedArrayCreate
hipMipmappedArrayCreate.restype = hipError_t
hipMipmappedArrayCreate.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipMipmappedArray)), ctypes.POINTER(struct_HIP_ARRAY3D_DESCRIPTOR), ctypes.c_uint32]
hipMipmappedArrayDestroy = _libraries['libamdhip64.so'].hipMipmappedArrayDestroy
hipMipmappedArrayDestroy.restype = hipError_t
hipMipmappedArrayDestroy.argtypes = [hipMipmappedArray_t]
hipMipmappedArrayGetLevel = _libraries['libamdhip64.so'].hipMipmappedArrayGetLevel
hipMipmappedArrayGetLevel.restype = hipError_t
hipMipmappedArrayGetLevel.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipArray)), hipMipmappedArray_t, ctypes.c_uint32]
hipBindTextureToMipmappedArray = _libraries['libamdhip64.so'].hipBindTextureToMipmappedArray
hipBindTextureToMipmappedArray.restype = hipError_t
hipBindTextureToMipmappedArray.argtypes = [ctypes.POINTER(struct_textureReference), hipMipmappedArray_const_t, ctypes.POINTER(struct_hipChannelFormatDesc)]
hipGetTextureReference = _libraries['libamdhip64.so'].hipGetTextureReference
hipGetTextureReference.restype = hipError_t
hipGetTextureReference.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_textureReference)), ctypes.POINTER(None)]
hipTexRefSetAddressMode = _libraries['libamdhip64.so'].hipTexRefSetAddressMode
hipTexRefSetAddressMode.restype = hipError_t
hipTexRefSetAddressMode.argtypes = [ctypes.POINTER(struct_textureReference), ctypes.c_int32, hipTextureAddressMode]
hipTexRefSetArray = _libraries['libamdhip64.so'].hipTexRefSetArray
hipTexRefSetArray.restype = hipError_t
hipTexRefSetArray.argtypes = [ctypes.POINTER(struct_textureReference), hipArray_const_t, ctypes.c_uint32]
hipTexRefSetFilterMode = _libraries['libamdhip64.so'].hipTexRefSetFilterMode
hipTexRefSetFilterMode.restype = hipError_t
hipTexRefSetFilterMode.argtypes = [ctypes.POINTER(struct_textureReference), hipTextureFilterMode]
hipTexRefSetFlags = _libraries['libamdhip64.so'].hipTexRefSetFlags
hipTexRefSetFlags.restype = hipError_t
hipTexRefSetFlags.argtypes = [ctypes.POINTER(struct_textureReference), ctypes.c_uint32]
hipTexRefSetFormat = _libraries['libamdhip64.so'].hipTexRefSetFormat
hipTexRefSetFormat.restype = hipError_t
hipTexRefSetFormat.argtypes = [ctypes.POINTER(struct_textureReference), hipArray_Format, ctypes.c_int32]
hipBindTexture = _libraries['libamdhip64.so'].hipBindTexture
hipBindTexture.restype = hipError_t
hipBindTexture.argtypes = [ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(struct_textureReference), ctypes.POINTER(None), ctypes.POINTER(struct_hipChannelFormatDesc), size_t]
hipBindTexture2D = _libraries['libamdhip64.so'].hipBindTexture2D
hipBindTexture2D.restype = hipError_t
hipBindTexture2D.argtypes = [ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(struct_textureReference), ctypes.POINTER(None), ctypes.POINTER(struct_hipChannelFormatDesc), size_t, size_t, size_t]
hipBindTextureToArray = _libraries['libamdhip64.so'].hipBindTextureToArray
hipBindTextureToArray.restype = hipError_t
hipBindTextureToArray.argtypes = [ctypes.POINTER(struct_textureReference), hipArray_const_t, ctypes.POINTER(struct_hipChannelFormatDesc)]
hipGetTextureAlignmentOffset = _libraries['libamdhip64.so'].hipGetTextureAlignmentOffset
hipGetTextureAlignmentOffset.restype = hipError_t
hipGetTextureAlignmentOffset.argtypes = [ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(struct_textureReference)]
hipUnbindTexture = _libraries['libamdhip64.so'].hipUnbindTexture
hipUnbindTexture.restype = hipError_t
hipUnbindTexture.argtypes = [ctypes.POINTER(struct_textureReference)]
hipTexRefGetAddress = _libraries['libamdhip64.so'].hipTexRefGetAddress
hipTexRefGetAddress.restype = hipError_t
hipTexRefGetAddress.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(struct_textureReference)]
hipTexRefGetAddressMode = _libraries['libamdhip64.so'].hipTexRefGetAddressMode
hipTexRefGetAddressMode.restype = hipError_t
hipTexRefGetAddressMode.argtypes = [ctypes.POINTER(hipTextureAddressMode), ctypes.POINTER(struct_textureReference), ctypes.c_int32]
hipTexRefGetFilterMode = _libraries['libamdhip64.so'].hipTexRefGetFilterMode
hipTexRefGetFilterMode.restype = hipError_t
hipTexRefGetFilterMode.argtypes = [ctypes.POINTER(hipTextureFilterMode), ctypes.POINTER(struct_textureReference)]
hipTexRefGetFlags = _libraries['libamdhip64.so'].hipTexRefGetFlags
hipTexRefGetFlags.restype = hipError_t
hipTexRefGetFlags.argtypes = [ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(struct_textureReference)]
hipTexRefGetFormat = _libraries['libamdhip64.so'].hipTexRefGetFormat
hipTexRefGetFormat.restype = hipError_t
hipTexRefGetFormat.argtypes = [ctypes.POINTER(hipArray_Format), ctypes.POINTER(ctypes.c_int32), ctypes.POINTER(struct_textureReference)]
hipTexRefGetMaxAnisotropy = _libraries['libamdhip64.so'].hipTexRefGetMaxAnisotropy
hipTexRefGetMaxAnisotropy.restype = hipError_t
hipTexRefGetMaxAnisotropy.argtypes = [ctypes.POINTER(ctypes.c_int32), ctypes.POINTER(struct_textureReference)]
hipTexRefGetMipmapFilterMode = _libraries['libamdhip64.so'].hipTexRefGetMipmapFilterMode
hipTexRefGetMipmapFilterMode.restype = hipError_t
hipTexRefGetMipmapFilterMode.argtypes = [ctypes.POINTER(hipTextureFilterMode), ctypes.POINTER(struct_textureReference)]
hipTexRefGetMipmapLevelBias = _libraries['libamdhip64.so'].hipTexRefGetMipmapLevelBias
hipTexRefGetMipmapLevelBias.restype = hipError_t
hipTexRefGetMipmapLevelBias.argtypes = [ctypes.POINTER(ctypes.c_float), ctypes.POINTER(struct_textureReference)]
hipTexRefGetMipmapLevelClamp = _libraries['libamdhip64.so'].hipTexRefGetMipmapLevelClamp
hipTexRefGetMipmapLevelClamp.restype = hipError_t
hipTexRefGetMipmapLevelClamp.argtypes = [ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_float), ctypes.POINTER(struct_textureReference)]
hipTexRefGetMipMappedArray = _libraries['FIXME_STUB'].hipTexRefGetMipMappedArray
hipTexRefGetMipMappedArray.restype = hipError_t
hipTexRefGetMipMappedArray.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipMipmappedArray)), ctypes.POINTER(struct_textureReference)]
hipTexRefSetAddress = _libraries['libamdhip64.so'].hipTexRefSetAddress
hipTexRefSetAddress.restype = hipError_t
hipTexRefSetAddress.argtypes = [ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(struct_textureReference), hipDeviceptr_t, size_t]
hipTexRefSetAddress2D = _libraries['libamdhip64.so'].hipTexRefSetAddress2D
hipTexRefSetAddress2D.restype = hipError_t
hipTexRefSetAddress2D.argtypes = [ctypes.POINTER(struct_textureReference), ctypes.POINTER(struct_HIP_ARRAY_DESCRIPTOR), hipDeviceptr_t, size_t]
hipTexRefSetMaxAnisotropy = _libraries['libamdhip64.so'].hipTexRefSetMaxAnisotropy
hipTexRefSetMaxAnisotropy.restype = hipError_t
hipTexRefSetMaxAnisotropy.argtypes = [ctypes.POINTER(struct_textureReference), ctypes.c_uint32]
hipTexRefSetBorderColor = _libraries['libamdhip64.so'].hipTexRefSetBorderColor
hipTexRefSetBorderColor.restype = hipError_t
hipTexRefSetBorderColor.argtypes = [ctypes.POINTER(struct_textureReference), ctypes.POINTER(ctypes.c_float)]
hipTexRefSetMipmapFilterMode = _libraries['libamdhip64.so'].hipTexRefSetMipmapFilterMode
hipTexRefSetMipmapFilterMode.restype = hipError_t
hipTexRefSetMipmapFilterMode.argtypes = [ctypes.POINTER(struct_textureReference), hipTextureFilterMode]
hipTexRefSetMipmapLevelBias = _libraries['libamdhip64.so'].hipTexRefSetMipmapLevelBias
hipTexRefSetMipmapLevelBias.restype = hipError_t
hipTexRefSetMipmapLevelBias.argtypes = [ctypes.POINTER(struct_textureReference), ctypes.c_float]
hipTexRefSetMipmapLevelClamp = _libraries['libamdhip64.so'].hipTexRefSetMipmapLevelClamp
hipTexRefSetMipmapLevelClamp.restype = hipError_t
hipTexRefSetMipmapLevelClamp.argtypes = [ctypes.POINTER(struct_textureReference), ctypes.c_float, ctypes.c_float]
hipTexRefSetMipmappedArray = _libraries['libamdhip64.so'].hipTexRefSetMipmappedArray
hipTexRefSetMipmappedArray.restype = hipError_t
hipTexRefSetMipmappedArray.argtypes = [ctypes.POINTER(struct_textureReference), ctypes.POINTER(struct_hipMipmappedArray), ctypes.c_uint32]
hipApiName = _libraries['libamdhip64.so'].hipApiName
hipApiName.restype = ctypes.POINTER(ctypes.c_char)
hipApiName.argtypes = [uint32_t]
hipKernelNameRef = _libraries['libamdhip64.so'].hipKernelNameRef
hipKernelNameRef.restype = ctypes.POINTER(ctypes.c_char)
hipKernelNameRef.argtypes = [hipFunction_t]
hipKernelNameRefByPtr = _libraries['libamdhip64.so'].hipKernelNameRefByPtr
hipKernelNameRefByPtr.restype = ctypes.POINTER(ctypes.c_char)
hipKernelNameRefByPtr.argtypes = [ctypes.POINTER(None), hipStream_t]
hipGetStreamDeviceId = _libraries['libamdhip64.so'].hipGetStreamDeviceId
hipGetStreamDeviceId.restype = ctypes.c_int32
hipGetStreamDeviceId.argtypes = [hipStream_t]
hipStreamBeginCapture = _libraries['libamdhip64.so'].hipStreamBeginCapture
hipStreamBeginCapture.restype = hipError_t
hipStreamBeginCapture.argtypes = [hipStream_t, hipStreamCaptureMode]
hipStreamEndCapture = _libraries['libamdhip64.so'].hipStreamEndCapture
hipStreamEndCapture.restype = hipError_t
hipStreamEndCapture.argtypes = [hipStream_t, ctypes.POINTER(ctypes.POINTER(struct_ihipGraph))]
hipStreamGetCaptureInfo = _libraries['libamdhip64.so'].hipStreamGetCaptureInfo
hipStreamGetCaptureInfo.restype = hipError_t
hipStreamGetCaptureInfo.argtypes = [hipStream_t, ctypes.POINTER(hipStreamCaptureStatus), ctypes.POINTER(ctypes.c_uint64)]
hipStreamGetCaptureInfo_v2 = _libraries['libamdhip64.so'].hipStreamGetCaptureInfo_v2
hipStreamGetCaptureInfo_v2.restype = hipError_t
hipStreamGetCaptureInfo_v2.argtypes = [hipStream_t, ctypes.POINTER(hipStreamCaptureStatus), ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(ctypes.POINTER(struct_ihipGraph)), ctypes.POINTER(ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode))), ctypes.POINTER(ctypes.c_uint64)]
hipStreamIsCapturing = _libraries['libamdhip64.so'].hipStreamIsCapturing
hipStreamIsCapturing.restype = hipError_t
hipStreamIsCapturing.argtypes = [hipStream_t, ctypes.POINTER(hipStreamCaptureStatus)]
hipStreamUpdateCaptureDependencies = _libraries['libamdhip64.so'].hipStreamUpdateCaptureDependencies
hipStreamUpdateCaptureDependencies.restype = hipError_t
hipStreamUpdateCaptureDependencies.argtypes = [hipStream_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, ctypes.c_uint32]
hipThreadExchangeStreamCaptureMode = _libraries['libamdhip64.so'].hipThreadExchangeStreamCaptureMode
hipThreadExchangeStreamCaptureMode.restype = hipError_t
hipThreadExchangeStreamCaptureMode.argtypes = [ctypes.POINTER(hipStreamCaptureMode)]
hipGraphCreate = _libraries['libamdhip64.so'].hipGraphCreate
hipGraphCreate.restype = hipError_t
hipGraphCreate.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipGraph)), ctypes.c_uint32]
hipGraphDestroy = _libraries['libamdhip64.so'].hipGraphDestroy
hipGraphDestroy.restype = hipError_t
hipGraphDestroy.argtypes = [hipGraph_t]
hipGraphAddDependencies = _libraries['libamdhip64.so'].hipGraphAddDependencies
hipGraphAddDependencies.restype = hipError_t
hipGraphAddDependencies.argtypes = [hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t]
hipGraphRemoveDependencies = _libraries['libamdhip64.so'].hipGraphRemoveDependencies
hipGraphRemoveDependencies.restype = hipError_t
hipGraphRemoveDependencies.argtypes = [hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t]
hipGraphGetEdges = _libraries['libamdhip64.so'].hipGraphGetEdges
hipGraphGetEdges.restype = hipError_t
hipGraphGetEdges.argtypes = [hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), ctypes.POINTER(ctypes.c_uint64)]
hipGraphGetNodes = _libraries['libamdhip64.so'].hipGraphGetNodes
hipGraphGetNodes.restype = hipError_t
hipGraphGetNodes.argtypes = [hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), ctypes.POINTER(ctypes.c_uint64)]
hipGraphGetRootNodes = _libraries['libamdhip64.so'].hipGraphGetRootNodes
hipGraphGetRootNodes.restype = hipError_t
hipGraphGetRootNodes.argtypes = [hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), ctypes.POINTER(ctypes.c_uint64)]
hipGraphNodeGetDependencies = _libraries['libamdhip64.so'].hipGraphNodeGetDependencies
hipGraphNodeGetDependencies.restype = hipError_t
hipGraphNodeGetDependencies.argtypes = [hipGraphNode_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), ctypes.POINTER(ctypes.c_uint64)]
hipGraphNodeGetDependentNodes = _libraries['libamdhip64.so'].hipGraphNodeGetDependentNodes
hipGraphNodeGetDependentNodes.restype = hipError_t
hipGraphNodeGetDependentNodes.argtypes = [hipGraphNode_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), ctypes.POINTER(ctypes.c_uint64)]
hipGraphNodeGetType = _libraries['libamdhip64.so'].hipGraphNodeGetType
hipGraphNodeGetType.restype = hipError_t
hipGraphNodeGetType.argtypes = [hipGraphNode_t, ctypes.POINTER(hipGraphNodeType)]
hipGraphDestroyNode = _libraries['libamdhip64.so'].hipGraphDestroyNode
hipGraphDestroyNode.restype = hipError_t
hipGraphDestroyNode.argtypes = [hipGraphNode_t]
hipGraphClone = _libraries['libamdhip64.so'].hipGraphClone
hipGraphClone.restype = hipError_t
hipGraphClone.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipGraph)), hipGraph_t]
hipGraphNodeFindInClone = _libraries['libamdhip64.so'].hipGraphNodeFindInClone
hipGraphNodeFindInClone.restype = hipError_t
hipGraphNodeFindInClone.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraphNode_t, hipGraph_t]
hipGraphInstantiate = _libraries['libamdhip64.so'].hipGraphInstantiate
hipGraphInstantiate.restype = hipError_t
hipGraphInstantiate.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphExec)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), ctypes.POINTER(ctypes.c_char), size_t]
hipGraphInstantiateWithFlags = _libraries['libamdhip64.so'].hipGraphInstantiateWithFlags
hipGraphInstantiateWithFlags.restype = hipError_t
hipGraphInstantiateWithFlags.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphExec)), hipGraph_t, ctypes.c_uint64]
hipGraphLaunch = _libraries['libamdhip64.so'].hipGraphLaunch
hipGraphLaunch.restype = hipError_t
hipGraphLaunch.argtypes = [hipGraphExec_t, hipStream_t]
hipGraphUpload = _libraries['libamdhip64.so'].hipGraphUpload
hipGraphUpload.restype = hipError_t
hipGraphUpload.argtypes = [hipGraphExec_t, hipStream_t]
hipGraphExecDestroy = _libraries['libamdhip64.so'].hipGraphExecDestroy
hipGraphExecDestroy.restype = hipError_t
hipGraphExecDestroy.argtypes = [hipGraphExec_t]
hipGraphExecUpdate = _libraries['libamdhip64.so'].hipGraphExecUpdate
hipGraphExecUpdate.restype = hipError_t
hipGraphExecUpdate.argtypes = [hipGraphExec_t, hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), ctypes.POINTER(hipGraphExecUpdateResult)]
hipGraphAddKernelNode = _libraries['libamdhip64.so'].hipGraphAddKernelNode
hipGraphAddKernelNode.restype = hipError_t
hipGraphAddKernelNode.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, ctypes.POINTER(struct_hipKernelNodeParams)]
hipGraphKernelNodeGetParams = _libraries['libamdhip64.so'].hipGraphKernelNodeGetParams
hipGraphKernelNodeGetParams.restype = hipError_t
hipGraphKernelNodeGetParams.argtypes = [hipGraphNode_t, ctypes.POINTER(struct_hipKernelNodeParams)]
hipGraphKernelNodeSetParams = _libraries['libamdhip64.so'].hipGraphKernelNodeSetParams
hipGraphKernelNodeSetParams.restype = hipError_t
hipGraphKernelNodeSetParams.argtypes = [hipGraphNode_t, ctypes.POINTER(struct_hipKernelNodeParams)]
hipGraphExecKernelNodeSetParams = _libraries['libamdhip64.so'].hipGraphExecKernelNodeSetParams
hipGraphExecKernelNodeSetParams.restype = hipError_t
hipGraphExecKernelNodeSetParams.argtypes = [hipGraphExec_t, hipGraphNode_t, ctypes.POINTER(struct_hipKernelNodeParams)]
hipGraphAddMemcpyNode = _libraries['libamdhip64.so'].hipGraphAddMemcpyNode
hipGraphAddMemcpyNode.restype = hipError_t
hipGraphAddMemcpyNode.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, ctypes.POINTER(struct_hipMemcpy3DParms)]
hipGraphMemcpyNodeGetParams = _libraries['libamdhip64.so'].hipGraphMemcpyNodeGetParams
hipGraphMemcpyNodeGetParams.restype = hipError_t
hipGraphMemcpyNodeGetParams.argtypes = [hipGraphNode_t, ctypes.POINTER(struct_hipMemcpy3DParms)]
hipGraphMemcpyNodeSetParams = _libraries['libamdhip64.so'].hipGraphMemcpyNodeSetParams
hipGraphMemcpyNodeSetParams.restype = hipError_t
hipGraphMemcpyNodeSetParams.argtypes = [hipGraphNode_t, ctypes.POINTER(struct_hipMemcpy3DParms)]
hipGraphKernelNodeSetAttribute = _libraries['libamdhip64.so'].hipGraphKernelNodeSetAttribute
hipGraphKernelNodeSetAttribute.restype = hipError_t
hipGraphKernelNodeSetAttribute.argtypes = [hipGraphNode_t, hipKernelNodeAttrID, ctypes.POINTER(union_hipKernelNodeAttrValue)]
hipGraphKernelNodeGetAttribute = _libraries['libamdhip64.so'].hipGraphKernelNodeGetAttribute
hipGraphKernelNodeGetAttribute.restype = hipError_t
hipGraphKernelNodeGetAttribute.argtypes = [hipGraphNode_t, hipKernelNodeAttrID, ctypes.POINTER(union_hipKernelNodeAttrValue)]
hipGraphExecMemcpyNodeSetParams = _libraries['libamdhip64.so'].hipGraphExecMemcpyNodeSetParams
hipGraphExecMemcpyNodeSetParams.restype = hipError_t
hipGraphExecMemcpyNodeSetParams.argtypes = [hipGraphExec_t, hipGraphNode_t, ctypes.POINTER(struct_hipMemcpy3DParms)]
hipGraphAddMemcpyNode1D = _libraries['libamdhip64.so'].hipGraphAddMemcpyNode1D
hipGraphAddMemcpyNode1D.restype = hipError_t
hipGraphAddMemcpyNode1D.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, ctypes.POINTER(None), ctypes.POINTER(None), size_t, hipMemcpyKind]
hipGraphMemcpyNodeSetParams1D = _libraries['libamdhip64.so'].hipGraphMemcpyNodeSetParams1D
hipGraphMemcpyNodeSetParams1D.restype = hipError_t
hipGraphMemcpyNodeSetParams1D.argtypes = [hipGraphNode_t, ctypes.POINTER(None), ctypes.POINTER(None), size_t, hipMemcpyKind]
hipGraphExecMemcpyNodeSetParams1D = _libraries['libamdhip64.so'].hipGraphExecMemcpyNodeSetParams1D
hipGraphExecMemcpyNodeSetParams1D.restype = hipError_t
hipGraphExecMemcpyNodeSetParams1D.argtypes = [hipGraphExec_t, hipGraphNode_t, ctypes.POINTER(None), ctypes.POINTER(None), size_t, hipMemcpyKind]
hipGraphAddMemcpyNodeFromSymbol = _libraries['libamdhip64.so'].hipGraphAddMemcpyNodeFromSymbol
hipGraphAddMemcpyNodeFromSymbol.restype = hipError_t
hipGraphAddMemcpyNodeFromSymbol.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, ctypes.POINTER(None), ctypes.POINTER(None), size_t, size_t, hipMemcpyKind]
hipGraphMemcpyNodeSetParamsFromSymbol = _libraries['libamdhip64.so'].hipGraphMemcpyNodeSetParamsFromSymbol
hipGraphMemcpyNodeSetParamsFromSymbol.restype = hipError_t
hipGraphMemcpyNodeSetParamsFromSymbol.argtypes = [hipGraphNode_t, ctypes.POINTER(None), ctypes.POINTER(None), size_t, size_t, hipMemcpyKind]
hipGraphExecMemcpyNodeSetParamsFromSymbol = _libraries['libamdhip64.so'].hipGraphExecMemcpyNodeSetParamsFromSymbol
hipGraphExecMemcpyNodeSetParamsFromSymbol.restype = hipError_t
hipGraphExecMemcpyNodeSetParamsFromSymbol.argtypes = [hipGraphExec_t, hipGraphNode_t, ctypes.POINTER(None), ctypes.POINTER(None), size_t, size_t, hipMemcpyKind]
hipGraphAddMemcpyNodeToSymbol = _libraries['libamdhip64.so'].hipGraphAddMemcpyNodeToSymbol
hipGraphAddMemcpyNodeToSymbol.restype = hipError_t
hipGraphAddMemcpyNodeToSymbol.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, ctypes.POINTER(None), ctypes.POINTER(None), size_t, size_t, hipMemcpyKind]
hipGraphMemcpyNodeSetParamsToSymbol = _libraries['libamdhip64.so'].hipGraphMemcpyNodeSetParamsToSymbol
hipGraphMemcpyNodeSetParamsToSymbol.restype = hipError_t
hipGraphMemcpyNodeSetParamsToSymbol.argtypes = [hipGraphNode_t, ctypes.POINTER(None), ctypes.POINTER(None), size_t, size_t, hipMemcpyKind]
hipGraphExecMemcpyNodeSetParamsToSymbol = _libraries['libamdhip64.so'].hipGraphExecMemcpyNodeSetParamsToSymbol
hipGraphExecMemcpyNodeSetParamsToSymbol.restype = hipError_t
hipGraphExecMemcpyNodeSetParamsToSymbol.argtypes = [hipGraphExec_t, hipGraphNode_t, ctypes.POINTER(None), ctypes.POINTER(None), size_t, size_t, hipMemcpyKind]
hipGraphAddMemsetNode = _libraries['libamdhip64.so'].hipGraphAddMemsetNode
hipGraphAddMemsetNode.restype = hipError_t
hipGraphAddMemsetNode.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, ctypes.POINTER(struct_hipMemsetParams)]
hipGraphMemsetNodeGetParams = _libraries['libamdhip64.so'].hipGraphMemsetNodeGetParams
hipGraphMemsetNodeGetParams.restype = hipError_t
hipGraphMemsetNodeGetParams.argtypes = [hipGraphNode_t, ctypes.POINTER(struct_hipMemsetParams)]
hipGraphMemsetNodeSetParams = _libraries['libamdhip64.so'].hipGraphMemsetNodeSetParams
hipGraphMemsetNodeSetParams.restype = hipError_t
hipGraphMemsetNodeSetParams.argtypes = [hipGraphNode_t, ctypes.POINTER(struct_hipMemsetParams)]
hipGraphExecMemsetNodeSetParams = _libraries['libamdhip64.so'].hipGraphExecMemsetNodeSetParams
hipGraphExecMemsetNodeSetParams.restype = hipError_t
hipGraphExecMemsetNodeSetParams.argtypes = [hipGraphExec_t, hipGraphNode_t, ctypes.POINTER(struct_hipMemsetParams)]
hipGraphAddHostNode = _libraries['libamdhip64.so'].hipGraphAddHostNode
hipGraphAddHostNode.restype = hipError_t
hipGraphAddHostNode.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, ctypes.POINTER(struct_hipHostNodeParams)]
hipGraphHostNodeGetParams = _libraries['libamdhip64.so'].hipGraphHostNodeGetParams
hipGraphHostNodeGetParams.restype = hipError_t
hipGraphHostNodeGetParams.argtypes = [hipGraphNode_t, ctypes.POINTER(struct_hipHostNodeParams)]
hipGraphHostNodeSetParams = _libraries['libamdhip64.so'].hipGraphHostNodeSetParams
hipGraphHostNodeSetParams.restype = hipError_t
hipGraphHostNodeSetParams.argtypes = [hipGraphNode_t, ctypes.POINTER(struct_hipHostNodeParams)]
hipGraphExecHostNodeSetParams = _libraries['libamdhip64.so'].hipGraphExecHostNodeSetParams
hipGraphExecHostNodeSetParams.restype = hipError_t
hipGraphExecHostNodeSetParams.argtypes = [hipGraphExec_t, hipGraphNode_t, ctypes.POINTER(struct_hipHostNodeParams)]
hipGraphAddChildGraphNode = _libraries['libamdhip64.so'].hipGraphAddChildGraphNode
hipGraphAddChildGraphNode.restype = hipError_t
hipGraphAddChildGraphNode.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, hipGraph_t]
hipGraphChildGraphNodeGetGraph = _libraries['libamdhip64.so'].hipGraphChildGraphNodeGetGraph
hipGraphChildGraphNodeGetGraph.restype = hipError_t
hipGraphChildGraphNodeGetGraph.argtypes = [hipGraphNode_t, ctypes.POINTER(ctypes.POINTER(struct_ihipGraph))]
hipGraphExecChildGraphNodeSetParams = _libraries['libamdhip64.so'].hipGraphExecChildGraphNodeSetParams
hipGraphExecChildGraphNodeSetParams.restype = hipError_t
hipGraphExecChildGraphNodeSetParams.argtypes = [hipGraphExec_t, hipGraphNode_t, hipGraph_t]
hipGraphAddEmptyNode = _libraries['libamdhip64.so'].hipGraphAddEmptyNode
hipGraphAddEmptyNode.restype = hipError_t
hipGraphAddEmptyNode.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t]
hipGraphAddEventRecordNode = _libraries['libamdhip64.so'].hipGraphAddEventRecordNode
hipGraphAddEventRecordNode.restype = hipError_t
hipGraphAddEventRecordNode.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, hipEvent_t]
hipGraphEventRecordNodeGetEvent = _libraries['libamdhip64.so'].hipGraphEventRecordNodeGetEvent
hipGraphEventRecordNodeGetEvent.restype = hipError_t
hipGraphEventRecordNodeGetEvent.argtypes = [hipGraphNode_t, ctypes.POINTER(ctypes.POINTER(struct_ihipEvent_t))]
hipGraphEventRecordNodeSetEvent = _libraries['libamdhip64.so'].hipGraphEventRecordNodeSetEvent
hipGraphEventRecordNodeSetEvent.restype = hipError_t
hipGraphEventRecordNodeSetEvent.argtypes = [hipGraphNode_t, hipEvent_t]
hipGraphExecEventRecordNodeSetEvent = _libraries['libamdhip64.so'].hipGraphExecEventRecordNodeSetEvent
hipGraphExecEventRecordNodeSetEvent.restype = hipError_t
hipGraphExecEventRecordNodeSetEvent.argtypes = [hipGraphExec_t, hipGraphNode_t, hipEvent_t]
hipGraphAddEventWaitNode = _libraries['libamdhip64.so'].hipGraphAddEventWaitNode
hipGraphAddEventWaitNode.restype = hipError_t
hipGraphAddEventWaitNode.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, hipEvent_t]
hipGraphEventWaitNodeGetEvent = _libraries['libamdhip64.so'].hipGraphEventWaitNodeGetEvent
hipGraphEventWaitNodeGetEvent.restype = hipError_t
hipGraphEventWaitNodeGetEvent.argtypes = [hipGraphNode_t, ctypes.POINTER(ctypes.POINTER(struct_ihipEvent_t))]
hipGraphEventWaitNodeSetEvent = _libraries['libamdhip64.so'].hipGraphEventWaitNodeSetEvent
hipGraphEventWaitNodeSetEvent.restype = hipError_t
hipGraphEventWaitNodeSetEvent.argtypes = [hipGraphNode_t, hipEvent_t]
hipGraphExecEventWaitNodeSetEvent = _libraries['libamdhip64.so'].hipGraphExecEventWaitNodeSetEvent
hipGraphExecEventWaitNodeSetEvent.restype = hipError_t
hipGraphExecEventWaitNodeSetEvent.argtypes = [hipGraphExec_t, hipGraphNode_t, hipEvent_t]
hipGraphAddMemAllocNode = _libraries['libamdhip64.so'].hipGraphAddMemAllocNode
hipGraphAddMemAllocNode.restype = hipError_t
hipGraphAddMemAllocNode.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, ctypes.POINTER(struct_hipMemAllocNodeParams)]
hipGraphMemAllocNodeGetParams = _libraries['libamdhip64.so'].hipGraphMemAllocNodeGetParams
hipGraphMemAllocNodeGetParams.restype = hipError_t
hipGraphMemAllocNodeGetParams.argtypes = [hipGraphNode_t, ctypes.POINTER(struct_hipMemAllocNodeParams)]
hipGraphAddMemFreeNode = _libraries['libamdhip64.so'].hipGraphAddMemFreeNode
hipGraphAddMemFreeNode.restype = hipError_t
hipGraphAddMemFreeNode.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, ctypes.POINTER(None)]
hipGraphMemFreeNodeGetParams = _libraries['libamdhip64.so'].hipGraphMemFreeNodeGetParams
hipGraphMemFreeNodeGetParams.restype = hipError_t
hipGraphMemFreeNodeGetParams.argtypes = [hipGraphNode_t, ctypes.POINTER(None)]
hipDeviceGetGraphMemAttribute = _libraries['libamdhip64.so'].hipDeviceGetGraphMemAttribute
hipDeviceGetGraphMemAttribute.restype = hipError_t
hipDeviceGetGraphMemAttribute.argtypes = [ctypes.c_int32, hipGraphMemAttributeType, ctypes.POINTER(None)]
hipDeviceSetGraphMemAttribute = _libraries['libamdhip64.so'].hipDeviceSetGraphMemAttribute
hipDeviceSetGraphMemAttribute.restype = hipError_t
hipDeviceSetGraphMemAttribute.argtypes = [ctypes.c_int32, hipGraphMemAttributeType, ctypes.POINTER(None)]
hipDeviceGraphMemTrim = _libraries['libamdhip64.so'].hipDeviceGraphMemTrim
hipDeviceGraphMemTrim.restype = hipError_t
hipDeviceGraphMemTrim.argtypes = [ctypes.c_int32]
hipUserObjectCreate = _libraries['libamdhip64.so'].hipUserObjectCreate
hipUserObjectCreate.restype = hipError_t
hipUserObjectCreate.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipUserObject)), ctypes.POINTER(None), hipHostFn_t, ctypes.c_uint32, ctypes.c_uint32]
hipUserObjectRelease = _libraries['libamdhip64.so'].hipUserObjectRelease
hipUserObjectRelease.restype = hipError_t
hipUserObjectRelease.argtypes = [hipUserObject_t, ctypes.c_uint32]
hipUserObjectRetain = _libraries['libamdhip64.so'].hipUserObjectRetain
hipUserObjectRetain.restype = hipError_t
hipUserObjectRetain.argtypes = [hipUserObject_t, ctypes.c_uint32]
hipGraphRetainUserObject = _libraries['libamdhip64.so'].hipGraphRetainUserObject
hipGraphRetainUserObject.restype = hipError_t
hipGraphRetainUserObject.argtypes = [hipGraph_t, hipUserObject_t, ctypes.c_uint32, ctypes.c_uint32]
hipGraphReleaseUserObject = _libraries['libamdhip64.so'].hipGraphReleaseUserObject
hipGraphReleaseUserObject.restype = hipError_t
hipGraphReleaseUserObject.argtypes = [hipGraph_t, hipUserObject_t, ctypes.c_uint32]
hipGraphDebugDotPrint = _libraries['libamdhip64.so'].hipGraphDebugDotPrint
hipGraphDebugDotPrint.restype = hipError_t
hipGraphDebugDotPrint.argtypes = [hipGraph_t, ctypes.POINTER(ctypes.c_char), ctypes.c_uint32]
hipGraphKernelNodeCopyAttributes = _libraries['libamdhip64.so'].hipGraphKernelNodeCopyAttributes
hipGraphKernelNodeCopyAttributes.restype = hipError_t
hipGraphKernelNodeCopyAttributes.argtypes = [hipGraphNode_t, hipGraphNode_t]
hipGraphNodeSetEnabled = _libraries['libamdhip64.so'].hipGraphNodeSetEnabled
hipGraphNodeSetEnabled.restype = hipError_t
hipGraphNodeSetEnabled.argtypes = [hipGraphExec_t, hipGraphNode_t, ctypes.c_uint32]
hipGraphNodeGetEnabled = _libraries['libamdhip64.so'].hipGraphNodeGetEnabled
hipGraphNodeGetEnabled.restype = hipError_t
hipGraphNodeGetEnabled.argtypes = [hipGraphExec_t, hipGraphNode_t, ctypes.POINTER(ctypes.c_uint32)]
hipGraphAddExternalSemaphoresWaitNode = _libraries['FIXME_STUB'].hipGraphAddExternalSemaphoresWaitNode
hipGraphAddExternalSemaphoresWaitNode.restype = hipError_t
hipGraphAddExternalSemaphoresWaitNode.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, ctypes.POINTER(struct_hipExternalSemaphoreWaitNodeParams)]
hipGraphAddExternalSemaphoresSignalNode = _libraries['FIXME_STUB'].hipGraphAddExternalSemaphoresSignalNode
hipGraphAddExternalSemaphoresSignalNode.restype = hipError_t
hipGraphAddExternalSemaphoresSignalNode.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), hipGraph_t, ctypes.POINTER(ctypes.POINTER(struct_hipGraphNode)), size_t, ctypes.POINTER(struct_hipExternalSemaphoreSignalNodeParams)]
hipGraphExternalSemaphoresSignalNodeSetParams = _libraries['FIXME_STUB'].hipGraphExternalSemaphoresSignalNodeSetParams
hipGraphExternalSemaphoresSignalNodeSetParams.restype = hipError_t
hipGraphExternalSemaphoresSignalNodeSetParams.argtypes = [hipGraphNode_t, ctypes.POINTER(struct_hipExternalSemaphoreSignalNodeParams)]
hipGraphExternalSemaphoresWaitNodeSetParams = _libraries['FIXME_STUB'].hipGraphExternalSemaphoresWaitNodeSetParams
hipGraphExternalSemaphoresWaitNodeSetParams.restype = hipError_t
hipGraphExternalSemaphoresWaitNodeSetParams.argtypes = [hipGraphNode_t, ctypes.POINTER(struct_hipExternalSemaphoreWaitNodeParams)]
hipGraphExternalSemaphoresSignalNodeGetParams = _libraries['FIXME_STUB'].hipGraphExternalSemaphoresSignalNodeGetParams
hipGraphExternalSemaphoresSignalNodeGetParams.restype = hipError_t
hipGraphExternalSemaphoresSignalNodeGetParams.argtypes = [hipGraphNode_t, ctypes.POINTER(struct_hipExternalSemaphoreSignalNodeParams)]
hipGraphExternalSemaphoresWaitNodeGetParams = _libraries['FIXME_STUB'].hipGraphExternalSemaphoresWaitNodeGetParams
hipGraphExternalSemaphoresWaitNodeGetParams.restype = hipError_t
hipGraphExternalSemaphoresWaitNodeGetParams.argtypes = [hipGraphNode_t, ctypes.POINTER(struct_hipExternalSemaphoreWaitNodeParams)]
hipGraphExecExternalSemaphoresSignalNodeSetParams = _libraries['FIXME_STUB'].hipGraphExecExternalSemaphoresSignalNodeSetParams
hipGraphExecExternalSemaphoresSignalNodeSetParams.restype = hipError_t
hipGraphExecExternalSemaphoresSignalNodeSetParams.argtypes = [hipGraphExec_t, hipGraphNode_t, ctypes.POINTER(struct_hipExternalSemaphoreSignalNodeParams)]
hipGraphExecExternalSemaphoresWaitNodeSetParams = _libraries['FIXME_STUB'].hipGraphExecExternalSemaphoresWaitNodeSetParams
hipGraphExecExternalSemaphoresWaitNodeSetParams.restype = hipError_t
hipGraphExecExternalSemaphoresWaitNodeSetParams.argtypes = [hipGraphExec_t, hipGraphNode_t, ctypes.POINTER(struct_hipExternalSemaphoreWaitNodeParams)]
hipMemAddressFree = _libraries['libamdhip64.so'].hipMemAddressFree
hipMemAddressFree.restype = hipError_t
hipMemAddressFree.argtypes = [ctypes.POINTER(None), size_t]
hipMemAddressReserve = _libraries['libamdhip64.so'].hipMemAddressReserve
hipMemAddressReserve.restype = hipError_t
hipMemAddressReserve.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), size_t, size_t, ctypes.POINTER(None), ctypes.c_uint64]
hipMemCreate = _libraries['libamdhip64.so'].hipMemCreate
hipMemCreate.restype = hipError_t
hipMemCreate.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipMemGenericAllocationHandle)), size_t, ctypes.POINTER(struct_hipMemAllocationProp), ctypes.c_uint64]
hipMemExportToShareableHandle = _libraries['libamdhip64.so'].hipMemExportToShareableHandle
hipMemExportToShareableHandle.restype = hipError_t
hipMemExportToShareableHandle.argtypes = [ctypes.POINTER(None), hipMemGenericAllocationHandle_t, hipMemAllocationHandleType, ctypes.c_uint64]
hipMemGetAccess = _libraries['libamdhip64.so'].hipMemGetAccess
hipMemGetAccess.restype = hipError_t
hipMemGetAccess.argtypes = [ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(struct_hipMemLocation), ctypes.POINTER(None)]
hipMemGetAllocationGranularity = _libraries['libamdhip64.so'].hipMemGetAllocationGranularity
hipMemGetAllocationGranularity.restype = hipError_t
hipMemGetAllocationGranularity.argtypes = [ctypes.POINTER(ctypes.c_uint64), ctypes.POINTER(struct_hipMemAllocationProp), hipMemAllocationGranularity_flags]
hipMemGetAllocationPropertiesFromHandle = _libraries['libamdhip64.so'].hipMemGetAllocationPropertiesFromHandle
hipMemGetAllocationPropertiesFromHandle.restype = hipError_t
hipMemGetAllocationPropertiesFromHandle.argtypes = [ctypes.POINTER(struct_hipMemAllocationProp), hipMemGenericAllocationHandle_t]
hipMemImportFromShareableHandle = _libraries['libamdhip64.so'].hipMemImportFromShareableHandle
hipMemImportFromShareableHandle.restype = hipError_t
hipMemImportFromShareableHandle.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipMemGenericAllocationHandle)), ctypes.POINTER(None), hipMemAllocationHandleType]
hipMemMap = _libraries['libamdhip64.so'].hipMemMap
hipMemMap.restype = hipError_t
hipMemMap.argtypes = [ctypes.POINTER(None), size_t, size_t, hipMemGenericAllocationHandle_t, ctypes.c_uint64]
hipMemMapArrayAsync = _libraries['libamdhip64.so'].hipMemMapArrayAsync
hipMemMapArrayAsync.restype = hipError_t
hipMemMapArrayAsync.argtypes = [ctypes.POINTER(struct_hipArrayMapInfo), ctypes.c_uint32, hipStream_t]
hipMemRelease = _libraries['libamdhip64.so'].hipMemRelease
hipMemRelease.restype = hipError_t
hipMemRelease.argtypes = [hipMemGenericAllocationHandle_t]
hipMemRetainAllocationHandle = _libraries['libamdhip64.so'].hipMemRetainAllocationHandle
hipMemRetainAllocationHandle.restype = hipError_t
hipMemRetainAllocationHandle.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_ihipMemGenericAllocationHandle)), ctypes.POINTER(None)]
hipMemSetAccess = _libraries['libamdhip64.so'].hipMemSetAccess
hipMemSetAccess.restype = hipError_t
hipMemSetAccess.argtypes = [ctypes.POINTER(None), size_t, ctypes.POINTER(struct_hipMemAccessDesc), size_t]
hipMemUnmap = _libraries['libamdhip64.so'].hipMemUnmap
hipMemUnmap.restype = hipError_t
hipMemUnmap.argtypes = [ctypes.POINTER(None), size_t]
GLuint = ctypes.c_uint32
GLenum = ctypes.c_uint32
hipGLGetDevices = _libraries['libamdhip64.so'].hipGLGetDevices
hipGLGetDevices.restype = hipError_t
hipGLGetDevices.argtypes = [ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_int32), ctypes.c_uint32, hipGLDeviceList]
hipGraphicsGLRegisterBuffer = _libraries['libamdhip64.so'].hipGraphicsGLRegisterBuffer
hipGraphicsGLRegisterBuffer.restype = hipError_t
hipGraphicsGLRegisterBuffer.argtypes = [ctypes.POINTER(ctypes.POINTER(struct__hipGraphicsResource)), GLuint, ctypes.c_uint32]
hipGraphicsGLRegisterImage = _libraries['libamdhip64.so'].hipGraphicsGLRegisterImage
hipGraphicsGLRegisterImage.restype = hipError_t
hipGraphicsGLRegisterImage.argtypes = [ctypes.POINTER(ctypes.POINTER(struct__hipGraphicsResource)), GLuint, GLenum, ctypes.c_uint32]
hipGraphicsMapResources = _libraries['libamdhip64.so'].hipGraphicsMapResources
hipGraphicsMapResources.restype = hipError_t
hipGraphicsMapResources.argtypes = [ctypes.c_int32, ctypes.POINTER(ctypes.POINTER(struct__hipGraphicsResource)), hipStream_t]
hipGraphicsSubResourceGetMappedArray = _libraries['libamdhip64.so'].hipGraphicsSubResourceGetMappedArray
hipGraphicsSubResourceGetMappedArray.restype = hipError_t
hipGraphicsSubResourceGetMappedArray.argtypes = [ctypes.POINTER(ctypes.POINTER(struct_hipArray)), hipGraphicsResource_t, ctypes.c_uint32, ctypes.c_uint32]
hipGraphicsResourceGetMappedPointer = _libraries['libamdhip64.so'].hipGraphicsResourceGetMappedPointer
hipGraphicsResourceGetMappedPointer.restype = hipError_t
hipGraphicsResourceGetMappedPointer.argtypes = [ctypes.POINTER(ctypes.POINTER(None)), ctypes.POINTER(ctypes.c_uint64), hipGraphicsResource_t]
hipGraphicsUnmapResources = _libraries['libamdhip64.so'].hipGraphicsUnmapResources
hipGraphicsUnmapResources.restype = hipError_t
hipGraphicsUnmapResources.argtypes = [ctypes.c_int32, ctypes.POINTER(ctypes.POINTER(struct__hipGraphicsResource)), hipStream_t]
hipGraphicsUnregisterResource = _libraries['libamdhip64.so'].hipGraphicsUnregisterResource
hipGraphicsUnregisterResource.restype = hipError_t
hipGraphicsUnregisterResource.argtypes = [hipGraphicsResource_t]
class struct___hip_surface(Structure):
pass
hipCreateSurfaceObject = _libraries['libamdhip64.so'].hipCreateSurfaceObject
hipCreateSurfaceObject.restype = hipError_t
hipCreateSurfaceObject.argtypes = [ctypes.POINTER(ctypes.POINTER(struct___hip_surface)), ctypes.POINTER(struct_hipResourceDesc)]
hipSurfaceObject_t = ctypes.POINTER(struct___hip_surface)
hipDestroySurfaceObject = _libraries['libamdhip64.so'].hipDestroySurfaceObject
hipDestroySurfaceObject.restype = hipError_t
hipDestroySurfaceObject.argtypes = [hipSurfaceObject_t]
__all__ = \
['GLenum', 'GLuint', 'HIPRTC_ERROR_BUILTIN_OPERATION_FAILURE',
'HIPRTC_ERROR_COMPILATION', 'HIPRTC_ERROR_INTERNAL_ERROR',
'HIPRTC_ERROR_INVALID_INPUT', 'HIPRTC_ERROR_INVALID_OPTION',
'HIPRTC_ERROR_INVALID_PROGRAM', 'HIPRTC_ERROR_LINKING',
'HIPRTC_ERROR_NAME_EXPRESSION_NOT_VALID',
'HIPRTC_ERROR_NO_LOWERED_NAMES_BEFORE_COMPILATION',
'HIPRTC_ERROR_NO_NAME_EXPRESSIONS_AFTER_COMPILATION',
'HIPRTC_ERROR_OUT_OF_MEMORY',
'HIPRTC_ERROR_PROGRAM_CREATION_FAILURE', 'HIPRTC_JIT_CACHE_MODE',
'HIPRTC_JIT_ERROR_LOG_BUFFER',
'HIPRTC_JIT_ERROR_LOG_BUFFER_SIZE_BYTES',
'HIPRTC_JIT_FALLBACK_STRATEGY', 'HIPRTC_JIT_FAST_COMPILE',
'HIPRTC_JIT_FMA', 'HIPRTC_JIT_FTZ',
'HIPRTC_JIT_GENERATE_DEBUG_INFO', 'HIPRTC_JIT_GENERATE_LINE_INFO',
'HIPRTC_JIT_GLOBAL_SYMBOL_ADDRESS',
'HIPRTC_JIT_GLOBAL_SYMBOL_COUNT',
'HIPRTC_JIT_GLOBAL_SYMBOL_NAMES', 'HIPRTC_JIT_INFO_LOG_BUFFER',
'HIPRTC_JIT_INFO_LOG_BUFFER_SIZE_BYTES', 'HIPRTC_JIT_INPUT_CUBIN',
'HIPRTC_JIT_INPUT_FATBINARY', 'HIPRTC_JIT_INPUT_LIBRARY',
'HIPRTC_JIT_INPUT_LLVM_ARCHIVES_OF_BUNDLED_BITCODE',
'HIPRTC_JIT_INPUT_LLVM_BITCODE',
'HIPRTC_JIT_INPUT_LLVM_BUNDLED_BITCODE', 'HIPRTC_JIT_INPUT_NVVM',
'HIPRTC_JIT_INPUT_OBJECT', 'HIPRTC_JIT_INPUT_PTX',
'HIPRTC_JIT_IR_TO_ISA_OPT_COUNT_EXT',
'HIPRTC_JIT_IR_TO_ISA_OPT_EXT', 'HIPRTC_JIT_LOG_VERBOSE',
'HIPRTC_JIT_LTO', 'HIPRTC_JIT_MAX_REGISTERS',
'HIPRTC_JIT_NEW_SM3X_OPT', 'HIPRTC_JIT_NUM_INPUT_TYPES',
'HIPRTC_JIT_NUM_LEGACY_INPUT_TYPES', 'HIPRTC_JIT_NUM_OPTIONS',
'HIPRTC_JIT_OPTIMIZATION_LEVEL', 'HIPRTC_JIT_PREC_DIV',
'HIPRTC_JIT_PREC_SQRT', 'HIPRTC_JIT_TARGET',
'HIPRTC_JIT_TARGET_FROM_HIPCONTEXT',
'HIPRTC_JIT_THREADS_PER_BLOCK', 'HIPRTC_JIT_WALL_TIME',
'HIPRTC_SUCCESS', 'HIP_AD_FORMAT_FLOAT', 'HIP_AD_FORMAT_HALF',
'HIP_AD_FORMAT_SIGNED_INT16', 'HIP_AD_FORMAT_SIGNED_INT32',
'HIP_AD_FORMAT_SIGNED_INT8', 'HIP_AD_FORMAT_UNSIGNED_INT16',
'HIP_AD_FORMAT_UNSIGNED_INT32', 'HIP_AD_FORMAT_UNSIGNED_INT8',
'HIP_ARRAY3D_DESCRIPTOR', 'HIP_ARRAY_DESCRIPTOR',
'HIP_ERROR_INVALID_VALUE', 'HIP_ERROR_LAUNCH_OUT_OF_RESOURCES',
'HIP_ERROR_NOT_INITIALIZED', 'HIP_FUNC_ATTRIBUTE_BINARY_VERSION',
'HIP_FUNC_ATTRIBUTE_CACHE_MODE_CA',
'HIP_FUNC_ATTRIBUTE_CONST_SIZE_BYTES',
'HIP_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES', 'HIP_FUNC_ATTRIBUTE_MAX',
'HIP_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES',
'HIP_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK',
'HIP_FUNC_ATTRIBUTE_NUM_REGS',
'HIP_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT',
'HIP_FUNC_ATTRIBUTE_PTX_VERSION',
'HIP_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES', 'HIP_MEMCPY3D',
'HIP_POINTER_ATTRIBUTE_ACCESS_FLAGS',
'HIP_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES',
'HIP_POINTER_ATTRIBUTE_BUFFER_ID',
'HIP_POINTER_ATTRIBUTE_CONTEXT',
'HIP_POINTER_ATTRIBUTE_DEVICE_ORDINAL',
'HIP_POINTER_ATTRIBUTE_DEVICE_POINTER',
'HIP_POINTER_ATTRIBUTE_HOST_POINTER',
'HIP_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE',
'HIP_POINTER_ATTRIBUTE_IS_LEGACY_HIP_IPC_CAPABLE',
'HIP_POINTER_ATTRIBUTE_IS_MANAGED',
'HIP_POINTER_ATTRIBUTE_MAPPED',
'HIP_POINTER_ATTRIBUTE_MEMORY_TYPE',
'HIP_POINTER_ATTRIBUTE_MEMPOOL_HANDLE',
'HIP_POINTER_ATTRIBUTE_P2P_TOKENS',
'HIP_POINTER_ATTRIBUTE_RANGE_SIZE',
'HIP_POINTER_ATTRIBUTE_RANGE_START_ADDR',
'HIP_POINTER_ATTRIBUTE_SYNC_MEMOPS', 'HIP_RESOURCE_DESC',
'HIP_RESOURCE_TYPE_ARRAY', 'HIP_RESOURCE_TYPE_LINEAR',
'HIP_RESOURCE_TYPE_MIPMAPPED_ARRAY', 'HIP_RESOURCE_TYPE_PITCH2D',
'HIP_RESOURCE_VIEW_DESC', 'HIP_RES_VIEW_FORMAT_FLOAT_1X16',
'HIP_RES_VIEW_FORMAT_FLOAT_1X32',
'HIP_RES_VIEW_FORMAT_FLOAT_2X16',
'HIP_RES_VIEW_FORMAT_FLOAT_2X32',
'HIP_RES_VIEW_FORMAT_FLOAT_4X16',
'HIP_RES_VIEW_FORMAT_FLOAT_4X32', 'HIP_RES_VIEW_FORMAT_NONE',
'HIP_RES_VIEW_FORMAT_SIGNED_BC4',
'HIP_RES_VIEW_FORMAT_SIGNED_BC5',
'HIP_RES_VIEW_FORMAT_SIGNED_BC6H',
'HIP_RES_VIEW_FORMAT_SINT_1X16', 'HIP_RES_VIEW_FORMAT_SINT_1X32',
'HIP_RES_VIEW_FORMAT_SINT_1X8', 'HIP_RES_VIEW_FORMAT_SINT_2X16',
'HIP_RES_VIEW_FORMAT_SINT_2X32', 'HIP_RES_VIEW_FORMAT_SINT_2X8',
'HIP_RES_VIEW_FORMAT_SINT_4X16', 'HIP_RES_VIEW_FORMAT_SINT_4X32',
'HIP_RES_VIEW_FORMAT_SINT_4X8', 'HIP_RES_VIEW_FORMAT_UINT_1X16',
'HIP_RES_VIEW_FORMAT_UINT_1X32', 'HIP_RES_VIEW_FORMAT_UINT_1X8',
'HIP_RES_VIEW_FORMAT_UINT_2X16', 'HIP_RES_VIEW_FORMAT_UINT_2X32',
'HIP_RES_VIEW_FORMAT_UINT_2X8', 'HIP_RES_VIEW_FORMAT_UINT_4X16',
'HIP_RES_VIEW_FORMAT_UINT_4X32', 'HIP_RES_VIEW_FORMAT_UINT_4X8',
'HIP_RES_VIEW_FORMAT_UNSIGNED_BC1',
'HIP_RES_VIEW_FORMAT_UNSIGNED_BC2',
'HIP_RES_VIEW_FORMAT_UNSIGNED_BC3',
'HIP_RES_VIEW_FORMAT_UNSIGNED_BC4',
'HIP_RES_VIEW_FORMAT_UNSIGNED_BC5',
'HIP_RES_VIEW_FORMAT_UNSIGNED_BC6H',
'HIP_RES_VIEW_FORMAT_UNSIGNED_BC7', 'HIP_SUCCESS',
'HIP_TEXTURE_DESC', 'HIP_TR_ADDRESS_MODE_BORDER',
'HIP_TR_ADDRESS_MODE_CLAMP', 'HIP_TR_ADDRESS_MODE_MIRROR',
'HIP_TR_ADDRESS_MODE_WRAP', 'HIP_TR_FILTER_MODE_LINEAR',
'HIP_TR_FILTER_MODE_POINT', 'HIPaddress_mode',
'HIPaddress_mode__enumvalues', 'HIPaddress_mode_enum',
'HIPfilter_mode', 'HIPfilter_mode__enumvalues',
'HIPfilter_mode_enum', 'HIPresourceViewFormat',
'HIPresourceViewFormat__enumvalues', 'HIPresourceViewFormat_enum',
'HIPresourcetype', 'HIPresourcetype__enumvalues',
'HIPresourcetype_enum', '__hipGetPCH',
'__hipPopCallConfiguration', '__hipPushCallConfiguration',
'c__Ea_HIP_SUCCESS', 'dim3', 'hipAccessPolicyWindow',
'hipAccessProperty', 'hipAccessPropertyNormal',
'hipAccessPropertyPersisting', 'hipAccessPropertyStreaming',
'hipAddressModeBorder', 'hipAddressModeClamp',
'hipAddressModeMirror', 'hipAddressModeWrap', 'hipApiName',
'hipArray', 'hipArray3DCreate', 'hipArray3DGetDescriptor',
'hipArrayCreate', 'hipArrayDestroy', 'hipArrayGetDescriptor',
'hipArrayGetInfo', 'hipArrayMapInfo',
'hipArraySparseSubresourceType',
'hipArraySparseSubresourceTypeMiptail',
'hipArraySparseSubresourceTypeSparseLevel', 'hipArray_Format',
'hipArray_const_t', 'hipArray_t', 'hipBindTexture',
'hipBindTexture2D', 'hipBindTextureToArray',
'hipBindTextureToMipmappedArray', 'hipChannelFormatDesc',
'hipChannelFormatKind', 'hipChannelFormatKindFloat',
'hipChannelFormatKindNone', 'hipChannelFormatKindSigned',
'hipChannelFormatKindUnsigned', 'hipChooseDevice',
'hipComputeMode', 'hipComputeModeDefault',
'hipComputeModeExclusive', 'hipComputeModeExclusiveProcess',
'hipComputeModeProhibited', 'hipConfigureCall',
'hipCreateSurfaceObject', 'hipCreateTextureObject',
'hipCtxCreate', 'hipCtxDestroy', 'hipCtxDisablePeerAccess',
'hipCtxEnablePeerAccess', 'hipCtxGetApiVersion',
'hipCtxGetCacheConfig', 'hipCtxGetCurrent', 'hipCtxGetDevice',
'hipCtxGetFlags', 'hipCtxGetSharedMemConfig', 'hipCtxPopCurrent',
'hipCtxPushCurrent', 'hipCtxSetCacheConfig', 'hipCtxSetCurrent',
'hipCtxSetSharedMemConfig', 'hipCtxSynchronize', 'hipCtx_t',
'hipDestroyExternalMemory', 'hipDestroyExternalSemaphore',
'hipDestroySurfaceObject', 'hipDestroyTextureObject',
'hipDevP2PAttrAccessSupported',
'hipDevP2PAttrHipArrayAccessSupported',
'hipDevP2PAttrNativeAtomicSupported',
'hipDevP2PAttrPerformanceRank', 'hipDeviceArch_t',
'hipDeviceAttributeAccessPolicyMaxWindowSize',
'hipDeviceAttributeAmdSpecificBegin',
'hipDeviceAttributeAmdSpecificEnd', 'hipDeviceAttributeArch',
'hipDeviceAttributeAsicRevision',
'hipDeviceAttributeAsyncEngineCount',
'hipDeviceAttributeCanMapHostMemory',
'hipDeviceAttributeCanUseHostPointerForRegisteredMem',
'hipDeviceAttributeCanUseStreamWaitValue',
'hipDeviceAttributeClockInstructionRate',
'hipDeviceAttributeClockRate',
'hipDeviceAttributeComputeCapabilityMajor',
'hipDeviceAttributeComputeCapabilityMinor',
'hipDeviceAttributeComputeMode',
'hipDeviceAttributeComputePreemptionSupported',
'hipDeviceAttributeConcurrentKernels',
'hipDeviceAttributeConcurrentManagedAccess',
'hipDeviceAttributeCooperativeLaunch',
'hipDeviceAttributeCooperativeMultiDeviceLaunch',
'hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim',
'hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc',
'hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim',
'hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem',
'hipDeviceAttributeCudaCompatibleBegin',
'hipDeviceAttributeCudaCompatibleEnd',
'hipDeviceAttributeDeviceOverlap',
'hipDeviceAttributeDirectManagedMemAccessFromHost',
'hipDeviceAttributeEccEnabled',
'hipDeviceAttributeFineGrainSupport', 'hipDeviceAttributeGcnArch',
'hipDeviceAttributeGcnArchName',
'hipDeviceAttributeGlobalL1CacheSupported',
'hipDeviceAttributeHdpMemFlushCntl',
'hipDeviceAttributeHdpRegFlushCntl',
'hipDeviceAttributeHostNativeAtomicSupported',
'hipDeviceAttributeImageSupport', 'hipDeviceAttributeIntegrated',
'hipDeviceAttributeIsLargeBar',
'hipDeviceAttributeIsMultiGpuBoard',
'hipDeviceAttributeKernelExecTimeout',
'hipDeviceAttributeL2CacheSize',
'hipDeviceAttributeLocalL1CacheSupported',
'hipDeviceAttributeLuid', 'hipDeviceAttributeLuidDeviceNodeMask',
'hipDeviceAttributeManagedMemory',
'hipDeviceAttributeMaxBlockDimX',
'hipDeviceAttributeMaxBlockDimY',
'hipDeviceAttributeMaxBlockDimZ',
'hipDeviceAttributeMaxBlocksPerMultiProcessor',
'hipDeviceAttributeMaxGridDimX', 'hipDeviceAttributeMaxGridDimY',
'hipDeviceAttributeMaxGridDimZ', 'hipDeviceAttributeMaxPitch',
'hipDeviceAttributeMaxRegistersPerBlock',
'hipDeviceAttributeMaxRegistersPerMultiprocessor',
'hipDeviceAttributeMaxSharedMemoryPerBlock',
'hipDeviceAttributeMaxSharedMemoryPerMultiprocessor',
'hipDeviceAttributeMaxSurface1D',
'hipDeviceAttributeMaxSurface1DLayered',
'hipDeviceAttributeMaxSurface2D',
'hipDeviceAttributeMaxSurface2DLayered',
'hipDeviceAttributeMaxSurface3D',
'hipDeviceAttributeMaxSurfaceCubemap',
'hipDeviceAttributeMaxSurfaceCubemapLayered',
'hipDeviceAttributeMaxTexture1DLayered',
'hipDeviceAttributeMaxTexture1DLinear',
'hipDeviceAttributeMaxTexture1DMipmap',
'hipDeviceAttributeMaxTexture1DWidth',
'hipDeviceAttributeMaxTexture2DGather',
'hipDeviceAttributeMaxTexture2DHeight',
'hipDeviceAttributeMaxTexture2DLayered',
'hipDeviceAttributeMaxTexture2DLinear',
'hipDeviceAttributeMaxTexture2DMipmap',
'hipDeviceAttributeMaxTexture2DWidth',
'hipDeviceAttributeMaxTexture3DAlt',
'hipDeviceAttributeMaxTexture3DDepth',
'hipDeviceAttributeMaxTexture3DHeight',
'hipDeviceAttributeMaxTexture3DWidth',
'hipDeviceAttributeMaxTextureCubemap',
'hipDeviceAttributeMaxTextureCubemapLayered',
'hipDeviceAttributeMaxThreadsDim',
'hipDeviceAttributeMaxThreadsPerBlock',
'hipDeviceAttributeMaxThreadsPerMultiProcessor',
'hipDeviceAttributeMemoryBusWidth',
'hipDeviceAttributeMemoryClockRate',
'hipDeviceAttributeMemoryPoolsSupported',
'hipDeviceAttributeMultiGpuBoardGroupID',
'hipDeviceAttributeMultiprocessorCount', 'hipDeviceAttributeName',
'hipDeviceAttributePageableMemoryAccess',
'hipDeviceAttributePageableMemoryAccessUsesHostPageTables',
'hipDeviceAttributePciBusId', 'hipDeviceAttributePciDeviceId',
'hipDeviceAttributePciDomainID',
'hipDeviceAttributePersistingL2CacheMaxSize',
'hipDeviceAttributePhysicalMultiProcessorCount',
'hipDeviceAttributeReservedSharedMemPerBlock',
'hipDeviceAttributeSharedMemPerBlockOptin',
'hipDeviceAttributeSharedMemPerMultiprocessor',
'hipDeviceAttributeSingleToDoublePrecisionPerfRatio',
'hipDeviceAttributeStreamPrioritiesSupported',
'hipDeviceAttributeSurfaceAlignment',
'hipDeviceAttributeTccDriver',
'hipDeviceAttributeTextureAlignment',
'hipDeviceAttributeTexturePitchAlignment',
'hipDeviceAttributeTotalConstantMemory',
'hipDeviceAttributeTotalGlobalMem',
'hipDeviceAttributeUnifiedAddressing', 'hipDeviceAttributeUuid',
'hipDeviceAttributeVendorSpecificBegin',
'hipDeviceAttributeVirtualMemoryManagementSupported',
'hipDeviceAttributeWallClockRate', 'hipDeviceAttributeWarpSize',
'hipDeviceAttribute_t', 'hipDeviceCanAccessPeer',
'hipDeviceComputeCapability', 'hipDeviceDisablePeerAccess',
'hipDeviceEnablePeerAccess', 'hipDeviceGet',
'hipDeviceGetAttribute', 'hipDeviceGetByPCIBusId',
'hipDeviceGetCacheConfig', 'hipDeviceGetDefaultMemPool',
'hipDeviceGetGraphMemAttribute', 'hipDeviceGetLimit',
'hipDeviceGetMemPool', 'hipDeviceGetName',
'hipDeviceGetP2PAttribute', 'hipDeviceGetPCIBusId',
'hipDeviceGetSharedMemConfig', 'hipDeviceGetStreamPriorityRange',
'hipDeviceGetUuid', 'hipDeviceGraphMemTrim', 'hipDeviceP2PAttr',
'hipDevicePrimaryCtxGetState', 'hipDevicePrimaryCtxRelease',
'hipDevicePrimaryCtxReset', 'hipDevicePrimaryCtxRetain',
'hipDevicePrimaryCtxSetFlags', 'hipDeviceProp_t',
'hipDeviceReset', 'hipDeviceSetCacheConfig',
'hipDeviceSetGraphMemAttribute', 'hipDeviceSetLimit',
'hipDeviceSetMemPool', 'hipDeviceSetSharedMemConfig',
'hipDeviceSynchronize', 'hipDeviceTotalMem', 'hipDevice_t',
'hipDeviceptr_t', 'hipDriverGetVersion', 'hipDrvGetErrorName',
'hipDrvGetErrorString', 'hipDrvMemcpy2DUnaligned',
'hipDrvMemcpy3D', 'hipDrvMemcpy3DAsync',
'hipDrvPointerGetAttributes', 'hipErrorAlreadyAcquired',
'hipErrorAlreadyMapped', 'hipErrorArrayIsMapped',
'hipErrorAssert', 'hipErrorCapturedEvent',
'hipErrorContextAlreadyCurrent', 'hipErrorContextAlreadyInUse',
'hipErrorContextIsDestroyed', 'hipErrorCooperativeLaunchTooLarge',
'hipErrorDeinitialized', 'hipErrorECCNotCorrectable',
'hipErrorFileNotFound', 'hipErrorGraphExecUpdateFailure',
'hipErrorHostMemoryAlreadyRegistered',
'hipErrorHostMemoryNotRegistered', 'hipErrorIllegalAddress',
'hipErrorIllegalState', 'hipErrorInitializationError',
'hipErrorInsufficientDriver', 'hipErrorInvalidConfiguration',
'hipErrorInvalidContext', 'hipErrorInvalidDevice',
'hipErrorInvalidDeviceFunction', 'hipErrorInvalidDevicePointer',
'hipErrorInvalidGraphicsContext', 'hipErrorInvalidHandle',
'hipErrorInvalidImage', 'hipErrorInvalidKernelFile',
'hipErrorInvalidMemcpyDirection', 'hipErrorInvalidPitchValue',
'hipErrorInvalidResourceHandle', 'hipErrorInvalidSource',
'hipErrorInvalidSymbol', 'hipErrorInvalidValue',
'hipErrorLaunchFailure', 'hipErrorLaunchOutOfResources',
'hipErrorLaunchTimeOut', 'hipErrorMapBufferObjectFailed',
'hipErrorMapFailed', 'hipErrorMemoryAllocation',
'hipErrorMissingConfiguration', 'hipErrorNoBinaryForGpu',
'hipErrorNoDevice', 'hipErrorNotFound', 'hipErrorNotInitialized',
'hipErrorNotMapped', 'hipErrorNotMappedAsArray',
'hipErrorNotMappedAsPointer', 'hipErrorNotReady',
'hipErrorNotSupported', 'hipErrorOperatingSystem',
'hipErrorOutOfMemory', 'hipErrorPeerAccessAlreadyEnabled',
'hipErrorPeerAccessNotEnabled', 'hipErrorPeerAccessUnsupported',
'hipErrorPriorLaunchFailure', 'hipErrorProfilerAlreadyStarted',
'hipErrorProfilerAlreadyStopped', 'hipErrorProfilerDisabled',
'hipErrorProfilerNotInitialized', 'hipErrorRuntimeMemory',
'hipErrorRuntimeOther', 'hipErrorSetOnActiveProcess',
'hipErrorSharedObjectInitFailed',
'hipErrorSharedObjectSymbolNotFound',
'hipErrorStreamCaptureImplicit',
'hipErrorStreamCaptureInvalidated',
'hipErrorStreamCaptureIsolation', 'hipErrorStreamCaptureMerge',
'hipErrorStreamCaptureUnjoined', 'hipErrorStreamCaptureUnmatched',
'hipErrorStreamCaptureUnsupported',
'hipErrorStreamCaptureWrongThread', 'hipErrorTbd',
'hipErrorUnknown', 'hipErrorUnmapFailed',
'hipErrorUnsupportedLimit', 'hipError_t', 'hipEventCreate',
'hipEventCreateWithFlags', 'hipEventDestroy',
'hipEventElapsedTime', 'hipEventQuery', 'hipEventRecord',
'hipEventSynchronize', 'hipEvent_t',
'hipExtGetLinkTypeAndHopCount', 'hipExtLaunchKernel',
'hipExtLaunchMultiKernelMultiDevice', 'hipExtMallocWithFlags',
'hipExtStreamCreateWithCUMask', 'hipExtStreamGetCUMask',
'hipExtent', 'hipExternalMemoryBufferDesc',
'hipExternalMemoryGetMappedBuffer', 'hipExternalMemoryHandleDesc',
'hipExternalMemoryHandleType',
'hipExternalMemoryHandleTypeD3D11Resource',
'hipExternalMemoryHandleTypeD3D11ResourceKmt',
'hipExternalMemoryHandleTypeD3D12Heap',
'hipExternalMemoryHandleTypeD3D12Resource',
'hipExternalMemoryHandleTypeOpaqueFd',
'hipExternalMemoryHandleTypeOpaqueWin32',
'hipExternalMemoryHandleTypeOpaqueWin32Kmt',
'hipExternalMemoryHandleType__enumvalues',
'hipExternalMemoryHandleType_enum', 'hipExternalMemory_t',
'hipExternalSemaphoreHandleDesc',
'hipExternalSemaphoreHandleType',
'hipExternalSemaphoreHandleTypeD3D12Fence',
'hipExternalSemaphoreHandleTypeOpaqueFd',
'hipExternalSemaphoreHandleTypeOpaqueWin32',
'hipExternalSemaphoreHandleTypeOpaqueWin32Kmt',
'hipExternalSemaphoreHandleType__enumvalues',
'hipExternalSemaphoreHandleType_enum',
'hipExternalSemaphoreSignalNodeParams',
'hipExternalSemaphoreSignalParams',
'hipExternalSemaphoreWaitNodeParams',
'hipExternalSemaphoreWaitParams', 'hipExternalSemaphore_t',
'hipFilterModeLinear', 'hipFilterModePoint', 'hipFree',
'hipFreeArray', 'hipFreeAsync', 'hipFreeHost',
'hipFreeMipmappedArray', 'hipFuncAttribute',
'hipFuncAttributeMax',
'hipFuncAttributeMaxDynamicSharedMemorySize',
'hipFuncAttributePreferredSharedMemoryCarveout',
'hipFuncAttributes', 'hipFuncCachePreferEqual',
'hipFuncCachePreferL1', 'hipFuncCachePreferNone',
'hipFuncCachePreferShared', 'hipFuncCache_t',
'hipFuncGetAttribute', 'hipFuncGetAttributes',
'hipFuncSetAttribute', 'hipFuncSetCacheConfig',
'hipFuncSetSharedMemConfig', 'hipFunctionLaunchParams',
'hipFunction_attribute', 'hipFunction_t', 'hipGLDeviceList',
'hipGLDeviceListAll', 'hipGLDeviceListCurrentFrame',
'hipGLDeviceListNextFrame', 'hipGLGetDevices',
'hipGetChannelDesc', 'hipGetDevice', 'hipGetDeviceCount',
'hipGetDeviceFlags', 'hipGetDeviceProperties', 'hipGetErrorName',
'hipGetErrorString', 'hipGetLastError',
'hipGetMipmappedArrayLevel', 'hipGetStreamDeviceId',
'hipGetSymbolAddress', 'hipGetSymbolSize',
'hipGetTextureAlignmentOffset', 'hipGetTextureObjectResourceDesc',
'hipGetTextureObjectResourceViewDesc',
'hipGetTextureObjectTextureDesc', 'hipGetTextureReference',
'hipGraphAddChildGraphNode', 'hipGraphAddDependencies',
'hipGraphAddEmptyNode', 'hipGraphAddEventRecordNode',
'hipGraphAddEventWaitNode',
'hipGraphAddExternalSemaphoresSignalNode',
'hipGraphAddExternalSemaphoresWaitNode', 'hipGraphAddHostNode',
'hipGraphAddKernelNode', 'hipGraphAddMemAllocNode',
'hipGraphAddMemFreeNode', 'hipGraphAddMemcpyNode',
'hipGraphAddMemcpyNode1D', 'hipGraphAddMemcpyNodeFromSymbol',
'hipGraphAddMemcpyNodeToSymbol', 'hipGraphAddMemsetNode',
'hipGraphChildGraphNodeGetGraph', 'hipGraphClone',
'hipGraphCreate', 'hipGraphDebugDotFlags',
'hipGraphDebugDotFlagsEventNodeParams',
'hipGraphDebugDotFlagsExtSemasSignalNodeParams',
'hipGraphDebugDotFlagsExtSemasWaitNodeParams',
'hipGraphDebugDotFlagsHandles',
'hipGraphDebugDotFlagsHostNodeParams',
'hipGraphDebugDotFlagsKernelNodeAttributes',
'hipGraphDebugDotFlagsKernelNodeParams',
'hipGraphDebugDotFlagsMemcpyNodeParams',
'hipGraphDebugDotFlagsMemsetNodeParams',
'hipGraphDebugDotFlagsVerbose', 'hipGraphDebugDotPrint',
'hipGraphDestroy', 'hipGraphDestroyNode',
'hipGraphEventRecordNodeGetEvent',
'hipGraphEventRecordNodeSetEvent',
'hipGraphEventWaitNodeGetEvent', 'hipGraphEventWaitNodeSetEvent',
'hipGraphExecChildGraphNodeSetParams', 'hipGraphExecDestroy',
'hipGraphExecEventRecordNodeSetEvent',
'hipGraphExecEventWaitNodeSetEvent',
'hipGraphExecExternalSemaphoresSignalNodeSetParams',
'hipGraphExecExternalSemaphoresWaitNodeSetParams',
'hipGraphExecHostNodeSetParams',
'hipGraphExecKernelNodeSetParams',
'hipGraphExecMemcpyNodeSetParams',
'hipGraphExecMemcpyNodeSetParams1D',
'hipGraphExecMemcpyNodeSetParamsFromSymbol',
'hipGraphExecMemcpyNodeSetParamsToSymbol',
'hipGraphExecMemsetNodeSetParams', 'hipGraphExecUpdate',
'hipGraphExecUpdateError',
'hipGraphExecUpdateErrorFunctionChanged',
'hipGraphExecUpdateErrorNodeTypeChanged',
'hipGraphExecUpdateErrorNotSupported',
'hipGraphExecUpdateErrorParametersChanged',
'hipGraphExecUpdateErrorTopologyChanged',
'hipGraphExecUpdateErrorUnsupportedFunctionChange',
'hipGraphExecUpdateResult', 'hipGraphExecUpdateSuccess',
'hipGraphExec_t', 'hipGraphExternalSemaphoresSignalNodeGetParams',
'hipGraphExternalSemaphoresSignalNodeSetParams',
'hipGraphExternalSemaphoresWaitNodeGetParams',
'hipGraphExternalSemaphoresWaitNodeSetParams', 'hipGraphGetEdges',
'hipGraphGetNodes', 'hipGraphGetRootNodes',
'hipGraphHostNodeGetParams', 'hipGraphHostNodeSetParams',
'hipGraphInstantiate', 'hipGraphInstantiateFlagAutoFreeOnLaunch',
'hipGraphInstantiateFlagDeviceLaunch',
'hipGraphInstantiateFlagUpload',
'hipGraphInstantiateFlagUseNodePriority',
'hipGraphInstantiateFlags', 'hipGraphInstantiateWithFlags',
'hipGraphKernelNodeCopyAttributes',
'hipGraphKernelNodeGetAttribute', 'hipGraphKernelNodeGetParams',
'hipGraphKernelNodeSetAttribute', 'hipGraphKernelNodeSetParams',
'hipGraphLaunch', 'hipGraphMemAllocNodeGetParams',
'hipGraphMemAttrReservedMemCurrent',
'hipGraphMemAttrReservedMemHigh', 'hipGraphMemAttrUsedMemCurrent',
'hipGraphMemAttrUsedMemHigh', 'hipGraphMemAttributeType',
'hipGraphMemFreeNodeGetParams', 'hipGraphMemcpyNodeGetParams',
'hipGraphMemcpyNodeSetParams', 'hipGraphMemcpyNodeSetParams1D',
'hipGraphMemcpyNodeSetParamsFromSymbol',
'hipGraphMemcpyNodeSetParamsToSymbol',
'hipGraphMemsetNodeGetParams', 'hipGraphMemsetNodeSetParams',
'hipGraphNodeFindInClone', 'hipGraphNodeGetDependencies',
'hipGraphNodeGetDependentNodes', 'hipGraphNodeGetEnabled',
'hipGraphNodeGetType', 'hipGraphNodeSetEnabled',
'hipGraphNodeType', 'hipGraphNodeTypeCount',
'hipGraphNodeTypeEmpty', 'hipGraphNodeTypeEventRecord',
'hipGraphNodeTypeExtSemaphoreSignal',
'hipGraphNodeTypeExtSemaphoreWait', 'hipGraphNodeTypeGraph',
'hipGraphNodeTypeHost', 'hipGraphNodeTypeKernel',
'hipGraphNodeTypeMemAlloc', 'hipGraphNodeTypeMemFree',
'hipGraphNodeTypeMemcpy', 'hipGraphNodeTypeMemcpyFromSymbol',
'hipGraphNodeTypeMemcpyToSymbol', 'hipGraphNodeTypeMemset',
'hipGraphNodeTypeWaitEvent', 'hipGraphNode_t',
'hipGraphReleaseUserObject', 'hipGraphRemoveDependencies',
'hipGraphRetainUserObject', 'hipGraphUpload',
'hipGraphUserObjectMove', 'hipGraph_t',
'hipGraphicsGLRegisterBuffer', 'hipGraphicsGLRegisterImage',
'hipGraphicsMapResources', 'hipGraphicsRegisterFlags',
'hipGraphicsRegisterFlagsNone',
'hipGraphicsRegisterFlagsReadOnly',
'hipGraphicsRegisterFlagsSurfaceLoadStore',
'hipGraphicsRegisterFlagsTextureGather',
'hipGraphicsRegisterFlagsWriteDiscard', 'hipGraphicsResource',
'hipGraphicsResourceGetMappedPointer', 'hipGraphicsResource_t',
'hipGraphicsSubResourceGetMappedArray',
'hipGraphicsUnmapResources', 'hipGraphicsUnregisterResource',
'hipHostAlloc', 'hipHostFn_t', 'hipHostFree',
'hipHostGetDevicePointer', 'hipHostGetFlags', 'hipHostMalloc',
'hipHostNodeParams', 'hipHostRegister', 'hipHostUnregister',
'hipImportExternalMemory', 'hipImportExternalSemaphore',
'hipInit', 'hipIpcCloseMemHandle', 'hipIpcEventHandle_t',
'hipIpcGetEventHandle', 'hipIpcGetMemHandle', 'hipIpcMemHandle_t',
'hipIpcOpenEventHandle', 'hipIpcOpenMemHandle', 'hipJitOption',
'hipJitOptionCacheMode', 'hipJitOptionErrorLogBuffer',
'hipJitOptionErrorLogBufferSizeBytes',
'hipJitOptionFallbackStrategy', 'hipJitOptionFastCompile',
'hipJitOptionGenerateDebugInfo', 'hipJitOptionGenerateLineInfo',
'hipJitOptionInfoLogBuffer', 'hipJitOptionInfoLogBufferSizeBytes',
'hipJitOptionLogVerbose', 'hipJitOptionMaxRegisters',
'hipJitOptionNumOptions', 'hipJitOptionOptimizationLevel',
'hipJitOptionSm3xOpt', 'hipJitOptionTarget',
'hipJitOptionTargetFromContext', 'hipJitOptionThreadsPerBlock',
'hipJitOptionWallTime', 'hipKernelNameRef',
'hipKernelNameRefByPtr', 'hipKernelNodeAttrID',
'hipKernelNodeAttrValue',
'hipKernelNodeAttributeAccessPolicyWindow',
'hipKernelNodeAttributeCooperative', 'hipKernelNodeParams',
'hipLaunchByPtr', 'hipLaunchCooperativeKernel',
'hipLaunchCooperativeKernelMultiDevice', 'hipLaunchHostFunc',
'hipLaunchKernel', 'hipLaunchParams', 'hipLimitMallocHeapSize',
'hipLimitPrintfFifoSize', 'hipLimitRange', 'hipLimitStackSize',
'hipLimit_t', 'hipMalloc', 'hipMalloc3D', 'hipMalloc3DArray',
'hipMallocArray', 'hipMallocAsync', 'hipMallocFromPoolAsync',
'hipMallocHost', 'hipMallocManaged', 'hipMallocMipmappedArray',
'hipMallocPitch', 'hipMemAccessDesc', 'hipMemAccessFlags',
'hipMemAccessFlagsProtNone', 'hipMemAccessFlagsProtRead',
'hipMemAccessFlagsProtReadWrite', 'hipMemAddressFree',
'hipMemAddressReserve', 'hipMemAdvise',
'hipMemAdviseSetAccessedBy', 'hipMemAdviseSetCoarseGrain',
'hipMemAdviseSetPreferredLocation', 'hipMemAdviseSetReadMostly',
'hipMemAdviseUnsetAccessedBy', 'hipMemAdviseUnsetCoarseGrain',
'hipMemAdviseUnsetPreferredLocation',
'hipMemAdviseUnsetReadMostly', 'hipMemAllocHost',
'hipMemAllocNodeParams', 'hipMemAllocPitch',
'hipMemAllocationGranularityMinimum',
'hipMemAllocationGranularityRecommended',
'hipMemAllocationGranularity_flags', 'hipMemAllocationHandleType',
'hipMemAllocationProp', 'hipMemAllocationType',
'hipMemAllocationTypeInvalid', 'hipMemAllocationTypeMax',
'hipMemAllocationTypePinned', 'hipMemCreate',
'hipMemExportToShareableHandle',
'hipMemGenericAllocationHandle_t', 'hipMemGetAccess',
'hipMemGetAddressRange', 'hipMemGetAllocationGranularity',
'hipMemGetAllocationPropertiesFromHandle', 'hipMemGetInfo',
'hipMemHandleType', 'hipMemHandleTypeGeneric',
'hipMemHandleTypeNone', 'hipMemHandleTypePosixFileDescriptor',
'hipMemHandleTypeWin32', 'hipMemHandleTypeWin32Kmt',
'hipMemImportFromShareableHandle', 'hipMemLocation',
'hipMemLocationType', 'hipMemLocationTypeDevice',
'hipMemLocationTypeInvalid', 'hipMemMap', 'hipMemMapArrayAsync',
'hipMemOperationType', 'hipMemOperationTypeMap',
'hipMemOperationTypeUnmap', 'hipMemPoolAttr',
'hipMemPoolAttrReleaseThreshold',
'hipMemPoolAttrReservedMemCurrent',
'hipMemPoolAttrReservedMemHigh', 'hipMemPoolAttrUsedMemCurrent',
'hipMemPoolAttrUsedMemHigh', 'hipMemPoolCreate',
'hipMemPoolDestroy', 'hipMemPoolExportPointer',
'hipMemPoolExportToShareableHandle', 'hipMemPoolGetAccess',
'hipMemPoolGetAttribute', 'hipMemPoolImportFromShareableHandle',
'hipMemPoolImportPointer', 'hipMemPoolProps',
'hipMemPoolPtrExportData',
'hipMemPoolReuseAllowInternalDependencies',
'hipMemPoolReuseAllowOpportunistic',
'hipMemPoolReuseFollowEventDependencies', 'hipMemPoolSetAccess',
'hipMemPoolSetAttribute', 'hipMemPoolTrimTo', 'hipMemPool_t',
'hipMemPrefetchAsync', 'hipMemPtrGetInfo', 'hipMemRangeAttribute',
'hipMemRangeAttributeAccessedBy',
'hipMemRangeAttributeCoherencyMode',
'hipMemRangeAttributeLastPrefetchLocation',
'hipMemRangeAttributePreferredLocation',
'hipMemRangeAttributeReadMostly', 'hipMemRangeCoherencyMode',
'hipMemRangeCoherencyModeCoarseGrain',
'hipMemRangeCoherencyModeFineGrain',
'hipMemRangeCoherencyModeIndeterminate',
'hipMemRangeGetAttribute', 'hipMemRangeGetAttributes',
'hipMemRelease', 'hipMemRetainAllocationHandle',
'hipMemSetAccess', 'hipMemUnmap', 'hipMemcpy', 'hipMemcpy2D',
'hipMemcpy2DAsync', 'hipMemcpy2DFromArray',
'hipMemcpy2DFromArrayAsync', 'hipMemcpy2DToArray',
'hipMemcpy2DToArrayAsync', 'hipMemcpy3D', 'hipMemcpy3DAsync',
'hipMemcpy3DParms', 'hipMemcpyAsync', 'hipMemcpyAtoH',
'hipMemcpyDefault', 'hipMemcpyDeviceToDevice',
'hipMemcpyDeviceToHost', 'hipMemcpyDtoD', 'hipMemcpyDtoDAsync',
'hipMemcpyDtoH', 'hipMemcpyDtoHAsync', 'hipMemcpyFromArray',
'hipMemcpyFromSymbol', 'hipMemcpyFromSymbolAsync',
'hipMemcpyHostToDevice', 'hipMemcpyHostToHost', 'hipMemcpyHtoA',
'hipMemcpyHtoD', 'hipMemcpyHtoDAsync', 'hipMemcpyKind',
'hipMemcpyParam2D', 'hipMemcpyParam2DAsync', 'hipMemcpyPeer',
'hipMemcpyPeerAsync', 'hipMemcpyToArray', 'hipMemcpyToSymbol',
'hipMemcpyToSymbolAsync', 'hipMemcpyWithStream',
'hipMemoryAdvise', 'hipMemoryType', 'hipMemoryTypeArray',
'hipMemoryTypeDevice', 'hipMemoryTypeHost',
'hipMemoryTypeManaged', 'hipMemoryTypeUnified', 'hipMemset',
'hipMemset2D', 'hipMemset2DAsync', 'hipMemset3D',
'hipMemset3DAsync', 'hipMemsetAsync', 'hipMemsetD16',
'hipMemsetD16Async', 'hipMemsetD32', 'hipMemsetD32Async',
'hipMemsetD8', 'hipMemsetD8Async', 'hipMemsetParams',
'hipMipmappedArray', 'hipMipmappedArrayCreate',
'hipMipmappedArrayDestroy', 'hipMipmappedArrayGetLevel',
'hipMipmappedArray_const_t', 'hipMipmappedArray_t',
'hipModuleGetFunction', 'hipModuleGetGlobal',
'hipModuleGetTexRef', 'hipModuleLaunchCooperativeKernel',
'hipModuleLaunchCooperativeKernelMultiDevice',
'hipModuleLaunchKernel', 'hipModuleLoad', 'hipModuleLoadData',
'hipModuleLoadDataEx',
'hipModuleOccupancyMaxActiveBlocksPerMultiprocessor',
'hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags',
'hipModuleOccupancyMaxPotentialBlockSize',
'hipModuleOccupancyMaxPotentialBlockSizeWithFlags',
'hipModuleUnload', 'hipModule_t',
'hipOccupancyMaxActiveBlocksPerMultiprocessor',
'hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags',
'hipOccupancyMaxPotentialBlockSize', 'hipPeekAtLastError',
'hipPitchedPtr', 'hipPointerAttribute_t',
'hipPointerGetAttribute', 'hipPointerGetAttributes',
'hipPointerSetAttribute', 'hipPointer_attribute', 'hipPos',
'hipProfilerStart', 'hipProfilerStop', 'hipReadModeElementType',
'hipReadModeNormalizedFloat', 'hipResViewFormatFloat1',
'hipResViewFormatFloat2', 'hipResViewFormatFloat4',
'hipResViewFormatHalf1', 'hipResViewFormatHalf2',
'hipResViewFormatHalf4', 'hipResViewFormatNone',
'hipResViewFormatSignedBlockCompressed4',
'hipResViewFormatSignedBlockCompressed5',
'hipResViewFormatSignedBlockCompressed6H',
'hipResViewFormatSignedChar1', 'hipResViewFormatSignedChar2',
'hipResViewFormatSignedChar4', 'hipResViewFormatSignedInt1',
'hipResViewFormatSignedInt2', 'hipResViewFormatSignedInt4',
'hipResViewFormatSignedShort1', 'hipResViewFormatSignedShort2',
'hipResViewFormatSignedShort4',
'hipResViewFormatUnsignedBlockCompressed1',
'hipResViewFormatUnsignedBlockCompressed2',
'hipResViewFormatUnsignedBlockCompressed3',
'hipResViewFormatUnsignedBlockCompressed4',
'hipResViewFormatUnsignedBlockCompressed5',
'hipResViewFormatUnsignedBlockCompressed6H',
'hipResViewFormatUnsignedBlockCompressed7',
'hipResViewFormatUnsignedChar1', 'hipResViewFormatUnsignedChar2',
'hipResViewFormatUnsignedChar4', 'hipResViewFormatUnsignedInt1',
'hipResViewFormatUnsignedInt2', 'hipResViewFormatUnsignedInt4',
'hipResViewFormatUnsignedShort1',
'hipResViewFormatUnsignedShort2',
'hipResViewFormatUnsignedShort4', 'hipResourceDesc',
'hipResourceType', 'hipResourceTypeArray',
'hipResourceTypeLinear', 'hipResourceTypeMipmappedArray',
'hipResourceTypePitch2D', 'hipResourceViewFormat',
'hipResourcetype', 'hipResourcetype__enumvalues',
'hipRuntimeGetVersion', 'hipSetDevice', 'hipSetDeviceFlags',
'hipSetupArgument', 'hipSharedMemBankSizeDefault',
'hipSharedMemBankSizeEightByte', 'hipSharedMemBankSizeFourByte',
'hipSharedMemConfig', 'hipSignalExternalSemaphoresAsync',
'hipStreamAddCallback', 'hipStreamAddCaptureDependencies',
'hipStreamAttachMemAsync', 'hipStreamBeginCapture',
'hipStreamCallback_t', 'hipStreamCaptureMode',
'hipStreamCaptureModeGlobal', 'hipStreamCaptureModeRelaxed',
'hipStreamCaptureModeThreadLocal', 'hipStreamCaptureStatus',
'hipStreamCaptureStatusActive',
'hipStreamCaptureStatusInvalidated', 'hipStreamCaptureStatusNone',
'hipStreamCreate', 'hipStreamCreateWithFlags',
'hipStreamCreateWithPriority', 'hipStreamDestroy',
'hipStreamEndCapture', 'hipStreamGetCaptureInfo',
'hipStreamGetCaptureInfo_v2', 'hipStreamGetDevice',
'hipStreamGetFlags', 'hipStreamGetPriority',
'hipStreamIsCapturing', 'hipStreamQuery',
'hipStreamSetCaptureDependencies', 'hipStreamSynchronize',
'hipStreamUpdateCaptureDependencies',
'hipStreamUpdateCaptureDependenciesFlags', 'hipStreamWaitEvent',
'hipStreamWaitValue32', 'hipStreamWaitValue64',
'hipStreamWriteValue32', 'hipStreamWriteValue64', 'hipStream_t',
'hipSuccess', 'hipSurfaceObject_t', 'hipTexObjectCreate',
'hipTexObjectDestroy', 'hipTexObjectGetResourceDesc',
'hipTexObjectGetResourceViewDesc', 'hipTexObjectGetTextureDesc',
'hipTexRefGetAddress', 'hipTexRefGetAddressMode',
'hipTexRefGetFilterMode', 'hipTexRefGetFlags',
'hipTexRefGetFormat', 'hipTexRefGetMaxAnisotropy',
'hipTexRefGetMipMappedArray', 'hipTexRefGetMipmapFilterMode',
'hipTexRefGetMipmapLevelBias', 'hipTexRefGetMipmapLevelClamp',
'hipTexRefSetAddress', 'hipTexRefSetAddress2D',
'hipTexRefSetAddressMode', 'hipTexRefSetArray',
'hipTexRefSetBorderColor', 'hipTexRefSetFilterMode',
'hipTexRefSetFlags', 'hipTexRefSetFormat',
'hipTexRefSetMaxAnisotropy', 'hipTexRefSetMipmapFilterMode',
'hipTexRefSetMipmapLevelBias', 'hipTexRefSetMipmapLevelClamp',
'hipTexRefSetMipmappedArray', 'hipTextureAddressMode',
'hipTextureFilterMode', 'hipTextureObject_t',
'hipTextureReadMode', 'hipThreadExchangeStreamCaptureMode',
'hipUUID', 'hipUnbindTexture', 'hipUserObjectCreate',
'hipUserObjectFlags', 'hipUserObjectNoDestructorSync',
'hipUserObjectRelease', 'hipUserObjectRetain',
'hipUserObjectRetainFlags', 'hipUserObject_t',
'hipWaitExternalSemaphoresAsync', 'hip_Memcpy2D', 'hiparray',
'hipmipmappedArray', 'hiprtcAddNameExpression',
'hiprtcCompileProgram', 'hiprtcCreateProgram',
'hiprtcDestroyProgram', 'hiprtcGetBitcode',
'hiprtcGetBitcodeSize', 'hiprtcGetCode', 'hiprtcGetCodeSize',
'hiprtcGetErrorString', 'hiprtcGetLoweredName',
'hiprtcGetProgramLog', 'hiprtcGetProgramLogSize',
'hiprtcJITInputType', 'hiprtcJIT_option', 'hiprtcLinkAddData',
'hiprtcLinkAddFile', 'hiprtcLinkComplete', 'hiprtcLinkCreate',
'hiprtcLinkDestroy', 'hiprtcLinkState', 'hiprtcProgram',
'hiprtcResult', 'hiprtcVersion', 'make_hipExtent',
'make_hipPitchedPtr', 'make_hipPos', 'size_t',
'struct_HIP_ARRAY3D_DESCRIPTOR', 'struct_HIP_ARRAY_DESCRIPTOR',
'struct_HIP_MEMCPY3D', 'struct_HIP_RESOURCE_DESC_st',
'struct_HIP_RESOURCE_DESC_st_0_array',
'struct_HIP_RESOURCE_DESC_st_0_linear',
'struct_HIP_RESOURCE_DESC_st_0_mipmap',
'struct_HIP_RESOURCE_DESC_st_0_pitch2D',
'struct_HIP_RESOURCE_DESC_st_0_reserved',
'struct_HIP_RESOURCE_VIEW_DESC_st', 'struct_HIP_TEXTURE_DESC_st',
'struct___hip_surface', 'struct___hip_texture',
'struct__hipGraphicsResource', 'struct__hiprtcProgram',
'struct_c__SA_hipDeviceArch_t', 'struct_dim3',
'struct_hipAccessPolicyWindow', 'struct_hipArray',
'struct_hipArrayMapInfo', 'struct_hipArrayMapInfo_1_miptail',
'struct_hipArrayMapInfo_1_sparseLevel',
'struct_hipChannelFormatDesc', 'struct_hipDeviceProp_t',
'struct_hipExtent', 'struct_hipExternalMemoryBufferDesc_st',
'struct_hipExternalMemoryHandleDesc_st',
'struct_hipExternalMemoryHandleDesc_st_0_win32',
'struct_hipExternalSemaphoreHandleDesc_st',
'struct_hipExternalSemaphoreHandleDesc_st_0_win32',
'struct_hipExternalSemaphoreSignalNodeParams',
'struct_hipExternalSemaphoreSignalParams_st',
'struct_hipExternalSemaphoreSignalParams_st_0_fence',
'struct_hipExternalSemaphoreSignalParams_st_0_keyedMutex',
'struct_hipExternalSemaphoreSignalParams_st_params',
'struct_hipExternalSemaphoreWaitNodeParams',
'struct_hipExternalSemaphoreWaitParams_st',
'struct_hipExternalSemaphoreWaitParams_st_0_fence',
'struct_hipExternalSemaphoreWaitParams_st_0_keyedMutex',
'struct_hipExternalSemaphoreWaitParams_st_params',
'struct_hipFuncAttributes', 'struct_hipFunctionLaunchParams_t',
'struct_hipGraphExec', 'struct_hipGraphNode',
'struct_hipHostNodeParams', 'struct_hipIpcEventHandle_st',
'struct_hipIpcMemHandle_st', 'struct_hipKernelNodeParams',
'struct_hipLaunchParams_t', 'struct_hipMemAccessDesc',
'struct_hipMemAllocNodeParams', 'struct_hipMemAllocationProp',
'struct_hipMemAllocationProp_allocFlags', 'struct_hipMemLocation',
'struct_hipMemPoolProps', 'struct_hipMemPoolPtrExportData',
'struct_hipMemcpy3DParms', 'struct_hipMemsetParams',
'struct_hipMipmappedArray', 'struct_hipPitchedPtr',
'struct_hipPointerAttribute_t', 'struct_hipPos',
'struct_hipResourceDesc', 'struct_hipResourceDesc_0_array',
'struct_hipResourceDesc_0_linear',
'struct_hipResourceDesc_0_mipmap',
'struct_hipResourceDesc_0_pitch2D', 'struct_hipResourceViewDesc',
'struct_hipTextureDesc', 'struct_hipUUID_t',
'struct_hipUserObject', 'struct_hip_Memcpy2D', 'struct_ihipCtx_t',
'struct_ihipEvent_t', 'struct_ihipGraph',
'struct_ihipMemGenericAllocationHandle',
'struct_ihipMemPoolHandle_t', 'struct_ihipModuleSymbol_t',
'struct_ihipModule_t', 'struct_ihipStream_t',
'struct_ihiprtcLinkState', 'struct_textureReference', 'uint32_t',
'uint64_t', 'union_HIP_RESOURCE_DESC_st_res',
'union_hipArrayMapInfo_memHandle',
'union_hipArrayMapInfo_resource',
'union_hipArrayMapInfo_subresource',
'union_hipExternalMemoryHandleDesc_st_handle',
'union_hipExternalSemaphoreHandleDesc_st_handle',
'union_hipKernelNodeAttrValue', 'union_hipPointerAttribute_t_0',
'union_hipResourceDesc_res']
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment