< 1 channel 16-bit floating point
< 1 channel 32-bit floating point
< 2 channel 16-bit floating point
< 2 channel 32-bit floating point
< 4 channel 16-bit floating point
< 4 channel 32-bit floating point
< No resource view format (use underlying resource format)
< Block compressed 4 signed
< Block compressed 5 signed
< Block compressed 6 signed half-float
< 1 channel signed 8-bit integers
< 1 channel signed 16-bit integers
< 1 channel signed 32-bit integers
< 2 channel signed 8-bit integers
< 2 channel signed 16-bit integers
< 2 channel signed 32-bit integers
< 4 channel signed 8-bit integers
< 4 channel signed 16-bit integers
< 4 channel signed 32-bit integers
< 1 channel unsigned 8-bit integers
< 1 channel unsigned 16-bit integers
< 1 channel unsigned 32-bit integers
< 2 channel unsigned 8-bit integers
< 2 channel unsigned 16-bit integers
< 2 channel unsigned 32-bit integers
< 4 channel unsigned 8-bit integers
< 4 channel unsigned 16-bit integers
< 4 channel unsigned 32-bit integers
< Block compressed 1
< Block compressed 2
< Block compressed 3
< Block compressed 4 unsigned
< Block compressed 5 unsigned
< Block compressed 7
< Block compressed 6 unsigned half-float
< Array resoure
< Linear resource
< Mipmapped array resource
< Pitch 2D resource
< Miptail
< Sparse level
< Cuda only. The maximum size of the window policy in bytes.
< Revision of the GPU in this device
< Asynchronous engines number.
< Whether host memory can be mapped into device address space
< Device can access host registered memory
< at the same virtual address as the CPU
< ‘1’ if Device supports hipStreamWaitValue32() and
< hipStreamWaitValue64(), ‘0’ otherwise.
< Frequency in khz of the timer used by the device-side “clock*”
< Peak clock frequency in kilohertz.
< Major compute capability version number.
< Minor compute capability version number.
< Compute mode that device is currently in.
< Device supports Compute Preemption.
< Device can possibly execute multiple kernels concurrently.
< Device can coherently access managed memory concurrently with the CPU
< Support cooperative launch
< Support cooperative launch on multiple devices
< Supports cooperative launch on multiple
< devices with unmatched block dimensions
< Supports cooperative launch on multiple
< devices with unmatched functions
< Supports cooperative launch on multiple
< devices with unmatched grid dimensions
< Supports cooperative launch on multiple
< devices with unmatched shared memories
< Device can concurrently copy memory and execute a kernel.
< Deprecated. Use instead asyncEngineCount.
< Host can directly access managed memory on
< the device without migration
< Whether ECC support is enabled.
< ‘1’ if Device supports fine grain, ‘0’ otherwise
< Device supports caching globals in L1
< Address of the HDP_MEM_COHERENCY_FLUSH_CNTL register
< Address of the HDP_REG_COHERENCY_FLUSH_CNTL register
< Link between the device and the host supports native atomic operations
< Can device support host memory registration via hipHostRegister
< ‘1’ if Device supports image, ‘0’ otherwise.
< Device is integrated GPU
< Whether it is LargeBar
< Multiple GPU devices.
< Run time limit for kernels executed on the device
< Size of L2 cache in bytes. 0 if the device doesn’t have L2 cache.
< caching locals in L1 is supported
< 8-byte locally unique identifier in 8 bytes. Undefined on TCC and non-Windows platforms
< Luid device node mask. Undefined on TCC and non-Windows platforms
< Device supports allocating managed memory on this system
< Max block size in width.
< Max block size in height.
< Max block size in depth.
< Max block size per multiprocessor
< Max grid size in width.
< Max grid size in height.
< Max grid size in depth.
< Maximum pitch in bytes allowed by memory copies
< 32-bit registers available to a thread block. This number is shared
< by all thread blocks simultaneously resident on a multiprocessor.
< 32-bit registers available per block.
< Maximum shared memory available per block in bytes.
< Maximum Shared Memory PerMultiprocessor.
< Maximum size of 1D surface.
< Cuda only. Maximum dimensions of 1D layered surface.
< Maximum dimension (width, height) of 2D surface.
< Cuda only. Maximum dimensions of 2D layered surface.
< Maximum dimension (width, height, depth) of 3D surface.
< Cuda only. Maximum dimensions of Cubemap surface.
< Cuda only. Maximum dimension of Cubemap layered surface.
< Maximum dimensions of 1D layered texture.
< Maximum number of elements allocatable in a 1D linear texture.
< Use cudaDeviceGetTexture1DLinearMaxWidth() instead on Cuda.
< Maximum size of 1D mipmapped texture.
< Maximum size of 1D texture.
< Maximum dimensions of 2D texture if gather operations performed.
< Maximum dimension hight of 2D texture.
< Maximum dimensions of 2D layered texture.
< Maximum dimensions (width, height, pitch) of 2D textures bound to pitched memory.
< Maximum dimensions of 2D mipmapped texture.
< Maximum dimension width of 2D texture.
< Maximum dimensions of alternate 3D texture.
< Maximum dimension depth of 3D texture.
< Maximum dimension height of 3D texture.
< Maximum dimension width of 3D texture.
< Maximum dimensions of Cubemap texture
< Maximum dimensions of Cubemap layered texture.
< Maximum dimension of a block
< Maximum number of threads per block.
< Maximum resident threads per multiprocessor.
< Global memory bus width in bits.
< Peak memory clock frequency in kilohertz.
< Supported handle mask for HIP Stream Ordered Memory Allocator
< Device supports HIP Stream Ordered Memory Allocator
< Unique ID of device group on the same multi-GPU board
< Number of multiprocessors on the device.
< Device supports coherently accessing pageable memory
< without calling hipHostRegister on it
< Device accesses pageable memory via the host’s page tables
< PCI Bus ID.
< PCI Device ID.
< PCI Domain ID.
< Maximum l2 persisting lines capacity in bytes
< All available physical compute
< units for the device
< Shared memory reserved by CUDA driver per block.
< Maximum shared memory per block usable by special opt in.
< Shared memory available per multiprocessor.
< Cuda only. Performance ratio of single precision to double precision.
< Whether to support stream priorities.
< Alignment requirement for surfaces
< Cuda only. Whether device is a Tesla device using TCC driver
< Alignment requirement for textures
< Pitch alignment requirement for 2D texture references bound to pitched memory;
< Constant memory size in bytes.
< Global memory available on devicice.
< Cuda only. An unified address space shared with the host.
< Previously hipDeviceAttributeName
< Previously hipDeviceAttributeUuid
< Previously hipDeviceAttributeArch
< Previously hipDeviceAttributeGcnArch
< Previously hipDeviceAttributeGcnArchName
< Device supports HIP virtual memory management
< Constant frequency of wall clock in kilohertz.
< Warp size in threads.
< Produced when the kernel calls assert.
< The operation is not permitted on an event which was last
< recorded in a capturing stream.
< The context is already in use
< The context is already destroyed
< This error indicates that the number of blocks
< launched per grid for a kernel that was launched
< via cooperative launch APIs exceeds the maximum
< number of allowed blocks for the current device.
< Deinitialized
< the file is not found.
< This error indicates that the graph update
< not performed because it included changes which
< violated constraintsspecific to instantiated graph
< update.
< Produced when trying to lock a page-locked
< memory.
< Produced when trying to unlock a non-page-locked
< memory.
< Resource required is not in a valid state to perform operation.
< Invalide configuration
< Produced when input context is invalid.
< DeviceID must be in range from 0 to compute-devices.
< Invalid device function
< Invalid Device Pointer
< Invalide handle
< Invalid image
< In CUDA DRV, it is CUDA_ERROR_INVALID_PTX
< Invalid memory copy direction
< Invalid pitch value
< Resource handle (hipEvent_t or hipStream_t) invalid.
< Invalid source.
< Invalid symbol
< One or more of the parameters passed to the API call is NULL
< or not in an acceptable range.
< An exception occurred on the device while executing a kernel.
< Out of resources error.
< Timeout for the launch.
< Produced when the IPC memory attach failed from ROCr.
< Memory allocation error.
< Call to hipGetDeviceCount returned 0 devices
< Not found
< Invalid not initialized
< Indicates that asynchronous operations enqueued earlier are not
< ready. This is not actually an error, but is used to distinguish
< from hipSuccess (which indicates completion). APIs that return
< this error include hipEventQuery and hipStreamQuery.
< Produced when the hip API is not supported/implemented
< Not the correct operating system
< out of memory range.
< Peer access was already enabled from the current
< device.
< Peer access was never enabled from the current device.
< HSA runtime memory call returned error. Typically not seen
< in production systems.
< HSA runtime call other than memory returned error. Typically
< not seen in production systems.
< The process is active.
< Failed to initialize shared object.
< The operation would have resulted in a disallowed
< implicit dependency on a current capture sequence
< from hipStreamLegacy.
< The current capture sequence on the stream
< has been invalidated due to a previous error.
< A dependency would have been created which crosses
< the capture sequence boundary. Only implicit
< in-stream ordering dependencies are allowed
< to cross the boundary
< The operation would have resulted in a merge of
< two independent capture sequences.
< The capture sequence contains a fork that was not
< joined to the primary stream.
< The capture was not initiated in this stream.
< The operation is not permitted when the stream
< is capturing.
< A stream capture sequence not initiated with
< the hipStreamCaptureModeRelaxed argument to
< hipStreamBeginCapture was passed to
< hipStreamEndCapture in a different thread.
< Marker that more error codes are needed.
< Unknown error.
< Unsupported limit
< Successful completion.
< prefer equal size L1 cache and shared memory
< prefer larger L1 cache and smaller shared memory
< no preference for shared memory or L1 (default)
< prefer larger shared memory and smaller L1 cache
< Adds hipHostNodeParams to output
< Adds hipKernelNodeParams to output
< Adds hipMemcpy3DParms to output
< Adds hipMemsetParams to output
< The update failed for an unexpected reason which is described
< in the return value of the function
< The update failed because a node type changed
< The update failed because the topology changed
< The update succeeded
< Instantiation failed for an
unexpected reason which is described in the return value of the function
< Instantiation failed due
to invalid structure, such as cycles
< Instantiation for device launch failed
due to the nodes belonging to different contexts
< Instantiation for device launch failed
because the graph contained an unsupported operation
< Instantiation Success
< Amount of memory, in bytes, currently allocated for graphs.
< High watermark of memory, in bytes, currently allocated for graphs
< Amount of memory, in bytes, currently associated with graphs
< High watermark of memory, in bytes, associated with graphs since the last time.
< Empty (no-op) node
< External event record node
< External Semaphore signal node
< External Semaphore wait node
< Node which executes an embedded graph
< Host (executable) node
< GPU kernel node
< Memory alloc node
< Memory free node
< Memcpy node
< MemcpyFromSymbol node
< MemcpyToSymbol node
< Memset node
< External event wait node
< HIP will not write to this registered resource
< HIP will bind this resource to a surface
< Valid for Streams, graph nodes, launches
< Valid for graph nodes, launches
< Valid for graph node, streams, launches
< Limit of heap size in bytes on the current device, should
< be less than the global memory size on the device
< Size limit in bytes of fifo used by printf call on the
< device. Currently not supported
< Supported limit range
< Limit of stack size in bytes on the current device, per
< thread. The size is in units of 256 dwords, up to the
< limit of (128K - 16)
< Default, make the address range not accessible
< Set the address range read accessible
< Set the address range read-write accessible
< Minimum granularity
< Recommended granularity for performance
< Does not allow any export mechanism
< Allows a file descriptor for exporting. Permitted only on POSIX systems
< Allows a Win32 NT handle for exporting. (HANDLE)
< Allows a Win32 KMT handle for exporting. (D3DKMT_HANDLE)
This allocation type is ‘pinned’, i.e. cannot migrate from its current
location while the application is actively using it
This allocation type is ‘pinned’, i.e. cannot migrate from its current
location while the application is actively using it
< Generic handle type
< Device location, thus it’s HIP device ID
< Map operation
< Unmap operation
(value type = uint64_t)
Amount of reserved memory in bytes to hold onto before trying
to release memory back to the OS. When more than the release
threshold bytes of memory are held by the memory pool, the
allocator will try to release memory back to the OS on the
next call to stream, event or context synchronize. (default 0)
(value type = uint64_t)
Amount of backing memory currently allocated for the mempool.
(value type = uint64_t)
High watermark of backing memory allocated for the mempool since the
last time it was reset. High watermark can only be reset to zero.
(value type = uint64_t)
Amount of memory from the pool that is currently in use by the application.
(value type = uint64_t)
High watermark of the amount of memory from the pool that was in use by the application since
the last time it was reset. High watermark can only be reset to zero.
(value type = int)
Allow @p hipMemAllocAsync to insert new stream dependencies
in order to establish the stream ordering required to reuse
a piece of memory released by cuFreeAsync (default enabled).
(value type = int)
Allow reuse of already completed frees when there is no dependency
between the free and allocation. (default enabled)
(value type = int)
Allow @p hipMemAllocAsync to use memory asynchronously freed
in another streams as long as a stream ordering dependency
of the allocating stream on the free action exists.
hip events and null stream interactions can create the required
stream ordered dependencies. (default enabled)
< Memory range has hipMemAdviseSetAccessedBy
< set for the specified device
< Returns coherency mode
< @ref hipMemRangeCoherencyMode for the range
< The last location to where the range was
< prefetched
< The preferred location of the range
< Whether the range will mostly be read and
< only occassionally be written to
< Writes to memory with this attribute can be
< performed by a single device at a time
< Updates to memory with this attribute can be
< done coherently from all devices
< Memory region queried contains subregions with
< both hipMemRangeCoherencyModeFineGrain and
< hipMemRangeCoherencyModeCoarseGrain attributes
< Runtime will automatically determine
<copy-kind based on virtual addresses.
< Device-to-Device Copy
< Device-to-Device Copy without using compute units
< Device-to-Host Copy
< Host-to-Device Copy
< Host-to-Host Copy
< Data will be accessed by the specified device
< so prevent page faults as much as possible
< The default memory model is fine-grain. That allows
< coherent operations between host and device, while
< executing kernels. The coarse-grain can be used
< for data that only needs to be coherent at dispatch
< boundaries for better performance
< Set the preferred location for the data as
< the specified device
< Data will mostly be read and only occassionally
< be written to
< Let HIP to decide on the page faulting policy
< for the specified device
< Restores cache coherency policy back to fine-grain
< Clear the preferred location for the data
< Undo the effect of hipMemAdviseSetReadMostly
< Array memory, physically located on device. (see deviceId for
< specific device)
< Memory is physically located on device. (see deviceId for
< specific device)
< Memory is physically located on host
< Managed memory, automaticallly managed by the unified
< memory system
< place holder for new values.
< unified address space
< Unregistered memory
< Returns the access flags the device associated with
< for the corresponding memory referenced by the ptr
< Bitmask of allowed hipmemAllocationHandleType
< for this allocation @warning - not supported in HIP
< Unique ID for an allocated memory region
< The context on which a pointer was allocated
< @warning - not supported in HIP
< device ordinal of a device on which a pointer
< was allocated or registered
< address at which the pointer is allocated on device
< address at which the pointer is allocated on host
< returns if the memory referenced by
< this pointer can be used with the GPUDirect RDMA API
< @warning - not supported in HIP
< if this pointer maps to an allocation
< that is suitable for hipIpcGetMemHandle
< @warning - not supported in HIP
< Indicates if the pointer points to managed memory
< tells if this pointer is in a valid address range
< that is mapped to a backing allocation
< memory type describing location of a pointer
< Returns the mempool handle for the allocation if
< it was allocated from a mempool
< @warning - not supported in HIP
< A pair of tokens for use with linux kernel interface
< @warning - not supported in HIP
< Size of the address range for this requested pointer
< Starting address for this requested pointer
< Synchronize every synchronous memory operation
< initiated on this region
< The compiler selects a device-specific value for the banking.
< Shared mem is banked at 8-byte intervals and performs best
< when adjacent threads access data 4 bytes apart.
< Shared mem is banked at 4-bytes intervals and performs best
< when adjacent threads access data 4 bytes apart.
< Stream is actively capturing
< Stream is part of a capture sequence that has been
< invalidated, but not terminated
< Stream is not capturing
< Add new nodes to the dependency set
< Replace the dependency set with the new nodes
< Destructor execution is not synchronized.
< Add new reference or retain.
< Input cubin
< Input fat binary
< Input library
< LLVM archives of boundled bitcode
< LLVM bitcode or IR assembly
< LLVM bundled bitcode
< Input NVVM
< Input object
< Input PTX
< Number of legacy input type
< CUDA Only Set cache mode
< CUDA Only Pointer to the buffer with logged error(s)
< CUDA Only Size of the buffer in bytes for logged error(s)
< CUDA Only Fallback strategy
< CUDA Only Set fast compile
< @deprecated CUDA Only Enable floating-point multiplies and adds/subtracts operations
< @deprecated CUDA Only Set single-precision denormals.
< CUDA Only Generate debug information
< CUDA Only Generate line number information
< CUDA Only Array of host addresses to be relocated to the device
< CUDA Only Number of symbol count.
< CUDA Only Array of device symbol names to be relocated to the host
< CUDA Only Pointer to the buffer with logged information
< CUDA Only Size of the buffer in bytes for logged info
< Count of linker options to be passed on to
< compiler @note Only supported for the AMD platform
< Linker options to be passed on to compiler
< CUDA Only Generate log verbose
< @deprecated CUDA Only Enable link-time optimization for device code
< CUDA Only Maximum registers may be used in a thread, passed to compiler
< @deprecated CUDA Only New SM3X option.
< Number of options
< Value of optimization level for generated codes, acceptable options -O0, -O1, -O2, -O3
< @deprecated CUDA Only Set single-precision floating-point division and
< reciprocals
< @deprecated CUDA Only Set single-precision floating-point square root
< CUDA Only JIT target
< CUDA Only The target context, which is the default
< CUDA Only Number of thread per block
< CUDA Only Value for total wall clock time
< Failed in builtin operation
< Compilation error
< Internal error
< Invalid input
< Invalid option
< Invalid program
< Error in linking
< Invalid name expression
< No lowered names before compilation
< No name expression after compilation
< Out of memory
< Failed to create program
< Success
Internal use only. This API may change in the future
Pre-Compiled header for online compilation
@brief Pop configuration of a kernel launch.
@brief Push configuration of a kernel launch.
@defgroup Callback Callback Activity APIs
@{
This section describes the callback/Activity of HIP runtime API.
/
/**
@brief Returns HIP API name by ID.
@brief Create a 3D array memory pointer on the device.
@brief Gets a 3D array descriptor
@brief Create an array memory pointer on the device.
@brief Destroy an array memory pointer on the device.
@brief Gets a 1D or 2D array descriptor
@brief Gets info about the specified array
@brief Binds a memory area to a texture.
@brief Binds a 2D memory area to a texture.
@brief Binds a memory area to a texture.
@brief Binds a mipmapped array to a texture.
@brief Device which matches hipDeviceProp_t is returned
@}
/
/**
@brief Create a surface object.
@brief Creates a texture object.
@brief Create a context and set it as current/default context
@brief Destroy a HIP context.
@brief 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.
@brief Enables direct access to memory allocations in a peer context.
@brief Returns the approximate HIP api version.
@brief Get Cache configuration for a specific function
@brief Get the handle of the current/ default context
@brief Get the handle of the device associated with current/default context
@brief Return flags used for creating default context.
@brief Get Shared memory bank configuration.
@brief Pop the current/default context and return the popped context.
@brief Push the context to be set as current/ default context
@brief Set L1/Shared cache partition.
@brief Set the passed context as current/default
@brief Set Shared memory bank configuration.
@brief Blocks until the default context has completed all preceding requested tasks.
@brief Destroys an external memory object.
@brief 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.
@brief Destroy a surface object.
@brief Destroys a texture object.
@}
/
/**
@brief Returns the compute capability of the device
@param [out] major Major compute capability version number
@param [out] minor Minor compute capability version number
@param [in] device Device ordinal
@brief Disable direct access from current device’s virtual address space to memory allocations
physically located on a peer device.
@brief Enable direct access from current device’s virtual address space to memory allocations
physically located on a peer device.
@brief Returns a handle to a compute device
@param [out] device Handle of device
@param [in] ordinal Device ordinal
@brief Query for a specific device attribute.
@brief Returns a handle to a compute device.
@param [out] device The handle of the device
@param [in] pciBusId The string of PCI Bus Id for the device
@brief Get Cache configuration for a specific Device
@brief Returns the default memory pool of the specified device
@brief Get the mem attribute for graphs.
@brief Gets resource limits of current device
@brief Gets the current memory pool for the specified device
@brief Returns an identifer string for the device.
@param [out] name String of the device name
@param [in] len Maximum length of string to store in device name
@param [in] device Device ordinal
@brief Returns a value for attribute of link between two devices
@param [out] value Pointer of the value for the attrubute
@param [in] attr enum of hipDeviceP2PAttr to query
@param [in] srcDevice The source device of the link
@param [in] dstDevice The destination device of the link
@brief Returns a PCI Bus Id string for the device, overloaded to take int device ID.
@param [out] pciBusId The string of PCI Bus Id format for the device
@param [in] len Maximum length of string
@param [in] device The device ordinal
@brief Returns bank width of shared memory for current device
@brief Returns numerical values that correspond to the least and greatest stream priority.
@brief Returns an UUID for the device.[BETA]
@param [out] uuid UUID for the device
@param [in] device device ordinal
@brief Free unused memory on specific device used for graph back to OS.
@brief Get the state of the primary context.
@brief Release the primary context on the GPU.
@brief Resets the primary context on the GPU.
@brief Retain the primary context on the GPU.
@brief Set flags for the primary context.
@brief The state of current device is discarded and updated to a fresh state.
@brief Set L1/Shared cache partition.
@brief Set the mem attribute for graphs.
@brief Sets resource limits of current device.
@brief Sets the current memory pool of a device
@brief The bank width of shared memory on current device is set
@}
/
/**
@defgroup Device Device Management
@{
This section describes the device management functions of HIP runtime API.
/
/**
@brief Waits on all active streams on current device
@brief Returns the total amount of memory on the device.
@param [out] bytes The size of memory in bytes, on the device
@param [in] device The ordinal of the device
@brief Returns the approximate HIP driver version.
@brief Return hip error as text string form.
@brief Return handy text string message to explain the error which occurred
@brief Creates a memcpy node and adds it to a graph.
@brief Creates a memset node and adds it to a graph.
Copies memory for 2D arrays.
@brief Copies data between host and device.
@brief Copies data between host and device asynchronously.
@brief Returns information about the specified pointer.[BETA]
Create an event
@}
/
/**
@brief Destroy the specified event.
@brief Return the elapsed time between two events.
@brief Query event status
@brief Wait for an event to complete.
@brief Return last error returned by any HIP runtime API call and resets the stored error code to
#hipSuccess
@brief Returns the link type and hop count between two devices
@brief Launches kernel from the pointer address, with arguments and shared memory on stream.
@brief 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
@brief Allocate memory on the default accelerator
@brief Create an asynchronous stream with the specified CU mask.
@brief Get CU mask associated with an asynchronous stream
@brief Maps a buffer onto an imported memory object.
@brief Maps a mipmapped array onto an external memory object.
@brief Free memory allocated by the hcc hip memory allocation API.
This API performs an implicit hipDeviceSynchronize() call.
If pointer is NULL, the hip runtime is initialized and hipSuccess is returned.
@brief Frees an array on the device.
@brief Frees memory with stream ordered semantics
@brief Free memory allocated by the hcc hip host memory allocation API [Deprecated]
@brief Frees a mipmapped array on the device.
@brief Find out a specific attribute for a given function.
@brief Find out attributes for a given function.
@}
/
/**
@brief Set Cache configuration for a specific function
@brief Set shared memory configuation for a specific function
@brief Gets the channel descriptor in an array.
@brief Return the default device id for the calling host thread.
@brief Return number of compute-capable devices.
@brief Gets the flags set for current device
@brief Returns device properties.
@brief Return hip error as text string form.
@brief Return handy text string message to explain the error which occurred
@brief Gets pointer to device entry function that matches entry function symbolPtr.
@}
/
/**
@brief Gets a mipmap level of a HIP mipmapped array.
@brief Gets the pointer of requested HIP driver function.
@brief Returns device ID on the stream.
@brief Gets device pointer associated with symbol on the device.
@brief Gets the size of the given symbol on the device.
@brief Get the offset of the alignment in a texture.
@brief Gets resource descriptor for the texture object.
@brief Gets resource view descriptor for the texture object.
@brief Gets texture descriptor for the texture object.
@brief Gets the texture reference related with the symbol.
@brief Creates a child graph node and adds it to a graph.
@brief Adds dependency edges to a graph.
@brief Creates an empty node and adds it to a graph.
@brief Creates an event record node and adds it to a graph.
@brief Creates an event wait node and adds it to a graph.
@brief Creates a external semaphor signal node and adds it to a graph.
@brief Creates a external semaphor wait node and adds it to a graph.
@brief Creates a host execution node and adds it to a graph.
@brief Creates a kernel execution node and adds it to a graph.
@brief Creates a memory allocation node and adds it to a graph
@brief Creates a memory free node and adds it to a graph
@brief Creates a memcpy node and adds it to a graph.
@brief Creates a 1D memcpy node and adds it to a graph.
@brief Creates a memcpy node to copy from a symbol on the device and adds it to a graph.
@brief Creates a memcpy node to copy to a symbol on the device and adds it to a graph.
@brief Creates a memset node and adds it to a graph.
@brief Creates a kernel execution node and adds it to a graph.
@brief Gets a handle to the embedded graph of a child graph node.
@brief Clones a graph.
@brief Creates a graph
@brief Write a DOT file describing graph structure.
@brief Destroys a graph
@brief Remove a node from the graph.
@brief Returns the event associated with an event record node.
@brief Sets an event record node’s event.
@brief Returns the event associated with an event wait node.
@brief Sets an event wait node’s event.
@brief Updates node parameters in the child graph node in the given graphExec.
@brief Destroys an executable graph
@brief Sets the event for an event record node in the given graphExec.
@brief Sets the event for an event record node in the given graphExec.
@brief Updates node parameters in the external semaphore signal node in the given graphExec.
@brief Updates node parameters in the external semaphore wait node in the given graphExec.
@brief Sets the parameters for a host node in the given graphExec.
@brief Sets the parameters for a kernel node in the given graphExec.
@brief Sets the parameters for a memcpy node in the given graphExec.
@brief Sets the parameters for a memcpy node in the given graphExec to perform a 1-dimensional
copy.
@brief Sets the parameters for a memcpy node in the given graphExec to copy from a symbol on the
@brief Sets the parameters for a memcpy node in the given graphExec to copy to a symbol on the
device.
@param [in] hGraphExec - instance of the executable graph with the node.
@param [in] node - instance of the node to set parameters to.
@param [in] symbol - Device symbol address.
@param [in] src - pointer to memory address of the src.
@param [in] count - the size of the memory to copy.
@param [in] offset - Offset from start of symbol in bytes.
@param [in] kind - the type of memory copy.
@returns #hipSuccess, #hipErrorInvalidValue
@warning : This API is marked as beta, meaning, while this is feature complete,
it is still open to changes and may have outstanding issues.
@brief Sets the parameters for a memset node in the given graphExec.
@brief Check whether an executable graph can be updated with a graph and perform the update if *
possible.
@brief Returns external semaphore signal node params.
@brief Updates node parameters in the external semaphore signal node.
@brief Returns external semaphore wait node params.
@brief Updates node parameters in the external semaphore wait node.
@brief Returns a graph’s dependency edges.
@brief Returns graph nodes.
@brief Returns graph’s root nodes.
@brief Returns a host node’s parameters.
@brief Sets a host node’s parameters.
@brief Creates an executable graph from a graph
@brief Creates an executable graph from a graph.
@brief Creates an executable graph from a graph.
@brief Copies attributes from source node to destination node.
@brief Gets a node attribute.
@brief Gets kernel node’s parameters.
@brief Sets a node attribute.
@brief Sets a kernel node’s parameters.
@brief launches an executable graph in a stream
@brief Returns parameters for memory allocation node
@brief Returns parameters for memory free node
@brief Gets a memcpy node’s parameters.
@brief Sets a memcpy node’s parameters.
@brief Sets a memcpy node’s parameters to perform a 1-dimensional copy.
@brief Sets a memcpy node’s parameters to copy from a symbol on the device.
@brief Sets a memcpy node’s parameters to copy to a symbol on the device.
@brief Gets a memset node’s parameters.
@brief Sets a memset node’s parameters.
@brief Finds a cloned version of a node.
@brief Returns a node’s dependencies.
@brief Returns a node’s dependent nodes.
@brief Query whether a node in the given graphExec is enabled
@brief Returns a node’s type.
@brief Enables or disables the specified node in the given graphExec
@brief Release user object from graphs.
@brief Removes dependency edges from a graph.
@brief Retain user object for graphs.
@brief uploads an executable graph in a stream
@brief Maps a graphics resource for access.
@brief Gets device accessible address of a graphics resource.
@brief Get an array through which to access a subresource of a mapped graphics resource.
@brief Unmaps graphics resources.
@brief Unregisters a graphics resource.
@brief Allocate device accessible page locked host memory [Deprecated]
@brief Free memory allocated by the hcc 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.
@brief Get Device pointer from Host Pointer allocated through hipHostMalloc
@brief Return flags associated with host pointer
@brief Allocates device accessible page locked (pinned) host memory
@brief Register host memory so it can be accessed from the current device.
@brief Un-register host pointer
@brief Imports an external memory object.
@}
/
/**
@defgroup API HIP API
@{
@brief Close memory mapped with hipIpcOpenMemHandle
@brief Gets an opaque interprocess handle for an event.
@brief Gets an interprocess memory handle for an existing device memory
allocation
@brief Opens an interprocess event handles.
@brief Opens an interprocess memory handle exported from another process
and returns a device pointer usable in the local process.
@brief Returns kernel name reference by function name.
@brief Retrives kernel for a given host pointer, unless stated otherwise.
@brief Launch a kernel.
@brief 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
@brief Launches kernels on multiple devices where thread blocks can cooperate and
synchronize as they execute.
@brief Enqueues a host function call in a stream.
@brief C compliant kernel launch API
@}
/
/**
@brief Allocate memory on the default accelerator
@brief Create a 3D memory pointer on the device.
@brief Allocate an array on the device.
@brief Allocate an array on the device.
@brief Allocates memory with stream ordered semantics
@brief Allocates memory from a specified pool with stream ordered semantics.
@brief Allocate pinned host memory [Deprecated]
@brief Allocate a mipmapped array on the device.
Allocates at least width (in bytes) * height bytes of linear memory
Padding may occur to ensure alighnment requirements are met for the given row
The change in width size due to padding will be returned in *pitch.
Currently the alignment is set to 128 bytes
@brief Frees an address range reservation made via hipMemAddressReserve
@brief Reserves an address range
@brief Advise about the usage of a given memory range to HIP.
@brief Allocate pinned host memory [Deprecated]
Allocates at least width (in bytes) * height bytes of linear memory
Padding may occur to ensure alighnment requirements are met for the given row
The change in width size due to padding will be returned in *pitch.
Currently the alignment is set to 128 bytes
@brief Creates a memory allocation described by the properties and size
@brief Exports an allocation to a requested shareable handle type.
@brief Get the access flags set for the given location and ptr.
@brief Get information on memory allocations.
@brief Calculates either the minimal or recommended granularity.
@brief Retrieve the property structure of the given handle.
@brief Query memory info.
@brief Imports an allocation from a requested shareable handle type.
@brief Maps an allocation handle to a reserved virtual address range.
@brief Maps or unmaps subregions of sparse HIP arrays and sparse HIP mipmapped arrays.
@brief Creates a memory pool
@brief Destroys the specified memory pool
@brief Export data to share a memory pool allocation between processes.
@brief Exports a memory pool to the requested handle type.
@brief Returns the accessibility of a pool from a device
@brief Gets attributes of a memory pool
@brief Imports a memory pool from a shared handle.
@brief Import a memory pool allocation from another process.
@brief Controls visibility of the specified pool between devices
@brief Sets attributes of a memory pool
@brief Releases freed memory back to the OS
@brief Prefetches memory to the specified destination device using HIP.
@brief Get allocated memory size via memory pointer.
@brief Query an attribute of a given memory range in HIP.
@brief Query attributes of a given memory range in HIP.
@brief Release a memory handle representing a memory allocation which was previously allocated through hipMemCreate.
@brief Returns the allocation handle of the backing memory allocation given the address.
@brief Set the access flags for each location specified in desc for the given virtual address range.
@brief Unmap memory allocation of a given address range.
@brief Copy data from src to dst.
@brief Copies data between host and device.
@brief Copies data between host and device.
@brief Copies data between host and device.
@brief Copies data between host and device.
@brief Copies data between host and device asynchronously.
@brief Copies data between host and device.
@brief Copies data between host and device.
@brief Copies data between host and device.
@brief Copies data between host and device asynchronously.
@brief Copy data from src to dst asynchronously.
@brief Copies from one 1D array to another.
@brief Copies from one 1D array to device memory.
@brief Copies data between host and device.
@brief Copies from one 1D array to host memory.
@brief Copies from device memory to a 1D array.
@brief Copy data from Device to Device
@brief Copy data from Device to Device asynchronously
@brief Copy data from Device to Host
@brief Copy data from Device to Host asynchronously
@brief Copies data between host and device.
@brief Copies data from the given symbol on the device.
@brief Copies data from the given symbol on the device asynchronously.
@brief Copies data between host and device.
@brief Copies from host memory to a 1D array.
@brief Copy data from Host to Device
@brief Copy data from Host to Device asynchronously
@brief Copies memory for 2D arrays.
@param[in] pCopy Parameters for the memory copy
@return #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,
#hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection
@brief Copies memory for 2D arrays.
@param[in] pCopy Parameters for the memory copy
@param[in] stream Stream to use
@return #hipSuccess, #hipErrorInvalidValue, #hipErrorInvalidPitchValue,
#hipErrorInvalidDevicePointer, #hipErrorInvalidMemcpyDirection
@brief Copies memory from one device to memory on another device.
@brief Copies memory from one device to memory on another device.
@brief Copies data between host and device.
@brief 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.
@brief Copies data to the given symbol on the device asynchronously.
@brief Memory copy on the stream.
It allows single or multiple devices to do memory copy on single or multiple streams.
@brief Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant
byte value value.
@brief Fills the memory area pointed to by dst with the constant value.
@brief Fills asynchronously the memory area pointed to by dst with the constant value.
@brief Fills synchronously the memory area pointed to by pitchedDevPtr with the constant value.
@brief Fills asynchronously the memory area pointed to by pitchedDevPtr with the constant value.
@brief Fills the first sizeBytes bytes of the memory area pointed to by dev with the constant
byte value value.
@brief Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant
byte value value.
@brief Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant
byte value value.
@brief Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant
short value value.
@brief Fills the memory area pointed to by dest with the constant integer
value for specified number of times.
@brief Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant
short value value.
@brief Fills the memory area pointed to by dev with the constant integer
value for specified number of times.
@brief Create a mipmapped array.
@brief Destroy a mipmapped array.
@brief Get a mipmapped array on a mipmapped level.
@brief Function with kname will be extracted if present in module
@brief Returns a global pointer from a module.
Returns in *dptr and *bytes the pointer and size of the global of name name located in module hmod.
If no variable of that name exists, it returns hipErrorNotFound. Both parameters dptr and bytes are optional.
If one of them is NULL, it is ignored and hipSuccess is returned.
@brief returns the handle of the texture reference with the name from the module.
@brief 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
@brief Launches kernels on multiple devices where thread blocks can cooperate and
synchronize as they execute.
@brief launches kernel f with launch parameters and shared memory on stream with arguments passed
to kernelparams or extra
@}
/
/**
@brief builds module from code object which resides in host memory. Image is pointer to that
location.
@brief builds module from code object which resides in host memory. Image is pointer to that
location. Options are not used. hipModuleLoadData is called.
@brief Returns occupancy for a device function.
@brief Returns occupancy for a device function.
@brief determine the grid and block sizes to achieves maximum occupancy for a kernel
@brief Frees the module
@brief Returns occupancy for a device function.
@brief Returns occupancy for a device function.
@brief determine the grid and block sizes to achieves maximum occupancy for a kernel
@brief Return last error returned by any HIP runtime API call.
@brief Returns information about the specified pointer.[BETA]
@brief Returns attributes for the specified pointer
@brief Sets information on the specified pointer.[BETA]
@brief Start recording of profiling information
When using this API, start the profiler with profiling disabled. (–startdisabled)
@returns #hipErrorNotSupported
@warning : hipProfilerStart API is deprecated, use roctracer/rocTX instead.
@brief Stop recording of profiling information.
When using this API, start the profiler with profiling disabled. (–startdisabled)
@returns #hipErrorNotSupported
@warning hipProfilerStart API is deprecated, use roctracer/rocTX instead.
@brief Returns the approximate HIP Runtime version.
@brief Set default device to be used for subsequent hip API calls from this thread.
@brief The current device behavior is changed according the flags passed.
@brief Set a list of devices that can be used.
@brief Set a kernel argument.
@brief Signals a set of external semaphore objects.
@brief 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.
@param[in] stream - Stream to add callback to
@param[in] callback - The function to call once preceding stream operations are complete
@param[in] userData - User specified data to be passed to the callback function
@param[in] flags - Reserved for future use, must be 0
@return #hipSuccess, #hipErrorInvalidHandle, #hipErrorNotSupported
@brief Attach memory to a stream asynchronously in HIP.
@brief Begins graph capture on a stream.
@brief Begins graph capture on a stream to an existing graph.
@brief Create an asynchronous stream.
@brief Create an asynchronous stream.
@brief Create an asynchronous stream with the specified priority.
@brief Destroys the specified stream.
@brief Ends capture on a stream, returning the captured graph.
@brief Get capture status of a stream.
@brief Get stream’s capture state
@brief Get the device assocaited with the stream
@brief Return flags associated with this stream.
@brief Query the priority of a stream.
@brief Get stream’s capture state
@brief Return #hipSuccess if all of the operations in the specified @p stream have completed, or
#hipErrorNotReady if not.
@brief Wait for all commands in stream to complete.
@brief Update the set of dependencies in a capturing stream
@brief Make the specified compute stream wait for an event
@}
/
/**
@brief Enqueues a wait command to the stream.[BETA]
@brief Enqueues a write command to the stream.[BETA]
@brief Enqueues a write command to the stream.[BETA]
@brief Creates a texture object.
@brief Destroys a texture object.
@brief Gets resource descriptor of a texture object.
@brief Gets resource view descriptor of a texture object.
@brief Gets texture descriptor of a texture object.
@brief Gets the address for a texture reference.
@brief Gets the address mode for a texture reference.
@brief Gets the array bound to a texture reference.
@brief Gets the border color used by a texture reference.
@brief Gets filter mode for a texture reference.
@brief Gets flags for a texture reference.
@brief Gets texture format for a texture reference.
@brief Gets the maximum anisotropy for a texture reference.
@brief Gets the mipmapped array bound to a texture reference.
@brief Gets the mipmap filter mode for a texture reference.
@brief Gets the mipmap level bias for a texture reference.
@brief Gets the minimum and maximum mipmap level clamps for a texture reference.
@brief Sets an bound address for a texture reference.
@brief Set a bind an address as a 2D texture reference.
@brief Sets address mode for a texture reference.
@brief Binds an array as a texture reference.
@brief Sets border color for a texture reference.
@brief Set filter mode for a texture reference.
@brief Set flags for a texture reference.
@brief Set format for a texture reference.
@brief Sets the maximum anisotropy for a texture reference.
@brief Sets mipmap filter mode for a texture reference.
@brief Sets mipmap level bias for a texture reference.
@brief Sets mipmap level clamp for a texture reference.
@brief Binds mipmapped array to a texture reference.
@brief Swaps the stream capture mode of a thread.
@brief Unbinds a texture.
@brief Create an instance of userObject to manage lifetime of a resource.
@brief Release number of references to resource.
@brief Retain number of references to resource.
@brief Waits on a set of external semaphore objects
@ingroup Runtime
@brief Adds the given name exprssion to the runtime compilation program.
@ingroup Runtime
@brief Compiles the given runtime compilation program.
@ingroup Runtime
@brief Creates an instance of hiprtcProgram with the given input parameters,
and sets the output hiprtcProgram prog with it.
@brief Destroys an instance of given hiprtcProgram.
@ingroup Runtime
@param [in] prog runtime compilation program instance.
@returns #HIPRTC_SUCCESS
@brief Gets the pointer of compiled bitcode by the runtime compilation program instance.
@brief Gets the size of compiled bitcode by the runtime compilation program instance.
@ingroup Runtime
@brief Gets the pointer of compilation binary by the runtime compilation program instance.
@ingroup Runtime
@param [in] prog runtime compilation program instance.
@param [out] code char pointer to binary.
@returns #HIPRTC_SUCCESS
@brief Gets the size of compilation binary by the runtime compilation program instance.
@ingroup Runtime
@param [in] prog runtime compilation program instance.
@param [out] codeSizeRet the size of binary.
@returns #HIPRTC_SUCCESS
@ingroup Runtime
@brief Gets the lowered (mangled) name from an instance of hiprtcProgram with the given input parameters,
and sets the output lowered_name with it.
@ingroup Runtime
@param [in] prog runtime compilation program instance.
@param [in] name_expression const char pointer to the name expression.
@param [in, out] lowered_name const char array to the lowered (mangled) name.
@returns #HIPRTC_SUCCESS
@brief Gets the log generated by the runtime compilation program instance.
@ingroup Runtime
@param [in] prog runtime compilation program instance.
@param [out] log memory pointer to the generated log.
@returns #HIPRTC_SUCCESS
@brief Gets the size of log generated by the runtime compilation program instance.
@brief Completes the linking of the given program.
@ingroup Runtime
@param [in] hip_link_state hiprtc link state
@param [in] input_type Type of the input data or bitcode
@param [in] image Input data which is null terminated
@param [in] image_size Size of the input data
@param [in] name Optional name for this input
@param [in] num_options Size of the options
@param [in] options_ptr Array of options applied to this input
@param [in] option_values Array of option values cast to void*
@brief Adds a file with bit code to be linked with options
@ingroup Runtime
@param [in] hip_link_state hiprtc link state
@param [in] input_type Type of the input data or bitcode
@param [in] file_path Path to the input file where bitcode is present
@param [in] num_options Size of the options
@param [in] options_ptr Array of options applied to this input
@param [in] option_values Array of option values cast to void*
@brief Completes the linking of the given program.
@ingroup Runtime
@param [in] hip_link_state hiprtc link state
@param [out] bin_out Upon success, points to the output binary
@param [out] size_out Size of the binary is stored (optional)
@brief Creates the link instance via hiprtc APIs.
@ingroup Runtime
@param [in] num_options Number of options
@param [in] option_ptr Array of options
@param [in] option_vals_pptr Array of option values cast to void*
@param [out] hip_link_state_ptr hiprtc link state created upon success
@brief Deletes the link instance via hiprtc APIs.
@ingroup Runtime
@param [in] hip_link_state link state instance
@ingroup Runtime
@brief Sets the parameters as major and minor version.