HIP: Heterogenous-computing Interface for Portability
Public Attributes | List of all members
hip_api_data_t Struct Reference

Public Attributes

uint64_t correlation_id
 
uint32_t phase
 
union {
   struct {
      hipStream_t *   stream
 
      unsigned int   flags
 
      int   priority
 
   }   hipStreamCreateWithPriority
 
   struct {
      const void *   symbolName
 
      const void *   src
 
      size_t   sizeBytes
 
      size_t   offset
 
      hipMemcpyKind   kind
 
      hipStream_t   stream
 
   }   hipMemcpyToSymbolAsync
 
   struct {
      void **   ptr
 
      size_t *   pitch
 
      size_t   width
 
      size_t   height
 
   }   hipMallocPitch
 
   struct {
      void **   ptr
 
      size_t   size
 
   }   hipMalloc
 
   struct {
      hipDeviceptr_t   dest
 
      unsigned short   value
 
      size_t   count
 
   }   hipMemsetD16
 
   struct {
      char *   name
 
      int   len
 
      hipDevice_t   device
 
   }   hipDeviceGetName
 
   struct {
      hipEvent_t   event
 
      hipStream_t   stream
 
   }   hipEventRecord
 
   struct {
      int *   numBlocks
 
      hipFunction_t   f
 
      int   blockSize
 
      size_t   dynSharedMemPerBlk
 
   }   hipDrvOccupancyMaxActiveBlocksPerMultiprocessor
 
   struct {
      int   deviceId
 
   }   hipSetDevice
 
   struct {
      hipCtx_t   ctx
 
      int *   apiVersion
 
   }   hipCtxGetApiVersion
 
   struct {
      const void *   arg
 
      size_t   size
 
      size_t   offset
 
   }   hipSetupArgument
 
   struct {
      void *   dst
 
      const void *   symbolName
 
      size_t   sizeBytes
 
      size_t   offset
 
      hipMemcpyKind   kind
 
      hipStream_t   stream
 
   }   hipMemcpyFromSymbolAsync
 
   struct {
      int   device1
 
      int   device2
 
      unsigned int *   linktype
 
      unsigned int *   hopcount
 
   }   hipExtGetLinkTypeAndHopCount
 
   struct {
      hipDeviceptr_t   dst
 
      hipDeviceptr_t   src
 
      size_t   sizeBytes
 
   }   hipMemcpyDtoD
 
   struct {
      void *   ptr
 
   }   hipHostFree
 
   struct {
      hipArray *   dst
 
      size_t   wOffset
 
      size_t   hOffset
 
      const void *   src
 
      size_t   spitch
 
      size_t   width
 
      size_t   height
 
      hipMemcpyKind   kind
 
   }   hipMemcpy2DToArray
 
   struct {
      hipDeviceptr_t   dest
 
      unsigned char   value
 
      size_t   count
 
      hipStream_t   stream
 
   }   hipMemsetD8Async
 
   struct {
      hipFuncCache_t *   cacheConfig
 
   }   hipCtxGetCacheConfig
 
   struct {
      hipStream_t   stream
 
      hipEvent_t   event
 
      unsigned int   flags
 
   }   hipStreamWaitEvent
 
   struct {
      int *   leastPriority
 
      int *   greatestPriority
 
   }   hipDeviceGetStreamPriorityRange
 
   struct {
      hipModule_t *   module
 
      const char *   fname
 
   }   hipModuleLoad
 
   struct {
      hipDevice_t   dev
 
      unsigned int   flags
 
   }   hipDevicePrimaryCtxSetFlags
 
   struct {
      const void *   f
 
      dim3   gridDim
 
      dim3   blockDimX
 
      void **   kernelParams
 
      unsigned int   sharedMemBytes
 
      hipStream_t   stream
 
   }   hipLaunchCooperativeKernel
 
   struct {
      hipLaunchParams *   launchParamsList
 
      int   numDevices
 
      unsigned int   flags
 
   }   hipLaunchCooperativeKernelMultiDevice
 
   struct {
      void *   dst
 
      const void *   src
 
      size_t   sizeBytes
 
