Defines the API signatures for HIP runtime. This file can be compiled with a standard compiler.
More...
|
hipError_t | hip_impl::hip_init () |
|
hipError_t | hipInit (unsigned int flags) |
| Explicitly initializes the HIP runtime.
|
|
hipError_t | hipDriverGetVersion (int *driverVersion) |
| Returns the approximate HIP driver version.
|
|
hipError_t | hipRuntimeGetVersion (int *runtimeVersion) |
| Returns the approximate HIP Runtime version.
|
|
hipError_t | hipDeviceGet (hipDevice_t *device, int ordinal) |
| Returns a handle to a compute device.
|
|
hipError_t | hipDeviceComputeCapability (int *major, int *minor, hipDevice_t device) |
| Returns the compute capability of the device.
|
|
hipError_t | hipDeviceGetName (char *name, int len, hipDevice_t device) |
| Returns an identifer string for the device.
|
|
hipError_t | hipDeviceGetUuid (hipUUID *uuid, hipDevice_t device) |
| Returns an UUID for the device.[BETA].
|
|
hipError_t | hipDeviceGetP2PAttribute (int *value, hipDeviceP2PAttr attr, int srcDevice, int dstDevice) |
| Returns a value for attribute of link between two devices.
|
|
hipError_t | hipDeviceGetPCIBusId (char *pciBusId, int len, int device) |
| Returns a PCI Bus Id string for the device, overloaded to take int device ID.
|
|
hipError_t | hipDeviceGetByPCIBusId (int *device, const char *pciBusId) |
| Returns a handle to a compute device.
|
|
hipError_t | hipDeviceTotalMem (size_t *bytes, hipDevice_t device) |
| Returns the total amount of memory on the device.
|
|
hipError_t | hipDeviceSynchronize (void) |
| Waits on all active streams on current device.
|
|
hipError_t | hipDeviceReset (void) |
| The state of current device is discarded and updated to a fresh state.
|
|
hipError_t | hipSetDevice (int deviceId) |
| Set default device to be used for subsequent hip API calls from this thread.
|
|
hipError_t | hipSetValidDevices (int *device_arr, int len) |
| Set a list of devices that can be used.
|
|
hipError_t | hipGetDevice (int *deviceId) |
| Return the default device id for the calling host thread.
|
|
hipError_t | hipGetDeviceCount (int *count) |
| Return number of compute-capable devices.
|
|
hipError_t | hipDeviceGetAttribute (int *pi, hipDeviceAttribute_t attr, int deviceId) |
| Query for a specific device attribute.
|
|
hipError_t | hipDeviceGetDefaultMemPool (hipMemPool_t *mem_pool, int device) |
| Returns the default memory pool of the specified device.
|
|
hipError_t | hipDeviceSetMemPool (int device, hipMemPool_t mem_pool) |
| Sets the current memory pool of a device.
|
|
hipError_t | hipDeviceGetMemPool (hipMemPool_t *mem_pool, int device) |
| Gets the current memory pool for the specified device.
|
|
hipError_t | hipGetDeviceProperties (hipDeviceProp_t *prop, int deviceId) |
| Returns device properties.
|
|
hipError_t | hipDeviceGetTexture1DLinearMaxWidth (size_t *max_width, const hipChannelFormatDesc *desc, int device) |
| Gets the maximum width for 1D linear textures on the specified device.
|
|
hipError_t | hipDeviceSetCacheConfig (hipFuncCache_t cacheConfig) |
| Set L1/Shared cache partition.
|
|
hipError_t | hipDeviceGetCacheConfig (hipFuncCache_t *cacheConfig) |
| Get Cache configuration for a specific Device.
|
|
hipError_t | hipDeviceGetLimit (size_t *pValue, enum hipLimit_t limit) |
| Gets resource limits of current device.
|
|
hipError_t | hipDeviceSetLimit (enum hipLimit_t limit, size_t value) |
| Sets resource limits of current device.
|
|
hipError_t | hipDeviceGetSharedMemConfig (hipSharedMemConfig *pConfig) |
| Returns bank width of shared memory for current device.
|
|
hipError_t | hipGetDeviceFlags (unsigned int *flags) |
| Gets the flags set for current device.
|
|
hipError_t | hipDeviceSetSharedMemConfig (hipSharedMemConfig config) |
| The bank width of shared memory on current device is set.
|
|
hipError_t | hipSetDeviceFlags (unsigned flags) |
| The current device behavior is changed according to the flags passed.
|
|
hipError_t | hipChooseDevice (int *device, const hipDeviceProp_t *prop) |
| Device which matches hipDeviceProp_t is returned.
|
|
hipError_t | hipExtGetLinkTypeAndHopCount (int device1, int device2, uint32_t *linktype, uint32_t *hopcount) |
| Returns the link type and hop count between two devices.
|
|
hipError_t | hipIpcGetMemHandle (hipIpcMemHandle_t *handle, void *devPtr) |
| Gets an interprocess memory handle for an existing device memory allocation.
|
|
hipError_t | hipIpcOpenMemHandle (void **devPtr, hipIpcMemHandle_t handle, unsigned int flags) |
| Opens an interprocess memory handle exported from another process and returns a device pointer usable in the local process.
|
|
hipError_t | hipIpcCloseMemHandle (void *devPtr) |
| Close memory mapped with hipIpcOpenMemHandle.
|
|
hipError_t | hipIpcGetEventHandle (hipIpcEventHandle_t *handle, hipEvent_t event) |
| Gets an opaque interprocess handle for an event.
|
|
hipError_t | hipIpcOpenEventHandle (hipEvent_t *event, hipIpcEventHandle_t handle) |
| Opens an interprocess event handles.
|
|
hipError_t | hipFuncSetAttribute (const void *func, hipFuncAttribute attr, int value) |
| Set attribute for a specific function.
|
|
hipError_t | hipFuncSetCacheConfig (const void *func, hipFuncCache_t config) |
| Set Cache configuration for a specific function.
|
|
hipError_t | hipFuncSetSharedMemConfig (const void *func, hipSharedMemConfig config) |
| Set shared memory configuation for a specific function.
|
|
hipError_t | hipGetLastError (void) |
| Return last error returned by any HIP runtime API call and resets the stored error code to hipSuccess.
|
|
hipError_t | hipExtGetLastError (void) |
| Return last error returned by any HIP runtime API call and resets the stored error code to hipSuccess.
|
|
hipError_t | hipPeekAtLastError (void) |
| Return last error returned by any HIP runtime API call.
|
|
const char * | hipGetErrorName (hipError_t hip_error) |
| Return hip error as text string form.
|
|
const char * | hipGetErrorString (hipError_t hipError) |
| Return handy text string message to explain the error which occurred.
|
|
hipError_t | hipDrvGetErrorName (hipError_t hipError, const char **errorString) |
| Return hip error as text string form.
|
|
hipError_t | hipDrvGetErrorString (hipError_t hipError, const char **errorString) |
| Return handy text string message to explain the error which occurred.
|
|
hipError_t | hipStreamCreate (hipStream_t *stream) |
| Creates an asynchronous stream.
|
|
hipError_t | hipStreamCreateWithFlags (hipStream_t *stream, unsigned int flags) |
| Creates an asynchronous stream with flag.
|
|
hipError_t | hipStreamCreateWithPriority (hipStream_t *stream, unsigned int flags, int priority) |
| Creates an asynchronous stream with the specified priority.
|
|
hipError_t | hipDeviceGetStreamPriorityRange (int *leastPriority, int *greatestPriority) |
| Returns numerical values that correspond to the least and greatest stream priority.
|
|
hipError_t | hipStreamDestroy (hipStream_t stream) |
| Destroys the specified stream.
|
|
hipError_t | hipStreamQuery (hipStream_t stream) |
| Returns hipSuccess if all of the operations in the specified stream have completed, or hipErrorNotReady if not.
|
|
hipError_t | hipStreamSynchronize (hipStream_t stream) |
| Waits for all commands in the stream to complete.
|
|
hipError_t | hipStreamWaitEvent (hipStream_t stream, hipEvent_t event, unsigned int flags) |
| Makes the specified compute stream wait for the specified event.
|
|
hipError_t | hipStreamGetFlags (hipStream_t stream, unsigned int *flags) |
| Returns flags associated with this stream.
|
|
hipError_t | hipStreamGetId (hipStream_t stream, unsigned long long *streamId) |
| Queries the Id of a stream.
|
|
hipError_t | hipStreamGetPriority (hipStream_t stream, int *priority) |
| Queries the priority of a stream.
|
|
hipError_t | hipStreamGetDevice (hipStream_t stream, hipDevice_t *device) |
| Gets the device associated with the stream.
|
|
hipError_t | hipExtStreamCreateWithCUMask (hipStream_t *stream, uint32_t cuMaskSize, const uint32_t *cuMask) |
| Creates an asynchronous stream with the specified CU mask.
|
|
hipError_t | hipExtStreamGetCUMask (hipStream_t stream, uint32_t cuMaskSize, uint32_t *cuMask) |
| Gets CU mask associated with an asynchronous stream.
|
|
hipError_t | hipStreamAddCallback (hipStream_t stream, hipStreamCallback_t callback, void *userData, unsigned int flags) |
| Adds a callback to be called on the host after all currently enqueued items in the stream have completed. For each hipStreamAddCallback call, a callback will be executed exactly once. The callback will block later work in the stream until it is finished.
|
|
hipError_t | hipStreamSetAttribute (hipStream_t stream, hipStreamAttrID attr, const hipStreamAttrValue *value) |
| Sets stream attribute. Updated attribute is applied to work submitted to the stream.
|
|
hipError_t | hipStreamGetAttribute (hipStream_t stream, hipStreamAttrID attr, hipStreamAttrValue *value_out) |
| queries stream attribute.
|
|
hipError_t | hipStreamWaitValue32 (hipStream_t stream, void *ptr, uint32_t value, unsigned int flags, uint32_t mask) |
| Enqueues a wait command to the stream.[BETA].
|
|
hipError_t | hipStreamWaitValue64 (hipStream_t stream, void *ptr, uint64_t value, unsigned int flags, uint64_t mask) |
| Enqueues a wait command to the stream.[BETA].
|
|
hipError_t | hipStreamWriteValue32 (hipStream_t stream, void *ptr, uint32_t value, unsigned int flags) |
| Enqueues a write command to the stream.[BETA].
|
|
hipError_t | hipStreamWriteValue64 (hipStream_t stream, void *ptr, uint64_t value, unsigned int flags) |
| Enqueues a write command to the stream.[BETA].
|
|
hipError_t | hipStreamBatchMemOp (hipStream_t stream, unsigned int count, hipStreamBatchMemOpParams *paramArray, unsigned int flags) |
| Enqueues an array of stream memory operations in the stream.[BETA].
|
|
hipError_t | hipGraphAddBatchMemOpNode (hipGraphNode_t *phGraphNode, hipGraph_t hGraph, const hipGraphNode_t *dependencies, size_t numDependencies, const hipBatchMemOpNodeParams *nodeParams) |
| Creates a batch memory operation node and adds it to a graph.[BETA].
|
|
hipError_t | hipGraphBatchMemOpNodeGetParams (hipGraphNode_t hNode, hipBatchMemOpNodeParams *nodeParams_out) |
| Returns a batch mem op node's parameters.[BETA].
|
|
hipError_t | hipGraphBatchMemOpNodeSetParams (hipGraphNode_t hNode, hipBatchMemOpNodeParams *nodeParams) |
| Sets the batch mem op node's parameters.[BETA].
|
|
hipError_t | hipGraphExecBatchMemOpNodeSetParams (hipGraphExec_t hGraphExec, hipGraphNode_t hNode, const hipBatchMemOpNodeParams *nodeParams) |
| Sets the parameters for a batch mem op node in the given graphExec.[BETA].
|
|
hipError_t | hipEventCreateWithFlags (hipEvent_t *event, unsigned flags) |
| Create an event with the specified flags.
|
|
hipError_t | hipEventCreate (hipEvent_t *event) |
|
hipError_t | hipEventRecordWithFlags (hipEvent_t event, hipStream_t stream, unsigned int flags) |
| Record an event in the specified stream.
|
|
hipError_t | hipEventRecord (hipEvent_t event, hipStream_t stream=NULL) |
| Record an event in the specified stream.
|
|
hipError_t | hipEventDestroy (hipEvent_t event) |
| Destroy the specified event.
|
|
hipError_t | hipEventSynchronize (hipEvent_t event) |
| Wait for an event to complete.
|
|
hipError_t | hipEventElapsedTime (float *ms, hipEvent_t start, hipEvent_t stop) |
| Return the elapsed time between two events.
|
|
hipError_t | hipEventQuery (hipEvent_t event) |
| Query event status.
|
|
hipError_t | hipPointerSetAttribute (const void *value, hipPointer_attribute attribute, hipDeviceptr_t ptr) |
| Sets information on the specified pointer.[BETA].
|
|
hipError_t | hipPointerGetAttributes (hipPointerAttribute_t *attributes, const void *ptr) |
| Returns attributes for the specified pointer.
|
|
hipError_t | hipPointerGetAttribute (void *data, hipPointer_attribute attribute, hipDeviceptr_t ptr) |
| Returns information about the specified pointer.[BETA].
|
|
hipError_t | hipDrvPointerGetAttributes (unsigned int numAttributes, hipPointer_attribute *attributes, void **data, hipDeviceptr_t ptr) |
| Returns information about the specified pointer.[BETA].
|
|
hipError_t | hipImportExternalSemaphore (hipExternalSemaphore_t *extSem_out, const hipExternalSemaphoreHandleDesc *semHandleDesc) |
| Imports an external semaphore.
|
|
hipError_t | hipSignalExternalSemaphoresAsync (const hipExternalSemaphore_t *extSemArray, const hipExternalSemaphoreSignalParams *paramsArray, unsigned int numExtSems, hipStream_t stream) |
| Signals a set of external semaphore objects.
|
|
hipError_t | hipWaitExternalSemaphoresAsync (const hipExternalSemaphore_t *extSemArray, const hipExternalSemaphoreWaitParams *paramsArray, unsigned int numExtSems, hipStream_t stream) |
| Waits on a set of external semaphore objects.
|
|
hipError_t | hipDestroyExternalSemaphore (hipExternalSemaphore_t extSem) |
| Destroys an external semaphore object and releases any references to the underlying resource. Any outstanding signals or waits must have completed before the semaphore is destroyed.
|
|
hipError_t | hipImportExternalMemory (hipExternalMemory_t *extMem_out, const hipExternalMemoryHandleDesc *memHandleDesc) |
| Imports an external memory object.
|
|
hipError_t | hipExternalMemoryGetMappedBuffer (void **devPtr, hipExternalMemory_t extMem, const hipExternalMemoryBufferDesc *bufferDesc) |
| Maps a buffer onto an imported memory object.
|
|
hipError_t | hipDestroyExternalMemory (hipExternalMemory_t extMem) |
| Destroys an external memory object.
|
|
hipError_t | hipExternalMemoryGetMappedMipmappedArray (hipMipmappedArray_t *mipmap, hipExternalMemory_t extMem, const hipExternalMemoryMipmappedArrayDesc *mipmapDesc) |
| Maps a mipmapped array onto an external memory object.
|
|
hipError_t | hipMalloc (void **ptr, size_t size) |
| Allocate memory on the default accelerator.
|
|
hipError_t | hipExtMallocWithFlags (void **ptr, size_t sizeBytes, unsigned int flags) |
| Allocate memory on the default accelerator.
|
|
hipError_t | hipMallocHost (void **ptr, size_t size) |
| Allocate pinned host memory [Deprecated].
|
|
hipError_t | hipMemAllocHost (void **ptr, size_t size) |
| Allocate pinned host memory [Deprecated].
|
|
hipError_t | hipHostMalloc (void **ptr, size_t size, unsigned int flags) |
| Allocates device accessible page locked (pinned) host memory.
|
|
hipError_t | hipMallocManaged (void **dev_ptr, size_t size, unsigned int flags) |
| Allocates memory that will be automatically managed by HIP.
|
|
hipError_t | hipMemPrefetchAsync (const void *dev_ptr, size_t count, int device, hipStream_t stream) |
| Prefetches memory to the specified destination device using HIP.
|
|
hipError_t | hipMemPrefetchAsync_v2 (const void *dev_ptr, size_t count, hipMemLocation location, unsigned int flags, hipStream_t stream) |
| Prefetches memory to the specified destination device using HIP.
|
|
hipError_t | hipMemAdvise (const void *dev_ptr, size_t count, hipMemoryAdvise advice, int device) |
| Advise about the usage of a given memory range to HIP.
|
|
hipError_t | hipMemAdvise_v2 (const void *dev_ptr, size_t count, hipMemoryAdvise advice, hipMemLocation location) |
| Advise about the usage of a given memory range to HIP.
|
|
hipError_t | hipMemRangeGetAttribute (void *data, size_t data_size, hipMemRangeAttribute attribute, const void *dev_ptr, size_t count) |
| Query an attribute of a given memory range in HIP.
|
|
hipError_t | hipMemRangeGetAttributes (void **data, size_t *data_sizes, hipMemRangeAttribute *attributes, size_t num_attributes, const void *dev_ptr, size_t count) |
| Query attributes of a given memory range in HIP.
|
|
hipError_t | hipStreamAttachMemAsync (hipStream_t stream, void *dev_ptr, size_t length, unsigned int flags) |
| Attach memory to a stream asynchronously in HIP.
|
|
hipError_t | hipMallocAsync (void **dev_ptr, size_t size, hipStream_t stream) |
| Allocates memory with stream ordered semantics.
|
|
hipError_t | hipFreeAsync (void *dev_ptr, hipStream_t stream) |
| Frees memory with stream ordered semantics.
|
|
hipError_t | hipMemPoolTrimTo (hipMemPool_t mem_pool, size_t min_bytes_to_hold) |
| Releases freed memory back to the OS.
|
|
hipError_t | hipMemPoolSetAttribute (hipMemPool_t mem_pool, hipMemPoolAttr attr, void *value) |
| Sets attributes of a memory pool.
|
|
hipError_t | hipMemPoolGetAttribute (hipMemPool_t mem_pool, hipMemPoolAttr attr, void *value) |
| Gets attributes of a memory pool.
|
|
hipError_t | hipMemPoolSetAccess (hipMemPool_t mem_pool, const hipMemAccessDesc *desc_list, size_t count) |
| Controls visibility of the specified pool between devices.
|
|
hipError_t | hipMemPoolGetAccess (hipMemAccessFlags *flags, hipMemPool_t mem_pool, hipMemLocation *location) |
| Returns the accessibility of a pool from a device.
|
|
hipError_t | hipMemPoolCreate (hipMemPool_t *mem_pool, const hipMemPoolProps *pool_props) |
| Creates a memory pool.
|
|
hipError_t | hipMemPoolDestroy (hipMemPool_t mem_pool) |
| Destroys the specified memory pool.
|
|
hipError_t | hipMallocFromPoolAsync (void **dev_ptr, size_t size, hipMemPool_t mem_pool, hipStream_t stream) |
| Allocates memory from a specified pool with stream ordered semantics.
|
|
hipError_t | hipMemPoolExportToShareableHandle (void *shared_handle, hipMemPool_t mem_pool, hipMemAllocationHandleType handle_type, unsigned int flags) |
| Exports a memory pool to the requested handle type.
|
|
hipError_t | hipMemPoolImportFromShareableHandle (hipMemPool_t *mem_pool, void *shared_handle, hipMemAllocationHandleType handle_type, unsigned int flags) |
| Imports a memory pool from a shared handle.
|
|
hipError_t | hipMemPoolExportPointer (hipMemPoolPtrExportData *export_data, void *dev_ptr) |
| Export data to share a memory pool allocation between processes.
|
|
hipError_t | hipMemPoolImportPointer (void **dev_ptr, hipMemPool_t mem_pool, hipMemPoolPtrExportData *export_data) |
| Import a memory pool allocation from another process.
|
|
hipError_t | hipHostAlloc (void **ptr, size_t size, unsigned int flags) |
| Allocate device accessible page locked host memory.
|
|
hipError_t | hipHostGetDevicePointer (void **devPtr, void *hstPtr, unsigned int flags) |
| Get Device pointer from Host Pointer allocated through hipHostMalloc.
|
|
hipError_t | hipHostGetFlags (unsigned int *flagsPtr, void *hostPtr) |
| Return flags associated with host pointer.
|
|
hipError_t | hipHostRegister (void *hostPtr, size_t sizeBytes, unsigned int flags) |
| Register host memory so it can be accessed from the current device.
|
|
hipError_t | hipHostUnregister (void *hostPtr) |
| Un-register host pointer.
|
|
hipError_t | hipMallocPitch (void **ptr, size_t *pitch, size_t width, size_t height) |
|
hipError_t | hipMemAllocPitch (hipDeviceptr_t *dptr, size_t *pitch, size_t widthInBytes, size_t height, unsigned int elementSizeBytes) |
|
hipError_t | hipFree (void *ptr) |
| Free memory allocated by the HIP-Clang hip memory allocation API. This API performs an implicit hipDeviceSynchronize() call. If pointer is NULL, the hip runtime is initialized and hipSuccess is returned.
|
|
hipError_t | hipFreeHost (void *ptr) |
| Frees page-locked memory This API performs an implicit hipDeviceSynchronize() call. If pointer is NULL, the hip runtime is initialized and hipSuccess is returned.
|
|
hipError_t | hipHostFree (void *ptr) |
| Free memory allocated by the HIP-Clang hip host memory allocation API This API performs an implicit hipDeviceSynchronize() call. If pointer is NULL, the hip runtime is initialized and hipSuccess is returned.
|
|
hipError_t | hipMemcpy (void *dst, const void *src, size_t sizeBytes, hipMemcpyKind kind) |
| Copy data from src to dst.
|
|
hipError_t | hipMemcpyWithStream (void *dst, const void *src, size_t sizeBytes, hipMemcpyKind kind, hipStream_t stream) |
| Memory copy on the stream. It allows single or multiple devices to do memory copy on single or multiple streams.
|
|
hipError_t | hipMemcpyHtoD (hipDeviceptr_t dst, const void *src, size_t sizeBytes) |
| Copy data from Host to Device.
|
|
hipError_t | hipMemcpyDtoH (void *dst, hipDeviceptr_t src, size_t sizeBytes) |
| Copy data from Device to Host.
|
|
hipError_t | hipMemcpyDtoD (hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes) |
| Copy data from Device to Device.
|
|
hipError_t | hipMemcpyAtoD (hipDeviceptr_t dstDevice, hipArray_t srcArray, size_t srcOffset, size_t ByteCount) |
| Copies from one 1D array to device memory.
|
|
hipError_t | hipMemcpyDtoA (hipArray_t dstArray, size_t dstOffset, hipDeviceptr_t srcDevice, size_t ByteCount) |
| Copies from device memory to a 1D array.
|
|
hipError_t | hipMemcpyAtoA (hipArray_t dstArray, size_t dstOffset, hipArray_t srcArray, size_t srcOffset, size_t ByteCount) |
| Copies from one 1D array to another.
|
|
hipError_t | hipMemcpyHtoDAsync (hipDeviceptr_t dst, const void *src, size_t sizeBytes, hipStream_t stream) |
| Copy data from Host to Device asynchronously.
|
|
hipError_t | hipMemcpyDtoHAsync (void *dst, hipDeviceptr_t src, size_t sizeBytes, hipStream_t stream) |
| Copy data from Device to Host asynchronously.
|
|
hipError_t | hipMemcpyDtoDAsync (hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes, hipStream_t stream) |
| Copy data from Device to Device asynchronously.
|
|
hipError_t | hipMemcpyAtoHAsync (void *dstHost, hipArray_t srcArray, size_t srcOffset, size_t ByteCount, hipStream_t stream) |
| Copies from one 1D array to host memory.
|
|
hipError_t | hipMemcpyHtoAAsync (hipArray_t dstArray, size_t dstOffset, const void *srcHost, size_t ByteCount, hipStream_t stream) |
| Copies from host memory to a 1D array.
|
|
hipError_t | hipModuleGetGlobal (hipDeviceptr_t *dptr, size_t *bytes, hipModule_t hmod, const char *name) |
| Returns a global pointer from a module.
|
|
hipError_t | hipGetSymbolAddress (void **devPtr, const void *symbol) |
| Gets device pointer associated with symbol on the device.
|
|
hipError_t | hipGetSymbolSize (size_t *size, const void *symbol) |
| Gets the size of the given symbol on the device.
|
|
hipError_t | hipGetProcAddress (const char *symbol, void **pfn, int hipVersion, uint64_t flags, hipDriverProcAddressQueryResult *symbolStatus) |
| Gets the pointer of requested HIP driver function.
|
|
hipError_t | hipMemcpyToSymbol (const void *symbol, const void *src, size_t sizeBytes, size_t offset, hipMemcpyKind kind) |
| Copies data to the given symbol on the device. Symbol HIP APIs allow a kernel to define a device-side data symbol which can be accessed on the host side. The symbol can be in __constant or device space. Note that the symbol name needs to be encased in the HIP_SYMBOL macro. This also applies to hipMemcpyFromSymbol, hipGetSymbolAddress, and hipGetSymbolSize. For detailed usage, see the memcpyToSymbol example in the HIP Porting Guide.
|
|
hipError_t | hipMemcpyToSymbolAsync (const void *symbol, const void *src, size_t sizeBytes, size_t offset, hipMemcpyKind kind, hipStream_t stream) |
| Copies data to the given symbol on the device asynchronously.
|
|
hipError_t | hipMemcpyFromSymbol (void *dst, const void *symbol, size_t sizeBytes, size_t offset, hipMemcpyKind kind) |
| Copies data from the given symbol on the device.
|
|
hipError_t | hipMemcpyFromSymbolAsync (void *dst, const void *symbol, size_t sizeBytes, size_t offset, hipMemcpyKind kind, hipStream_t stream) |
| Copies data from the given symbol on the device asynchronously.
|
|
hipError_t | hipMemcpyAsync (void *dst, const void *src, size_t sizeBytes, hipMemcpyKind kind, hipStream_t stream) |
| Copies data from src to dst asynchronously.
|
|
hipError_t | hipMemset (void *dst, int value, size_t sizeBytes) |
| Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value value.
|
|
hipError_t | hipMemsetD8 (hipDeviceptr_t dest, unsigned char value, size_t count) |
| Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value value.
|
|
hipError_t | hipMemsetD8Async (hipDeviceptr_t dest, unsigned char value, size_t count, hipStream_t stream) |
| Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value value.
|
|
hipError_t | hipMemsetD16 (hipDeviceptr_t dest, unsigned short value, size_t count) |
| Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant short value value.
|
|
hipError_t | hipMemsetD16Async (hipDeviceptr_t dest, unsigned short value, size_t count, hipStream_t stream) |
| Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant short value value.
|
|
hipError_t | hipMemsetD32 (hipDeviceptr_t dest, int value, size_t count) |
| Fills the memory area pointed to by dest with the constant integer value for specified number of times.
|
|
hipError_t | hipMemsetAsync (void *dst, int value, size_t sizeBytes, hipStream_t stream) |
| Fills the first sizeBytes bytes of the memory area pointed to by dev with the constant byte value value.
|
|
hipError_t | hipMemsetD32Async (hipDeviceptr_t dst, int value, size_t count, hipStream_t stream) |
| Fills the memory area pointed to by dev with the constant integer value for specified number of times.
|
|
hipError_t | hipMemset2D (void *dst, size_t pitch, int value, size_t width, size_t height) |
| Fills the memory area pointed to by dst with the constant value.
|
|
hipError_t | hipMemset2DAsync (void *dst, size_t pitch, int value, size_t width, size_t height, hipStream_t stream) |
| Fills asynchronously the memory area pointed to by dst with the constant value.
|
|
hipError_t | hipMemset3D (hipPitchedPtr pitchedDevPtr, int value, hipExtent extent) |
| Fills synchronously the memory area pointed to by pitchedDevPtr with the constant value.
|
|
hipError_t | hipMemset3DAsync (hipPitchedPtr pitchedDevPtr, int value, hipExtent extent, hipStream_t stream) |
| Fills asynchronously the memory area pointed to by pitchedDevPtr with the constant value.
|
|
hipError_t | hipMemsetD2D8 (hipDeviceptr_t dst, size_t dstPitch, unsigned char value, size_t width, size_t height) |
| Fills 2D memory range of 'width' 8-bit values synchronously to the specified char value. Height specifies numbers of rows to set and dstPitch speicifies the number of bytes between each row.
|
|
hipError_t | hipMemsetD2D8Async (hipDeviceptr_t dst, size_t dstPitch, unsigned char value, size_t width, size_t height, hipStream_t stream) |
| Fills 2D memory range of 'width' 8-bit values asynchronously to the specified char value. Height specifies numbers of rows to set and dstPitch speicifies the number of bytes between each row.
|
|
hipError_t | hipMemsetD2D16 (hipDeviceptr_t dst, size_t dstPitch, unsigned short value, size_t width, size_t height) |
| Fills 2D memory range of 'width' 16-bit values synchronously to the specified short value. Height specifies numbers of rows to set and dstPitch speicifies the number of bytes between each row.
|
|
hipError_t | hipMemsetD2D16Async (hipDeviceptr_t dst, size_t dstPitch, unsigned short value, size_t width, size_t height, hipStream_t stream) |
| Fills 2D memory range of 'width' 16-bit values asynchronously to the specified short value. Height specifies numbers of rows to set and dstPitch speicifies the number of bytes between each row.
|
|
hipError_t | hipMemsetD2D32 (hipDeviceptr_t dst, size_t dstPitch, unsigned int value, size_t width, size_t height) |
| Fills 2D memory range of 'width' 32-bit values synchronously to the specified int value. Height specifies numbers of rows to set and dstPitch speicifies the number of bytes between each row.
|
|
hipError_t | hipMemsetD2D32Async (hipDeviceptr_t dst, size_t dstPitch, unsigned int value, size_t width, size_t height, hipStream_t stream) |
| Fills 2D memory range of 'width' 32-bit values asynchronously to the specified int value. Height specifies numbers of rows to set and dstPitch speicifies the number of bytes between each row.
|
|
hipError_t | hipMemGetInfo (size_t *free, size_t *total) |
| Query memory info.
|
|
hipError_t | hipMemPtrGetInfo (void *ptr, size_t *size) |
| Get allocated memory size via memory pointer.
|
|
hipError_t | hipMallocArray (hipArray_t *array, const hipChannelFormatDesc *desc, size_t width, size_t height, unsigned int flags) |
| Allocate an array on the device.
|
|
hipError_t | hipArrayCreate (hipArray_t *pHandle, const HIP_ARRAY_DESCRIPTOR *pAllocateArray) |
| Create an array memory pointer on the device.
|
|
hipError_t | hipArrayDestroy (hipArray_t array) |
| Destroy an array memory pointer on the device.
|
|
hipError_t | hipArray3DCreate (hipArray_t *array, const HIP_ARRAY3D_DESCRIPTOR *pAllocateArray) |
| Create a 3D array memory pointer on the device.
|
|
hipError_t | hipMalloc3D (hipPitchedPtr *pitchedDevPtr, hipExtent extent) |
| Create a 3D memory pointer on the device.
|
|
hipError_t | hipFreeArray (hipArray_t array) |
| Frees an array on the device.
|
|
hipError_t | hipMalloc3DArray (hipArray_t *array, const struct hipChannelFormatDesc *desc, struct hipExtent extent, unsigned int flags) |
| Allocate an array on the device.
|
|
hipError_t | hipArrayGetInfo (hipChannelFormatDesc *desc, hipExtent *extent, unsigned int *flags, hipArray_t array) |
| Gets info about the specified array.
|
|
hipError_t | hipArrayGetDescriptor (HIP_ARRAY_DESCRIPTOR *pArrayDescriptor, hipArray_t array) |
| Gets a 1D or 2D array descriptor.
|
|
hipError_t | hipArray3DGetDescriptor (HIP_ARRAY3D_DESCRIPTOR *pArrayDescriptor, hipArray_t array) |
| Gets a 3D array descriptor.
|
|
hipError_t | hipMemcpy2D (void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind) |
| Copies data between host and device.
|
|
hipError_t | hipMemcpyParam2D (const hip_Memcpy2D *pCopy) |
| Copies memory for 2D arrays.
|
|
hipError_t | hipMemcpyParam2DAsync (const hip_Memcpy2D *pCopy, hipStream_t stream) |
| Copies memory for 2D arrays.
|
|
hipError_t | hipMemcpy2DAsync (void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind, hipStream_t stream) |
| Copies data between host and device asynchronously.
|
|
hipError_t | hipMemcpy2DToArray (hipArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind) |
| Copies data between host and device.
|
|
hipError_t | hipMemcpy2DToArrayAsync (hipArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind, hipStream_t stream) |
| Copies data between host and device.
|
|
hipError_t | hipMemcpy2DArrayToArray (hipArray_t dst, size_t wOffsetDst, size_t hOffsetDst, hipArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, hipMemcpyKind kind) |
| Copies data between host and device.
|
|
hipError_t | hipMemcpyToArray (hipArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t count, hipMemcpyKind kind) |
| Copies data between host and device [Deprecated].
|
|
hipError_t | hipMemcpyFromArray (void *dst, hipArray_const_t srcArray, size_t wOffset, size_t hOffset, size_t count, hipMemcpyKind kind) |
| Copies data between host and device [Deprecated].
|
|
hipError_t | hipMemcpy2DFromArray (void *dst, size_t dpitch, hipArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, hipMemcpyKind kind) |
| Copies data between host and device.
|
|
hipError_t | hipMemcpy2DFromArrayAsync (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) |
| Copies data between host and device asynchronously.
|
|
hipError_t | hipMemcpyAtoH (void *dst, hipArray_t srcArray, size_t srcOffset, size_t count) |
| Copies data between host and device.
|
|
hipError_t | hipMemcpyHtoA (hipArray_t dstArray, size_t dstOffset, const void *srcHost, size_t count) |
| Copies data between host and device.
|
|
hipError_t | hipMemcpy3D (const struct hipMemcpy3DParms *p) |
| Copies data between host and device.
|
|
hipError_t | hipMemcpy3DAsync (const struct hipMemcpy3DParms *p, hipStream_t stream) |
| Copies data between host and device asynchronously.
|
|
hipError_t | hipDrvMemcpy3D (const HIP_MEMCPY3D *pCopy) |
| Copies data between host and device.
|
|
hipError_t | hipDrvMemcpy3DAsync (const HIP_MEMCPY3D *pCopy, hipStream_t stream) |
| Copies data between host and device asynchronously.
|
|
hipError_t | hipMemGetAddressRange (hipDeviceptr_t *pbase, size_t *psize, hipDeviceptr_t dptr) |
| Get information on memory allocations.
|
|
hipError_t | hipMemcpyBatchAsync (void **dsts, void **srcs, size_t *sizes, size_t count, hipMemcpyAttributes *attrs, size_t *attrsIdxs, size_t numAttrs, size_t *failIdx, hipStream_t stream) |
| Perform Batch of 1D copies.
|
|
hipError_t | hipMemcpy3DBatchAsync (size_t numOps, struct hipMemcpy3DBatchOp *opList, size_t *failIdx, unsigned long long flags, hipStream_t stream) |
| Perform Batch of 3D copies.
|
|
hipError_t | hipMemcpy3DPeer (hipMemcpy3DPeerParms *p) |
| Performs 3D memory copies between devices This API is asynchronous with respect to host.
|
|
hipError_t | hipMemcpy3DPeerAsync (hipMemcpy3DPeerParms *p, hipStream_t stream) |
| Performs 3D memory copies between devices asynchronously.
|
|
hipError_t | hipDeviceCanAccessPeer (int *canAccessPeer, int deviceId, int peerDeviceId) |
| Determines if a device can access a peer device's memory.
|
|
hipError_t | hipDeviceEnablePeerAccess (int peerDeviceId, unsigned int flags) |
| Enables direct access to memory allocations on a peer device.
|
|
hipError_t | hipDeviceDisablePeerAccess (int peerDeviceId) |
| Disables direct access to memory allocations on a peer device.
|
|
hipError_t | hipMemcpyPeer (void *dst, int dstDeviceId, const void *src, int srcDeviceId, size_t sizeBytes) |
| Copies memory between two peer accessible devices.
|
|
hipError_t | hipMemcpyPeerAsync (void *dst, int dstDeviceId, const void *src, int srcDevice, size_t sizeBytes, hipStream_t stream) |
| Copies memory between two peer accessible devices asynchronously.
|
|
hipError_t | hipCtxCreate (hipCtx_t *ctx, unsigned int flags, hipDevice_t device) |
| Create a context and set it as current/default context.
|
|
hipError_t | hipCtxDestroy (hipCtx_t ctx) |
| Destroy a HIP context [Deprecated].
|
|
hipError_t | hipCtxPopCurrent (hipCtx_t *ctx) |
| Pop the current/default context and return the popped context [Deprecated].
|
|
hipError_t | hipCtxPushCurrent (hipCtx_t ctx) |
| Push the context to be set as current/ default context [Deprecated].
|
|
hipError_t | hipCtxSetCurrent (hipCtx_t ctx) |
| Set the passed context as current/default [Deprecated].
|
|
hipError_t | hipCtxGetCurrent (hipCtx_t *ctx) |
| Get the handle of the current/ default context [Deprecated].
|
|
hipError_t | hipCtxGetDevice (hipDevice_t *device) |
| Get the handle of the device associated with current/default context [Deprecated].
|
|
hipError_t | hipCtxGetApiVersion (hipCtx_t ctx, unsigned int *apiVersion) |
| Returns the approximate HIP api version.
|
|
hipError_t | hipCtxGetCacheConfig (hipFuncCache_t *cacheConfig) |
| Get Cache configuration for a specific function [Deprecated].
|
|
hipError_t | hipCtxSetCacheConfig (hipFuncCache_t cacheConfig) |
| Set L1/Shared cache partition [Deprecated].
|
|
hipError_t | hipCtxSetSharedMemConfig (hipSharedMemConfig config) |
| Set Shared memory bank configuration [Deprecated].
|
|
hipError_t | hipCtxGetSharedMemConfig (hipSharedMemConfig *pConfig) |
| Get Shared memory bank configuration [Deprecated].
|
|
hipError_t | hipCtxSynchronize (void) |
| Blocks until the default context has completed all preceding requested tasks [Deprecated].
|
|
hipError_t | hipCtxGetFlags (unsigned int *flags) |
| Return flags used for creating default context [Deprecated].
|
|
hipError_t | hipCtxEnablePeerAccess (hipCtx_t peerCtx, unsigned int flags) |
| Enables direct access to memory allocations in a peer context [Deprecated].
|
|
hipError_t | hipCtxDisablePeerAccess (hipCtx_t peerCtx) |
| Disable direct access from current context's virtual address space to memory allocations physically located on a peer context.Disables direct access to memory allocations in a peer context and unregisters any registered allocations [Deprecated].
|
|
hipError_t | hipDevicePrimaryCtxGetState (hipDevice_t dev, unsigned int *flags, int *active) |
| Get the state of the primary context [Deprecated].
|
|
hipError_t | hipDevicePrimaryCtxRelease (hipDevice_t dev) |
| Release the primary context on the GPU.
|
|
hipError_t | hipDevicePrimaryCtxRetain (hipCtx_t *pctx, hipDevice_t dev) |
| Retain the primary context on the GPU [Deprecated].
|
|
hipError_t | hipDevicePrimaryCtxReset (hipDevice_t dev) |
| Resets the primary context on the GPU [Deprecated].
|
|
hipError_t | hipDevicePrimaryCtxSetFlags (hipDevice_t dev, unsigned int flags) |
| Set flags for the primary context [Deprecated].
|
|
hipError_t | hipModuleLoadFatBinary (hipModule_t *module, const void *fatbin) |
| Loads fatbin object.
|
|
hipError_t | hipModuleLoad (hipModule_t *module, const char *fname) |
| Loads code object from file into a module the currrent context.
|
|
hipError_t | hipModuleUnload (hipModule_t module) |
| Frees the module.
|
|
hipError_t | hipModuleGetFunction (hipFunction_t *function, hipModule_t module, const char *kname) |
| Function with kname will be extracted if present in module.
|
|
hipError_t | hipModuleGetFunctionCount (unsigned int *count, hipModule_t mod) |
| Returns the number of functions within a module.
|
|
hipError_t | hipFuncGetAttributes (struct hipFuncAttributes *attr, const void *func) |
| Find out attributes for a given function.
|
|
hipError_t | hipFuncGetAttribute (int *value, hipFunction_attribute attrib, hipFunction_t hfunc) |
| Find out a specific attribute for a given function.
|
|
hipError_t | hipGetFuncBySymbol (hipFunction_t *functionPtr, const void *symbolPtr) |
| Gets pointer to device entry function that matches entry function symbolPtr.
|
|
hipError_t | hipGetDriverEntryPoint (const char *symbol, void **funcPtr, unsigned long long flags, hipDriverEntryPointQueryResult *driverStatus) |
| Gets function pointer of a requested HIP API.
|
|
hipError_t | hipModuleGetTexRef (textureReference **texRef, hipModule_t hmod, const char *name) |
| returns the handle of the texture reference with the name from the module.
|
|
hipError_t | hipModuleLoadData (hipModule_t *module, const void *image) |
| builds module from code object which resides in host memory. Image is pointer to that location.
|
|
hipError_t | hipModuleLoadDataEx (hipModule_t *module, const void *image, unsigned int numOptions, hipJitOption *options, void **optionValues) |
| builds module from code object which resides in host memory. Image is pointer to that location. Options are not used. hipModuleLoadData is called.
|
|
hipError_t | hipLinkAddData (hipLinkState_t state, hipJitInputType type, void *data, size_t size, const char *name, unsigned int numOptions, hipJitOption *options, void **optionValues) |
| Adds bitcode data to be linked with options.
|
|
hipError_t | hipLinkAddFile (hipLinkState_t state, hipJitInputType type, const char *path, unsigned int numOptions, hipJitOption *options, void **optionValues) |
| Adds a file with bitcode to be linked with options.
|
|
hipError_t | hipLinkComplete (hipLinkState_t state, void **hipBinOut, size_t *sizeOut) |
| Completes the linking of the given program.
|
|
hipError_t | hipLinkCreate (unsigned int numOptions, hipJitOption *options, void **optionValues, hipLinkState_t *stateOut) |
| Creates a linker instance with options.
|
|
hipError_t | hipLinkDestroy (hipLinkState_t state) |
| Deletes the linker instance.
|
|
hipError_t | hipModuleLaunchKernel (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) |
| launches kernel f with launch parameters and shared memory on stream with arguments passed to kernelparams or extra
|
|
hipError_t | hipModuleLaunchCooperativeKernel (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) |
| launches kernel f with launch parameters and shared memory on stream with arguments passed to kernelParams, where thread blocks can cooperate and synchronize as they execute
|
|
hipError_t | hipModuleLaunchCooperativeKernelMultiDevice (hipFunctionLaunchParams *launchParamsList, unsigned int numDevices, unsigned int flags) |
| Launches kernels on multiple devices where thread blocks can cooperate and synchronize as they execute.
|
|
hipError_t | hipLaunchCooperativeKernel (const void *f, dim3 gridDim, dim3 blockDimX, void **kernelParams, unsigned int sharedMemBytes, hipStream_t stream) |
| Launches kernel f with launch parameters and shared memory on stream with arguments passed to kernelparams or extra, where thread blocks can cooperate and synchronize as they execute.
|
|
hipError_t | hipLaunchCooperativeKernelMultiDevice (hipLaunchParams *launchParamsList, int numDevices, unsigned int flags) |
| Launches kernels on multiple devices where thread blocks can cooperate and synchronize as they execute.
|
|
hipError_t | hipExtLaunchMultiKernelMultiDevice (hipLaunchParams *launchParamsList, int numDevices, unsigned int flags) |
| Launches kernels on multiple devices and guarantees all specified kernels are dispatched on respective streams before enqueuing any other work on the specified streams from any other threads.
|
|
hipError_t | hipLaunchKernelExC (const hipLaunchConfig_t *config, const void *fPtr, void **args) |
| Launches a HIP kernel using a generic function pointer and the specified configuration.
|
|
hipError_t | hipDrvLaunchKernelEx (const HIP_LAUNCH_CONFIG *config, hipFunction_t f, void **params, void **extra) |
| Launches a HIP kernel using the driver API with the specified configuration.
|
|
hipError_t | hipMemGetHandleForAddressRange (void *handle, hipDeviceptr_t dptr, size_t size, hipMemRangeHandleType handleType, unsigned long long flags) |
| Returns a handle for the address range requested.
|
|
hipError_t | hipModuleOccupancyMaxPotentialBlockSize (int *gridSize, int *blockSize, hipFunction_t f, size_t dynSharedMemPerBlk, int blockSizeLimit) |
| determine the grid and block sizes to achieves maximum occupancy for a kernel
|
|
hipError_t | hipModuleOccupancyMaxPotentialBlockSizeWithFlags (int *gridSize, int *blockSize, hipFunction_t f, size_t dynSharedMemPerBlk, int blockSizeLimit, unsigned int flags) |
| determine the grid and block sizes to achieves maximum occupancy for a kernel
|
|
hipError_t | hipModuleOccupancyMaxActiveBlocksPerMultiprocessor (int *numBlocks, hipFunction_t f, int blockSize, size_t dynSharedMemPerBlk) |
| Returns occupancy for a device function.
|
|
hipError_t | hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags (int *numBlocks, hipFunction_t f, int blockSize, size_t dynSharedMemPerBlk, unsigned int flags) |
| Returns occupancy for a device function.
|
|
hipError_t | hipOccupancyMaxActiveBlocksPerMultiprocessor (int *numBlocks, const void *f, int blockSize, size_t dynSharedMemPerBlk) |
| Returns occupancy for a device function.
|
|
hipError_t | hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags (int *numBlocks, const void *f, int blockSize, size_t dynSharedMemPerBlk, unsigned int flags) |
| Returns occupancy for a device function.
|
|
hipError_t | hipOccupancyMaxPotentialBlockSize (int *gridSize, int *blockSize, const void *f, size_t dynSharedMemPerBlk, int blockSizeLimit) |
| determine the grid and block sizes to achieves maximum occupancy for a kernel
|
|
hipError_t | hipProfilerStart () |
| Start recording of profiling information [Deprecated] When using this API, start the profiler with profiling disabled. (–startdisabled)
|
|
hipError_t | hipProfilerStop () |
| Stop recording of profiling information [Deprecated] When using this API, start the profiler with profiling disabled. (–startdisabled)
|
|
hipError_t | hipConfigureCall (dim3 gridDim, dim3 blockDim, size_t sharedMem, hipStream_t stream) |
| Configure a kernel launch.
|
|
hipError_t | hipSetupArgument (const void *arg, size_t size, size_t offset) |
| Set a kernel argument.
|
|
hipError_t | hipLaunchByPtr (const void *func) |
| Launch a kernel.
|
|
hipError_t | __hipPushCallConfiguration (dim3 gridDim, dim3 blockDim, size_t sharedMem, hipStream_t stream) |
| Push configuration of a kernel launch.
|
|
hipError_t | __hipPopCallConfiguration (dim3 *gridDim, dim3 *blockDim, size_t *sharedMem, hipStream_t *stream) |
| Pop configuration of a kernel launch.
|
|
hipError_t | hipLaunchKernel (const void *function_address, dim3 numBlocks, dim3 dimBlocks, void **args, size_t sharedMemBytes, hipStream_t stream) |
| C compliant kernel launch API.
|
|
hipError_t | hipLaunchHostFunc (hipStream_t stream, hipHostFn_t fn, void *userData) |
| Enqueues a host function call in a stream.
|
|
hipError_t | hipDrvMemcpy2DUnaligned (const hip_Memcpy2D *pCopy) |
|
hipError_t | hipExtLaunchKernel (const void *function_address, dim3 numBlocks, dim3 dimBlocks, void **args, size_t sharedMemBytes, hipStream_t stream, hipEvent_t startEvent, hipEvent_t stopEvent, int flags) |
| Launches kernel from the pointer address, with arguments and shared memory on stream.
|
|
hipError_t | hipCreateTextureObject (hipTextureObject_t *pTexObject, const hipResourceDesc *pResDesc, const hipTextureDesc *pTexDesc, const struct hipResourceViewDesc *pResViewDesc) |
| Creates a texture object.
|
|
hipError_t | hipDestroyTextureObject (hipTextureObject_t textureObject) |
| Destroys a texture object.
|
|
hipError_t | hipGetChannelDesc (hipChannelFormatDesc *desc, hipArray_const_t array) |
| Gets the channel descriptor in an array.
|
|
hipError_t | hipGetTextureObjectResourceDesc (hipResourceDesc *pResDesc, hipTextureObject_t textureObject) |
| Gets resource descriptor for the texture object.
|
|
hipError_t | hipGetTextureObjectResourceViewDesc (struct hipResourceViewDesc *pResViewDesc, hipTextureObject_t textureObject) |
| Gets resource view descriptor for the texture object.
|
|
hipError_t | hipGetTextureObjectTextureDesc (hipTextureDesc *pTexDesc, hipTextureObject_t textureObject) |
| Gets texture descriptor for the texture object.
|
|
hipError_t | hipTexObjectCreate (hipTextureObject_t *pTexObject, const HIP_RESOURCE_DESC *pResDesc, const HIP_TEXTURE_DESC *pTexDesc, const HIP_RESOURCE_VIEW_DESC *pResViewDesc) |
| Creates a texture object.
|
|
hipError_t | hipTexObjectDestroy (hipTextureObject_t texObject) |
| Destroys a texture object.
|
|
hipError_t | hipTexObjectGetResourceDesc (HIP_RESOURCE_DESC *pResDesc, hipTextureObject_t texObject) |
| Gets resource descriptor of a texture object.
|
|
hipError_t | hipTexObjectGetResourceViewDesc (HIP_RESOURCE_VIEW_DESC *pResViewDesc, hipTextureObject_t texObject) |
| Gets resource view descriptor of a texture object.
|
|
hipError_t | hipTexObjectGetTextureDesc (HIP_TEXTURE_DESC *pTexDesc, hipTextureObject_t texObject) |
| Gets texture descriptor of a texture object.
|
|
hipError_t | hipMallocMipmappedArray (hipMipmappedArray_t *mipmappedArray, const struct hipChannelFormatDesc *desc, struct hipExtent extent, unsigned int numLevels, unsigned int flags) |
| Allocate a mipmapped array on the device.
|
|
hipError_t | hipFreeMipmappedArray (hipMipmappedArray_t mipmappedArray) |
| Frees a mipmapped array on the device.
|
|
hipError_t | hipGetMipmappedArrayLevel (hipArray_t *levelArray, hipMipmappedArray_const_t mipmappedArray, unsigned int level) |
| Gets a mipmap level of a HIP mipmapped array.
|
|
hipError_t | hipMipmappedArrayCreate (hipMipmappedArray_t *pHandle, HIP_ARRAY3D_DESCRIPTOR *pMipmappedArrayDesc, unsigned int numMipmapLevels) |
| Create a mipmapped array.
|
|
hipError_t | hipMipmappedArrayDestroy (hipMipmappedArray_t hMipmappedArray) |
| Destroy a mipmapped array.
|
|
hipError_t | hipMipmappedArrayGetLevel (hipArray_t *pLevelArray, hipMipmappedArray_t hMipMappedArray, unsigned int level) |
| Get a mipmapped array on a mipmapped level.
|
|
hipError_t | hipBindTextureToMipmappedArray (const textureReference *tex, hipMipmappedArray_const_t mipmappedArray, const hipChannelFormatDesc *desc) |
| Binds a mipmapped array to a texture [Deprecated].
|
|
hipError_t | hipGetTextureReference (const textureReference **texref, const void *symbol) |
| Gets the texture reference related with the symbol [Deprecated].
|
|
hipError_t | hipTexRefGetBorderColor (float *pBorderColor, const textureReference *texRef) |
| Gets the border color used by a texture reference [Deprecated].
|
|
hipError_t | hipTexRefGetArray (hipArray_t *pArray, const textureReference *texRef) |
| Gets the array bound to a texture reference [Deprecated].
|
|
hipError_t | hipTexRefSetAddressMode (textureReference *texRef, int dim, enum hipTextureAddressMode am) |
| Sets address mode for a texture reference [Deprecated].
|
|
hipError_t | hipTexRefSetArray (textureReference *tex, hipArray_const_t array, unsigned int flags) |
| Binds an array as a texture reference [Deprecated].
|
|
hipError_t | hipTexRefSetFilterMode (textureReference *texRef, enum hipTextureFilterMode fm) |
| Set filter mode for a texture reference [Deprecated].
|
|
hipError_t | hipTexRefSetFlags (textureReference *texRef, unsigned int Flags) |
| Set flags for a texture reference [Deprecated].
|
|
hipError_t | hipTexRefSetFormat (textureReference *texRef, hipArray_Format fmt, int NumPackedComponents) |
| Set format for a texture reference [Deprecated].
|
|
hipError_t | hipBindTexture (size_t *offset, const textureReference *tex, const void *devPtr, const hipChannelFormatDesc *desc, size_t size) |
| Binds a memory area to a texture [Deprecated].
|
|
hipError_t | hipBindTexture2D (size_t *offset, const textureReference *tex, const void *devPtr, const hipChannelFormatDesc *desc, size_t width, size_t height, size_t pitch) |
| Binds a 2D memory area to a texture [Deprecated].
|
|
hipError_t | hipBindTextureToArray (const textureReference *tex, hipArray_const_t array, const hipChannelFormatDesc *desc) |
| Binds a memory area to a texture [Deprecated].
|
|
hipError_t | hipGetTextureAlignmentOffset (size_t *offset, const textureReference *texref) |
| Get the offset of the alignment in a texture [Deprecated].
|
|
hipError_t | hipUnbindTexture (const textureReference *tex) |
| Unbinds a texture [Deprecated].
|
|
hipError_t | hipTexRefGetAddress (hipDeviceptr_t *dev_ptr, const textureReference *texRef) |
| Gets the address for a texture reference [Deprecated].
|
|
hipError_t | hipTexRefGetAddressMode (enum hipTextureAddressMode *pam, const textureReference *texRef, int dim) |
| Gets the address mode for a texture reference [Deprecated].
|
|
hipError_t | hipTexRefGetFilterMode (enum hipTextureFilterMode *pfm, const textureReference *texRef) |
| Gets filter mode for a texture reference [Deprecated].
|
|
hipError_t | hipTexRefGetFlags (unsigned int *pFlags, const textureReference *texRef) |
| Gets flags for a texture reference [Deprecated].
|
|
hipError_t | hipTexRefGetFormat (hipArray_Format *pFormat, int *pNumChannels, const textureReference *texRef) |
| Gets texture format for a texture reference [Deprecated].
|
|
hipError_t | hipTexRefGetMaxAnisotropy (int *pmaxAnsio, const textureReference *texRef) |
| Gets the maximum anisotropy for a texture reference [Deprecated].
|
|
hipError_t | hipTexRefGetMipmapFilterMode (enum hipTextureFilterMode *pfm, const textureReference *texRef) |
| Gets the mipmap filter mode for a texture reference [Deprecated].
|
|
hipError_t | hipTexRefGetMipmapLevelBias (float *pbias, const textureReference *texRef) |
| Gets the mipmap level bias for a texture reference [Deprecated].
|
|
hipError_t | hipTexRefGetMipmapLevelClamp (float *pminMipmapLevelClamp, float *pmaxMipmapLevelClamp, const textureReference *texRef) |
| Gets the minimum and maximum mipmap level clamps for a texture reference [Deprecated].
|
|
hipError_t | hipTexRefGetMipMappedArray (hipMipmappedArray_t *pArray, const textureReference *texRef) |
| Gets the mipmapped array bound to a texture reference [Deprecated].
|
|
hipError_t | hipTexRefSetAddress (size_t *ByteOffset, textureReference *texRef, hipDeviceptr_t dptr, size_t bytes) |
| Sets an bound address for a texture reference [Deprecated].
|
|
hipError_t | hipTexRefSetAddress2D (textureReference *texRef, const HIP_ARRAY_DESCRIPTOR *desc, hipDeviceptr_t dptr, size_t Pitch) |
| Set a bind an address as a 2D texture reference [Deprecated].
|
|
hipError_t | hipTexRefSetMaxAnisotropy (textureReference *texRef, unsigned int maxAniso) |
| Sets the maximum anisotropy for a texture reference [Deprecated].
|
|
hipError_t | hipTexRefSetBorderColor (textureReference *texRef, float *pBorderColor) |
| Sets border color for a texture reference [Deprecated].
|
|
hipError_t | hipTexRefSetMipmapFilterMode (textureReference *texRef, enum hipTextureFilterMode fm) |
| Sets mipmap filter mode for a texture reference [Deprecated].
|
|
hipError_t | hipTexRefSetMipmapLevelBias (textureReference *texRef, float bias) |
| Sets mipmap level bias for a texture reference [Deprecated].
|
|
hipError_t | hipTexRefSetMipmapLevelClamp (textureReference *texRef, float minMipMapLevelClamp, float maxMipMapLevelClamp) |
| Sets mipmap level clamp for a texture reference [Deprecated].
|
|
hipError_t | hipTexRefSetMipmappedArray (textureReference *texRef, struct hipMipmappedArray *mipmappedArray, unsigned int Flags) |
| Binds mipmapped array to a texture reference [Deprecated].
|
|
const char * | hipApiName (uint32_t id) |
| Returns HIP API name by ID.
|
|
const char * | hipKernelNameRef (const hipFunction_t f) |
| Returns kernel name reference by function name.
|
|
const char * | hipKernelNameRefByPtr (const void *hostFunction, hipStream_t stream) |
| Retrives kernel for a given host pointer, unless stated otherwise.
|
|
int | hipGetStreamDeviceId (hipStream_t stream) |
| Returns device ID on the stream.
|
|
hipError_t | hipStreamBeginCapture (hipStream_t stream, hipStreamCaptureMode mode) |
| Begins graph capture on a stream.
|
|
hipError_t | hipStreamBeginCaptureToGraph (hipStream_t stream, hipGraph_t graph, const hipGraphNode_t *dependencies, const hipGraphEdgeData *dependencyData, size_t numDependencies, hipStreamCaptureMode mode) |
| Begins graph capture on a stream to an existing graph.
|
|
hipError_t | hipStreamEndCapture (hipStream_t stream, hipGraph_t *pGraph) |
| Ends capture on a stream, returning the captured graph.
|
|
hipError_t | hipStreamGetCaptureInfo (hipStream_t stream, hipStreamCaptureStatus *pCaptureStatus, unsigned long long *pId) |
| Get capture status of a stream.
|
|
hipError_t | hipStreamGetCaptureInfo_v2 (hipStream_t stream, hipStreamCaptureStatus *captureStatus_out, unsigned long long *id_out, hipGraph_t *graph_out, const hipGraphNode_t **dependencies_out, size_t *numDependencies_out) |
| Get stream's capture state.
|
|
hipError_t | hipStreamIsCapturing (hipStream_t stream, hipStreamCaptureStatus *pCaptureStatus) |
| Get stream's capture state.
|
|
hipError_t | hipStreamUpdateCaptureDependencies (hipStream_t stream, hipGraphNode_t *dependencies, size_t numDependencies, unsigned int flags) |
| Update the set of dependencies in a capturing stream.
|
|
hipError_t | hipThreadExchangeStreamCaptureMode (hipStreamCaptureMode *mode) |
| Swaps the stream capture mode of a thread.
|
|
hipError_t | hipGraphCreate (hipGraph_t *pGraph, unsigned int flags) |
| Creates a graph.
|
|
hipError_t | hipGraphDestroy (hipGraph_t graph) |
| Destroys a graph.
|
|
hipError_t | hipGraphAddDependencies (hipGraph_t graph, const hipGraphNode_t *from, const hipGraphNode_t *to, size_t numDependencies) |
| Adds dependency edges to a graph.
|
|
hipError_t | hipGraphRemoveDependencies (hipGraph_t graph, const hipGraphNode_t *from, const hipGraphNode_t *to, size_t numDependencies) |
| Removes dependency edges from a graph.
|
|
hipError_t | hipGraphGetEdges (hipGraph_t graph, hipGraphNode_t *from, hipGraphNode_t *to, size_t *numEdges) |
| Returns a graph's dependency edges.
|
|
hipError_t | hipGraphGetNodes (hipGraph_t graph, hipGraphNode_t *nodes, size_t *numNodes) |
| Returns a graph's nodes.
|
|
hipError_t | hipGraphGetRootNodes (hipGraph_t graph, hipGraphNode_t *pRootNodes, size_t *pNumRootNodes) |
| Returns a graph's root nodes.
|
|
hipError_t | hipGraphNodeGetDependencies (hipGraphNode_t node, hipGraphNode_t *pDependencies, size_t *pNumDependencies) |
| Returns a node's dependencies.
|
|
hipError_t | hipGraphNodeGetDependentNodes (hipGraphNode_t node, hipGraphNode_t *pDependentNodes, size_t *pNumDependentNodes) |
| Returns a node's dependent nodes.
|
|
hipError_t | hipGraphNodeGetType (hipGraphNode_t node, hipGraphNodeType *pType) |
| Returns a node's type.
|
|
hipError_t | hipGraphDestroyNode (hipGraphNode_t node) |
| Remove a node from the graph.
|
|
hipError_t | hipGraphClone (hipGraph_t *pGraphClone, hipGraph_t originalGraph) |
| Clones a graph.
|
|
hipError_t | hipGraphNodeFindInClone (hipGraphNode_t *pNode, hipGraphNode_t originalNode, hipGraph_t clonedGraph) |
| Finds a cloned version of a node.
|
|
hipError_t | hipGraphInstantiate (hipGraphExec_t *pGraphExec, hipGraph_t graph, hipGraphNode_t *pErrorNode, char *pLogBuffer, size_t bufferSize) |
| Creates an executable graph from a graph.
|
|
hipError_t | hipGraphInstantiateWithFlags (hipGraphExec_t *pGraphExec, hipGraph_t graph, unsigned long long flags) |
| Creates an executable graph from a graph.
|
|
hipError_t | hipGraphInstantiateWithParams (hipGraphExec_t *pGraphExec, hipGraph_t graph, hipGraphInstantiateParams *instantiateParams) |
| Creates an executable graph from a graph.
|
|
hipError_t | hipGraphLaunch (hipGraphExec_t graphExec, hipStream_t stream) |
| Launches an executable graph in the specified stream.
|
|
hipError_t | hipGraphUpload (hipGraphExec_t graphExec, hipStream_t stream) |
| Uploads an executable graph to a stream.
|
|
hipError_t | hipGraphAddNode (hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, hipGraphNodeParams *nodeParams) |
| Creates a kernel execution node and adds it to a graph.
|
|
hipError_t | hipGraphExecGetFlags (hipGraphExec_t graphExec, unsigned long long *flags) |
| Return the flags of an executable graph.
|
|
hipError_t | hipGraphNodeSetParams (hipGraphNode_t node, hipGraphNodeParams *nodeParams) |
| Updates parameters of a graph's node.
|
|
hipError_t | hipGraphExecNodeSetParams (hipGraphExec_t graphExec, hipGraphNode_t node, hipGraphNodeParams *nodeParams) |
| Updates parameters of an executable graph's node.
|
|
hipError_t | hipGraphExecDestroy (hipGraphExec_t graphExec) |
| Destroys an executable graph.
|
|
hipError_t | hipGraphExecUpdate (hipGraphExec_t hGraphExec, hipGraph_t hGraph, hipGraphNode_t *hErrorNode_out, hipGraphExecUpdateResult *updateResult_out) |
| Check whether an executable graph can be updated with a graph and perform the update if * possible.
|
|
hipError_t | hipGraphAddKernelNode (hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, const hipKernelNodeParams *pNodeParams) |
| Creates a kernel execution node and adds it to a graph.
|
|
hipError_t | hipGraphKernelNodeGetParams (hipGraphNode_t node, hipKernelNodeParams *pNodeParams) |
| Gets kernel node's parameters.
|
|
hipError_t | hipGraphKernelNodeSetParams (hipGraphNode_t node, const hipKernelNodeParams *pNodeParams) |
| Sets a kernel node's parameters.
|
|
hipError_t | hipGraphExecKernelNodeSetParams (hipGraphExec_t hGraphExec, hipGraphNode_t node, const hipKernelNodeParams *pNodeParams) |
| Sets the parameters for a kernel node in the given graphExec.
|
|
hipError_t | hipDrvGraphAddMemcpyNode (hipGraphNode_t *phGraphNode, hipGraph_t hGraph, const hipGraphNode_t *dependencies, size_t numDependencies, const HIP_MEMCPY3D *copyParams, hipCtx_t ctx) |
| Creates a memcpy node and adds it to a graph.
|
|
hipError_t | hipGraphAddMemcpyNode (hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, const hipMemcpy3DParms *pCopyParams) |
| Creates a memcpy node and adds it to a graph.
|
|
hipError_t | hipGraphMemcpyNodeGetParams (hipGraphNode_t node, hipMemcpy3DParms *pNodeParams) |
| Gets a memcpy node's parameters.
|
|
hipError_t | hipGraphMemcpyNodeSetParams (hipGraphNode_t node, const hipMemcpy3DParms *pNodeParams) |
| Sets a memcpy node's parameters.
|
|
hipError_t | hipGraphKernelNodeSetAttribute (hipGraphNode_t hNode, hipKernelNodeAttrID attr, const hipKernelNodeAttrValue *value) |
| Sets a node's attribute.
|
|
hipError_t | hipGraphKernelNodeGetAttribute (hipGraphNode_t hNode, hipKernelNodeAttrID attr, hipKernelNodeAttrValue *value) |
| Gets a node's attribute.
|
|
hipError_t | hipGraphExecMemcpyNodeSetParams (hipGraphExec_t hGraphExec, hipGraphNode_t node, hipMemcpy3DParms *pNodeParams) |
| Sets the parameters of a memcpy node in the given graphExec.
|
|
hipError_t | hipGraphAddMemcpyNode1D (hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, void *dst, const void *src, size_t count, hipMemcpyKind kind) |
| Creates a 1D memcpy node and adds it to a graph.
|
|
hipError_t | hipGraphMemcpyNodeSetParams1D (hipGraphNode_t node, void *dst, const void *src, size_t count, hipMemcpyKind kind) |
| Sets a memcpy node's parameters to perform a 1-dimensional copy.
|
|
hipError_t | hipGraphExecMemcpyNodeSetParams1D (hipGraphExec_t hGraphExec, hipGraphNode_t node, void *dst, const void *src, size_t count, hipMemcpyKind kind) |
| Sets the parameters for a memcpy node in the given graphExec to perform a 1-dimensional copy.
|
|
hipError_t | hipGraphAddMemcpyNodeFromSymbol (hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, void *dst, const void *symbol, size_t count, size_t offset, hipMemcpyKind kind) |
| Creates a memcpy node to copy from a symbol on the device and adds it to a graph.
|
|
hipError_t | hipGraphMemcpyNodeSetParamsFromSymbol (hipGraphNode_t node, void *dst, const void *symbol, size_t count, size_t offset, hipMemcpyKind kind) |
| Sets a memcpy node's parameters to copy from a symbol on the device.
|
|
hipError_t | hipGraphExecMemcpyNodeSetParamsFromSymbol (hipGraphExec_t hGraphExec, hipGraphNode_t node, void *dst, const void *symbol, size_t count, size_t offset, hipMemcpyKind kind) |
| Sets the parameters for a memcpy node in the given graphExec to copy from a symbol on the.
|
|
hipError_t | hipGraphAddMemcpyNodeToSymbol (hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, const void *symbol, const void *src, size_t count, size_t offset, hipMemcpyKind kind) |
| Creates a memcpy node to copy to a symbol on the device and adds it to a graph.
|
|
hipError_t | hipGraphMemcpyNodeSetParamsToSymbol (hipGraphNode_t node, const void *symbol, const void *src, size_t count, size_t offset, hipMemcpyKind kind) |
| Sets a memcpy node's parameters to copy to a symbol on the device.
|
|
hipError_t | hipGraphExecMemcpyNodeSetParamsToSymbol (hipGraphExec_t hGraphExec, hipGraphNode_t node, const void *symbol, const void *src, size_t count, size_t offset, hipMemcpyKind kind) |
| Sets the parameters for a memcpy node in the given graphExec to copy to a symbol on the device.
|
|
hipError_t | hipGraphAddMemsetNode (hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, const hipMemsetParams *pMemsetParams) |
| Creates a memset node and adds it to a graph.
|
|
hipError_t | hipGraphMemsetNodeGetParams (hipGraphNode_t node, hipMemsetParams *pNodeParams) |
| Gets a memset node's parameters.
|
|
hipError_t | hipGraphMemsetNodeSetParams (hipGraphNode_t node, const hipMemsetParams *pNodeParams) |
| Sets a memset node's parameters.
|
|
hipError_t | hipGraphExecMemsetNodeSetParams (hipGraphExec_t hGraphExec, hipGraphNode_t node, const hipMemsetParams *pNodeParams) |
| Sets the parameters for a memset node in the given graphExec.
|
|
hipError_t | hipGraphAddHostNode (hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, const hipHostNodeParams *pNodeParams) |
| Creates a host execution node and adds it to a graph.
|
|
hipError_t | hipGraphHostNodeGetParams (hipGraphNode_t node, hipHostNodeParams *pNodeParams) |
| Returns a host node's parameters.
|
|
hipError_t | hipGraphHostNodeSetParams (hipGraphNode_t node, const hipHostNodeParams *pNodeParams) |
| Sets a host node's parameters.
|
|
hipError_t | hipGraphExecHostNodeSetParams (hipGraphExec_t hGraphExec, hipGraphNode_t node, const hipHostNodeParams *pNodeParams) |
| Sets the parameters for a host node in the given graphExec.
|
|
hipError_t | hipGraphAddChildGraphNode (hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, hipGraph_t childGraph) |
| Creates a child graph node and adds it to a graph.
|
|
hipError_t | hipGraphChildGraphNodeGetGraph (hipGraphNode_t node, hipGraph_t *pGraph) |
| Gets a handle to the embedded graph of a child graph node.
|
|
hipError_t | hipGraphExecChildGraphNodeSetParams (hipGraphExec_t hGraphExec, hipGraphNode_t node, hipGraph_t childGraph) |
| Updates node parameters in the child graph node in the given graphExec.
|
|
hipError_t | hipGraphAddEmptyNode (hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies) |
| Creates an empty node and adds it to a graph.
|
|
hipError_t | hipGraphAddEventRecordNode (hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, hipEvent_t event) |
| Creates an event record node and adds it to a graph.
|
|
hipError_t | hipGraphEventRecordNodeGetEvent (hipGraphNode_t node, hipEvent_t *event_out) |
| Returns the event associated with an event record node.
|
|
hipError_t | hipGraphEventRecordNodeSetEvent (hipGraphNode_t node, hipEvent_t event) |
| Sets an event record node's event.
|
|
hipError_t | hipGraphExecEventRecordNodeSetEvent (hipGraphExec_t hGraphExec, hipGraphNode_t hNode, hipEvent_t event) |
| Sets the event for an event record node in the given graphExec.
|
|
hipError_t | hipGraphAddEventWaitNode (hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, hipEvent_t event) |
| Creates an event wait node and adds it to a graph.
|
|
hipError_t | hipGraphEventWaitNodeGetEvent (hipGraphNode_t node, hipEvent_t *event_out) |
| Returns the event associated with an event wait node.
|
|
hipError_t | hipGraphEventWaitNodeSetEvent (hipGraphNode_t node, hipEvent_t event) |
| Sets an event wait node's event.
|
|
hipError_t | hipGraphExecEventWaitNodeSetEvent (hipGraphExec_t hGraphExec, hipGraphNode_t hNode, hipEvent_t event) |
| Sets the event for an event record node in the given graphExec.
|
|
hipError_t | hipGraphAddMemAllocNode (hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, hipMemAllocNodeParams *pNodeParams) |
| Creates a memory allocation node and adds it to a graph.
|
|
hipError_t | hipGraphMemAllocNodeGetParams (hipGraphNode_t node, hipMemAllocNodeParams *pNodeParams) |
| Returns parameters for memory allocation node.
|
|
hipError_t | hipGraphAddMemFreeNode (hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, void *dev_ptr) |
| Creates a memory free node and adds it to a graph.
|
|
hipError_t | hipGraphMemFreeNodeGetParams (hipGraphNode_t node, void *dev_ptr) |
| Returns parameters for memory free node.
|
|
hipError_t | hipDeviceGetGraphMemAttribute (int device, hipGraphMemAttributeType attr, void *value) |
| Get the mem attribute for graphs.
|
|
hipError_t | hipDeviceSetGraphMemAttribute (int device, hipGraphMemAttributeType attr, void *value) |
| Set the mem attribute for graphs.
|
|
hipError_t | hipDeviceGraphMemTrim (int device) |
| Free unused memory reserved for graphs on a specific device and return it back to the OS.
|
|
hipError_t | hipUserObjectCreate (hipUserObject_t *object_out, void *ptr, hipHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) |
| Create an instance of userObject to manage lifetime of a resource.
|
|
hipError_t | hipUserObjectRelease (hipUserObject_t object, unsigned int count) |
| Release number of references to resource.
|
|
hipError_t | hipUserObjectRetain (hipUserObject_t object, unsigned int count) |
| Retain number of references to resource.
|
|
hipError_t | hipGraphRetainUserObject (hipGraph_t graph, hipUserObject_t object, unsigned int count, unsigned int flags) |
| Retain user object for graphs.
|
|
hipError_t | hipGraphReleaseUserObject (hipGraph_t graph, hipUserObject_t object, unsigned int count) |
| Release user object from graphs.
|
|
hipError_t | hipGraphDebugDotPrint (hipGraph_t graph, const char *path, unsigned int flags) |
| Write a DOT file describing graph structure.
|
|
hipError_t | hipGraphKernelNodeCopyAttributes (hipGraphNode_t hSrc, hipGraphNode_t hDst) |
| Copies attributes from source node to destination node.
|
|
hipError_t | hipGraphNodeSetEnabled (hipGraphExec_t hGraphExec, hipGraphNode_t hNode, unsigned int isEnabled) |
| Enables or disables the specified node in the given graphExec.
|
|
hipError_t | hipGraphNodeGetEnabled (hipGraphExec_t hGraphExec, hipGraphNode_t hNode, unsigned int *isEnabled) |
| Query whether a node in the given graphExec is enabled.
|
|
hipError_t | hipGraphAddExternalSemaphoresWaitNode (hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, const hipExternalSemaphoreWaitNodeParams *nodeParams) |
| Creates a external semaphor wait node and adds it to a graph.
|
|
hipError_t | hipGraphAddExternalSemaphoresSignalNode (hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, const hipExternalSemaphoreSignalNodeParams *nodeParams) |
| Creates a external semaphor signal node and adds it to a graph.
|
|
hipError_t | hipGraphExternalSemaphoresSignalNodeSetParams (hipGraphNode_t hNode, const hipExternalSemaphoreSignalNodeParams *nodeParams) |
| Updates node parameters in the external semaphore signal node.
|
|
hipError_t | hipGraphExternalSemaphoresWaitNodeSetParams (hipGraphNode_t hNode, const hipExternalSemaphoreWaitNodeParams *nodeParams) |
| Updates node parameters in the external semaphore wait node.
|
|
hipError_t | hipGraphExternalSemaphoresSignalNodeGetParams (hipGraphNode_t hNode, hipExternalSemaphoreSignalNodeParams *params_out) |
| Returns external semaphore signal node params.
|
|
hipError_t | hipGraphExternalSemaphoresWaitNodeGetParams (hipGraphNode_t hNode, hipExternalSemaphoreWaitNodeParams *params_out) |
| Returns external semaphore wait node params.
|
|
hipError_t | hipGraphExecExternalSemaphoresSignalNodeSetParams (hipGraphExec_t hGraphExec, hipGraphNode_t hNode, const hipExternalSemaphoreSignalNodeParams *nodeParams) |
| Updates node parameters in the external semaphore signal node in the given graphExec.
|
|
hipError_t | hipGraphExecExternalSemaphoresWaitNodeSetParams (hipGraphExec_t hGraphExec, hipGraphNode_t hNode, const hipExternalSemaphoreWaitNodeParams *nodeParams) |
| Updates node parameters in the external semaphore wait node in the given graphExec.
|
|
hipError_t | hipDrvGraphMemcpyNodeGetParams (hipGraphNode_t hNode, HIP_MEMCPY3D *nodeParams) |
| Gets a memcpy node's parameters.
|
|
hipError_t | hipDrvGraphMemcpyNodeSetParams (hipGraphNode_t hNode, const HIP_MEMCPY3D *nodeParams) |
| Sets a memcpy node's parameters.
|
|
hipError_t | hipDrvGraphAddMemsetNode (hipGraphNode_t *phGraphNode, hipGraph_t hGraph, const hipGraphNode_t *dependencies, size_t numDependencies, const hipMemsetParams *memsetParams, hipCtx_t ctx) |
| Creates a memset node and adds it to a graph.
|
|
hipError_t | hipDrvGraphAddMemFreeNode (hipGraphNode_t *phGraphNode, hipGraph_t hGraph, const hipGraphNode_t *dependencies, size_t numDependencies, hipDeviceptr_t dptr) |
| Creates a memory free node and adds it to a graph.
|
|
hipError_t | hipDrvGraphExecMemcpyNodeSetParams (hipGraphExec_t hGraphExec, hipGraphNode_t hNode, const HIP_MEMCPY3D *copyParams, hipCtx_t ctx) |
| Sets the parameters for a memcpy node in the given graphExec.
|
|
hipError_t | hipDrvGraphExecMemsetNodeSetParams (hipGraphExec_t hGraphExec, hipGraphNode_t hNode, const hipMemsetParams *memsetParams, hipCtx_t ctx) |
| Sets the parameters for a memset node in the given graphExec.
|
|
hipError_t | hipMemAddressFree (void *devPtr, size_t size) |
| Frees an address range reservation made via hipMemAddressReserve.
|
|
hipError_t | hipMemAddressReserve (void **ptr, size_t size, size_t alignment, void *addr, unsigned long long flags) |
| Reserves an address range.
|
|
hipError_t | hipMemCreate (hipMemGenericAllocationHandle_t *handle, size_t size, const hipMemAllocationProp *prop, unsigned long long flags) |
| Creates a memory allocation described by the properties and size.
|
|
hipError_t | hipMemExportToShareableHandle (void *shareableHandle, hipMemGenericAllocationHandle_t handle, hipMemAllocationHandleType handleType, unsigned long long flags) |
| Exports an allocation to a requested shareable handle type.
|
|
hipError_t | hipMemGetAccess (unsigned long long *flags, const hipMemLocation *location, void *ptr) |
| Get the access flags set for the given location and ptr.
|
|
hipError_t | hipMemGetAllocationGranularity (size_t *granularity, const hipMemAllocationProp *prop, hipMemAllocationGranularity_flags option) |
| Calculates either the minimal or recommended granularity.
|
|
hipError_t | hipMemGetAllocationPropertiesFromHandle (hipMemAllocationProp *prop, hipMemGenericAllocationHandle_t handle) |
| Retrieve the property structure of the given handle.
|
|
hipError_t | hipMemImportFromShareableHandle (hipMemGenericAllocationHandle_t *handle, void *osHandle, hipMemAllocationHandleType shHandleType) |
| Imports an allocation from a requested shareable handle type.
|
|
hipError_t | hipMemMap (void *ptr, size_t size, size_t offset, hipMemGenericAllocationHandle_t handle, unsigned long long flags) |
| Maps an allocation handle to a reserved virtual address range.
|
|
hipError_t | hipMemMapArrayAsync (hipArrayMapInfo *mapInfoList, unsigned int count, hipStream_t stream) |
| Maps or unmaps subregions of sparse HIP arrays and sparse HIP mipmapped arrays.
|
|
hipError_t | hipMemRelease (hipMemGenericAllocationHandle_t handle) |
| Release a memory handle representing a memory allocation which was previously allocated through hipMemCreate.
|
|
hipError_t | hipMemRetainAllocationHandle (hipMemGenericAllocationHandle_t *handle, void *addr) |
| Returns the allocation handle of the backing memory allocation given the address.
|
|
hipError_t | hipMemSetAccess (void *ptr, size_t size, const hipMemAccessDesc *desc, size_t count) |
| Set the access flags for each location specified in desc for the given virtual address range.
|
|
hipError_t | hipMemUnmap (void *ptr, size_t size) |
| Unmap memory allocation of a given address range.
|
|
hipError_t | hipGraphicsMapResources (int count, hipGraphicsResource_t *resources, hipStream_t stream) |
| Maps a graphics resource for access.
|
|
hipError_t | hipGraphicsSubResourceGetMappedArray (hipArray_t *array, hipGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) |
| Get an array through which to access a subresource of a mapped graphics resource.
|
|
hipError_t | hipGraphicsResourceGetMappedPointer (void **devPtr, size_t *size, hipGraphicsResource_t resource) |
| Gets device accessible address of a graphics resource.
|
|
hipError_t | hipGraphicsUnmapResources (int count, hipGraphicsResource_t *resources, hipStream_t stream) |
| Unmaps graphics resources.
|
|
hipError_t | hipGraphicsUnregisterResource (hipGraphicsResource_t resource) |
| Unregisters a graphics resource.
|
|
hipError_t | hipCreateSurfaceObject (hipSurfaceObject_t *pSurfObject, const hipResourceDesc *pResDesc) |
| Create a surface object.
|
|
hipError_t | hipDestroySurfaceObject (hipSurfaceObject_t surfaceObject) |
| Destroy a surface object.
|
|
template<typename T > |
hipError_t | hipGetSymbolAddress (void **devPtr, const T &symbol) |
| Gets the address of a symbol.
|
|
template<typename T > |
hipError_t | hipGetSymbolSize (size_t *size, const T &symbol) |
| Gets the size of a symbol.
|
|
template<typename T > |
hipError_t | hipMemcpyToSymbol (const T &symbol, const void *src, size_t sizeBytes, size_t offset, hipMemcpyKind kind) |
| Copies data to the given symbol on the device.
|
|
template<typename T > |
hipError_t | hipMemcpyToSymbolAsync (const T &symbol, const void *src, size_t sizeBytes, size_t offset, hipMemcpyKind kind, hipStream_t stream) |
| Copies data to the given symbol on the device asynchronously on the stream.
|
|
template<typename T > |
hipError_t | hipMemcpyFromSymbol (void *dst, const T &symbol, size_t sizeBytes, size_t offset, hipMemcpyKind kind) |
| Copies data from the given symbol on the device.
|
|
template<typename T > |
hipError_t | hipMemcpyFromSymbolAsync (void *dst, const T &symbol, size_t sizeBytes, size_t offset, hipMemcpyKind kind, hipStream_t stream) |
| Copies data from the given symbol on the device asynchronously on the stream.
|
|
template<class T > |
hipError_t | hipOccupancyMaxActiveBlocksPerMultiprocessor (int *numBlocks, T f, int blockSize, size_t dynSharedMemPerBlk) |
| Returns occupancy for a kernel function.
|
|
template<class T > |
hipError_t | hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags (int *numBlocks, T f, int blockSize, size_t dynSharedMemPerBlk, unsigned int flags) |
| Returns occupancy for a device function with the specified flags.
|
|
template<typename F > |
hipError_t | hipOccupancyMaxPotentialBlockSize (int *gridSize, int *blockSize, F kernel, size_t dynSharedMemPerBlk, uint32_t blockSizeLimit) |
| Returns grid and block size that achieves maximum potential occupancy for a device function.
|
|
template<class T > |
hipError_t | hipLaunchCooperativeKernel (T f, dim3 gridDim, dim3 blockDim, void **kernelParams, unsigned int sharedMemBytes, hipStream_t stream) |
| Launches a device function.
|
|
template<class T > |
hipError_t | hipLaunchCooperativeKernelMultiDevice (hipLaunchParams *launchParamsList, unsigned int numDevices, unsigned int flags=0) |
| Launches kernel function on multiple devices, where thread blocks can cooperate and synchronize on execution.
|
|
template<class T > |
hipError_t | hipExtLaunchMultiKernelMultiDevice (hipLaunchParams *launchParamsList, unsigned int numDevices, unsigned int flags=0) |
| Launches kernels on multiple devices and guarantees all specified kernels are dispatched on respective streams before enqueuing any other work on the specified streams from any other threads.
|
|
template<class T , int dim, enum hipTextureReadMode readMode> |
| HIP_DEPRECATED (HIP_DEPRECATED_MSG) static inline hipError_t hipBindTexture(size_t *offset |
| Binds a memory area to a texture [Deprecated].
|
|
const struct texture< T, dim, readMode > const void size_t int enum hipTextureReadMode readMode | HIP_DEPRECATED (HIP_DEPRECATED_MSG) static inline hipError_t hipBindTexture(size_t *offset |
|
| return (err==hipSuccess) ? hipBindTextureToArray(&tex |
|
| if (err !=hipSuccess) |
|
|