      hipMemcpyKind   kind
 
      hipStream_t   stream
 
   }   hipMemcpyAsync
 
   struct {
      hipArray **   array
 
      const hipChannelFormatDesc *   desc
 
      hipExtent   extent
 
      unsigned int   flags
 
   }   hipMalloc3DArray
 
   struct {
      hipStream_t *   stream
 
   }   hipStreamCreate
 
   struct {
      hipCtx_t *   ctx
 
   }   hipCtxGetCurrent
 
   struct {
      hipDevice_t   dev
 
      unsigned int *   flags
 
      int *   active
 
   }   hipDevicePrimaryCtxGetState
 
   struct {
      hipEvent_t   event
 
   }   hipEventQuery
 
   struct {
      int *   numBlocks
 
      hipFunction_t   f
 
      int   blockSize
 
      size_t   dynSharedMemPerBlk
 
      unsigned int   flags
 
   }   hipDrvOccupancyMaxActiveBlocksPerMultiprocessorWithFlags
 
   struct {
      hipEvent_t *   event
 
   }   hipEventCreate
 
   struct {
      hipDeviceptr_t *   pbase
 
      size_t *   psize
 
      hipDeviceptr_t   dptr
 
   }   hipMemGetAddressRange
 
   struct {
      void *   dst
 
      const void *   symbolName
 
      size_t   sizeBytes
 
      size_t   offset
 
      hipMemcpyKind   kind
 
   }   hipMemcpyFromSymbol
 
   struct {
      hipArray **   pHandle
 
      const HIP_ARRAY_DESCRIPTOR *   pAllocateArray
 
   }   hipArrayCreate
 
   struct {
      hipStream_t   stream
 
      unsigned int *   flags
 
   }   hipStreamGetFlags
 
   struct {
      hipArray **   array
 
      const hipChannelFormatDesc *   desc
 
      size_t   width
 
      size_t   height
 
      unsigned int   flags
 
   }   hipMallocArray
 
   struct {
      hipSharedMemConfig *   pConfig
 
   }   hipCtxGetSharedMemConfig
 
   struct {
      void *   ptr
 
      size_t *   size
 
   }   hipMemPtrGetInfo
 
   struct {
      int *   value
 
      hipFunction_attribute   attrib
 
      hipFunction_t   hfunc
 
   }   hipFuncGetAttribute
 
   struct {
      unsigned int *   flags
 
   }   hipCtxGetFlags
 
   struct {
      hipStream_t   stream
 
   }   hipStreamDestroy
 
   struct {
      dim3   gridDim
 
      dim3   blockDim
 
      size_t   sharedMem
 
      hipStream_t   stream
 
   }   __hipPushCallConfiguration
 
   struct {
      hipPitchedPtr   pitchedDevPtr
 
      int   value
 
      hipExtent   extent
 
      hipStream_t   stream
 
   }   hipMemset3DAsync
 
   struct {
      const hipMemcpy3DParms *   p
 
   }   hipMemcpy3D
 
   struct {
      unsigned int   flags
 
   }   hipInit
 
   struct {
      void *   dst
 
      hipArray *   srcArray
 
      size_t   srcOffset
 
      size_t   count
 
   }   hipMemcpyAtoH
 
   struct {
      hipStream_t   stream
 
      int *   priority
 
   }   hipStreamGetPriority
 
   struct {
      void *   dst
 
      size_t   pitch
 
      int   value
 
      size_t   width
 
      size_t   height
 
   }   hipMemset2D
 
   struct {
      void *   dst
 
      size_t   pitch
 
      int   value
 
      size_t   width
 
      size_t   height
 
      hipStream_t   stream
 
   }   hipMemset2DAsync
 
   struct {
      int *   canAccessPeer
 
      int   deviceId
 
      int   peerDeviceId
 
   }   hipDeviceCanAccessPeer
 
   struct {
      int   peerDeviceId
 
      unsigned int   flags
 
   }   hipDeviceEnablePeerAccess
 
   struct {
      const void *   function_address
 
      dim3   numBlocks
 
      dim3   dimBlocks
 
      void **   args
 
      size_t   sharedMemBytes
 
      hipStream_t   stream
 
   }   hipLaunchKernel
 
   struct {
      hipDeviceptr_t   dest
 
      unsigned short   value
 
      size_t   count
 
      hipStream_t   stream
 
   }   hipMemsetD16Async
 
   struct {
      hipModule_t   module
 
   }   hipModuleUnload
 
   struct {
      void *   hostPtr
 
   }   hipHostUnregister
 
   struct {
      const void *   func
 
   }   hipLaunchByPtr
 
   struct {
      hipStream_t   stream
 
   }   hipStreamSynchronize
 
   struct {
      hipFuncCache_t   cacheConfig
 
   }   hipDeviceSetCacheConfig
 
   struct {
      hipError_t   hip_error
 
   }   hipGetErrorName
 
   struct {
      hipDeviceptr_t   dst
 
      void *   src
 
      size_t   sizeBytes
 
   }   hipMemcpyHtoD
 
   struct {
      hipDeviceptr_t *   dptr
 
      size_t *   bytes
 
      hipModule_t   hmod
 
      const char *   name
 
   }   hipModuleGetGlobal
 
   struct {
      hipArray *   dstArray
 
      size_t   dstOffset
 
      const void *   srcHost
 
      size_t   count
 
   }   hipMemcpyHtoA
 
   struct {
      hipCtx_t *   ctx
 
      unsigned int   flags
 
      hipDevice_t   device
 
   }   hipCtxCreate
 
   struct {
      void *   dst
 
      size_t   dpitch
 
      const void *   src
 
      size_t   spitch
 
      size_t   width
 
      size_t   height
 
      hipMemcpyKind   kind
 
   }   hipMemcpy2D
 
   struct {
      void *   devPtr
 
   }   hipIpcCloseMemHandle
 
   struct {
      int *   device
 
      const hipDeviceProp_t *   prop
 
   }   hipChooseDevice
 
   struct {
      int *   major
 
      int *   minor
 
      hipDevice_t   device
 
   }   hipDeviceComputeCapability
 
   struct {
      hipDevice_t *   device
 
      int   ordinal
 
   }   hipDeviceGet
 
   struct {
      hipFuncCache_t   cacheConfig
 
   }   hipCtxSetCacheConfig
 
   struct {
      const void *   func
 
      hipFuncCache_t   config
 
   }   hipFuncSetCacheConfig
 
   struct {
      textureReference **   texRef
 
      hipModule_t   hmod
 
      const char *   name
 
   }   hipModuleGetTexRef
 
   struct {
      void *   dst
 
      int   dstDeviceId
 
      const void *   src
 
      int   srcDevice
 
      size_t   sizeBytes
 
      hipStream_t   stream
 
   }   hipMemcpyPeerAsync
 
   struct {
      void *   dst
 
      const void *   src
 
      size_t   sizeBytes
 
      hipMemcpyKind   kind
 
      hipStream_t   stream
 
   }   hipMemcpyWithStream
 
   struct {
      hipDevice_t   dev
 
   }   hipDevicePrimaryCtxReset
 
   struct {
      const hipMemcpy3DParms *   p
 
      hipStream_t   stream
 
   }   hipMemcpy3DAsync
 
   struct {
      hipEvent_t   event
 
   }   hipEventDestroy
 
   struct {
      hipCtx_t *   ctx
 
   }   hipCtxPopCurrent
 
   struct {
      void **   devPtr
 
      const void *   symbolName
 
   }   hipGetSymbolAddress
 
   struct {
      unsigned int *   flagsPtr
 
      void *   hostPtr
 
   }   hipHostGetFlags
 
   struct {
      void **   ptr
 
      size_t   size
 
      unsigned int   flags
 
   }   hipHostMalloc
 
   struct {
      int *   driverVersion
 
   }   hipDriverGetVersion
 
   struct {
      size_t *   free
 
      size_t *   total
 
   }   hipMemGetInfo
 
   struct {
      void *   dst
 
      int   value
 
      size_t   sizeBytes
 
   }   hipMemset
 
   struct {
      hipDeviceptr_t   dest
 
      unsigned char   value
 
      size_t   count
 
   }   hipMemsetD8
 
   struct {
      const hip_Memcpy2D *   pCopy
 
      hipStream_t   stream
 
   }   hipMemcpyParam2DAsync
 
   struct {
      void *   hostPtr
 
      size_t   sizeBytes
 
      unsigned int   flags
 
   }   hipHostRegister
 
   struct {
      hipSharedMemConfig   config
 
   }   hipCtxSetSharedMemConfig
 
   struct {
      hipArray **   array
 
      const HIP_ARRAY3D_DESCRIPTOR *   pAllocateArray
 
   }   hipArray3DCreate
 
   struct {
      void **   devPtr
 
      hipIpcMemHandle_t   handle
 
      unsigned int   flags
 
   }   hipIpcOpenMemHandle
 
   struct {
      hipSharedMemConfig   config
 
   }   hipDeviceSetSharedMemConfig
 
   struct {
      hipCtx_t   ctx
 
   }   hipCtxDestroy
 
   struct {
      hipSharedMemConfig *   pConfig
 
   }   hipDeviceGetSharedMemConfig
 
   struct {
      void *   dst
 
      size_t   dpitch
 
      hipArray_const_t   src
 
      size_t   wOffset
 
      size_t   hOffset
 
      size_t   width
 
      size_t   height
 
      hipMemcpyKind   kind
 
   }   hipMemcpy2DFromArray
 
   struct {
      unsigned int *   numBlocks
 
      hipFunction_t   f
 
      unsigned int   blockSize
 
      size_t   dynSharedMemPerBlk
 
      unsigned int   flags
 
   }   hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags
 
   struct {
      unsigned int   flags
 
   }   hipSetDeviceFlags
 
   struct {
      hipFunction_t   f
 
      unsigned int   globalWorkSizeX
 
      unsigned int   globalWorkSizeY
 
      unsigned int   globalWorkSizeZ
 
      unsigned int   localWorkSizeX
 
      unsigned int   localWorkSizeY
 
      unsigned int   localWorkSizeZ
 
      size_t   sharedMemBytes
 
      hipStream_t   hStream
 
      void **   kernelParams
 
      void **   extra
 
      hipEvent_t   startEvent
 
      hipEvent_t   stopEvent
 
   }   hipHccModuleLaunchKernel
 
   struct {
      void *   ptr
 
   }   hipFree
 
   struct {
      unsigned int *   gridSize
 
      unsigned int *   blockSize
 
      hipFunction_t   f
 
      size_t   dynSharedMemPerBlk
 
      unsigned int   blockSizeLimit
 
   }   hipOccupancyMaxPotentialBlockSize
 
   struct {
      int *   pi
 
      hipDeviceAttribute_t   attr
 
      int   deviceId
 
   }   hipDeviceGetAttribute
 
   struct {
      void *   dst
 
      hipDeviceptr_t   src
 
      size_t   sizeBytes
 
   }   hipMemcpyDtoH
 
   struct {
      hipCtx_t   peerCtx
 
   }   hipCtxDisablePeerAccess
 
   struct {
      void **   devPtr
 
      size_t   size
 
      unsigned int   flags
 
   }   hipMallocManaged
 
   struct {
      int *   device
 
      const char *   pciBusId
 
   }   hipDeviceGetByPCIBusId
 
   struct {
      hipIpcMemHandle_t *   handle
 
      void *   devPtr
 
   }   hipIpcGetMemHandle
 
   struct {
      hipDeviceptr_t   dst
 
      void *   src
 
      size_t   sizeBytes
 
      hipStream_t   stream
 
   }   hipMemcpyHtoDAsync
 
   struct {
      hipDevice_t *   device
 
   }   hipCtxGetDevice
 
   struct {
      hipPitchedPtr   pitchedDevPtr
 
      int   value
 
      hipExtent   extent
 
   }   hipMemset3D
 
   struct {
      hipModule_t *   module
 
      const void *   image
 
   }   hipModuleLoadData
 
   struct {
      size_t *   bytes
 
      hipDevice_t   device
 
   }   hipDeviceTotalMem
 
   struct {
      unsigned int *   numBlocks
 
      hipFunction_t   f
 
      unsigned int   blockSize
 
      size_t   dynSharedMemPerBlk
 
   }   hipOccupancyMaxActiveBlocksPerMultiprocessor
 
   struct {
      hipCtx_t   ctx
 
   }   hipCtxSetCurrent
 
   struct {
      hipError_t   hipError
 
   }   hipGetErrorString
 
   struct {
      hipCtx_t *   pctx
 
      hipDevice_t   dev
 
   }   hipDevicePrimaryCtxRetain
 
   struct {
      int   peerDeviceId
 
   }   hipDeviceDisablePeerAccess
 
   struct {
      hipStream_t *   stream
 
      unsigned int   flags
 
   }   hipStreamCreateWithFlags
 
   struct {
      void *   dst
 
      hipArray_const_t   srcArray
 
      size_t   wOffset
 
      size_t   hOffset
 
      size_t   count
 
      hipMemcpyKind   kind
 
   }   hipMemcpyFromArray
 
   struct {
      void *   dst
 
      size_t   dpitch
 
      const void *   src
 
      size_t   spitch
 
      size_t   width
 
      size_t   height
 
      hipMemcpyKind   kind
 
      hipStream_t   stream
 
   }   hipMemcpy2DAsync
 
   struct {
      hipFuncAttributes *   attr
 
      const void *   func
 
   }   hipFuncGetAttributes
 
   struct {
      size_t *   size
 
      const void *   symbolName
 
   }   hipGetSymbolSize
 
   struct {
      hipEvent_t *   event
 
      unsigned int   flags
 
   }   hipEventCreateWithFlags
 
   struct {
      hipStream_t   stream
 
   }   hipStreamQuery
 
   struct {
      char *   pciBusId
 
      int   len
 
      int   device
 
   }   hipDeviceGetPCIBusId
 
   struct {
      void *   dst
 
      const void *   src
 
      size_t   sizeBytes
 
      hipMemcpyKind   kind
 
   }   hipMemcpy
 
   struct {
      hipLaunchParams *   launchParamsList
 
      int   numDevices
 
      unsigned int   flags
 
   }   hipExtLaunchMultiKernelMultiDevice
 
   struct {
      hipStream_t   stream
 
      hipStreamCallback_t   callback
 
      void *   userData
 
      unsigned int   flags
 
   }   hipStreamAddCallback
 
   struct {
      hipArray *   dst
 
      size_t   wOffset
 
      size_t   hOffset
 
      const void *   src
 
      size_t   count
 
      hipMemcpyKind   kind
 
   }   hipMemcpyToArray
 
   struct {
      hipDeviceptr_t   dest
 
      int   value
 
      size_t   count
 
   }   hipMemsetD32
 
   struct {
      hipFunction_t   f
 
      unsigned int   globalWorkSizeX
 
      unsigned int   globalWorkSizeY
 
      unsigned int   globalWorkSizeZ
 
      unsigned int   localWorkSizeX
 
      unsigned int   localWorkSizeY
 
      unsigned int   localWorkSizeZ
 
      size_t   sharedMemBytes
 
      hipStream_t   hStream
 
      void **   kernelParams
 
      void **   extra
 
      hipEvent_t   startEvent
 
      hipEvent_t   stopEvent
 
      unsigned int   flags
 
   }   hipExtModuleLaunchKernel
 
   struct {
      hipFuncCache_t *   cacheConfig
 
   }   hipDeviceGetCacheConfig
 
   struct {
      hipPitchedPtr *   pitchedDevPtr
 
      hipExtent   extent
 
   }   hipMalloc3D
 
   struct {
      hipPointerAttribute_t *   attributes
 
      const void *   ptr
 
   }   hipPointerGetAttributes
 
   struct {
      void *   dst
 
      int   value
 
      size_t   sizeBytes
 
      hipStream_t   stream
 
   }   hipMemsetAsync
 
   struct {
      const void *   symbolName
 
      const void *   src
 
      size_t   sizeBytes
 
      size_t   offset
 
      hipMemcpyKind   kind
 
   }   hipMemcpyToSymbol
 
   struct {
      hipCtx_t   ctx
 
   }   hipCtxPushCurrent
 
   struct {
      void *   dst
 
      int   dstDeviceId
 
      const void *   src
 
      int   srcDeviceId
 
      size_t   sizeBytes
 
   }   hipMemcpyPeer
 
   struct {
      hipEvent_t   event
 
   }   hipEventSynchronize
 
   struct {
      hipDeviceptr_t   dst
 
      hipDeviceptr_t   src
 
      size_t   sizeBytes
 
      hipStream_t   stream
 
   }   hipMemcpyDtoDAsync
 
   struct {
      void **   ptr
 
      size_t   sizeBytes
 
      unsigned int   flags
 
   }   hipExtMallocWithFlags
 
   struct {
      hipCtx_t   peerCtx
 
      unsigned int   flags
 
   }   hipCtxEnablePeerAccess
 
   struct {
      void *   dst
 
      hipDeviceptr_t   src
 
      size_t   sizeBytes
 
      hipStream_t   stream
 
   }   hipMemcpyDtoHAsync
 
   struct {
      hipFunction_t   f
 
      unsigned int   gridDimX
 
      unsigned int   gridDimY
 
      unsigned int   gridDimZ
 
      unsigned int   blockDimX
 
      unsigned int   blockDimY
 
      unsigned int   blockDimZ
 
      unsigned int   sharedMemBytes
 
      hipStream_t   stream
 
      void **   kernelParams
 
      void **   extra
 
   }   hipModuleLaunchKernel
 
   struct {
      hipDeviceptr_t *   dptr
 
      size_t *   pitch
 
      size_t   widthInBytes
 
      size_t   height
 
      unsigned int   elementSizeBytes
 
   }   hipMemAllocPitch
 
   struct {
      void *   dst
 
      size_t   dpitch
 
      hipArray_const_t   src
 
      size_t   wOffset
 
      size_t   hOffset
 
      size_t   width
 
      size_t   height
 
      hipMemcpyKind   kind
 
      hipStream_t   stream
 
   }   hipMemcpy2DFromArrayAsync
 
   struct {
      size_t *   pValue
 
      enum hipLimit_t   limit
 
   }   hipDeviceGetLimit
 
   struct {
      hipModule_t *   module
 
      const void *   image
 
      unsigned int   numOptions
 
      hipJitOption *   options
 
      void **   optionValues
 
   }   hipModuleLoadDataEx
 
   struct {
      int *   runtimeVersion
 
   }   hipRuntimeGetVersion
 
   struct {
      dim3 *   gridDim
 
      dim3 *   blockDim
 
      size_t *   sharedMem
 
      hipStream_t *   stream
 
   }   __hipPopCallConfiguration
 
   struct {
      hipDeviceProp_t *   prop
 
      int   deviceId
 
   }   hipGetDeviceProperties
 
   struct {
      hipArray *   array
 
   }   hipFreeArray
 
   struct {
      float *   ms
 
      hipEvent_t   start
 
      hipEvent_t   stop
 
   }   hipEventElapsedTime
 
   struct {
      hipDevice_t   dev
 
   }   hipDevicePrimaryCtxRelease
 
   struct {
      void **   devPtr
 
      void *   hstPtr
 
      unsigned int   flags
 
   }   hipHostGetDevicePointer
 
   struct {
      const hip_Memcpy2D *   pCopy
 
   }   hipMemcpyParam2D
 
   struct {
      hipFunction_t *   function
 
      hipModule_t   module
 
      const char *   kname
 
   }   hipModuleGetFunction
 
   struct {
      hipDeviceptr_t   dst
 
      int   value
 
      size_t   count
 
      hipStream_t   stream
 
   }   hipMemsetD32Async
 
   struct {
      int *   deviceId
 
   }   hipGetDevice
 
   struct {
      int *   count
 
   }   hipGetDeviceCount
 
args
 

The documentation for this struct was generated from the following file: