include/hip/hip_runtime_api.h Source File

• include
• hip

hip_runtime_api.h

Go to the documentation of this file.

1 /*

2 Copyright (c) 2015 - 2023 Advanced Micro Devices, Inc. All rights reserved.

3 

4 Permission is hereby granted, free of charge, to any person obtaining a copy

5 of this software and associated documentation files (the "Software"), to deal

6 in the Software without restriction, including without limitation the rights

7 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

8 copies of the Software, and to permit persons to whom the Software is

9 furnished to do so, subject to the following conditions:

10 

11 The above copyright notice and this permission notice shall be included in

12 all copies or substantial portions of the Software.

13 

14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

15 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

17 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

18 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

19 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

20 THE SOFTWARE.

21 */

22 

31 #ifndef HIP_INCLUDE_HIP_HIP_RUNTIME_API_H

32 #define HIP_INCLUDE_HIP_HIP_RUNTIME_API_H

33 

34 #if __cplusplus

35 #include <climits>

36 #include <cstdint>

37 #include <cstdlib>

38 #include <utility>

39 #else

40 #include <limits.h>

41 #include <stdint.h>

42 #include <stdlib.h>

43 #endif

44 

45 #include <hip/hip_version.h>

46 #include <hip/hip_common.h>

47 #include <hip/linker_types.h>

48 

49 enum {

50  HIP_SUCCESS = 0,

51  HIP_ERROR_INVALID_VALUE,

52  HIP_ERROR_NOT_INITIALIZED,

53  HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

54 };

55 // hack to get these to show up in Doxygen:

65 typedef struct {

66  // 32-bit Atomics

67  unsigned hasGlobalInt32Atomics : 1;

68  unsigned hasGlobalFloatAtomicExch : 1;

69  unsigned hasSharedInt32Atomics : 1;

70  unsigned hasSharedFloatAtomicExch : 1;

71  unsigned hasFloatAtomicAdd : 1;

72 

73  // 64-bit Atomics

74  unsigned hasGlobalInt64Atomics : 1;

75  unsigned hasSharedInt64Atomics : 1;

76 

77  // Doubles

78  unsigned hasDoubles : 1;

79 

80  // Warp cross-lane operations

81  unsigned hasWarpVote : 1;

82  unsigned hasWarpBallot : 1;

83  unsigned hasWarpShuffle : 1;

84  unsigned hasFunnelShift : 1;

85 

86  // Sync

87  unsigned hasThreadFenceSystem : 1;

88  unsigned hasSyncThreadsExt : 1;

89 

90  // Misc

91  unsigned hasSurfaceFuncs : 1;

92  unsigned has3dGrid : 1;

93  unsigned hasDynamicParallelism : 1;

94 } hipDeviceArch_t;

95 

96 typedef struct hipUUID_t {

97  char bytes[16];

98 } hipUUID;

99 

100 //---

101 // Common headers for both NVCC and HIP-Clang paths:

102 

103 #define hipGetDeviceProperties hipGetDevicePropertiesR0600

104 #define hipDeviceProp_t hipDeviceProp_tR0600

105 #define hipChooseDevice hipChooseDeviceR0600

106 

111 typedef struct hipDeviceProp_t {

112  char name[256];

113  hipUUID uuid;

114  char luid[8];

115  unsigned int luidDeviceNodeMask;

116  size_t totalGlobalMem;

117  size_t sharedMemPerBlock;

118  int regsPerBlock;

119  int warpSize;

120  size_t memPitch;

122  int maxThreadsPerBlock;

123  int maxThreadsDim[3];

124  int maxGridSize[3];

125  int clockRate;

126  size_t totalConstMem;

128  int major;

132  int minor;

137  size_t textureAlignment;

138  size_t texturePitchAlignment;

139  int deviceOverlap;

140  int multiProcessorCount;

144  int kernelExecTimeoutEnabled;

145  int integrated;

146  int canMapHostMemory;

147  int computeMode;

148  int maxTexture1D;

149  int maxTexture1DMipmap;

150  int maxTexture1DLinear;

151  int maxTexture2D[2];

152  int maxTexture2DMipmap[2];

153  int maxTexture2DLinear[3];

154  int maxTexture2DGather[2];

155  int maxTexture3D[3];

157  int maxTexture3DAlt[3];

158  int maxTextureCubemap;

159  int maxTexture1DLayered[2];

160  int maxTexture2DLayered[3];

161  int maxTextureCubemapLayered[2];

162  int maxSurface1D;

163  int maxSurface2D[2];

164  int maxSurface3D[3];

165  int maxSurface1DLayered[2];

166  int maxSurface2DLayered[3];

167  int maxSurfaceCubemap;

168  int maxSurfaceCubemapLayered[2];

169  size_t surfaceAlignment;

170  int concurrentKernels;

171  int ECCEnabled;

172  int pciBusID;

173  int pciDeviceID;

174  int pciDomainID;

175  int tccDriver;

176  int asyncEngineCount;

177  int unifiedAddressing;

178  int memoryClockRate;

179  int memoryBusWidth;

180  int l2CacheSize;

181  int persistingL2CacheMaxSize;

182  int maxThreadsPerMultiProcessor;

183  int streamPrioritiesSupported;

184  int globalL1CacheSupported;

185  int localL1CacheSupported;

186  size_t sharedMemPerMultiprocessor;

187  int regsPerMultiprocessor;

188  int managedMemory;

189  int isMultiGpuBoard;

190  int multiGpuBoardGroupID;

191  int hostNativeAtomicSupported;

192  int singleToDoublePrecisionPerfRatio;

193  int pageableMemoryAccess;

195  int concurrentManagedAccess;

197  int computePreemptionSupported;

198  int canUseHostPointerForRegisteredMem;

200  int cooperativeLaunch;

201  int cooperativeMultiDeviceLaunch;

203  size_t sharedMemPerBlockOptin;

204  int pageableMemoryAccessUsesHostPageTables;

206  int directManagedMemAccessFromHost;

208  int maxBlocksPerMultiProcessor;

209  int accessPolicyMaxWindowSize;

210  size_t reservedSharedMemPerBlock;

211  int hostRegisterSupported;

212  int sparseHipArraySupported;

213  int hostRegisterReadOnlySupported;

215  int timelineSemaphoreInteropSupported;

216  int memoryPoolsSupported;

217  int gpuDirectRDMASupported;

218  unsigned int gpuDirectRDMAFlushWritesOptions;

220  int gpuDirectRDMAWritesOrdering;

221  unsigned int

222  memoryPoolSupportedHandleTypes;

223  int deferredMappingHipArraySupported;

225  int ipcEventSupported;

226  int clusterLaunch;

227  int unifiedFunctionPointers;

228  int reserved[63];

229 

230  int hipReserved[32];

231 

232  /* HIP Only struct members */

233  char gcnArchName[256];

234  size_t maxSharedMemoryPerMultiProcessor;

235  int clockInstructionRate;

237  hipDeviceArch_t arch;

238  unsigned int* hdpMemFlushCntl;

239  unsigned int* hdpRegFlushCntl;

240  int cooperativeMultiDeviceUnmatchedFunc;

243  int cooperativeMultiDeviceUnmatchedGridDim;

246  int cooperativeMultiDeviceUnmatchedBlockDim;

249  int cooperativeMultiDeviceUnmatchedSharedMem;

252  int isLargeBar;

253  int asicRevision;

254 } hipDeviceProp_t;

255 

263 typedef enum hipMemoryType {

264  hipMemoryTypeUnregistered = 0,

265  hipMemoryTypeHost = 1,

266  hipMemoryTypeDevice = 2,

268  hipMemoryTypeManaged = 3,

271  hipMemoryTypeArray = 10,

273  hipMemoryTypeUnified = 11

274 

275 } hipMemoryType;

276 

280 typedef struct hipPointerAttribute_t {

281  enum hipMemoryType type;

282  int device;

283  void* devicePointer;

284  void* hostPointer;

285  int isManaged;

286  unsigned allocationFlags; /* flags specified when memory was allocated*/

287  /* peers? */

288 } hipPointerAttribute_t;

289 

290 // Ignoring error-code return values from hip APIs is discouraged. On C++17,

291 // we can make that yield a warning

292 #if __cplusplus >= 201703L

293 #define __HIP_NODISCARD [[nodiscard]]

294 #else

295 #define __HIP_NODISCARD

296 #endif

297 

302 // Developer note - when updating these, update the hipErrorName and hipErrorString functions in

303 // NVCC and HIP-Clang paths Also update the hipCUDAErrorTohipError function in NVCC path.

304 

305 typedef enum __HIP_NODISCARD hipError_t {

306  hipSuccess = 0,

307  hipErrorInvalidValue = 1,

309  hipErrorOutOfMemory = 2,

310  // Deprecated

311  hipErrorMemoryAllocation = 2,

312  hipErrorNotInitialized = 3,

313  // Deprecated

314  hipErrorInitializationError = 3,

315  hipErrorDeinitialized = 4,

316  hipErrorProfilerDisabled = 5,

317  hipErrorProfilerNotInitialized = 6,

318  hipErrorProfilerAlreadyStarted = 7,

319  hipErrorProfilerAlreadyStopped = 8,

320  hipErrorInvalidConfiguration = 9,

321  hipErrorInvalidPitchValue = 12,

322  hipErrorInvalidSymbol = 13,

323  hipErrorInvalidDevicePointer = 17,

324  hipErrorInvalidMemcpyDirection = 21,

325  hipErrorInsufficientDriver = 35,

326  hipErrorMissingConfiguration = 52,

327  hipErrorPriorLaunchFailure = 53,

328  hipErrorInvalidDeviceFunction = 98,

329  hipErrorNoDevice = 100,

330  hipErrorInvalidDevice = 101,

331  hipErrorInvalidImage = 200,

332  hipErrorInvalidContext = 201,

333  hipErrorContextAlreadyCurrent = 202,

334  hipErrorMapFailed = 205,

335  // Deprecated

336  hipErrorMapBufferObjectFailed = 205,

337  hipErrorUnmapFailed = 206,

338  hipErrorArrayIsMapped = 207,

339  hipErrorAlreadyMapped = 208,

340  hipErrorNoBinaryForGpu = 209,

341  hipErrorAlreadyAcquired = 210,

342  hipErrorNotMapped = 211,

343  hipErrorNotMappedAsArray = 212,

344  hipErrorNotMappedAsPointer = 213,

345  hipErrorECCNotCorrectable = 214,

346  hipErrorUnsupportedLimit = 215,

347  hipErrorContextAlreadyInUse = 216,

348  hipErrorPeerAccessUnsupported = 217,

349  hipErrorInvalidKernelFile = 218,

350  hipErrorInvalidGraphicsContext = 219,

351  hipErrorInvalidSource = 300,

352  hipErrorFileNotFound = 301,

353  hipErrorSharedObjectSymbolNotFound = 302,

354  hipErrorSharedObjectInitFailed = 303,

355  hipErrorOperatingSystem = 304,

356  hipErrorInvalidHandle = 400,

357  // Deprecated

358  hipErrorInvalidResourceHandle = 400,

359  hipErrorIllegalState = 401,

360  hipErrorNotFound = 500,

361  hipErrorNotReady = 600,

365  hipErrorIllegalAddress = 700,

366  hipErrorLaunchOutOfResources = 701,

367  hipErrorLaunchTimeOut = 702,

368  hipErrorPeerAccessAlreadyEnabled = 704,

370  hipErrorPeerAccessNotEnabled = 705,

371  hipErrorSetOnActiveProcess = 708,

372  hipErrorContextIsDestroyed = 709,

373  hipErrorAssert = 710,

374  hipErrorHostMemoryAlreadyRegistered = 712,

376  hipErrorHostMemoryNotRegistered = 713,

378  hipErrorLaunchFailure = 719,

379  hipErrorCooperativeLaunchTooLarge = 720,

383  hipErrorNotSupported = 801,

384  hipErrorStreamCaptureUnsupported = 900,

386  hipErrorStreamCaptureInvalidated = 901,

388  hipErrorStreamCaptureMerge = 902,

390  hipErrorStreamCaptureUnmatched = 903,

391  hipErrorStreamCaptureUnjoined = 904,

393  hipErrorStreamCaptureIsolation = 905,

397  hipErrorStreamCaptureImplicit = 906,

400  hipErrorCapturedEvent = 907,

402  hipErrorStreamCaptureWrongThread = 908,

406  hipErrorGraphExecUpdateFailure = 910,

410  hipErrorInvalidChannelDescriptor = 911,

411  hipErrorInvalidTexture = 912,

412  hipErrorUnknown = 999,

413  // HSA Runtime Error Codes start here.

414  hipErrorRuntimeMemory = 1052,

416  hipErrorRuntimeOther = 1053,

418  hipErrorTbd

419 } hipError_t;

420 

421 #undef __HIP_NODISCARD

422 

427 typedef enum hipDeviceAttribute_t {

428  hipDeviceAttributeCudaCompatibleBegin = 0,

429 

430  hipDeviceAttributeEccEnabled =

431  hipDeviceAttributeCudaCompatibleBegin,

432  hipDeviceAttributeAccessPolicyMaxWindowSize,

434  hipDeviceAttributeAsyncEngineCount,

435  hipDeviceAttributeCanMapHostMemory,

437  hipDeviceAttributeCanUseHostPointerForRegisteredMem,

440  hipDeviceAttributeClockRate,

441  hipDeviceAttributeComputeMode,

442  hipDeviceAttributeComputePreemptionSupported,

443  hipDeviceAttributeConcurrentKernels,

445  hipDeviceAttributeConcurrentManagedAccess,

447  hipDeviceAttributeCooperativeLaunch,

448  hipDeviceAttributeCooperativeMultiDeviceLaunch,

450  hipDeviceAttributeDeviceOverlap,

452  hipDeviceAttributeDirectManagedMemAccessFromHost,

454  hipDeviceAttributeGlobalL1CacheSupported,

455  hipDeviceAttributeHostNativeAtomicSupported,

457  hipDeviceAttributeIntegrated,

458  hipDeviceAttributeIsMultiGpuBoard,

459  hipDeviceAttributeKernelExecTimeout,

460  hipDeviceAttributeL2CacheSize,

462  hipDeviceAttributeLocalL1CacheSupported,

463  hipDeviceAttributeLuid,

465  hipDeviceAttributeLuidDeviceNodeMask,

467  hipDeviceAttributeComputeCapabilityMajor,

468  hipDeviceAttributeManagedMemory,

469  hipDeviceAttributeMaxBlocksPerMultiProcessor,

470  hipDeviceAttributeMaxBlockDimX,

471  hipDeviceAttributeMaxBlockDimY,

472  hipDeviceAttributeMaxBlockDimZ,

473  hipDeviceAttributeMaxGridDimX,

474  hipDeviceAttributeMaxGridDimY,

475  hipDeviceAttributeMaxGridDimZ,

476  hipDeviceAttributeMaxSurface1D,

477  hipDeviceAttributeMaxSurface1DLayered,

478  hipDeviceAttributeMaxSurface2D,

479  hipDeviceAttributeMaxSurface2DLayered,

480  hipDeviceAttributeMaxSurface3D,

481  hipDeviceAttributeMaxSurfaceCubemap,

482  hipDeviceAttributeMaxSurfaceCubemapLayered,

484  hipDeviceAttributeMaxTexture1DWidth,

485  hipDeviceAttributeMaxTexture1DLayered,

486  hipDeviceAttributeMaxTexture1DLinear,

489  hipDeviceAttributeMaxTexture1DMipmap,

490  hipDeviceAttributeMaxTexture2DWidth,

491  hipDeviceAttributeMaxTexture2DHeight,

492  hipDeviceAttributeMaxTexture2DGather,

494  hipDeviceAttributeMaxTexture2DLayered,

495  hipDeviceAttributeMaxTexture2DLinear,

497  hipDeviceAttributeMaxTexture2DMipmap,

498  hipDeviceAttributeMaxTexture3DWidth,

499  hipDeviceAttributeMaxTexture3DHeight,

500  hipDeviceAttributeMaxTexture3DDepth,

501  hipDeviceAttributeMaxTexture3DAlt,

502  hipDeviceAttributeMaxTextureCubemap,

503  hipDeviceAttributeMaxTextureCubemapLayered,

504  hipDeviceAttributeMaxThreadsDim,

505  hipDeviceAttributeMaxThreadsPerBlock,

506  hipDeviceAttributeMaxThreadsPerMultiProcessor,

507  hipDeviceAttributeMaxPitch,

508  hipDeviceAttributeMemoryBusWidth,

509  hipDeviceAttributeMemoryClockRate,

510  hipDeviceAttributeComputeCapabilityMinor,

511  hipDeviceAttributeMultiGpuBoardGroupID,

513  hipDeviceAttributeMultiprocessorCount,

517  hipDeviceAttributeUnused1,

518  hipDeviceAttributePageableMemoryAccess,

520  hipDeviceAttributePageableMemoryAccessUsesHostPageTables,

522  hipDeviceAttributePciBusId,

523  hipDeviceAttributePciDeviceId,

524  hipDeviceAttributePciDomainId,

525  hipDeviceAttributePciDomainID =

526  hipDeviceAttributePciDomainId,

527  hipDeviceAttributePersistingL2CacheMaxSize,

528  hipDeviceAttributeMaxRegistersPerBlock,

531  hipDeviceAttributeMaxRegistersPerMultiprocessor,

532  hipDeviceAttributeReservedSharedMemPerBlock,

534  hipDeviceAttributeMaxSharedMemoryPerBlock,

536  hipDeviceAttributeSharedMemPerBlockOptin,

538  hipDeviceAttributeSharedMemPerMultiprocessor,

539  hipDeviceAttributeSingleToDoublePrecisionPerfRatio,

541  hipDeviceAttributeStreamPrioritiesSupported,

542  hipDeviceAttributeSurfaceAlignment,

543  hipDeviceAttributeTccDriver,

544  hipDeviceAttributeTextureAlignment,

545  hipDeviceAttributeTexturePitchAlignment,

547  hipDeviceAttributeTotalConstantMemory,

548  hipDeviceAttributeTotalGlobalMem,

549  hipDeviceAttributeUnifiedAddressing,

551  hipDeviceAttributeUnused2,

552  hipDeviceAttributeWarpSize,

553  hipDeviceAttributeMemoryPoolsSupported,

554  hipDeviceAttributeVirtualMemoryManagementSupported,

556  hipDeviceAttributeHostRegisterSupported,

558  hipDeviceAttributeMemoryPoolSupportedHandleTypes,

560  hipDeviceAttributeHostNumaId,

562 

563  hipDeviceAttributeCudaCompatibleEnd = 9999,

564  hipDeviceAttributeAmdSpecificBegin = 10000,

565 

566  hipDeviceAttributeClockInstructionRate =

567  hipDeviceAttributeAmdSpecificBegin,

569  hipDeviceAttributeUnused3,

570  hipDeviceAttributeMaxSharedMemoryPerMultiprocessor,

571  hipDeviceAttributeUnused4,

572  hipDeviceAttributeUnused5,

573  hipDeviceAttributeHdpMemFlushCntl,

574  hipDeviceAttributeHdpRegFlushCntl,

575  hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc,

578  hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim,

581  hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim,

584  hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem,

587  hipDeviceAttributeIsLargeBar,

588  hipDeviceAttributeAsicRevision,

589  hipDeviceAttributeCanUseStreamWaitValue,

591  hipDeviceAttributeImageSupport,

592  hipDeviceAttributePhysicalMultiProcessorCount,

594  hipDeviceAttributeFineGrainSupport,

595  hipDeviceAttributeWallClockRate,

596  hipDeviceAttributeNumberOfXccs,

597  hipDeviceAttributeMaxAvailableVgprsPerThread,

600  hipDeviceAttributePciChipId,

601 

602  hipDeviceAttributeAmdSpecificEnd = 19999,

603  hipDeviceAttributeVendorSpecificBegin = 20000,

604  // Extended attributes for vendors

605 } hipDeviceAttribute_t;

606 

607 typedef enum hipDriverProcAddressQueryResult {

608  HIP_GET_PROC_ADDRESS_SUCCESS = 0,

609  HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND = 1,

610  HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT = 2

611 } hipDriverProcAddressQueryResult;

612 

613 enum hipComputeMode {

614  hipComputeModeDefault = 0,

615  hipComputeModeExclusive = 1,

616  hipComputeModeProhibited = 2,

617  hipComputeModeExclusiveProcess = 3

618 };

619 

620 enum hipFlushGPUDirectRDMAWritesOptions {

621  hipFlushGPUDirectRDMAWritesOptionHost = 1 << 0,

622  hipFlushGPUDirectRDMAWritesOptionMemOps = 1 << 1

623 };

624 

625 enum hipGPUDirectRDMAWritesOrdering {

626  hipGPUDirectRDMAWritesOrderingNone = 0,

627  hipGPUDirectRDMAWritesOrderingOwner = 100,

628  hipGPUDirectRDMAWritesOrderingAllDevices = 200

629 };

630 

631 #if defined(__HIP_PLATFORM_AMD__) && !defined(__HIP_PLATFORM_NVIDIA__)

632 

633 #ifndef GENERIC_GRID_LAUNCH

634 #define GENERIC_GRID_LAUNCH 1

635 #endif

636 #include <hip/amd_detail/host_defines.h>

637 #include <hip/driver_types.h>

638 #include <hip/texture_types.h>

639 #include <hip/surface_types.h>

640 #if defined(_MSC_VER)

641 #define HIP_DEPRECATED(msg) __declspec(deprecated(msg))

642 #else // !defined(_MSC_VER)

643 #define HIP_DEPRECATED(msg) __attribute__((deprecated(msg)))

644 #endif // !defined(_MSC_VER)

645 #define HIP_DEPRECATED_MSG \

646  "This API is marked as deprecated and might not be supported in future releases. For more " \

647  "details please refer " \

648  "https://github.com/ROCm/HIP/blob/develop/docs/reference/deprecated_api_list.md"

649 #define HIP_LAUNCH_PARAM_BUFFER_POINTER ((void*)0x01)

650 #define HIP_LAUNCH_PARAM_BUFFER_SIZE ((void*)0x02)

651 #define HIP_LAUNCH_PARAM_END ((void*)0x03)

652 #ifdef __cplusplus

653 #define __dparm(x) = x

654 #else

655 #define __dparm(x)

656 #endif

657 #ifdef __GNUC__

658 #pragma GCC visibility push(default)

659 #endif

660 #ifdef __cplusplus

661 namespace hip_impl {

662 hipError_t hip_init();

663 } // namespace hip_impl

664 #endif

665 // Structure definitions:

666 #ifdef __cplusplus

667 extern "C" {

668 #endif

669 //---

670 // API-visible structures

671 typedef struct ihipCtx_t* hipCtx_t;

672 // Note many APIs also use integer deviceIds as an alternative to the device pointer:

673 typedef int hipDevice_t;

674 typedef enum hipDeviceP2PAttr {

675  hipDevP2PAttrPerformanceRank = 0,

676  hipDevP2PAttrAccessSupported,

677  hipDevP2PAttrNativeAtomicSupported,

678  hipDevP2PAttrHipArrayAccessSupported

679 } hipDeviceP2PAttr;

680 typedef enum hipDriverEntryPointQueryResult {

681  hipDriverEntryPointSuccess = 0,

682  hipDriverEntryPointSymbolNotFound = 1,

683  hipDriverEntryPointVersionNotSufficent = 2

684 } hipDriverEntryPointQueryResult;

685 typedef struct ihipStream_t* hipStream_t;

686 #define hipIpcMemLazyEnablePeerAccess 0x01

687 #define HIP_IPC_HANDLE_SIZE 64

688 typedef struct hipIpcMemHandle_st {

689  char reserved[HIP_IPC_HANDLE_SIZE];

690 } hipIpcMemHandle_t;

691 typedef struct hipIpcEventHandle_st {

692  char reserved[HIP_IPC_HANDLE_SIZE];

693 } hipIpcEventHandle_t;

694 typedef struct ihipModule_t* hipModule_t;

695 typedef struct ihipModuleSymbol_t* hipFunction_t;

696 typedef struct ihipLinkState_t* hipLinkState_t;

697 typedef struct ihipLibrary_t* hipLibrary_t;

698 typedef struct ihipKernel_t* hipKernel_t;

702 typedef struct ihipMemPoolHandle_t* hipMemPool_t;

703 

704 typedef struct hipFuncAttributes {

705  int binaryVersion;

706  int cacheModeCA;

707  size_t constSizeBytes;

708  size_t localSizeBytes;

709  int maxDynamicSharedSizeBytes;

710  int maxThreadsPerBlock;

711  int numRegs;

712  int preferredShmemCarveout;

713  int ptxVersion;

714  size_t sharedSizeBytes;

715 } hipFuncAttributes;

716 typedef struct ihipEvent_t* hipEvent_t;

717 

724 enum hipLimit_t {

725  hipLimitStackSize = 0x0,

728  hipLimitPrintfFifoSize = 0x01,

730  hipLimitMallocHeapSize = 0x02,

732  hipExtLimitScratchMin = 0x1000,

734  hipExtLimitScratchMax = 0x1001,

736  hipExtLimitScratchCurrent = 0x1002,

740  hipLimitRange

741 };

742 

746 // Flags that can be used with hipStreamCreateWithFlags.

748 #define hipStreamDefault 0x00

749 

751 #define hipStreamNonBlocking 0x01

752 

753 // Flags that can be used with hipEventCreateWithFlags.

755 #define hipEventDefault 0x0

756 

758 #define hipEventBlockingSync 0x1

759 

761 #define hipEventDisableTiming 0x2

762 

764 #define hipEventInterprocess 0x4

765 

766 // Flags that can be used with hipEventRecordWithFlags.

768 #define hipEventRecordDefault 0x00

769 

771 #define hipEventRecordExternal 0x01

772 

773 //Flags that can be used with hipStreamWaitEvent.

775 #define hipEventWaitDefault 0x00

776 

778 #define hipEventWaitExternal 0x01

779 

788 #define hipEventDisableSystemFence 0x20000000

789 

792 #define hipEventReleaseToDevice 0x40000000

793 

796 #define hipEventReleaseToSystem 0x80000000

797 

798 // Flags that can be used with hipGetDriverEntryPoint.

802 #define hipEnableDefault 0x0

803 

805 #define hipEnableLegacyStream 0x1

806 

809 #define hipEnablePerThreadDefaultStream 0x2

810 

811 // Flags that can be used with hipHostMalloc/hipHostAlloc.

813 #define hipHostAllocDefault 0x0

814 

817 #define hipHostMallocDefault 0x0

818 

820 #define hipHostAllocPortable 0x1

821 

824 #define hipHostMallocPortable 0x1

825 

828 #define hipHostAllocMapped 0x2

829 

833 #define hipHostMallocMapped 0x2

834 

840 #define hipHostAllocWriteCombined 0x4

841 

848 #define hipHostMallocWriteCombined 0x4

849 

855 #define hipHostMallocUncached 0x10000000

856 #define hipHostAllocUncached hipHostMallocUncached

857 

862 #define hipHostMallocNumaUser 0x20000000

863 

865 #define hipHostMallocCoherent 0x40000000

866 

868 #define hipHostMallocNonCoherent 0x80000000

869 

871 #define hipMemAttachGlobal 0x01

872 

874 #define hipMemAttachHost 0x02

875 

877 #define hipMemAttachSingle 0x04

878 

879 #define hipDeviceMallocDefault 0x0

880 

882 #define hipDeviceMallocFinegrained 0x1

883 

885 #define hipMallocSignalMemory 0x2

886 

888 #define hipDeviceMallocUncached 0x3

889 

891 #define hipDeviceMallocContiguous 0x4

892 

893 // Flags that can be used with hipHostRegister.

895 #define hipHostRegisterDefault 0x0

896 

898 #define hipHostRegisterPortable 0x1

899 

902 #define hipHostRegisterMapped 0x2

903 

908 #define hipHostRegisterIoMemory 0x4

909 

911 #define hipHostRegisterReadOnly 0x08

912 

914 #define hipExtHostRegisterCoarseGrained 0x8

915 

919 #define hipExtHostRegisterUncached 0x80000000

920 

922 #define hipDeviceScheduleAuto 0x0

923 

926 #define hipDeviceScheduleSpin 0x1

927 

930 #define hipDeviceScheduleYield 0x2

931 #define hipDeviceScheduleBlockingSync 0x4

932 #define hipDeviceScheduleMask 0x7

933 #define hipDeviceMapHost 0x8

934 #define hipDeviceLmemResizeToMax 0x10

936 #define hipArrayDefault 0x00

937 #define hipArrayLayered 0x01

938 #define hipArraySurfaceLoadStore 0x02

939 #define hipArrayCubemap 0x04

940 #define hipArrayTextureGather 0x08

941 #define hipOccupancyDefault 0x00

942 #define hipOccupancyDisableCachingOverride 0x01

943 #define hipCooperativeLaunchMultiDeviceNoPreSync 0x01

944 #define hipCooperativeLaunchMultiDeviceNoPostSync 0x02

945 #define hipCpuDeviceId ((int)-1)

946 #define hipInvalidDeviceId ((int)-2)

947 // Flags that can be used with hipExtLaunch Set of APIs.

949 #define hipExtAnyOrderLaunch 0x01

950 // Flags to be used with hipStreamWaitValue32 and hipStreamWaitValue64.

951 #define hipStreamWaitValueGte 0x0

952 #define hipStreamWaitValueEq 0x1

953 #define hipStreamWaitValueAnd 0x2

954 #define hipStreamWaitValueNor 0x3

955 

957 typedef enum hipStreamBatchMemOpType {

958  hipStreamMemOpWaitValue32 = 0x1,

959  hipStreamMemOpWriteValue32 = 0x2,

960  hipStreamMemOpWaitValue64 = 0x4,

961  hipStreamMemOpWriteValue64 = 0x5,

962  hipStreamMemOpBarrier = 0x6,

963  hipStreamMemOpFlushRemoteWrites = 0x3

964 } hipStreamBatchMemOpType;

965 

1002 typedef union hipStreamBatchMemOpParams_union {

1003  hipStreamBatchMemOpType operation;

1004  struct hipStreamMemOpWaitValueParams_t {

1005  hipStreamBatchMemOpType operation;

1006  hipDeviceptr_t address;

1007  union {

1008  uint32_t value;

1009  uint64_t value64;

1010  };

1011  unsigned int flags;

1012  hipDeviceptr_t alias;

1013  } waitValue;

1014  struct hipStreamMemOpWriteValueParams_t {

1015  hipStreamBatchMemOpType operation;

1016  hipDeviceptr_t address;

1017  union {

1018  uint32_t value;

1019  uint64_t value64;

1020  };

1021  unsigned int flags;

1022  hipDeviceptr_t alias;

1023  } writeValue;

1024  struct hipStreamMemOpFlushRemoteWritesParams_t {

1025  hipStreamBatchMemOpType operation;

1026  unsigned int flags;

1027  } flushRemoteWrites;

1028  struct hipStreamMemOpMemoryBarrierParams_t {

1029  hipStreamBatchMemOpType operation;

1030  unsigned int flags;

1031  } memoryBarrier;

1032  uint64_t pad[6];

1033 } hipStreamBatchMemOpParams;

1034 

1062 typedef struct hipBatchMemOpNodeParams {

1063  hipCtx_t ctx;

1064  unsigned int count;

1065  hipStreamBatchMemOpParams* paramArray;

1066  unsigned int flags;

1067 } hipBatchMemOpNodeParams;

1068 

1069 // Stream per thread

1071 #define hipStreamPerThread ((hipStream_t)2)

1072 

1073 #define hipStreamLegacy ((hipStream_t)1)

1074 

1075 // Indicates that the external memory object is a dedicated resource

1076 #define hipExternalMemoryDedicated 0x1

1082 typedef enum hipMemoryAdvise {

1083  hipMemAdviseSetReadMostly = 1,

1085  hipMemAdviseUnsetReadMostly = 2,

1086  hipMemAdviseSetPreferredLocation = 3,

1088  hipMemAdviseUnsetPreferredLocation = 4,

1089  hipMemAdviseSetAccessedBy = 5,

1091  hipMemAdviseUnsetAccessedBy = 6,

1093  hipMemAdviseSetCoarseGrain = 100,

1098  hipMemAdviseUnsetCoarseGrain = 101

1099 } hipMemoryAdvise;

1103 typedef enum hipMemRangeCoherencyMode {

1104  hipMemRangeCoherencyModeFineGrain = 0,

1106  hipMemRangeCoherencyModeCoarseGrain = 1,

1108  hipMemRangeCoherencyModeIndeterminate = 2

1111 } hipMemRangeCoherencyMode;

1115 typedef enum hipMemRangeAttribute {

1116  hipMemRangeAttributeReadMostly = 1,

1118  hipMemRangeAttributePreferredLocation = 2,

1119  hipMemRangeAttributeAccessedBy = 3,

1121  hipMemRangeAttributeLastPrefetchLocation = 4,

1123  hipMemRangeAttributeCoherencyMode = 100,

1125 } hipMemRangeAttribute;

1126 

1130 typedef enum hipMemPoolAttr {

1139  hipMemPoolReuseFollowEventDependencies = 0x1,

1145  hipMemPoolReuseAllowOpportunistic = 0x2,

1152  hipMemPoolReuseAllowInternalDependencies = 0x3,

1161  hipMemPoolAttrReleaseThreshold = 0x4,

1166  hipMemPoolAttrReservedMemCurrent = 0x5,

1172  hipMemPoolAttrReservedMemHigh = 0x6,

1177  hipMemPoolAttrUsedMemCurrent = 0x7,

1183  hipMemPoolAttrUsedMemHigh = 0x8

1184 } hipMemPoolAttr;

1185 

1190 typedef enum hipMemAccessFlags {

1191  hipMemAccessFlagsProtNone = 0,

1192  hipMemAccessFlagsProtRead = 1,

1193  hipMemAccessFlagsProtReadWrite = 3

1194 } hipMemAccessFlags;

1201 typedef struct hipMemAccessDesc {

1202  hipMemLocation location;

1203  hipMemAccessFlags flags;

1204 } hipMemAccessDesc;

1208 typedef enum hipMemAllocationType {

1209  hipMemAllocationTypeInvalid = 0x0,

1213  hipMemAllocationTypePinned = 0x1,

1214  hipMemAllocationTypeUncached = 0x40000000,

1215  hipMemAllocationTypeMax = 0x7FFFFFFF

1216 } hipMemAllocationType;

1221 typedef enum hipMemAllocationHandleType {

1222  hipMemHandleTypeNone = 0x0,

1223  hipMemHandleTypePosixFileDescriptor =

1224  0x1,

1225  hipMemHandleTypeWin32 = 0x2,

1226  hipMemHandleTypeWin32Kmt = 0x4

1227 } hipMemAllocationHandleType;

1231 typedef struct hipMemPoolProps {

1232  hipMemAllocationType

1233  allocType;

1234  hipMemAllocationHandleType

1235  handleTypes;

1236  hipMemLocation location;

1240  void* win32SecurityAttributes;

1241  size_t maxSize;

1242  unsigned char reserved[56];

1243 } hipMemPoolProps;

1247 typedef struct hipMemPoolPtrExportData {

1248  unsigned char reserved[64];

1249 } hipMemPoolPtrExportData;

1250 

1254 typedef enum hipFuncAttribute {

1255  hipFuncAttributeMaxDynamicSharedMemorySize =

1256  8,

1257  hipFuncAttributePreferredSharedMemoryCarveout =

1258  9,

1259  hipFuncAttributeMax

1260 } hipFuncAttribute;

1264 typedef enum hipFuncCache_t {

1265  hipFuncCachePreferNone,

1266  hipFuncCachePreferShared,

1267  hipFuncCachePreferL1,

1268  hipFuncCachePreferEqual,

1269 } hipFuncCache_t;

1273 typedef enum hipSharedMemConfig {

1274  hipSharedMemBankSizeDefault,

1275  hipSharedMemBankSizeFourByte,

1277  hipSharedMemBankSizeEightByte

1279 } hipSharedMemConfig;

1283 typedef struct dim3 {

1284  uint32_t x;

1285  uint32_t y;

1286  uint32_t z;

1287 #ifdef __cplusplus

1288  constexpr __host__ __device__ dim3(uint32_t _x = 1, uint32_t _y = 1, uint32_t _z = 1)

1289  : x(_x), y(_y), z(_z) {};

1290 #endif

1291 } dim3;

1295 typedef struct hipLaunchParams_t {

1296  void* func;

1297  dim3 gridDim;

1298  dim3 blockDim;

1299  void** args;

1300  size_t sharedMem;

1301  hipStream_t stream;

1302 } hipLaunchParams;

1306 typedef struct hipFunctionLaunchParams_t {

1307  hipFunction_t function;

1308  unsigned int gridDimX;

1309  unsigned int gridDimY;

1310  unsigned int gridDimZ;

1311  unsigned int blockDimX;

1312  unsigned int blockDimY;

1313  unsigned int blockDimZ;

1314  unsigned int sharedMemBytes;

1315  hipStream_t hStream;

1316  void** kernelParams;

1317 } hipFunctionLaunchParams;

1318 typedef enum hipExternalMemoryHandleType_enum {

1319  hipExternalMemoryHandleTypeOpaqueFd = 1,

1320  hipExternalMemoryHandleTypeOpaqueWin32 = 2,

1321  hipExternalMemoryHandleTypeOpaqueWin32Kmt = 3,

1322  hipExternalMemoryHandleTypeD3D12Heap = 4,

1323  hipExternalMemoryHandleTypeD3D12Resource = 5,

1324  hipExternalMemoryHandleTypeD3D11Resource = 6,

1325  hipExternalMemoryHandleTypeD3D11ResourceKmt = 7,

1326  hipExternalMemoryHandleTypeNvSciBuf = 8

1327 } hipExternalMemoryHandleType;

1328 typedef struct hipExternalMemoryHandleDesc_st {

1329  hipExternalMemoryHandleType type;

1330  union {

1331  int fd;

1332  struct {

1333  void* handle;

1334  const void* name;

1335  } win32;

1336  const void* nvSciBufObject;

1337  } handle;

1338  unsigned long long size;

1339  unsigned int flags;

1340  unsigned int reserved[16];

1341 } hipExternalMemoryHandleDesc;

1342 typedef struct hipExternalMemoryBufferDesc_st {

1343  unsigned long long offset;

1344  unsigned long long size;

1345  unsigned int flags;

1346  unsigned int reserved[16];

1347 } hipExternalMemoryBufferDesc;

1348 typedef struct hipExternalMemoryMipmappedArrayDesc_st {

1349  unsigned long long offset;

1350  hipChannelFormatDesc formatDesc;

1351  hipExtent extent;

1352  unsigned int flags;

1353  unsigned int numLevels;

1354 } hipExternalMemoryMipmappedArrayDesc;

1355 typedef void* hipExternalMemory_t;

1356 typedef enum hipExternalSemaphoreHandleType_enum {

1357  hipExternalSemaphoreHandleTypeOpaqueFd = 1,

1358  hipExternalSemaphoreHandleTypeOpaqueWin32 = 2,

1359  hipExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3,

1360  hipExternalSemaphoreHandleTypeD3D12Fence = 4,

1361  hipExternalSemaphoreHandleTypeD3D11Fence = 5,

1362  hipExternalSemaphoreHandleTypeNvSciSync = 6,

1363  hipExternalSemaphoreHandleTypeKeyedMutex = 7,

1364  hipExternalSemaphoreHandleTypeKeyedMutexKmt = 8,

1365  hipExternalSemaphoreHandleTypeTimelineSemaphoreFd = 9,

1366  hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = 10

1367 } hipExternalSemaphoreHandleType;

1368 typedef struct hipExternalSemaphoreHandleDesc_st {

1369  hipExternalSemaphoreHandleType type;

1370  union {

1371  int fd;

1372  struct {

1373  void* handle;

1374  const void* name;

1375  } win32;

1376  const void* NvSciSyncObj;

1377  } handle;

1378  unsigned int flags;

1379  unsigned int reserved[16];

1380 } hipExternalSemaphoreHandleDesc;

1381 typedef void* hipExternalSemaphore_t;

1382 typedef struct hipExternalSemaphoreSignalParams_st {

1383  struct {

1384  struct {

1385  unsigned long long value;

1386  } fence;

1387  union {

1388  void* fence;

1389  unsigned long long reserved;

1390  } nvSciSync;

1391  struct {

1392  unsigned long long key;

1393  } keyedMutex;

1394  unsigned int reserved[12];

1395  } params;

1396  unsigned int flags;

1397  unsigned int reserved[16];

1398 } hipExternalSemaphoreSignalParams;

1402 typedef struct hipExternalSemaphoreWaitParams_st {

1403  struct {

1404  struct {

1405  unsigned long long value;

1406  } fence;

1407  union {

1408  void* fence;

1409  unsigned long long reserved;

1410  } nvSciSync;

1411  struct {

1412  unsigned long long key;

1413  unsigned int timeoutMs;

1414  } keyedMutex;

1415  unsigned int reserved[10];

1416  } params;

1417  unsigned int flags;

1418  unsigned int reserved[16];

1419 } hipExternalSemaphoreWaitParams;

1420 

1421 #if __HIP_HAS_GET_PCH

1426 void __hipGetPCH(const char** pch, unsigned int* size);

1427 #endif

1428 

1432 typedef enum hipGraphicsRegisterFlags {

1433  hipGraphicsRegisterFlagsNone = 0,

1434  hipGraphicsRegisterFlagsReadOnly = 1,

1435  hipGraphicsRegisterFlagsWriteDiscard =

1436  2,

1437  hipGraphicsRegisterFlagsSurfaceLoadStore = 4,

1438  hipGraphicsRegisterFlagsTextureGather =

1439  8

1440 } hipGraphicsRegisterFlags;

1441 

1442 typedef struct _hipGraphicsResource hipGraphicsResource;

1443 

1444 typedef hipGraphicsResource* hipGraphicsResource_t;

1445 

1449 typedef struct ihipGraph* hipGraph_t;

1453 typedef struct hipGraphNode* hipGraphNode_t;

1457 typedef struct hipGraphExec* hipGraphExec_t;

1458 

1462 typedef struct hipUserObject* hipUserObject_t;

1463 

1464 

1468 typedef enum hipGraphNodeType {

1469  hipGraphNodeTypeKernel = 0,

1470  hipGraphNodeTypeMemcpy = 1,

1471  hipGraphNodeTypeMemset = 2,

1472  hipGraphNodeTypeHost = 3,

1473  hipGraphNodeTypeGraph = 4,

1474  hipGraphNodeTypeEmpty = 5,

1475  hipGraphNodeTypeWaitEvent = 6,

1476  hipGraphNodeTypeEventRecord = 7,

1477  hipGraphNodeTypeExtSemaphoreSignal = 8,

1478  hipGraphNodeTypeExtSemaphoreWait = 9,

1479  hipGraphNodeTypeMemAlloc = 10,

1480  hipGraphNodeTypeMemFree = 11,

1481  hipGraphNodeTypeMemcpyFromSymbol = 12,

1482  hipGraphNodeTypeMemcpyToSymbol = 13,

1483  hipGraphNodeTypeBatchMemOp = 14,

1484  hipGraphNodeTypeCount

1485 } hipGraphNodeType;

1486 

1487 typedef void (*hipHostFn_t)(void* userData);

1488 typedef struct hipHostNodeParams {

1489  hipHostFn_t fn;

1490  void* userData;

1491 } hipHostNodeParams;

1492 typedef struct hipKernelNodeParams {

1493  dim3 blockDim;

1494  void** extra;

1495  void* func;

1496  dim3 gridDim;

1497  void** kernelParams;

1498  unsigned int sharedMemBytes;

1499 } hipKernelNodeParams;

1500 typedef struct hipMemsetParams {

1501  void* dst;

1502  unsigned int elementSize;

1503  size_t height;

1504  size_t pitch;

1505  unsigned int value;

1506  size_t width;

1507 } hipMemsetParams;

1508 

1509 typedef struct hipMemAllocNodeParams {

1510  hipMemPoolProps poolProps;

1512  const hipMemAccessDesc* accessDescs;

1513  size_t accessDescCount;

1515  size_t bytesize;

1516  void* dptr;

1517 } hipMemAllocNodeParams;

1518 

1522 typedef enum hipAccessProperty {

1523  hipAccessPropertyNormal = 0,

1524  hipAccessPropertyStreaming = 1,

1525  hipAccessPropertyPersisting = 2,

1526 } hipAccessProperty;

1527 

1528 /***

1529  * Specifies access policy for a window, a contiguous extent of memory

1530  * beginning at base_ptr and ending at base_ptr + num_bytes.

1531  */

1532 typedef struct hipAccessPolicyWindow {

1533  void* base_ptr;

1534  hipAccessProperty hitProp;

1535  float hitRatio;

1536  hipAccessProperty missProp;

1537  size_t num_bytes;

1538 } hipAccessPolicyWindow;

1539 

1543 typedef struct hipLaunchMemSyncDomainMap {

1544  unsigned char default_;

1545  unsigned char remote;

1546 } hipLaunchMemSyncDomainMap;

1547 

1551 typedef enum hipLaunchMemSyncDomain {

1552  hipLaunchMemSyncDomainDefault = 0,

1553  hipLaunchMemSyncDomainRemote = 1

1554 } hipLaunchMemSyncDomain;

1555 

1560 typedef enum hipSynchronizationPolicy {

1561  hipSyncPolicyAuto = 1,

1562  hipSyncPolicySpin = 2,

1563  hipSyncPolicyYield = 3,

1564  hipSyncPolicyBlockingSync = 4

1565 } hipSynchronizationPolicy;

1566 

1570 typedef enum hipLaunchAttributeID {

1571  hipLaunchAttributeAccessPolicyWindow = 1,

1572  hipLaunchAttributeCooperative = 2,

1573  hipLaunchAttributeSynchronizationPolicy = 3,

1574  hipLaunchAttributePriority = 8,

1575  hipLaunchAttributeMemSyncDomainMap = 9,

1576  hipLaunchAttributeMemSyncDomain = 10,

1577  hipLaunchAttributeMax

1578 } hipLaunchAttributeID;

1579 

1580 

1584 typedef union hipLaunchAttributeValue {

1585  char pad[64];

1586  hipAccessPolicyWindow

1587  accessPolicyWindow;

1588  int cooperative;

1590  int priority;

1592  hipSynchronizationPolicy

1593  syncPolicy;

1595  hipLaunchMemSyncDomainMap

1596  memSyncDomainMap;

1597  hipLaunchMemSyncDomain

1598  memSyncDomain;

1599 } hipLaunchAttributeValue;

1600 

1604 #define hipStreamAttrID hipLaunchAttributeID

1605 #define hipStreamAttributeAccessPolicyWindow hipLaunchAttributeAccessPolicyWindow

1606 #define hipStreamAttributeSynchronizationPolicy hipLaunchAttributeSynchronizationPolicy

1607 #define hipStreamAttributeMemSyncDomainMap hipLaunchAttributeMemSyncDomainMap

1608 #define hipStreamAttributeMemSyncDomain hipLaunchAttributeMemSyncDomain

1609 #define hipStreamAttributePriority hipLaunchAttributePriority

1610 

1611 #define hipStreamAttrValue hipLaunchAttributeValue

1612 

1616 #define hipKernelNodeAttrID hipLaunchAttributeID

1617 #define hipKernelNodeAttributeAccessPolicyWindow hipLaunchAttributeAccessPolicyWindow

1618 #define hipKernelNodeAttributeCooperative hipLaunchAttributeCooperative

1619 #define hipKernelNodeAttributePriority hipLaunchAttributePriority

1620 

1624 #define hipKernelNodeAttrValue hipLaunchAttributeValue

1625 

1629 #define hipDrvLaunchAttributeCooperative hipLaunchAttributeCooperative

1630 

1631 #define hipDrvLaunchAttributeID hipLaunchAttributeID

1632 #define hipDrvLaunchAttributeValue hipLaunchAttributeValue

1633 #define hipDrvLaunchAttribute hipLaunchAttribute

1634 

1638 typedef enum hipGraphExecUpdateResult {

1639  hipGraphExecUpdateSuccess = 0x0,

1640  hipGraphExecUpdateError = 0x1,

1642  hipGraphExecUpdateErrorTopologyChanged = 0x2,

1643  hipGraphExecUpdateErrorNodeTypeChanged = 0x3,

1644  hipGraphExecUpdateErrorFunctionChanged =

1645  0x4,

1646  hipGraphExecUpdateErrorParametersChanged =

1647  0x5,

1648  hipGraphExecUpdateErrorNotSupported =

1649  0x6,

1650  hipGraphExecUpdateErrorUnsupportedFunctionChange = 0x7

1651 } hipGraphExecUpdateResult;

1652 

1653 typedef enum hipStreamCaptureMode {

1654  hipStreamCaptureModeGlobal = 0,

1655  hipStreamCaptureModeThreadLocal,

1656  hipStreamCaptureModeRelaxed

1657 } hipStreamCaptureMode;

1658 typedef enum hipStreamCaptureStatus {

1659  hipStreamCaptureStatusNone = 0,

1660  hipStreamCaptureStatusActive,

1661  hipStreamCaptureStatusInvalidated

1663 } hipStreamCaptureStatus;

1664 

1665 typedef enum hipStreamUpdateCaptureDependenciesFlags {

1666  hipStreamAddCaptureDependencies = 0,

1667  hipStreamSetCaptureDependencies,

1668 } hipStreamUpdateCaptureDependenciesFlags;

1669 

1670 typedef enum hipGraphMemAttributeType {

1671  hipGraphMemAttrUsedMemCurrent =

1672  0,

1673  hipGraphMemAttrUsedMemHigh,

1675  hipGraphMemAttrReservedMemCurrent,

1677  hipGraphMemAttrReservedMemHigh,

1679 } hipGraphMemAttributeType;

1680 typedef enum hipUserObjectFlags {

1681  hipUserObjectNoDestructorSync = 0x1,

1682 } hipUserObjectFlags;

1683 

1684 typedef enum hipUserObjectRetainFlags {

1685  hipGraphUserObjectMove = 0x1,

1686 } hipUserObjectRetainFlags;

1687 

1688 typedef enum hipGraphInstantiateFlags {

1689  hipGraphInstantiateFlagAutoFreeOnLaunch =

1690  1,

1691  hipGraphInstantiateFlagUpload = 2,

1692  hipGraphInstantiateFlagDeviceLaunch =

1693  4,

1694  hipGraphInstantiateFlagUseNodePriority =

1695  8,

1697 } hipGraphInstantiateFlags;

1698 

1699 enum hipGraphDebugDotFlags {

1700  hipGraphDebugDotFlagsVerbose =

1701  1 << 0,

1702  hipGraphDebugDotFlagsKernelNodeParams = 1 << 2,

1703  hipGraphDebugDotFlagsMemcpyNodeParams = 1 << 3,

1704  hipGraphDebugDotFlagsMemsetNodeParams = 1 << 4,

1705  hipGraphDebugDotFlagsHostNodeParams = 1 << 5,

1706  hipGraphDebugDotFlagsEventNodeParams =

1707  1 << 6,

1708  hipGraphDebugDotFlagsExtSemasSignalNodeParams =

1709  1 << 7,

1710  hipGraphDebugDotFlagsExtSemasWaitNodeParams =

1711  1 << 8,

1712  hipGraphDebugDotFlagsKernelNodeAttributes =

1713  1 << 9,

1714  hipGraphDebugDotFlagsHandles =

1715  1 << 10

1716 };

1717 

1721 typedef enum hipGraphInstantiateResult {

1722  hipGraphInstantiateSuccess = 0,

1723  hipGraphInstantiateError = 1,

1725  hipGraphInstantiateInvalidStructure = 2,

1727  hipGraphInstantiateNodeOperationNotSupported = 3,

1729  hipGraphInstantiateMultipleDevicesNotSupported = 4,

1731 } hipGraphInstantiateResult;

1732 

1736 typedef struct hipGraphInstantiateParams {

1737  hipGraphNode_t errNode_out;

1738  unsigned long long flags;

1739  hipGraphInstantiateResult result_out;

1741  hipStream_t uploadStream;

1742 } hipGraphInstantiateParams;

1743 

1744 

1748 typedef struct hipMemAllocationProp {

1749  hipMemAllocationType type;

1750  union {

1751  hipMemAllocationHandleType requestedHandleType;

1752  hipMemAllocationHandleType requestedHandleTypes;

1753  };

1754  hipMemLocation location;

1755  void* win32HandleMetaData;

1756  struct {

1757  unsigned char compressionType;

1758  unsigned char gpuDirectRDMACapable;

1759  unsigned short usage;

1760  } allocFlags;

1761 } hipMemAllocationProp;

1762 

1766 typedef struct hipExternalSemaphoreSignalNodeParams {

1768  hipExternalSemaphore_t* extSemArray;

1770  const hipExternalSemaphoreSignalParams* paramsArray;

1772  unsigned int numExtSems;

1773 } hipExternalSemaphoreSignalNodeParams;

1774 

1778 typedef struct hipExternalSemaphoreWaitNodeParams {

1780  hipExternalSemaphore_t* extSemArray;

1782  const hipExternalSemaphoreWaitParams* paramsArray;

1784  unsigned int numExtSems;

1785 } hipExternalSemaphoreWaitNodeParams;

1786 

1790 typedef struct ihipMemGenericAllocationHandle* hipMemGenericAllocationHandle_t;

1791 

1795 typedef enum hipMemAllocationGranularity_flags {

1796  hipMemAllocationGranularityMinimum = 0x0,

1797  hipMemAllocationGranularityRecommended = 0x1

1798 } hipMemAllocationGranularity_flags;

1799 

1803 typedef enum hipMemHandleType {

1804  hipMemHandleTypeGeneric = 0x0

1805 } hipMemHandleType;

1806 

1810 typedef enum hipMemOperationType {

1811  hipMemOperationTypeMap = 0x1,

1812  hipMemOperationTypeUnmap = 0x2

1813 } hipMemOperationType;

1814 

1818 typedef enum hipArraySparseSubresourceType {

1819  hipArraySparseSubresourceTypeSparseLevel = 0x0,

1820  hipArraySparseSubresourceTypeMiptail = 0x1

1821 } hipArraySparseSubresourceType;

1822 

1826 typedef struct hipArrayMapInfo {

1827  hipResourceType resourceType;

1828  union {

1829  hipMipmappedArray mipmap;

1830  hipArray_t array;

1831  } resource;

1832  hipArraySparseSubresourceType subresourceType;

1833  union {

1834  struct {

1835  unsigned int

1836  level;

1837  unsigned int

1838  layer;

1839  unsigned int offsetX;

1840  unsigned int offsetY;

1841  unsigned int offsetZ;

1842  unsigned int extentWidth;

1843  unsigned int extentHeight;

1844  unsigned int extentDepth;

1845  } sparseLevel;

1846  struct {

1847  unsigned int

1848  layer;

1849  unsigned long long offset;

1850  unsigned long long size;

1851  } miptail;

1852  } subresource;

1853  hipMemOperationType memOperationType;

1854  hipMemHandleType memHandleType;

1855  union {

1856  hipMemGenericAllocationHandle_t memHandle;

1857  } memHandle;

1858  unsigned long long offset;

1859  unsigned int deviceBitMask;

1860  unsigned int flags;

1861  unsigned int reserved[2];

1862 } hipArrayMapInfo;

1863 

1867 typedef struct hipMemcpyNodeParams {

1868  int flags;

1869  int reserved[3];

1870  hipMemcpy3DParms copyParams;

1871 } hipMemcpyNodeParams;

1872 

1876 typedef struct hipChildGraphNodeParams {

1877  hipGraph_t graph;

1879 } hipChildGraphNodeParams;

1880 

1884 typedef struct hipEventWaitNodeParams {

1885  hipEvent_t event;

1886 } hipEventWaitNodeParams;

1887 

1891 typedef struct hipEventRecordNodeParams {

1892  hipEvent_t event;

1893 } hipEventRecordNodeParams;

1894 

1898 typedef struct hipMemFreeNodeParams {

1899  void* dptr;

1900 } hipMemFreeNodeParams;

1901 

1905 typedef struct hipGraphNodeParams {

1906  hipGraphNodeType type;

1907  int reserved0[3];

1908  union {

1909  long long reserved1[29];

1910  hipKernelNodeParams kernel;

1911  hipMemcpyNodeParams memcpy;

1912  hipMemsetParams memset;

1913  hipHostNodeParams host;

1914  hipChildGraphNodeParams graph;

1915  hipEventWaitNodeParams eventWait;

1916  hipEventRecordNodeParams eventRecord;

1917  hipExternalSemaphoreSignalNodeParams extSemSignal;

1918  hipExternalSemaphoreWaitNodeParams extSemWait;

1919  hipMemAllocNodeParams alloc;

1920  hipMemFreeNodeParams free;

1921  };

1922 

1923  long long reserved2;

1924 } hipGraphNodeParams;

1925 

1929 #define hipGraphKernelNodePortDefault 0

1930 

1934 #define hipGraphKernelNodePortLaunchCompletion 2

1935 

1941 #define hipGraphKernelNodePortProgrammatic 1

1942 

1943 typedef enum hipGraphDependencyType {

1944  hipGraphDependencyTypeDefault = 0,

1945  hipGraphDependencyTypeProgrammatic = 1

1946 } hipGraphDependencyType;

1947 

1948 typedef struct hipGraphEdgeData {

1949  unsigned char

1950  from_port;

1957  unsigned char reserved[5];

1958  unsigned char

1959  to_port;

1960  unsigned char type;

1961 } hipGraphEdgeData;

1962 

1963 

1967 typedef struct hipLaunchAttribute_st {

1968  hipLaunchAttributeID id;

1969  char pad[8 - sizeof(hipLaunchAttributeID)];

1970  union {

1971  hipLaunchAttributeValue val;

1972  hipLaunchAttributeValue value;

1973  };

1974 } hipLaunchAttribute;

1975 

1979 typedef struct hipLaunchConfig_st {

1980  dim3 gridDim;

1981  dim3 blockDim;

1982  size_t dynamicSmemBytes;

1983  hipStream_t stream;

1984  hipLaunchAttribute* attrs;

1985  unsigned int numAttrs;

1986 } hipLaunchConfig_t;

1987 

1991 typedef struct HIP_LAUNCH_CONFIG_st {

1992  unsigned int gridDimX;

1993  unsigned int gridDimY;

1994  unsigned int gridDimZ;

1995  unsigned int blockDimX;

1996  unsigned int blockDimY;

1997  unsigned int blockDimZ;

1998  unsigned int sharedMemBytes;

1999  hipStream_t hStream;

2000  hipLaunchAttribute* attrs;

2001  unsigned int numAttrs;

2002 } HIP_LAUNCH_CONFIG;

2003 

2007 typedef enum hipMemRangeHandleType {

2008  hipMemRangeHandleTypeDmaBufFd = 0x1,

2009  hipMemRangeHandleTypeMax = 0x7fffffff

2010 } hipMemRangeHandleType;

2011 

2015 typedef enum hipMemRangeFlags {

2016  hipMemRangeFlagDmaBufMappingTypePcie = 0x1,

2017  hipMemRangeFlagsMax = 0x7fffffff

2018 } hipMemRangeFlags;

2019 

2020 // Doxygen end group GlobalDefs

2046 // TODO-ctx - more description on error codes.

2047 hipError_t hipInit(unsigned int flags);

2048 

2066 hipError_t hipDriverGetVersion(int* driverVersion);

2081 hipError_t hipRuntimeGetVersion(int* runtimeVersion);

2089 hipError_t hipDeviceGet(hipDevice_t* device, int ordinal);

2090 

2099 hipError_t hipDeviceComputeCapability(int* major, int* minor, hipDevice_t device);

2108 hipError_t hipDeviceGetName(char* name, int len, hipDevice_t device);

2120 hipError_t hipDeviceGetUuid(hipUUID* uuid, hipDevice_t device);

2130 hipError_t hipDeviceGetP2PAttribute(int* value, hipDeviceP2PAttr attr, int srcDevice,

2131  int dstDevice);

2140 hipError_t hipDeviceGetPCIBusId(char* pciBusId, int len, int device);

2148 hipError_t hipDeviceGetByPCIBusId(int* device, const char* pciBusId);

2156 hipError_t hipDeviceTotalMem(size_t* bytes, hipDevice_t device);

2157 // doxygen end initialization

2176 hipError_t hipDeviceSynchronize(void);

2188 hipError_t hipDeviceReset(void);

2220 hipError_t hipSetDevice(int deviceId);

2233 hipError_t hipSetValidDevices(int* device_arr, int len);

2247 hipError_t hipGetDevice(int* deviceId);

2260 hipError_t hipGetDeviceCount(int* count);

2270 hipError_t hipDeviceGetAttribute(int* pi, hipDeviceAttribute_t attr, int deviceId);

2285 hipError_t hipDeviceGetDefaultMemPool(hipMemPool_t* mem_pool, int device);

2307 hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool);

2327 hipError_t hipDeviceGetMemPool(hipMemPool_t* mem_pool, int device);

2341 hipError_t hipGetDeviceProperties(hipDeviceProp_t* prop, int deviceId);

2358 hipError_t hipDeviceGetTexture1DLinearMaxWidth(size_t* max_width, const hipChannelFormatDesc* desc,

2359  int device);

2371 hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig);

2382 hipError_t hipDeviceGetCacheConfig(hipFuncCache_t* cacheConfig);

2396 hipError_t hipDeviceGetLimit(size_t* pValue, enum hipLimit_t limit);

2416 hipError_t hipDeviceSetLimit(enum hipLimit_t limit, size_t value);

2428 hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig* pConfig);

2436 hipError_t hipGetDeviceFlags(unsigned int* flags);

2448 hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config);

2480 hipError_t hipSetDeviceFlags(unsigned flags);

2489 hipError_t hipChooseDevice(int* device, const hipDeviceProp_t* prop);

2503 hipError_t hipExtGetLinkTypeAndHopCount(int device1, int device2, uint32_t* linktype,

2504  uint32_t* hopcount);

2505 // TODO: implement IPC apis

2529 hipError_t hipIpcGetMemHandle(hipIpcMemHandle_t* handle, void* devPtr);

2565 hipError_t hipIpcOpenMemHandle(void** devPtr, hipIpcMemHandle_t handle, unsigned int flags);

2583 hipError_t hipIpcCloseMemHandle(void* devPtr);

2584 

2601 hipError_t hipIpcGetEventHandle(hipIpcEventHandle_t* handle, hipEvent_t event);

2602 

2621 hipError_t hipIpcOpenEventHandle(hipEvent_t* event, hipIpcEventHandle_t handle);

2622 

2623 // end doxygen Device

2647 hipError_t hipFuncSetAttribute(const void* func, hipFuncAttribute attr, int value);

2659 hipError_t hipFuncSetCacheConfig(const void* func, hipFuncCache_t config);

2672 hipError_t hipFuncSetSharedMemConfig(const void* func, hipSharedMemConfig config);

2673 // doxygen end execution

2695 hipError_t hipGetLastError(void);

2696 

2708 hipError_t hipExtGetLastError(void);

2709 

2720 hipError_t hipPeekAtLastError(void);

2729 const char* hipGetErrorName(hipError_t hip_error);

2738 const char* hipGetErrorString(hipError_t hipError);

2748 hipError_t hipDrvGetErrorName(hipError_t hipError, const char** errorString);

2758 hipError_t hipDrvGetErrorString(hipError_t hipError, const char** errorString);

2759 // end doxygen Error

2792 hipError_t hipStreamCreate(hipStream_t* stream);

2813 hipError_t hipStreamCreateWithFlags(hipStream_t* stream, unsigned int flags);

2835 hipError_t hipStreamCreateWithPriority(hipStream_t* stream, unsigned int flags, int priority);

2854 hipError_t hipDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority);

2872 hipError_t hipStreamDestroy(hipStream_t stream);

2888 hipError_t hipStreamQuery(hipStream_t stream);

2910 hipError_t hipStreamSynchronize(hipStream_t stream);

2937 hipError_t hipStreamWaitEvent(hipStream_t stream, hipEvent_t event, unsigned int flags __dparm(0));

2947 hipError_t hipStreamGetFlags(hipStream_t stream, unsigned int* flags);

2957 hipError_t hipStreamGetId(hipStream_t stream, unsigned long long* streamId);

2969 hipError_t hipStreamGetPriority(hipStream_t stream, int* priority);

2980 hipError_t hipStreamGetDevice(hipStream_t stream, hipDevice_t* device);

2999 hipError_t hipExtStreamCreateWithCUMask(hipStream_t* stream, uint32_t cuMaskSize,

3000  const uint32_t* cuMask);

3013 hipError_t hipExtStreamGetCUMask(hipStream_t stream, uint32_t cuMaskSize, uint32_t* cuMask);

3017 typedef void (*hipStreamCallback_t)(hipStream_t stream, hipError_t status, void* userData);

3033 hipError_t hipStreamAddCallback(hipStream_t stream, hipStreamCallback_t callback, void* userData,

3034  unsigned int flags);

3035 

3043 hipError_t hipStreamSetAttribute(hipStream_t stream, hipStreamAttrID attr,

3044  const hipStreamAttrValue* value);

3045 

3053 hipError_t hipStreamGetAttribute(hipStream_t stream, hipStreamAttrID attr,

3054  hipStreamAttrValue* value_out);

3055 

3062 hipError_t hipStreamCopyAttributes(hipStream_t dst, hipStream_t src);

3063 

3064 // end doxygen Stream

3112 hipError_t hipStreamWaitValue32(hipStream_t stream, void* ptr, uint32_t value, unsigned int flags,

3113  uint32_t mask __dparm(0xFFFFFFFF));

3114 

3151 hipError_t hipStreamWaitValue64(hipStream_t stream, void* ptr, uint64_t value, unsigned int flags,

3152  uint64_t mask __dparm(0xFFFFFFFFFFFFFFFF));

3153 

3174 hipError_t hipStreamWriteValue32(hipStream_t stream, void* ptr, uint32_t value, unsigned int flags);

3195 hipError_t hipStreamWriteValue64(hipStream_t stream, void* ptr, uint64_t value, unsigned int flags);

3196 

3216 hipError_t hipStreamBatchMemOp(hipStream_t stream, unsigned int count,

3217  hipStreamBatchMemOpParams* paramArray, unsigned int flags);

3218 

3236 hipError_t hipGraphAddBatchMemOpNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

3237  const hipGraphNode_t* dependencies, size_t numDependencies,

3238  const hipBatchMemOpNodeParams* nodeParams);

3239 

3260 hipError_t hipGraphBatchMemOpNodeGetParams(hipGraphNode_t hNode,

3261  hipBatchMemOpNodeParams* nodeParams_out);

3262 

3280 hipError_t hipGraphBatchMemOpNodeSetParams(hipGraphNode_t hNode,

3281  hipBatchMemOpNodeParams* nodeParams);

3282 

3302 hipError_t hipGraphExecBatchMemOpNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

3303  const hipBatchMemOpNodeParams* nodeParams);

3304 

3305 // end doxygen Stream Memory Operations

3341 hipError_t hipEventCreateWithFlags(hipEvent_t* event, unsigned flags);

3353 hipError_t hipEventCreate(hipEvent_t* event);

3390 hipError_t hipEventRecordWithFlags(hipEvent_t event, hipStream_t stream __dparm(0),

3391  unsigned int flags __dparm(0));

3422 #ifdef __cplusplus

3423 hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream = NULL);

3424 #else

3425 hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream);

3426 #endif

3443 hipError_t hipEventDestroy(hipEvent_t event);

3462 hipError_t hipEventSynchronize(hipEvent_t event);

3491 hipError_t hipEventElapsedTime(float* ms, hipEvent_t start, hipEvent_t stop);

3508 hipError_t hipEventQuery(hipEvent_t event);

3509 // end doxygen Events

3540 hipError_t hipPointerSetAttribute(const void* value, hipPointer_attribute attribute,

3541  hipDeviceptr_t ptr);

3542 

3543 

3563 hipError_t hipPointerGetAttributes(hipPointerAttribute_t* attributes, const void* ptr);

3578 hipError_t hipPointerGetAttribute(void* data, hipPointer_attribute attribute, hipDeviceptr_t ptr);

3595 hipError_t hipDrvPointerGetAttributes(unsigned int numAttributes, hipPointer_attribute* attributes,

3596  void** data, hipDeviceptr_t ptr);

3620 hipError_t hipImportExternalSemaphore(hipExternalSemaphore_t* extSem_out,

3621  const hipExternalSemaphoreHandleDesc* semHandleDesc);

3637 hipError_t hipSignalExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

3638  const hipExternalSemaphoreSignalParams* paramsArray,

3639  unsigned int numExtSems, hipStream_t stream);

3655 hipError_t hipWaitExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

3656  const hipExternalSemaphoreWaitParams* paramsArray,

3657  unsigned int numExtSems, hipStream_t stream);

3671 hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem);

3672 

3684 hipError_t hipImportExternalMemory(hipExternalMemory_t* extMem_out,

3685  const hipExternalMemoryHandleDesc* memHandleDesc);

3697 hipError_t hipExternalMemoryGetMappedBuffer(void** devPtr, hipExternalMemory_t extMem,

3698  const hipExternalMemoryBufferDesc* bufferDesc);

3708 hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem);

3723 hipError_t hipExternalMemoryGetMappedMipmappedArray(

3724  hipMipmappedArray_t* mipmap, hipExternalMemory_t extMem,

3725  const hipExternalMemoryMipmappedArrayDesc* mipmapDesc);

3726 // end of external resource

3743 hipError_t hipMalloc(void** ptr, size_t size);

3763 hipError_t hipExtMallocWithFlags(void** ptr, size_t sizeBytes, unsigned int flags);

3764 

3765 

3788 HIP_DEPRECATED("use hipHostMalloc instead")

3789 hipError_t hipMallocHost(void** ptr, size_t size);

3802 HIP_DEPRECATED("use hipHostMalloc instead")

3803 hipError_t hipMemAllocHost(void** ptr, size_t size);

3804 // end doxygen deprecated management memory

3841 hipError_t hipHostMalloc(void** ptr, size_t size, unsigned int flags);

3876 hipError_t hipMallocManaged(void** dev_ptr, size_t size,

3877  unsigned int flags __dparm(hipMemAttachGlobal));

3890 hipError_t hipMemPrefetchAsync(const void* dev_ptr, size_t count, int device,

3891  hipStream_t stream __dparm(0));

3905 hipError_t hipMemPrefetchAsync_v2(const void* dev_ptr, size_t count, hipMemLocation location,

3906  unsigned int flags, hipStream_t stream __dparm(0));

3926 hipError_t hipMemAdvise(const void* dev_ptr, size_t count, hipMemoryAdvise advice, int device);

3946 hipError_t hipMemAdvise_v2(const void* dev_ptr, size_t count, hipMemoryAdvise advice,

3947  hipMemLocation location);

3962 hipError_t hipMemRangeGetAttribute(void* data, size_t data_size, hipMemRangeAttribute attribute,

3963  const void* dev_ptr, size_t count);

3980 hipError_t hipMemRangeGetAttributes(void** data, size_t* data_sizes,

3981  hipMemRangeAttribute* attributes, size_t num_attributes,

3982  const void* dev_ptr, size_t count);

3998 hipError_t hipStreamAttachMemAsync(hipStream_t stream, void* dev_ptr, size_t length __dparm(0),

3999  unsigned int flags __dparm(hipMemAttachSingle));

4000 // end doxygen Managed Memory

4060 hipError_t hipMallocAsync(void** dev_ptr, size_t size, hipStream_t stream);

4085 hipError_t hipFreeAsync(void* dev_ptr, hipStream_t stream);

4113 hipError_t hipMemPoolTrimTo(hipMemPool_t mem_pool, size_t min_bytes_to_hold);

4152 hipError_t hipMemPoolSetAttribute(hipMemPool_t mem_pool, hipMemPoolAttr attr, void* value);

4192 hipError_t hipMemPoolGetAttribute(hipMemPool_t mem_pool, hipMemPoolAttr attr, void* value);

4211 hipError_t hipMemPoolSetAccess(hipMemPool_t mem_pool, const hipMemAccessDesc* desc_list,

4212  size_t count);

4232 hipError_t hipMemPoolGetAccess(hipMemAccessFlags* flags, hipMemPool_t mem_pool,

4233  hipMemLocation* location);

4258 hipError_t hipMemPoolCreate(hipMemPool_t* mem_pool, const hipMemPoolProps* pool_props);

4286 hipError_t hipMemPoolDestroy(hipMemPool_t mem_pool);

4322 hipError_t hipMallocFromPoolAsync(void** dev_ptr, size_t size, hipMemPool_t mem_pool,

4323  hipStream_t stream);

4350 hipError_t hipMemPoolExportToShareableHandle(void* shared_handle, hipMemPool_t mem_pool,

4351  hipMemAllocationHandleType handle_type,

4352  unsigned int flags);

4376 hipError_t hipMemPoolImportFromShareableHandle(hipMemPool_t* mem_pool, void* shared_handle,

4377  hipMemAllocationHandleType handle_type,

4378  unsigned int flags);

4398 hipError_t hipMemPoolExportPointer(hipMemPoolPtrExportData* export_data, void* dev_ptr);

4427 hipError_t hipMemPoolImportPointer(void** dev_ptr, hipMemPool_t mem_pool,

4428  hipMemPoolPtrExportData* export_data);

4429 // Doxygen end of ordered memory allocator

4453 hipError_t hipHostAlloc(void** ptr, size_t size, unsigned int flags);

4465 hipError_t hipHostGetDevicePointer(void** devPtr, void* hstPtr, unsigned int flags);

4475 hipError_t hipHostGetFlags(unsigned int* flagsPtr, void* hostPtr);

4513 hipError_t hipHostRegister(void* hostPtr, size_t sizeBytes, unsigned int flags);

4522 hipError_t hipHostUnregister(void* hostPtr);

4541 hipError_t hipMallocPitch(void** ptr, size_t* pitch, size_t width, size_t height);

4564 hipError_t hipMemAllocPitch(hipDeviceptr_t* dptr, size_t* pitch, size_t widthInBytes, size_t height,

4565  unsigned int elementSizeBytes);

4579 hipError_t hipFree(void* ptr);

4591 hipError_t hipFreeHost(void* ptr);

4608 hipError_t hipHostFree(void* ptr);

4638 hipError_t hipMemcpy(void* dst, const void* src, size_t sizeBytes, hipMemcpyKind kind);

4654 hipError_t hipMemcpyWithStream(void* dst, const void* src, size_t sizeBytes, hipMemcpyKind kind,

4655  hipStream_t stream);

4673 hipError_t hipMemcpyHtoD(hipDeviceptr_t dst, const void* src, size_t sizeBytes);

4691 hipError_t hipMemcpyDtoH(void* dst, hipDeviceptr_t src, size_t sizeBytes);

4709 hipError_t hipMemcpyDtoD(hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes);

4728 hipError_t hipMemcpyAtoD(hipDeviceptr_t dstDevice, hipArray_t srcArray, size_t srcOffset,

4729  size_t ByteCount);

4748 hipError_t hipMemcpyDtoA(hipArray_t dstArray, size_t dstOffset, hipDeviceptr_t srcDevice,

4749  size_t ByteCount);

4750 

4770 hipError_t hipMemcpyAtoA(hipArray_t dstArray, size_t dstOffset, hipArray_t srcArray,

4771  size_t srcOffset, size_t ByteCount);

4790 hipError_t hipMemcpyHtoDAsync(hipDeviceptr_t dst, const void* src, size_t sizeBytes,

4791  hipStream_t stream);

4810 hipError_t hipMemcpyDtoHAsync(void* dst, hipDeviceptr_t src, size_t sizeBytes, hipStream_t stream);

4829 hipError_t hipMemcpyDtoDAsync(hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes,

4830  hipStream_t stream);

4850 hipError_t hipMemcpyAtoHAsync(void* dstHost, hipArray_t srcArray, size_t srcOffset,

4851  size_t ByteCount, hipStream_t stream);

4871 hipError_t hipMemcpyHtoAAsync(hipArray_t dstArray, size_t dstOffset, const void* srcHost,

4872  size_t ByteCount, hipStream_t stream);

4889 hipError_t hipModuleGetGlobal(hipDeviceptr_t* dptr, size_t* bytes, hipModule_t hmod,

4890  const char* name);

4891 

4901 hipError_t hipGetSymbolAddress(void** devPtr, const void* symbol);

4902 

4903 

4913 hipError_t hipGetSymbolSize(size_t* size, const void* symbol);

4914 

4934 hipError_t hipGetProcAddress(const char* symbol, void** pfn, int hipVersion, uint64_t flags,

4935  hipDriverProcAddressQueryResult* symbolStatus);

4936 

4958 hipError_t hipMemcpyToSymbol(const void* symbol, const void* src, size_t sizeBytes,

4959  size_t offset __dparm(0),

4960  hipMemcpyKind kind __dparm(hipMemcpyHostToDevice));

4961 

4975 hipError_t hipMemcpyToSymbolAsync(const void* symbol, const void* src, size_t sizeBytes,

4976  size_t offset, hipMemcpyKind kind, hipStream_t stream __dparm(0));

4977 

4990 hipError_t hipMemcpyFromSymbol(void* dst, const void* symbol, size_t sizeBytes,

4991  size_t offset __dparm(0),

4992  hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost));

4993 

5007 hipError_t hipMemcpyFromSymbolAsync(void* dst, const void* symbol, size_t sizeBytes, size_t offset,

5008  hipMemcpyKind kind, hipStream_t stream __dparm(0));

5037 hipError_t hipMemcpyAsync(void* dst, const void* src, size_t sizeBytes, hipMemcpyKind kind,

5038  hipStream_t stream __dparm(0));

5048 hipError_t hipMemset(void* dst, int value, size_t sizeBytes);

5058 hipError_t hipMemsetD8(hipDeviceptr_t dest, unsigned char value, size_t count);

5074 hipError_t hipMemsetD8Async(hipDeviceptr_t dest, unsigned char value, size_t count,

5075  hipStream_t stream __dparm(0));

5085 hipError_t hipMemsetD16(hipDeviceptr_t dest, unsigned short value, size_t count);

5101 hipError_t hipMemsetD16Async(hipDeviceptr_t dest, unsigned short value, size_t count,

5102  hipStream_t stream __dparm(0));

5112 hipError_t hipMemsetD32(hipDeviceptr_t dest, int value, size_t count);

5128 hipError_t hipMemsetAsync(void* dst, int value, size_t sizeBytes, hipStream_t stream __dparm(0));

5144 hipError_t hipMemsetD32Async(hipDeviceptr_t dst, int value, size_t count,

5145  hipStream_t stream __dparm(0));

5156 hipError_t hipMemset2D(void* dst, size_t pitch, int value, size_t width, size_t height);

5168 hipError_t hipMemset2DAsync(void* dst, size_t pitch, int value, size_t width, size_t height,

5169  hipStream_t stream __dparm(0));

5178 hipError_t hipMemset3D(hipPitchedPtr pitchedDevPtr, int value, hipExtent extent);

5188 hipError_t hipMemset3DAsync(hipPitchedPtr pitchedDevPtr, int value, hipExtent extent,

5189  hipStream_t stream __dparm(0));

5190 

5202 hipError_t hipMemsetD2D8(hipDeviceptr_t dst, size_t dstPitch, unsigned char value, size_t width,

5203  size_t height);

5216 hipError_t hipMemsetD2D8Async(hipDeviceptr_t dst, size_t dstPitch, unsigned char value,

5217  size_t width, size_t height, hipStream_t stream __dparm(0));

5218 

5230 hipError_t hipMemsetD2D16(hipDeviceptr_t dst, size_t dstPitch, unsigned short value, size_t width,

5231  size_t height);

5244 hipError_t hipMemsetD2D16Async(hipDeviceptr_t dst, size_t dstPitch, unsigned short value,

5245  size_t width, size_t height, hipStream_t stream __dparm(0));

5257 hipError_t hipMemsetD2D32(hipDeviceptr_t dst, size_t dstPitch, unsigned int value, size_t width,

5258  size_t height);

5271 hipError_t hipMemsetD2D32Async(hipDeviceptr_t dst, size_t dstPitch, unsigned int value,

5272  size_t width, size_t height, hipStream_t stream __dparm(0));

5273 

5290 hipError_t hipMemGetInfo(size_t* free, size_t* total);

5291 

5303 hipError_t hipMemPtrGetInfo(void* ptr, size_t* size);

5316 hipError_t hipMallocArray(hipArray_t* array, const hipChannelFormatDesc* desc, size_t width,

5317  size_t height __dparm(0), unsigned int flags __dparm(hipArrayDefault));

5328 hipError_t hipArrayCreate(hipArray_t* pHandle, const HIP_ARRAY_DESCRIPTOR* pAllocateArray);

5338 hipError_t hipArrayDestroy(hipArray_t array);

5349 hipError_t hipArray3DCreate(hipArray_t* array, const HIP_ARRAY3D_DESCRIPTOR* pAllocateArray);

5360 hipError_t hipMalloc3D(hipPitchedPtr* pitchedDevPtr, hipExtent extent);

5369 hipError_t hipFreeArray(hipArray_t array);

5381 hipError_t hipMalloc3DArray(hipArray_t* array, const struct hipChannelFormatDesc* desc,

5382  struct hipExtent extent, unsigned int flags);

5395 hipError_t hipArrayGetInfo(hipChannelFormatDesc* desc, hipExtent* extent, unsigned int* flags,

5396  hipArray_t array);

5414 hipError_t hipArrayGetDescriptor(HIP_ARRAY_DESCRIPTOR* pArrayDescriptor, hipArray_t array);

5432 hipError_t hipArray3DGetDescriptor(HIP_ARRAY3D_DESCRIPTOR* pArrayDescriptor, hipArray_t array);

5467 hipError_t hipMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width,

5468  size_t height, hipMemcpyKind kind);

5478 hipError_t hipMemcpyParam2D(const hip_Memcpy2D* pCopy);

5489 hipError_t hipMemcpyParam2DAsync(const hip_Memcpy2D* pCopy, hipStream_t stream __dparm(0));

5530 hipError_t hipMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width,

5531  size_t height, hipMemcpyKind kind, hipStream_t stream __dparm(0));

5549 hipError_t hipMemcpy2DToArray(hipArray_t dst, size_t wOffset, size_t hOffset, const void* src,

5550  size_t spitch, size_t width, size_t height, hipMemcpyKind kind);

5569 hipError_t hipMemcpy2DToArrayAsync(hipArray_t dst, size_t wOffset, size_t hOffset, const void* src,

5570  size_t spitch, size_t width, size_t height, hipMemcpyKind kind,

5571  hipStream_t stream __dparm(0));

5590 hipError_t hipMemcpy2DArrayToArray(hipArray_t dst, size_t wOffsetDst, size_t hOffsetDst,

5591  hipArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc,

5592  size_t width, size_t height, hipMemcpyKind kind);

5611 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5612 hipError_t hipMemcpyToArray(hipArray_t dst, size_t wOffset, size_t hOffset, const void* src,

5613  size_t count, hipMemcpyKind kind);

5632 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5633 hipError_t hipMemcpyFromArray(void* dst, hipArray_const_t srcArray, size_t wOffset, size_t hOffset,

5634  size_t count, hipMemcpyKind kind);

5652 hipError_t hipMemcpy2DFromArray(void* dst, size_t dpitch, hipArray_const_t src, size_t wOffset,

5653  size_t hOffset, size_t width, size_t height, hipMemcpyKind kind);

5672 hipError_t hipMemcpy2DFromArrayAsync(void* dst, size_t dpitch, hipArray_const_t src, size_t wOffset,

5673  size_t hOffset, size_t width, size_t height,

5674  hipMemcpyKind kind, hipStream_t stream __dparm(0));

5688 hipError_t hipMemcpyAtoH(void* dst, hipArray_t srcArray, size_t srcOffset, size_t count);

5702 hipError_t hipMemcpyHtoA(hipArray_t dstArray, size_t dstOffset, const void* srcHost, size_t count);

5713 hipError_t hipMemcpy3D(const struct hipMemcpy3DParms* p);

5725 hipError_t hipMemcpy3DAsync(const struct hipMemcpy3DParms* p, hipStream_t stream __dparm(0));

5736 hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D* pCopy);

5748 hipError_t hipDrvMemcpy3DAsync(const HIP_MEMCPY3D* pCopy, hipStream_t stream);

5761 hipError_t hipMemGetAddressRange(hipDeviceptr_t* pbase, size_t* psize, hipDeviceptr_t dptr);

5762 

5778 hipError_t hipMemcpyBatchAsync(void** dsts, void** srcs, size_t* sizes, size_t count,

5779  hipMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs,

5780  size_t* failIdx, hipStream_t stream __dparm(0));

5781 

5794 hipError_t hipMemcpy3DBatchAsync(size_t numOps, struct hipMemcpy3DBatchOp* opList, size_t* failIdx,

5795  unsigned long long flags, hipStream_t stream __dparm(0));

5796 

5805 hipError_t hipMemcpy3DPeer(hipMemcpy3DPeerParms* p);

5806 

5815 hipError_t hipMemcpy3DPeerAsync(hipMemcpy3DPeerParms* p, hipStream_t stream __dparm(0));

5816 // doxygen end Memory

5851 hipError_t hipDeviceCanAccessPeer(int* canAccessPeer, int deviceId, int peerDeviceId);

5866 hipError_t hipDeviceEnablePeerAccess(int peerDeviceId, unsigned int flags);

5877 hipError_t hipDeviceDisablePeerAccess(int peerDeviceId);

5878 

5890 hipError_t hipMemcpyPeer(void* dst, int dstDeviceId, const void* src, int srcDeviceId,

5891  size_t sizeBytes);

5904 hipError_t hipMemcpyPeerAsync(void* dst, int dstDeviceId, const void* src, int srcDevice,

5905  size_t sizeBytes, hipStream_t stream __dparm(0));

5906 

5907 // doxygen end PeerToPeer

5948 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5949 hipError_t hipCtxCreate(hipCtx_t* ctx, unsigned int flags, hipDevice_t device);

5963 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5964 hipError_t hipCtxDestroy(hipCtx_t ctx);

5978 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5979 hipError_t hipCtxPopCurrent(hipCtx_t* ctx);

5993 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5994 hipError_t hipCtxPushCurrent(hipCtx_t ctx);

6008 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6009 hipError_t hipCtxSetCurrent(hipCtx_t ctx);

6023 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6024 hipError_t hipCtxGetCurrent(hipCtx_t* ctx);

6038 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6039 hipError_t hipCtxGetDevice(hipDevice_t* device);

6060 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6061 hipError_t hipCtxGetApiVersion(hipCtx_t ctx, unsigned int* apiVersion);

6078 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6079 hipError_t hipCtxGetCacheConfig(hipFuncCache_t* cacheConfig);

6096 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6097 hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig);

6114 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6115 hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config);

6132 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6133 hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig* pConfig);

6148 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6149 hipError_t hipCtxSynchronize(void);

6163 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6164 hipError_t hipCtxGetFlags(unsigned int* flags);

6187 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6188 hipError_t hipCtxEnablePeerAccess(hipCtx_t peerCtx, unsigned int flags);

6208 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6209 hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx);

6210 

6226 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6227 hipError_t hipDevicePrimaryCtxGetState(hipDevice_t dev, unsigned int* flags, int* active);

6243 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6244 hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev);

6259 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6260 hipError_t hipDevicePrimaryCtxRetain(hipCtx_t* pctx, hipDevice_t dev);

6274 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6275 hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev);

6290 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6291 hipError_t hipDevicePrimaryCtxSetFlags(hipDevice_t dev, unsigned int flags);

6292 // doxygen end Context Management

6316 hipError_t hipModuleLoadFatBinary(hipModule_t* module, const void* fatbin);

6330 hipError_t hipModuleLoad(hipModule_t* module, const char* fname);

6340 hipError_t hipModuleUnload(hipModule_t module);

6351 hipError_t hipModuleGetFunction(hipFunction_t* function, hipModule_t module, const char* kname);

6352 

6362 hipError_t hipModuleGetFunctionCount(unsigned int* count, hipModule_t mod);

6363 

6377 hipError_t hipLibraryLoadData(hipLibrary_t* library, const void* code, hipJitOption* jitOptions,

6378  void** jitOptionsValues, unsigned int numJitOptions,

6379  hipLibraryOption* libraryOptions, void** libraryOptionValues,

6380  unsigned int numLibraryOptions);

6381 

6395 hipError_t hipLibraryLoadFromFile(hipLibrary_t* library, const char* fileName,

6396  hipJitOption* jitOptions, void** jitOptionsValues,

6397  unsigned int numJitOptions, hipLibraryOption* libraryOptions,

6398  void** libraryOptionValues, unsigned int numLibraryOptions);

6399 

6406 hipError_t hipLibraryUnload(hipLibrary_t library);

6407 

6416 hipError_t hipLibraryGetKernel(hipKernel_t* pKernel, hipLibrary_t library, const char* name);

6417 

6425 hipError_t hipLibraryGetKernelCount(unsigned int *count, hipLibrary_t library);

6426 

6435 hipError_t hipLibraryEnumerateKernels(hipKernel_t* kernels, unsigned int numKernels,

6436  hipLibrary_t library);

6437 

6445 hipError_t hipKernelGetLibrary(hipLibrary_t* library, hipKernel_t kernel);

6446 

6454 hipError_t hipKernelGetName(const char** name, hipKernel_t kernel);

6455 

6464 hipError_t hipFuncGetAttributes(struct hipFuncAttributes* attr, const void* func);

6474 hipError_t hipFuncGetAttribute(int* value, hipFunction_attribute attrib, hipFunction_t hfunc);

6484 hipError_t hipGetFuncBySymbol(hipFunction_t* functionPtr, const void* symbolPtr);

6496 hipError_t hipGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags,

6497  hipDriverEntryPointQueryResult* driverStatus);

6507 hipError_t hipModuleGetTexRef(textureReference** texRef, hipModule_t hmod, const char* name);

6531 hipError_t hipModuleLoadData(hipModule_t* module, const void* image);

6544 hipError_t hipModuleLoadDataEx(hipModule_t* module, const void* image, unsigned int numOptions,

6545  hipJitOption* options, void** optionValues);

6564 hipError_t hipLinkAddData(hipLinkState_t state, hipJitInputType type, void* data, size_t size,

6565  const char* name, unsigned int numOptions, hipJitOption* options,

6566  void** optionValues);

6567 

6584 hipError_t hipLinkAddFile(hipLinkState_t state, hipJitInputType type, const char* path,

6585  unsigned int numOptions, hipJitOption* options, void** optionValues);

6586 

6601 hipError_t hipLinkComplete(hipLinkState_t state, void** hipBinOut, size_t* sizeOut);

6602 

6614 hipError_t hipLinkCreate(unsigned int numOptions, hipJitOption* options, void** optionValues,

6615  hipLinkState_t* stateOut);

6624 hipError_t hipLinkDestroy(hipLinkState_t state);

6625 

6654 hipError_t hipModuleLaunchKernel(hipFunction_t f, unsigned int gridDimX, unsigned int gridDimY,

6655  unsigned int gridDimZ, unsigned int blockDimX,

6656  unsigned int blockDimY, unsigned int blockDimZ,

6657  unsigned int sharedMemBytes, hipStream_t stream,

6658  void** kernelParams, void** extra);

6687 hipError_t hipModuleLaunchCooperativeKernel(hipFunction_t f, unsigned int gridDimX,

6688  unsigned int gridDimY, unsigned int gridDimZ,

6689  unsigned int blockDimX, unsigned int blockDimY,

6690  unsigned int blockDimZ, unsigned int sharedMemBytes,

6691  hipStream_t stream, void** kernelParams);

6706 hipError_t hipModuleLaunchCooperativeKernelMultiDevice(hipFunctionLaunchParams* launchParamsList,

6707  unsigned int numDevices, unsigned int flags);

6728 hipError_t hipLaunchCooperativeKernel(const void* f, dim3 gridDim, dim3 blockDimX,

6729  void** kernelParams, unsigned int sharedMemBytes,

6730  hipStream_t stream);

6742 hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList, int numDevices,

6743  unsigned int flags);

6744 

6745 // Doxygen end group ModuleCooperativeG

6759 hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList, int numDevices,

6760  unsigned int flags);

6774 hipError_t hipLaunchKernelExC(const hipLaunchConfig_t* config, const void* fPtr, void** args);

6790 hipError_t hipDrvLaunchKernelEx(const HIP_LAUNCH_CONFIG* config, hipFunction_t f, void** params,

6791  void** extra);

6806 hipError_t hipMemGetHandleForAddressRange(void* handle, hipDeviceptr_t dptr, size_t size,

6807  hipMemRangeHandleType handleType,

6808  unsigned long long flags);

6809 // doxygen end Module

6837 // TODO - Match CUoccupancyB2DSize

6838 hipError_t hipModuleOccupancyMaxPotentialBlockSize(int* gridSize, int* blockSize, hipFunction_t f,

6839  size_t dynSharedMemPerBlk, int blockSizeLimit);

6855 // TODO - Match CUoccupancyB2DSize

6856 hipError_t hipModuleOccupancyMaxPotentialBlockSizeWithFlags(int* gridSize, int* blockSize,

6857  hipFunction_t f,

6858  size_t dynSharedMemPerBlk,

6859  int blockSizeLimit, unsigned int flags);

6869 hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, hipFunction_t f,

6870  int blockSize,

6871  size_t dynSharedMemPerBlk);

6882 hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

6883  int* numBlocks, hipFunction_t f, int blockSize, size_t dynSharedMemPerBlk, unsigned int flags);

6893 hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* f,

6894  int blockSize, size_t dynSharedMemPerBlk);

6905 hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

6906  int* numBlocks, const void* f, int blockSize, size_t dynSharedMemPerBlk,

6907  unsigned int flags __dparm(hipOccupancyDefault));

6922 hipError_t hipOccupancyMaxPotentialBlockSize(int* gridSize, int* blockSize, const void* f,

6923  size_t dynSharedMemPerBlk, int blockSizeLimit);

6939 hipError_t hipOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* f,

6940  int numBlocks, int blockSize);

6941 // doxygen end Occupancy

6955 // TODO - expand descriptions:

6962 HIP_DEPRECATED("use roctracer/rocTX instead")

6963 hipError_t hipProfilerStart();

6970 HIP_DEPRECATED("use roctracer/rocTX instead")

6971 hipError_t hipProfilerStop();

6972 // doxygen end profiler

6999 hipError_t hipConfigureCall(dim3 gridDim, dim3 blockDim, size_t sharedMem __dparm(0),

7000  hipStream_t stream __dparm(0));

7011 hipError_t hipSetupArgument(const void* arg, size_t size, size_t offset);

7020 hipError_t hipLaunchByPtr(const void* func);

7037 hipError_t __hipPushCallConfiguration(dim3 gridDim, dim3 blockDim, size_t sharedMem __dparm(0),

7038  hipStream_t stream __dparm(0));

7058 hipError_t __hipPopCallConfiguration(dim3* gridDim, dim3* blockDim, size_t* sharedMem,

7059  hipStream_t* stream);

7076 hipError_t hipLaunchKernel(const void* function_address, dim3 numBlocks, dim3 dimBlocks,

7077  void** args, size_t sharedMemBytes __dparm(0),

7078  hipStream_t stream __dparm(0));

7079 

7106 hipError_t hipLaunchHostFunc(hipStream_t stream, hipHostFn_t fn, void* userData);

7107 

7115 hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D* pCopy);

7116 // TODO: Move this to hip_ext.h

7138 hipError_t hipExtLaunchKernel(const void* function_address, dim3 numBlocks, dim3 dimBlocks,

7139  void** args, size_t sharedMemBytes, hipStream_t stream,

7140  hipEvent_t startEvent, hipEvent_t stopEvent, int flags);

7141 // doxygen end Clang launch

7167 hipError_t hipCreateTextureObject(hipTextureObject_t* pTexObject, const hipResourceDesc* pResDesc,

7168  const hipTextureDesc* pTexDesc,

7169  const struct hipResourceViewDesc* pResViewDesc);

7170 

7179 hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject);

7180 

7190 hipError_t hipGetChannelDesc(hipChannelFormatDesc* desc, hipArray_const_t array);

7191 

7201 hipError_t hipGetTextureObjectResourceDesc(hipResourceDesc* pResDesc,

7202  hipTextureObject_t textureObject);

7203 

7213 hipError_t hipGetTextureObjectResourceViewDesc(struct hipResourceViewDesc* pResViewDesc,

7214  hipTextureObject_t textureObject);

7215 

7225 hipError_t hipGetTextureObjectTextureDesc(hipTextureDesc* pTexDesc,

7226  hipTextureObject_t textureObject);

7227 

7239 hipError_t hipTexObjectCreate(hipTextureObject_t* pTexObject, const HIP_RESOURCE_DESC* pResDesc,

7240  const HIP_TEXTURE_DESC* pTexDesc,

7241  const HIP_RESOURCE_VIEW_DESC* pResViewDesc);

7242 

7251 hipError_t hipTexObjectDestroy(hipTextureObject_t texObject);

7252 

7262 hipError_t hipTexObjectGetResourceDesc(HIP_RESOURCE_DESC* pResDesc, hipTextureObject_t texObject);

7263 

7273 hipError_t hipTexObjectGetResourceViewDesc(HIP_RESOURCE_VIEW_DESC* pResViewDesc,

7274  hipTextureObject_t texObject);

7275 

7285 hipError_t hipTexObjectGetTextureDesc(HIP_TEXTURE_DESC* pTexDesc, hipTextureObject_t texObject);

7286 

7301 hipError_t hipMallocMipmappedArray(hipMipmappedArray_t* mipmappedArray,

7302  const struct hipChannelFormatDesc* desc, struct hipExtent extent,

7303  unsigned int numLevels, unsigned int flags __dparm(0));

7304 

7315 hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray);

7316 

7329 hipError_t hipGetMipmappedArrayLevel(hipArray_t* levelArray,

7330  hipMipmappedArray_const_t mipmappedArray, unsigned int level);

7331 

7343 hipError_t hipMipmappedArrayCreate(hipMipmappedArray_t* pHandle,

7344  HIP_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc,

7345  unsigned int numMipmapLevels);

7346 

7357 hipError_t hipMipmappedArrayDestroy(hipMipmappedArray_t hMipmappedArray);

7358 

7371 hipError_t hipMipmappedArrayGetLevel(hipArray_t* pLevelArray, hipMipmappedArray_t hMipMappedArray,

7372  unsigned int level);

7373 

7392 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7393 hipError_t hipBindTextureToMipmappedArray(const textureReference* tex,

7394  hipMipmappedArray_const_t mipmappedArray,

7395  const hipChannelFormatDesc* desc);

7396 

7407 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7408 hipError_t hipGetTextureReference(const textureReference** texref, const void* symbol);

7409 

7420 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7421 hipError_t hipTexRefGetBorderColor(float* pBorderColor, const textureReference* texRef);

7422 

7434 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7435 hipError_t hipTexRefGetArray(hipArray_t* pArray, const textureReference* texRef);

7436 

7448 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7449 hipError_t hipTexRefSetAddressMode(textureReference* texRef, int dim,

7450  enum hipTextureAddressMode am);

7463 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7464 hipError_t hipTexRefSetArray(textureReference* tex, hipArray_const_t array, unsigned int flags);

7476 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7477 hipError_t hipTexRefSetFilterMode(textureReference* texRef, enum hipTextureFilterMode fm);

7489 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7490 hipError_t hipTexRefSetFlags(textureReference* texRef, unsigned int Flags);

7503 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7504 hipError_t hipTexRefSetFormat(textureReference* texRef, hipArray_Format fmt,

7505  int NumPackedComponents);

7520 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7521 hipError_t hipBindTexture(size_t* offset, const textureReference* tex, const void* devPtr,

7522  const hipChannelFormatDesc* desc, size_t size __dparm(UINT_MAX));

7539 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7540 hipError_t hipBindTexture2D(size_t* offset, const textureReference* tex, const void* devPtr,

7541  const hipChannelFormatDesc* desc, size_t width, size_t height,

7542  size_t pitch);

7555 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7556 hipError_t hipBindTextureToArray(const textureReference* tex, hipArray_const_t array,

7557  const hipChannelFormatDesc* desc);

7569 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7570 hipError_t hipGetTextureAlignmentOffset(size_t* offset, const textureReference* texref);

7581 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7582 hipError_t hipUnbindTexture(const textureReference* tex);

7594 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7595 hipError_t hipTexRefGetAddress(hipDeviceptr_t* dev_ptr, const textureReference* texRef);

7608 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7609 hipError_t hipTexRefGetAddressMode(enum hipTextureAddressMode* pam, const textureReference* texRef,

7610  int dim);

7622 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7623 hipError_t hipTexRefGetFilterMode(enum hipTextureFilterMode* pfm, const textureReference* texRef);

7635 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7636 hipError_t hipTexRefGetFlags(unsigned int* pFlags, const textureReference* texRef);

7649 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7650 hipError_t hipTexRefGetFormat(hipArray_Format* pFormat, int* pNumChannels,

7651  const textureReference* texRef);

7663 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7664 hipError_t hipTexRefGetMaxAnisotropy(int* pmaxAnsio, const textureReference* texRef);

7676 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7677 hipError_t hipTexRefGetMipmapFilterMode(enum hipTextureFilterMode* pfm,

7678  const textureReference* texRef);

7690 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7691 hipError_t hipTexRefGetMipmapLevelBias(float* pbias, const textureReference* texRef);

7704 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7705 hipError_t hipTexRefGetMipmapLevelClamp(float* pminMipmapLevelClamp, float* pmaxMipmapLevelClamp,

7706  const textureReference* texRef);

7718 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7719 hipError_t hipTexRefGetMipMappedArray(hipMipmappedArray_t* pArray, const textureReference* texRef);

7733 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7734 hipError_t hipTexRefSetAddress(size_t* ByteOffset, textureReference* texRef, hipDeviceptr_t dptr,

7735  size_t bytes);

7749 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7750 hipError_t hipTexRefSetAddress2D(textureReference* texRef, const HIP_ARRAY_DESCRIPTOR* desc,

7751  hipDeviceptr_t dptr, size_t Pitch);

7763 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7764 hipError_t hipTexRefSetMaxAnisotropy(textureReference* texRef, unsigned int maxAniso);

7776 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7777 hipError_t hipTexRefSetBorderColor(textureReference* texRef, float* pBorderColor);

7789 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7790 hipError_t hipTexRefSetMipmapFilterMode(textureReference* texRef, enum hipTextureFilterMode fm);

7802 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7803 hipError_t hipTexRefSetMipmapLevelBias(textureReference* texRef, float bias);

7816 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7817 hipError_t hipTexRefSetMipmapLevelClamp(textureReference* texRef, float minMipMapLevelClamp,

7818  float maxMipMapLevelClamp);

7831 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7832 hipError_t hipTexRefSetMipmappedArray(textureReference* texRef,

7833  struct hipMipmappedArray* mipmappedArray, unsigned int Flags);

7834 

7835 // doxygen end deprecated texture management

7840 // doxygen end Texture management

7852 // This group is for HIPrtc

7853 

7854 // doxygen end Runtime

7873 const char* hipApiName(uint32_t id);

7882 const char* hipKernelNameRef(const hipFunction_t f);

7892 const char* hipKernelNameRefByPtr(const void* hostFunction, hipStream_t stream);

7901 int hipGetStreamDeviceId(hipStream_t stream);

7902 

7903 // doxygen end Callback

7925 hipError_t hipStreamBeginCapture(hipStream_t stream, hipStreamCaptureMode mode);

7926 

7946 hipError_t hipStreamBeginCaptureToGraph(hipStream_t stream, hipGraph_t graph,

7947  const hipGraphNode_t* dependencies,

7948  const hipGraphEdgeData* dependencyData,

7949  size_t numDependencies, hipStreamCaptureMode mode);

7950 

7960 hipError_t hipStreamEndCapture(hipStream_t stream, hipGraph_t* pGraph);

7961 

7972 hipError_t hipStreamGetCaptureInfo(hipStream_t stream, hipStreamCaptureStatus* pCaptureStatus,

7973  unsigned long long* pId);

7974 

7989 hipError_t hipStreamGetCaptureInfo_v2(hipStream_t stream, hipStreamCaptureStatus* captureStatus_out,

7990  unsigned long long* id_out __dparm(0),

7991  hipGraph_t* graph_out __dparm(0),

7992  const hipGraphNode_t** dependencies_out __dparm(0),

7993  size_t* numDependencies_out __dparm(0));

7994 

8004 hipError_t hipStreamIsCapturing(hipStream_t stream, hipStreamCaptureStatus* pCaptureStatus);

8005 

8017 hipError_t hipStreamUpdateCaptureDependencies(hipStream_t stream, hipGraphNode_t* dependencies,

8018  size_t numDependencies,

8019  unsigned int flags __dparm(0));

8020 

8028 hipError_t hipThreadExchangeStreamCaptureMode(hipStreamCaptureMode* mode);

8029 

8039 hipError_t hipGraphCreate(hipGraph_t* pGraph, unsigned int flags);

8040 

8049 hipError_t hipGraphDestroy(hipGraph_t graph);

8050 

8061 hipError_t hipGraphAddDependencies(hipGraph_t graph, const hipGraphNode_t* from,

8062  const hipGraphNode_t* to, size_t numDependencies);

8063 

8074 hipError_t hipGraphRemoveDependencies(hipGraph_t graph, const hipGraphNode_t* from,

8075  const hipGraphNode_t* to, size_t numDependencies);

8076 

8092 hipError_t hipGraphGetEdges(hipGraph_t graph, hipGraphNode_t* from, hipGraphNode_t* to,

8093  size_t* numEdges);

8094 

8109 hipError_t hipGraphGetNodes(hipGraph_t graph, hipGraphNode_t* nodes, size_t* numNodes);

8110 

8125 hipError_t hipGraphGetRootNodes(hipGraph_t graph, hipGraphNode_t* pRootNodes,

8126  size_t* pNumRootNodes);

8127 

8142 hipError_t hipGraphNodeGetDependencies(hipGraphNode_t node, hipGraphNode_t* pDependencies,

8143  size_t* pNumDependencies);

8144 

8160 hipError_t hipGraphNodeGetDependentNodes(hipGraphNode_t node, hipGraphNode_t* pDependentNodes,

8161  size_t* pNumDependentNodes);

8162 

8171 hipError_t hipGraphNodeGetType(hipGraphNode_t node, hipGraphNodeType* pType);

8172 

8180 hipError_t hipGraphDestroyNode(hipGraphNode_t node);

8181 

8190 hipError_t hipGraphClone(hipGraph_t* pGraphClone, hipGraph_t originalGraph);

8191 

8201 hipError_t hipGraphNodeFindInClone(hipGraphNode_t* pNode, hipGraphNode_t originalNode,

8202  hipGraph_t clonedGraph);

8203 

8217 hipError_t hipGraphInstantiate(hipGraphExec_t* pGraphExec, hipGraph_t graph,

8218  hipGraphNode_t* pErrorNode, char* pLogBuffer, size_t bufferSize);

8219 

8230 hipError_t hipGraphInstantiateWithFlags(hipGraphExec_t* pGraphExec, hipGraph_t graph,

8231  unsigned long long flags);

8232 

8242 hipError_t hipGraphInstantiateWithParams(hipGraphExec_t* pGraphExec, hipGraph_t graph,

8243  hipGraphInstantiateParams* instantiateParams);

8252 hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream);

8253 

8262 hipError_t hipGraphUpload(hipGraphExec_t graphExec, hipStream_t stream);

8263 

8275 hipError_t hipGraphAddNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8276  const hipGraphNode_t* pDependencies, size_t numDependencies,

8277  hipGraphNodeParams* nodeParams);

8278 

8287 hipError_t hipGraphExecGetFlags(hipGraphExec_t graphExec, unsigned long long* flags);

8288 

8298 hipError_t hipGraphNodeSetParams(hipGraphNode_t node, hipGraphNodeParams* nodeParams);

8299 

8310 hipError_t hipGraphExecNodeSetParams(hipGraphExec_t graphExec, hipGraphNode_t node,

8311  hipGraphNodeParams* nodeParams);

8312 

8321 hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec);

8322 

8323 // Check whether an executable graph can be updated with a graph and perform the update if possible.

8335 hipError_t hipGraphExecUpdate(hipGraphExec_t hGraphExec, hipGraph_t hGraph,

8336  hipGraphNode_t* hErrorNode_out,

8337  hipGraphExecUpdateResult* updateResult_out);

8338 

8350 hipError_t hipGraphAddKernelNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8351  const hipGraphNode_t* pDependencies, size_t numDependencies,

8352  const hipKernelNodeParams* pNodeParams);

8353 

8362 hipError_t hipGraphKernelNodeGetParams(hipGraphNode_t node, hipKernelNodeParams* pNodeParams);

8363 

8372 hipError_t hipGraphKernelNodeSetParams(hipGraphNode_t node, const hipKernelNodeParams* pNodeParams);

8373 

8383 hipError_t hipGraphExecKernelNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8384  const hipKernelNodeParams* pNodeParams);

8385 

8398 hipError_t hipDrvGraphAddMemcpyNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

8399  const hipGraphNode_t* dependencies, size_t numDependencies,

8400  const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);

8412 hipError_t hipGraphAddMemcpyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8413  const hipGraphNode_t* pDependencies, size_t numDependencies,

8414  const hipMemcpy3DParms* pCopyParams);

8423 hipError_t hipGraphMemcpyNodeGetParams(hipGraphNode_t node, hipMemcpy3DParms* pNodeParams);

8424 

8433 hipError_t hipGraphMemcpyNodeSetParams(hipGraphNode_t node, const hipMemcpy3DParms* pNodeParams);

8434 

8444 hipError_t hipGraphKernelNodeSetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

8445  const hipKernelNodeAttrValue* value);

8455 hipError_t hipGraphKernelNodeGetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

8456  hipKernelNodeAttrValue* value);

8466 hipError_t hipGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8467  hipMemcpy3DParms* pNodeParams);

8468 

8483 hipError_t hipGraphAddMemcpyNode1D(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8484  const hipGraphNode_t* pDependencies, size_t numDependencies,

8485  void* dst, const void* src, size_t count, hipMemcpyKind kind);

8486 

8498 hipError_t hipGraphMemcpyNodeSetParams1D(hipGraphNode_t node, void* dst, const void* src,

8499  size_t count, hipMemcpyKind kind);

8500 

8514 hipError_t hipGraphExecMemcpyNodeSetParams1D(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8515  void* dst, const void* src, size_t count,

8516  hipMemcpyKind kind);

8517 

8533 hipError_t hipGraphAddMemcpyNodeFromSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8534  const hipGraphNode_t* pDependencies,

8535  size_t numDependencies, void* dst, const void* symbol,

8536  size_t count, size_t offset, hipMemcpyKind kind);

8537 

8550 hipError_t hipGraphMemcpyNodeSetParamsFromSymbol(hipGraphNode_t node, void* dst, const void* symbol,

8551  size_t count, size_t offset, hipMemcpyKind kind);

8552 

8567 hipError_t hipGraphExecMemcpyNodeSetParamsFromSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8568  void* dst, const void* symbol, size_t count,

8569  size_t offset, hipMemcpyKind kind);

8570 

8586 hipError_t hipGraphAddMemcpyNodeToSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8587  const hipGraphNode_t* pDependencies,

8588  size_t numDependencies, const void* symbol,

8589  const void* src, size_t count, size_t offset,

8590  hipMemcpyKind kind);

8591 

8604 hipError_t hipGraphMemcpyNodeSetParamsToSymbol(hipGraphNode_t node, const void* symbol,

8605  const void* src, size_t count, size_t offset,

8606  hipMemcpyKind kind);

8607 

8608 

8622 hipError_t hipGraphExecMemcpyNodeSetParamsToSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8623  const void* symbol, const void* src,

8624  size_t count, size_t offset, hipMemcpyKind kind);

8625 

8637 hipError_t hipGraphAddMemsetNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8638  const hipGraphNode_t* pDependencies, size_t numDependencies,

8639  const hipMemsetParams* pMemsetParams);

8640 

8649 hipError_t hipGraphMemsetNodeGetParams(hipGraphNode_t node, hipMemsetParams* pNodeParams);

8650 

8659 hipError_t hipGraphMemsetNodeSetParams(hipGraphNode_t node, const hipMemsetParams* pNodeParams);

8660 

8670 hipError_t hipGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8671  const hipMemsetParams* pNodeParams);

8672 

8684 hipError_t hipGraphAddHostNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8685  const hipGraphNode_t* pDependencies, size_t numDependencies,

8686  const hipHostNodeParams* pNodeParams);

8687 

8696 hipError_t hipGraphHostNodeGetParams(hipGraphNode_t node, hipHostNodeParams* pNodeParams);

8697 

8706 hipError_t hipGraphHostNodeSetParams(hipGraphNode_t node, const hipHostNodeParams* pNodeParams);

8707 

8717 hipError_t hipGraphExecHostNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8718  const hipHostNodeParams* pNodeParams);

8719 

8731 hipError_t hipGraphAddChildGraphNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8732  const hipGraphNode_t* pDependencies, size_t numDependencies,

8733  hipGraph_t childGraph);

8734 

8743 hipError_t hipGraphChildGraphNodeGetGraph(hipGraphNode_t node, hipGraph_t* pGraph);

8744 

8754 hipError_t hipGraphExecChildGraphNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8755  hipGraph_t childGraph);

8756 

8767 hipError_t hipGraphAddEmptyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8768  const hipGraphNode_t* pDependencies, size_t numDependencies);

8769 

8770 

8782 hipError_t hipGraphAddEventRecordNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8783  const hipGraphNode_t* pDependencies, size_t numDependencies,

8784  hipEvent_t event);

8785 

8794 hipError_t hipGraphEventRecordNodeGetEvent(hipGraphNode_t node, hipEvent_t* event_out);

8795 

8804 hipError_t hipGraphEventRecordNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

8805 

8815 hipError_t hipGraphExecEventRecordNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8816  hipEvent_t event);

8817 

8829 hipError_t hipGraphAddEventWaitNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8830  const hipGraphNode_t* pDependencies, size_t numDependencies,

8831  hipEvent_t event);

8832 

8833 

8842 hipError_t hipGraphEventWaitNodeGetEvent(hipGraphNode_t node, hipEvent_t* event_out);

8843 

8852 hipError_t hipGraphEventWaitNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

8853 

8863 hipError_t hipGraphExecEventWaitNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8864  hipEvent_t event);

8865 

8878 hipError_t hipGraphAddMemAllocNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8879  const hipGraphNode_t* pDependencies, size_t numDependencies,

8880  hipMemAllocNodeParams* pNodeParams);

8881 

8890 hipError_t hipGraphMemAllocNodeGetParams(hipGraphNode_t node, hipMemAllocNodeParams* pNodeParams);

8891 

8903 hipError_t hipGraphAddMemFreeNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8904  const hipGraphNode_t* pDependencies, size_t numDependencies,

8905  void* dev_ptr);

8906 

8915 hipError_t hipGraphMemFreeNodeGetParams(hipGraphNode_t node, void* dev_ptr);

8916 

8926 hipError_t hipDeviceGetGraphMemAttribute(int device, hipGraphMemAttributeType attr, void* value);

8927 

8937 hipError_t hipDeviceSetGraphMemAttribute(int device, hipGraphMemAttributeType attr, void* value);

8938 

8946 hipError_t hipDeviceGraphMemTrim(int device);

8947 

8959 hipError_t hipUserObjectCreate(hipUserObject_t* object_out, void* ptr, hipHostFn_t destroy,

8960  unsigned int initialRefcount, unsigned int flags);

8961 

8970 hipError_t hipUserObjectRelease(hipUserObject_t object, unsigned int count __dparm(1));

8971 

8980 hipError_t hipUserObjectRetain(hipUserObject_t object, unsigned int count __dparm(1));

8981 

8992 hipError_t hipGraphRetainUserObject(hipGraph_t graph, hipUserObject_t object,

8993  unsigned int count __dparm(1), unsigned int flags __dparm(0));

8994 

9004 hipError_t hipGraphReleaseUserObject(hipGraph_t graph, hipUserObject_t object,

9005  unsigned int count __dparm(1));

9006 

9016 hipError_t hipGraphDebugDotPrint(hipGraph_t graph, const char* path, unsigned int flags);

9017 

9031 hipError_t hipGraphKernelNodeCopyAttributes(hipGraphNode_t hSrc, hipGraphNode_t hDst);

9032 

9054 hipError_t hipGraphNodeSetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9055  unsigned int isEnabled);

9075 hipError_t hipGraphNodeGetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9076  unsigned int* isEnabled);

9077 

9089 hipError_t hipGraphAddExternalSemaphoresWaitNode(

9090  hipGraphNode_t* pGraphNode, hipGraph_t graph, const hipGraphNode_t* pDependencies,

9091  size_t numDependencies, const hipExternalSemaphoreWaitNodeParams* nodeParams);

9092 

9104 hipError_t hipGraphAddExternalSemaphoresSignalNode(

9105  hipGraphNode_t* pGraphNode, hipGraph_t graph, const hipGraphNode_t* pDependencies,

9106  size_t numDependencies, const hipExternalSemaphoreSignalNodeParams* nodeParams);

9115 hipError_t hipGraphExternalSemaphoresSignalNodeSetParams(

9116  hipGraphNode_t hNode, const hipExternalSemaphoreSignalNodeParams* nodeParams);

9125 hipError_t hipGraphExternalSemaphoresWaitNodeSetParams(

9126  hipGraphNode_t hNode, const hipExternalSemaphoreWaitNodeParams* nodeParams);

9135 hipError_t hipGraphExternalSemaphoresSignalNodeGetParams(

9136  hipGraphNode_t hNode, hipExternalSemaphoreSignalNodeParams* params_out);

9145 hipError_t hipGraphExternalSemaphoresWaitNodeGetParams(

9146  hipGraphNode_t hNode, hipExternalSemaphoreWaitNodeParams* params_out);

9156 hipError_t hipGraphExecExternalSemaphoresSignalNodeSetParams(

9157  hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9158  const hipExternalSemaphoreSignalNodeParams* nodeParams);

9168 hipError_t hipGraphExecExternalSemaphoresWaitNodeSetParams(

9169  hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9170  const hipExternalSemaphoreWaitNodeParams* nodeParams);

9171 

9180 hipError_t hipDrvGraphMemcpyNodeGetParams(hipGraphNode_t hNode, HIP_MEMCPY3D* nodeParams);

9181 

9190 hipError_t hipDrvGraphMemcpyNodeSetParams(hipGraphNode_t hNode, const HIP_MEMCPY3D* nodeParams);

9191 

9204 hipError_t hipDrvGraphAddMemsetNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

9205  const hipGraphNode_t* dependencies, size_t numDependencies,

9206  const hipMemsetParams* memsetParams, hipCtx_t ctx);

9207 

9219 hipError_t hipDrvGraphAddMemFreeNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

9220  const hipGraphNode_t* dependencies, size_t numDependencies,

9221  hipDeviceptr_t dptr);

9222 

9233 hipError_t hipDrvGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9234  const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);

9235 

9246 hipError_t hipDrvGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9247  const hipMemsetParams* memsetParams, hipCtx_t ctx);

9248 

9249 // doxygen end graph API

9280 hipError_t hipMemAddressFree(void* devPtr, size_t size);

9281 

9296 hipError_t hipMemAddressReserve(void** ptr, size_t size, size_t alignment, void* addr,

9297  unsigned long long flags);

9298 

9312 hipError_t hipMemCreate(hipMemGenericAllocationHandle_t* handle, size_t size,

9313  const hipMemAllocationProp* prop, unsigned long long flags);

9314 

9328 hipError_t hipMemExportToShareableHandle(void* shareableHandle,

9329  hipMemGenericAllocationHandle_t handle,

9330  hipMemAllocationHandleType handleType,

9331  unsigned long long flags);

9332 

9345 hipError_t hipMemGetAccess(unsigned long long* flags, const hipMemLocation* location, void* ptr);

9346 

9360 hipError_t hipMemGetAllocationGranularity(size_t* granularity, const hipMemAllocationProp* prop,

9361  hipMemAllocationGranularity_flags option);

9362 

9374 hipError_t hipMemGetAllocationPropertiesFromHandle(hipMemAllocationProp* prop,

9375  hipMemGenericAllocationHandle_t handle);

9376 

9389 hipError_t hipMemImportFromShareableHandle(hipMemGenericAllocationHandle_t* handle, void* osHandle,

9390  hipMemAllocationHandleType shHandleType);

9391 

9406 hipError_t hipMemMap(void* ptr, size_t size, size_t offset, hipMemGenericAllocationHandle_t handle,

9407  unsigned long long flags);

9408 

9419 hipError_t hipMemMapArrayAsync(hipArrayMapInfo* mapInfoList, unsigned int count,

9420  hipStream_t stream);

9421 

9433 hipError_t hipMemRelease(hipMemGenericAllocationHandle_t handle);

9434 

9446 hipError_t hipMemRetainAllocationHandle(hipMemGenericAllocationHandle_t* handle, void* addr);

9447 

9462 hipError_t hipMemSetAccess(void* ptr, size_t size, const hipMemAccessDesc* desc, size_t count);

9463 

9475 hipError_t hipMemUnmap(void* ptr, size_t size);

9476 

9477 // doxygen end virtual memory management API

9499 hipError_t hipGraphicsMapResources(int count, hipGraphicsResource_t* resources,

9500  hipStream_t stream __dparm(0));

9514 hipError_t hipGraphicsSubResourceGetMappedArray(hipArray_t* array, hipGraphicsResource_t resource,

9515  unsigned int arrayIndex, unsigned int mipLevel);

9526 hipError_t hipGraphicsResourceGetMappedPointer(void** devPtr, size_t* size,

9527  hipGraphicsResource_t resource);

9538 hipError_t hipGraphicsUnmapResources(int count, hipGraphicsResource_t* resources,

9539  hipStream_t stream __dparm(0));

9548 hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource);

9549 // doxygen end GraphicsInterop

9575 hipError_t hipCreateSurfaceObject(hipSurfaceObject_t* pSurfObject, const hipResourceDesc* pResDesc);

9583 hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject);

9584 // end of surface

9588 #ifdef __cplusplus

9589 } /* extern "c" */

9590 #endif

9591 #ifdef __cplusplus

9592 #if defined(__clang__) && defined(__HIP__)

9593 template <typename T> static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSize(

9594  int* gridSize, int* blockSize, T f, size_t dynSharedMemPerBlk = 0, int blockSizeLimit = 0) {

9595  return hipOccupancyMaxPotentialBlockSize(gridSize, blockSize, reinterpret_cast<const void*>(f),

9596  dynSharedMemPerBlk, blockSizeLimit);

9597 }

9598 template <typename T> static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeWithFlags(

9599  int* gridSize, int* blockSize, T f, size_t dynSharedMemPerBlk = 0, int blockSizeLimit = 0,

9600  unsigned int flags = 0) {

9601  (void)flags;

9602  return hipOccupancyMaxPotentialBlockSize(gridSize, blockSize, reinterpret_cast<const void*>(f),

9603  dynSharedMemPerBlk, blockSizeLimit);

9604 }

9605 #endif // defined(__clang__) && defined(__HIP__)

9606 

9616 template <typename T> hipError_t hipGetSymbolAddress(void** devPtr, const T& symbol) {

9617  return ::hipGetSymbolAddress(devPtr, (const void*)&symbol);

9618 }

9629 template <typename T> hipError_t hipGetSymbolSize(size_t* size, const T& symbol) {

9630  return ::hipGetSymbolSize(size, (const void*)&symbol);

9631 }

9632 

9641 template <typename T>

9642 hipError_t hipMemcpyToSymbol(const T& symbol, const void* src, size_t sizeBytes,

9643  size_t offset __dparm(0),

9644  hipMemcpyKind kind __dparm(hipMemcpyHostToDevice)) {

9645  return ::hipMemcpyToSymbol((const void*)&symbol, src, sizeBytes, offset, kind);

9646 }

9655 template <typename T>

9656 hipError_t hipMemcpyToSymbolAsync(const T& symbol, const void* src, size_t sizeBytes, size_t offset,

9657  hipMemcpyKind kind, hipStream_t stream __dparm(0)) {

9658  return ::hipMemcpyToSymbolAsync((const void*)&symbol, src, sizeBytes, offset, kind, stream);

9659 }

9667 template <typename T>

9668 hipError_t hipMemcpyFromSymbol(void* dst, const T& symbol, size_t sizeBytes,

9669  size_t offset __dparm(0),

9670  hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost)) {

9671  return ::hipMemcpyFromSymbol(dst, (const void*)&symbol, sizeBytes, offset, kind);

9672 }

9680 template <typename T>

9681 hipError_t hipMemcpyFromSymbolAsync(void* dst, const T& symbol, size_t sizeBytes, size_t offset,

9682  hipMemcpyKind kind, hipStream_t stream __dparm(0)) {

9683  return ::hipMemcpyFromSymbolAsync(dst, (const void*)&symbol, sizeBytes, offset, kind, stream);

9684 }

9685 

9697 template <class T>

9698 inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, T f, int blockSize,

9699  size_t dynSharedMemPerBlk) {

9700  return hipOccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, reinterpret_cast<const void*>(f),

9701  blockSize, dynSharedMemPerBlk);

9702 }

9716 template <class T> inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

9717  int* numBlocks, T f, int blockSize, size_t dynSharedMemPerBlk, unsigned int flags) {

9718  return hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

9719  numBlocks, reinterpret_cast<const void*>(f), blockSize, dynSharedMemPerBlk, flags);

9720 }

9743 template <typename UnaryFunction, class T>

9744 static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(

9745  int* min_grid_size, int* block_size, T func, UnaryFunction block_size_to_dynamic_smem_size,

9746  int block_size_limit = 0, unsigned int flags = 0) {

9747  if (min_grid_size == nullptr || block_size == nullptr ||

9748  reinterpret_cast<const void*>(func) == nullptr) {

9749  return hipErrorInvalidValue;

9750  }

9751 

9752  int dev;

9753  hipError_t status;

9754  if ((status = hipGetDevice(&dev)) != hipSuccess) {

9755  return status;

9756  }

9757 

9758  int max_threads_per_cu;

9759  if ((status = hipDeviceGetAttribute(&max_threads_per_cu,

9760  hipDeviceAttributeMaxThreadsPerMultiProcessor, dev)) !=

9761  hipSuccess) {

9762  return status;

9763  }

9764 

9765  int warp_size;

9766  if ((status = hipDeviceGetAttribute(&warp_size, hipDeviceAttributeWarpSize, dev)) != hipSuccess) {

9767  return status;

9768  }

9769 

9770  int max_cu_count;

9771  if ((status = hipDeviceGetAttribute(&max_cu_count, hipDeviceAttributeMultiprocessorCount, dev)) !=

9772  hipSuccess) {

9773  return status;

9774  }

9775 

9776  struct hipFuncAttributes attr;

9777  if ((status = hipFuncGetAttributes(&attr, reinterpret_cast<const void*>(func))) != hipSuccess) {

9778  return status;

9779  }

9780 

9781  // Initial limits for the execution

9782  const int func_max_threads_per_block = attr.maxThreadsPerBlock;

9783  if (block_size_limit == 0) {

9784  block_size_limit = func_max_threads_per_block;

9785  }

9786 

9787  if (func_max_threads_per_block < block_size_limit) {

9788  block_size_limit = func_max_threads_per_block;

9789  }

9790 

9791  const int block_size_limit_aligned =

9792  ((block_size_limit + (warp_size - 1)) / warp_size) * warp_size;

9793 

9794  // For maximum search

9795  int max_threads = 0;

9796  int max_block_size{};

9797  int max_num_blocks{};

9798  for (int block_size_check_aligned = block_size_limit_aligned; block_size_check_aligned > 0;

9799  block_size_check_aligned -= warp_size) {

9800  // Make sure the logic uses the requested limit and not aligned

9801  int block_size_check =

9802  (block_size_limit < block_size_check_aligned) ? block_size_limit : block_size_check_aligned;

9803 

9804  size_t dyn_smem_size = block_size_to_dynamic_smem_size(block_size_check);

9805  int optimal_blocks;

9806  if ((status = hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

9807  &optimal_blocks, func, block_size_check, dyn_smem_size, flags)) != hipSuccess) {

9808  return status;

9809  }

9810 

9811  int total_threads = block_size_check * optimal_blocks;

9812  if (total_threads > max_threads) {

9813  max_block_size = block_size_check;

9814  max_num_blocks = optimal_blocks;

9815  max_threads = total_threads;

9816  }

9817 

9818  // Break if the logic reached possible maximum

9819  if (max_threads_per_cu == max_threads) {

9820  break;

9821  }

9822  }

9823 

9824  // Grid size is the number of blocks per CU * CU count

9825  *min_grid_size = max_num_blocks * max_cu_count;

9826  *block_size = max_block_size;

9827 

9828  return status;

9829 }

9830 

9852 template <typename UnaryFunction, class T>

9853 static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMem(

9854  int* min_grid_size, int* block_size, T func, UnaryFunction block_size_to_dynamic_smem_size,

9855  int block_size_limit = 0) {

9856  return hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(

9857  min_grid_size, block_size, func, block_size_to_dynamic_smem_size, block_size_limit);

9858 }

9874 template <typename F> inline hipError_t hipOccupancyMaxPotentialBlockSize(int* gridSize,

9875  int* blockSize, F kernel,

9876  size_t dynSharedMemPerBlk,

9877  uint32_t blockSizeLimit) {

9878  return hipOccupancyMaxPotentialBlockSize(gridSize, blockSize, (hipFunction_t)kernel,

9879  dynSharedMemPerBlk, blockSizeLimit);

9880 }

9881 

9897 template <typename F>

9898 inline hipError_t hipOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, F f,

9899  int numBlocks, int blockSize) {

9900  return hipOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, reinterpret_cast<const void*>(f),

9901  numBlocks, blockSize);

9902 }

9924 template <class T>

9925 inline hipError_t hipLaunchCooperativeKernel(T f, dim3 gridDim, dim3 blockDim, void** kernelParams,

9926  unsigned int sharedMemBytes, hipStream_t stream) {

9927  return hipLaunchCooperativeKernel(reinterpret_cast<const void*>(f), gridDim, blockDim,

9928  kernelParams, sharedMemBytes, stream);

9929 }

9945 template <class T>

9946 inline hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

9947  unsigned int numDevices,

9948  unsigned int flags = 0) {

9949  return hipLaunchCooperativeKernelMultiDevice(launchParamsList, numDevices, flags);

9950 }

9963 template <class T>

9964 inline hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

9965  unsigned int numDevices,

9966  unsigned int flags = 0) {

9967  return hipExtLaunchMultiKernelMultiDevice(launchParamsList, numDevices, flags);

9968 }

9982 template <class T, int dim, enum hipTextureReadMode readMode> HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9983 static inline hipError_t hipBindTexture(size_t* offset, const struct texture<T, dim, readMode>& tex,

9984  const void* devPtr, size_t size = UINT_MAX) {

9985  return hipBindTexture(offset, &tex, devPtr, &tex.channelDesc, size);

9986 }

10001 template <class T, int dim, enum hipTextureReadMode readMode> HIP_DEPRECATED(HIP_DEPRECATED_MSG)

10002 static inline hipError_t

10003  hipBindTexture(size_t* offset, const struct texture<T, dim, readMode>& tex, const void* devPtr,

10004  const struct hipChannelFormatDesc& desc, size_t size = UINT_MAX) {

10005  return hipBindTexture(offset, &tex, devPtr, &desc, size);

10006 }

10022 template <class T, int dim, enum hipTextureReadMode readMode> HIP_DEPRECATED(HIP_DEPRECATED_MSG)

10023 static inline hipError_t

10024  hipBindTexture2D(size_t* offset, const struct texture<T, dim, readMode>& tex,

10025  const void* devPtr, size_t width, size_t height, size_t pitch) {

10026  return hipBindTexture2D(offset, &tex, devPtr, &tex.channelDesc, width, height, pitch);

10027 }

10044 template <class T, int dim, enum hipTextureReadMode readMode> HIP_DEPRECATED(HIP_DEPRECATED_MSG)

10045 static inline hipError_t

10046  hipBindTexture2D(size_t* offset, const struct texture<T, dim, readMode>& tex,

10047  const void* devPtr, const struct hipChannelFormatDesc& desc, size_t width,

10048  size_t height, size_t pitch) {

10049  return hipBindTexture2D(offset, &tex, devPtr, &desc, width, height, pitch);

10050 }

10062 template <class T, int dim, enum hipTextureReadMode readMode> HIP_DEPRECATED(HIP_DEPRECATED_MSG)

10063 static inline hipError_t

10064  hipBindTextureToArray(const struct texture<T, dim, readMode>& tex, hipArray_const_t array) {

10065  struct hipChannelFormatDesc desc;

10066  hipError_t err = hipGetChannelDesc(&desc, array);

10067  return (err == hipSuccess) ? hipBindTextureToArray(&tex, array, &desc) : err;

10068 }

10081 template <class T, int dim, enum hipTextureReadMode readMode> HIP_DEPRECATED(HIP_DEPRECATED_MSG)

10082 static inline hipError_t

10083  hipBindTextureToArray(const struct texture<T, dim, readMode>& tex, hipArray_const_t array,

10084  const struct hipChannelFormatDesc& desc) {

10085  return hipBindTextureToArray(&tex, array, &desc);

10086 }

10098 template <class T, int dim, enum hipTextureReadMode readMode> HIP_DEPRECATED(HIP_DEPRECATED_MSG)

10099 static inline hipError_t hipBindTextureToMipmappedArray(const struct texture<T, dim, readMode>& tex,

10100  hipMipmappedArray_const_t mipmappedArray) {

10101  struct hipChannelFormatDesc desc;

10102  hipArray_t levelArray;

10103  hipError_t err = hipGetMipmappedArrayLevel(&levelArray, mipmappedArray, 0);

10104  if (err != hipSuccess) {

10105  return err;

10106  }

10107  err = hipGetChannelDesc(&desc, levelArray);

10108  return (err == hipSuccess) ? hipBindTextureToMipmappedArray(&tex, mipmappedArray, &desc) : err;

10109 }

10122 template <class T, int dim, enum hipTextureReadMode readMode> HIP_DEPRECATED(HIP_DEPRECATED_MSG)

10123 static inline hipError_t hipBindTextureToMipmappedArray(const struct texture<T, dim, readMode>& tex,

10124  hipMipmappedArray_const_t mipmappedArray,

10125  const struct hipChannelFormatDesc& desc) {

10126  return hipBindTextureToMipmappedArray(&tex, mipmappedArray, &desc);

10127 }

10138 template <class T, int dim, enum hipTextureReadMode readMode> HIP_DEPRECATED(HIP_DEPRECATED_MSG)

10139 static inline hipError_t hipUnbindTexture(const struct texture<T, dim, readMode>& tex) {

10140  return hipUnbindTexture(&tex);

10141 }

10165 static inline hipError_t hipMallocAsync(void** dev_ptr, size_t size, hipMemPool_t mem_pool,

10166  hipStream_t stream) {

10167  return hipMallocFromPoolAsync(dev_ptr, size, mem_pool, stream);

10168 }

10179 template <class T> static inline hipError_t hipMallocAsync(T** dev_ptr, size_t size,

10180  hipMemPool_t mem_pool,

10181  hipStream_t stream) {

10182  return hipMallocFromPoolAsync(reinterpret_cast<void**>(dev_ptr), size, mem_pool, stream);

10183 }

10194 template <class T>

10195 static inline hipError_t hipMallocAsync(T** dev_ptr, size_t size, hipStream_t stream) {

10196  return hipMallocAsync(reinterpret_cast<void**>(dev_ptr), size, stream);

10197 }

10208 template <class T> static inline hipError_t hipMallocFromPoolAsync(T** dev_ptr, size_t size,

10209  hipMemPool_t mem_pool,

10210  hipStream_t stream) {

10211  return hipMallocFromPoolAsync(reinterpret_cast<void**>(dev_ptr), size, mem_pool, stream);

10212 }

10226 template <typename... KernelArgs, typename... Params>

10227 static inline __host__ hipError_t hipLaunchKernelEx(const hipLaunchConfig_t* config,

10228  void (*kernel)(KernelArgs...),

10229  Params&&... args) {

10230  return [&](KernelArgs... convertedArgs) {

10231  void* pArgs[] = {&convertedArgs...};

10232  return ::hipLaunchKernelExC(config, reinterpret_cast<void*>(kernel), pArgs);

10233  }(std::forward<Params>(args)...);

10234 }

10240 #endif // __cplusplus

10241 

10242 #ifdef __GNUC__

10243 #pragma GCC visibility pop

10244 #endif

10245 

10246 

10247 #elif !defined(__HIP_PLATFORM_AMD__) && defined(__HIP_PLATFORM_NVIDIA__)

10248 #include "hip/nvidia_detail/nvidia_hip_runtime_api.h"

10249 #else

10250 #error ("Must define exactly one of __HIP_PLATFORM_AMD__ or __HIP_PLATFORM_NVIDIA__");

10251 #endif

10252 

10253 

10265 #if defined(__cplusplus) && !defined(__HIP_DISABLE_CPP_FUNCTIONS__)

10266 template <class T> static inline hipError_t hipMalloc(T** devPtr, size_t size) {

10267  return hipMalloc((void**)devPtr, size);

10268 }

10280 template <class T>

10281 static inline hipError_t hipMallocPitch(T** devPtr, size_t* pitch, size_t width, size_t height) {

10282  return hipMallocPitch((void**)devPtr, pitch, width, height);

10283 }

10296 template <class T>

10297 static inline hipError_t hipHostMalloc(T** ptr, size_t size,

10298  unsigned int flags = hipHostMallocDefault) {

10299  return hipHostMalloc((void**)ptr, size, flags);

10300 }

10313 template <class T> static inline hipError_t hipHostAlloc(T** ptr, size_t size,

10314  unsigned int flags = hipHostAllocDefault) {

10315  return hipHostAlloc((void**)ptr, size, flags);

10316 }

10331 template <class T>

10332 static inline hipError_t hipMallocManaged(T** devPtr, size_t size,

10333  unsigned int flags = hipMemAttachGlobal) {

10334  return hipMallocManaged((void**)devPtr, size, flags);

10335 }

10336 

10337 

10338 #endif

10339 #endif

10340 // doxygen end HIP API

10344 #include <hip/amd_detail/amd_hip_runtime_pt_api.h>

10345 

10346 #if USE_PROF_API

10347 #include <hip/amd_detail/hip_prof_str.h>

10348 #endif

driver_types.h

err

hipError_t err

Definition: hip_runtime_api.h:10066

tex

const struct texture< T, dim, readMode > & tex

Definition: hip_runtime_api.h:9983

size

const struct texture< T, dim, readMode > const void size_t size

Definition: hip_runtime_api.h:9984

pitch

const struct texture< T, dim, readMode > const void size_t int enum hipTextureReadMode readMode const struct texture< T, dim, readMode > const void const struct hipChannelFormatDesc size_t int enum hipTextureReadMode readMode const struct texture< T, dim, readMode > const void size_t size_t size_t pitch

Definition: hip_runtime_api.h:10025

levelArray

hipArray_t levelArray

Definition: hip_runtime_api.h:10102

dim

const struct texture< T, dim, readMode > const void size_t int dim

Definition: hip_runtime_api.h:10001

mipmappedArray

readMode hipMipmappedArray_const_t mipmappedArray

Definition: hip_runtime_api.h:10100

height

const struct texture< T, dim, readMode > const void size_t int enum hipTextureReadMode readMode const struct texture< T, dim, readMode > const void const struct hipChannelFormatDesc size_t int enum hipTextureReadMode readMode const struct texture< T, dim, readMode > const void size_t size_t height

Definition: hip_runtime_api.h:10025

devPtr

const struct texture< T, dim, readMode > const void * devPtr

Definition: hip_runtime_api.h:9984

desc

const struct texture< T, dim, readMode > const void size_t int enum hipTextureReadMode readMode const struct texture< T, dim, readMode > const void const struct hipChannelFormatDesc & desc

Definition: hip_runtime_api.h:10004

array

readMode hipArray_const_t array

Definition: hip_runtime_api.h:10064

width

const struct texture< T, dim, readMode > const void size_t int enum hipTextureReadMode readMode const struct texture< T, dim, readMode > const void const struct hipChannelFormatDesc size_t int enum hipTextureReadMode readMode const struct texture< T, dim, readMode > const void size_t width

Definition: hip_runtime_api.h:10025

hipKernelNameRef

const char * hipKernelNameRef(const hipFunction_t f)

Returns kernel name reference by function name.

hipKernelNameRefByPtr

const char * hipKernelNameRefByPtr(const void *hostFunction, hipStream_t stream)

Retrives kernel for a given host pointer, unless stated otherwise.

hipApiName

const char * hipApiName(uint32_t id)

Returns HIP API name by ID.

hipGetStreamDeviceId

int hipGetStreamDeviceId(hipStream_t stream)

Returns device ID on the stream.

hipSetupArgument

hipError_t hipSetupArgument(const void *arg, size_t size, size_t offset)

Set a kernel argument.

__hipPopCallConfiguration

hipError_t __hipPopCallConfiguration(dim3 *gridDim, dim3 *blockDim, size_t *sharedMem, hipStream_t *stream)

Pop configuration of a kernel launch.

hipLaunchHostFunc

hipError_t hipLaunchHostFunc(hipStream_t stream, hipHostFn_t fn, void *userData)

Enqueues a host function call in a stream.

hipLaunchKernel

hipError_t hipLaunchKernel(const void *function_address, dim3 numBlocks, dim3 dimBlocks, void **args, size_t sharedMemBytes, hipStream_t stream)

C compliant kernel launch API.

hipExtLaunchKernel

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.

__hipPushCallConfiguration

hipError_t __hipPushCallConfiguration(dim3 gridDim, dim3 blockDim, size_t sharedMem, hipStream_t stream)

Push configuration of a kernel launch.

hipLaunchByPtr

hipError_t hipLaunchByPtr(const void *func)

Launch a kernel.

hipDrvMemcpy2DUnaligned

hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D *pCopy)

hipConfigureCall

hipError_t hipConfigureCall(dim3 gridDim, dim3 blockDim, size_t sharedMem, hipStream_t stream)

Configure a kernel launch.

hipCtxGetFlags

hipError_t hipCtxGetFlags(unsigned int *flags)

Return flags used for creating default context [Deprecated].

hipCtxGetApiVersion

hipError_t hipCtxGetApiVersion(hipCtx_t ctx, unsigned int *apiVersion)

Returns the approximate HIP api version.

hipCtxPopCurrent

hipError_t hipCtxPopCurrent(hipCtx_t *ctx)

Pop the current/default context and return the popped context [Deprecated].

hipCtxGetSharedMemConfig

hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig *pConfig)

Get Shared memory bank configuration [Deprecated].

hipDevicePrimaryCtxSetFlags

hipError_t hipDevicePrimaryCtxSetFlags(hipDevice_t dev, unsigned int flags)

Set flags for the primary context [Deprecated].

hipDevicePrimaryCtxGetState

hipError_t hipDevicePrimaryCtxGetState(hipDevice_t dev, unsigned int *flags, int *active)

Get the state of the primary context [Deprecated].

hipCtxGetCurrent

hipError_t hipCtxGetCurrent(hipCtx_t *ctx)

Get the handle of the current/ default context [Deprecated].

hipDevicePrimaryCtxRelease

hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev)

Release the primary context on the GPU.

hipCtxSetCacheConfig

hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig)

Set L1/Shared cache partition [Deprecated].

hipCtxSetCurrent

hipError_t hipCtxSetCurrent(hipCtx_t ctx)

Set the passed context as current/default [Deprecated].

hipCtxEnablePeerAccess

hipError_t hipCtxEnablePeerAccess(hipCtx_t peerCtx, unsigned int flags)

Enables direct access to memory allocations in a peer context [Deprecated].

hipCtxGetDevice

hipError_t hipCtxGetDevice(hipDevice_t *device)

Get the handle of the device associated with current/default context [Deprecated].

hipCtxDestroy

hipError_t hipCtxDestroy(hipCtx_t ctx)

Destroy a HIP context [Deprecated].

hipCtxPushCurrent

hipError_t hipCtxPushCurrent(hipCtx_t ctx)

Push the context to be set as current/ default context [Deprecated].

hipCtxGetCacheConfig

hipError_t hipCtxGetCacheConfig(hipFuncCache_t *cacheConfig)

Get Cache configuration for a specific function [Deprecated].

hipCtxCreate

hipError_t hipCtxCreate(hipCtx_t *ctx, unsigned int flags, hipDevice_t device)

Create a context and set it as current/default context.

hipDevicePrimaryCtxRetain

hipError_t hipDevicePrimaryCtxRetain(hipCtx_t *pctx, hipDevice_t dev)

Retain the primary context on the GPU [Deprecated].

hipDevicePrimaryCtxReset

hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev)

Resets the primary context on the GPU [Deprecated].

hipCtxSynchronize

hipError_t hipCtxSynchronize(void)

Blocks until the default context has completed all preceding requested tasks [Deprecated].

hipCtxSetSharedMemConfig

hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config)

Set Shared memory bank configuration [Deprecated].

hipCtxDisablePeerAccess

hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx)

Disable direct access from current context's virtual address space to memory allocations physically l...

hipGetDeviceFlags

hipError_t hipGetDeviceFlags(unsigned int *flags)

Gets the flags set for current device.

hipIpcGetEventHandle

hipError_t hipIpcGetEventHandle(hipIpcEventHandle_t *handle, hipEvent_t event)

Gets an opaque interprocess handle for an event.

hipDeviceGetDefaultMemPool

hipError_t hipDeviceGetDefaultMemPool(hipMemPool_t *mem_pool, int device)

Returns the default memory pool of the specified device.

hipDeviceGetSharedMemConfig

hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig *pConfig)

Returns bank width of shared memory for current device.

hipDeviceSetMemPool

hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool)

Sets the current memory pool of a device.

hipIpcOpenMemHandle

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...

hipDeviceGetCacheConfig

hipError_t hipDeviceGetCacheConfig(hipFuncCache_t *cacheConfig)

Get Cache configuration for a specific Device.

hipSetDevice

hipError_t hipSetDevice(int deviceId)

Set default device to be used for subsequent hip API calls from this thread.

hipExtGetLinkTypeAndHopCount

hipError_t hipExtGetLinkTypeAndHopCount(int device1, int device2, uint32_t *linktype, uint32_t *hopcount)

Returns the link type and hop count between two devices.

hipDeviceGetTexture1DLinearMaxWidth

hipError_t hipDeviceGetTexture1DLinearMaxWidth(size_t *max_width, const hipChannelFormatDesc *desc, int device)

Gets the maximum width for 1D linear textures on the specified device.

hipSetDeviceFlags

hipError_t hipSetDeviceFlags(unsigned flags)

The current device behavior is changed according to the flags passed.

hipDeviceGetAttribute

hipError_t hipDeviceGetAttribute(int *pi, hipDeviceAttribute_t attr, int deviceId)

Query for a specific device attribute.

hipGetDevice

hipError_t hipGetDevice(int *deviceId)

Return the default device id for the calling host thread.

hipGetDeviceCount

hipError_t hipGetDeviceCount(int *count)

Return number of compute-capable devices.

hipDeviceGetMemPool

hipError_t hipDeviceGetMemPool(hipMemPool_t *mem_pool, int device)

Gets the current memory pool for the specified device.

hipDeviceReset

hipError_t hipDeviceReset(void)

The state of current device is discarded and updated to a fresh state.

hipDeviceGetLimit

hipError_t hipDeviceGetLimit(size_t *pValue, enum hipLimit_t limit)

Gets resource limits of current device.

hipDeviceSetSharedMemConfig

hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config)

The bank width of shared memory on current device is set.

hipDeviceSetLimit

hipError_t hipDeviceSetLimit(enum hipLimit_t limit, size_t value)

Sets resource limits of current device.

hipDeviceSetCacheConfig

hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig)

Set L1/Shared cache partition.

hipIpcCloseMemHandle

hipError_t hipIpcCloseMemHandle(void *devPtr)

Close memory mapped with hipIpcOpenMemHandle.

hipSetValidDevices

hipError_t hipSetValidDevices(int *device_arr, int len)

Set a list of devices that can be used.

hipIpcOpenEventHandle

hipError_t hipIpcOpenEventHandle(hipEvent_t *event, hipIpcEventHandle_t handle)

Opens an interprocess event handles.

hipDeviceSynchronize

hipError_t hipDeviceSynchronize(void)

Waits on all active streams on current device.

hipIpcGetMemHandle

hipError_t hipIpcGetMemHandle(hipIpcMemHandle_t *handle, void *devPtr)

Gets an interprocess memory handle for an existing device memory allocation.

hipInit

hipError_t hipInit(unsigned int flags)

Explicitly initializes the HIP runtime.

hipDeviceComputeCapability

hipError_t hipDeviceComputeCapability(int *major, int *minor, hipDevice_t device)

Returns the compute capability of the device.

hipDeviceGetName

hipError_t hipDeviceGetName(char *name, int len, hipDevice_t device)

Returns an identifer string for the device.

hipDeviceGetByPCIBusId

hipError_t hipDeviceGetByPCIBusId(int *device, const char *pciBusId)

Returns a handle to a compute device.

hipDeviceGetUuid

hipError_t hipDeviceGetUuid(hipUUID *uuid, hipDevice_t device)

Returns an UUID for the device.[BETA].

hipDeviceTotalMem

hipError_t hipDeviceTotalMem(size_t *bytes, hipDevice_t device)

Returns the total amount of memory on the device.

hipDeviceGetPCIBusId

hipError_t hipDeviceGetPCIBusId(char *pciBusId, int len, int device)

Returns a PCI Bus Id string for the device, overloaded to take int device ID.

hipDeviceGet

hipError_t hipDeviceGet(hipDevice_t *device, int ordinal)

Returns a handle to a compute device.

hipRuntimeGetVersion

hipError_t hipRuntimeGetVersion(int *runtimeVersion)

Returns the approximate HIP Runtime version.

hipDeviceGetP2PAttribute

hipError_t hipDeviceGetP2PAttribute(int *value, hipDeviceP2PAttr attr, int srcDevice, int dstDevice)

Returns a value for attribute of link between two devices.

hipDriverGetVersion

hipError_t hipDriverGetVersion(int *driverVersion)

Returns the approximate HIP driver version.

hipMemcpyKind

hipMemcpyKind

Definition: driver_types.h:373

hipPointer_attribute

hipPointer_attribute

Definition: driver_types.h:634

hipArray_t

struct hipArray * hipArray_t

Definition: driver_types.h:75

hipDeviceptr_t

void * hipDeviceptr_t

Definition: driver_types.h:46

hipFunction_attribute

hipFunction_attribute

Definition: driver_types.h:613

hipArray_const_t

const struct hipArray * hipArray_const_t

Definition: driver_types.h:76

hipArray_Format

hipArray_Format

Definition: driver_types.h:80

hipResourceType

hipResourceType

Definition: driver_types.h:159

hipMemcpyDeviceToHost

@ hipMemcpyDeviceToHost

Device-to-Host Copy.

Definition: driver_types.h:376

hipMemcpyHostToDevice

@ hipMemcpyHostToDevice

Host-to-Device Copy.

Definition: driver_types.h:375

hipGetErrorString

const char * hipGetErrorString(hipError_t hipError)

Return handy text string message to explain the error which occurred.

hipPeekAtLastError

hipError_t hipPeekAtLastError(void)

Return last error returned by any HIP runtime API call.

hipDrvGetErrorString

hipError_t hipDrvGetErrorString(hipError_t hipError, const char **errorString)

Return handy text string message to explain the error which occurred.

hipGetLastError

hipError_t hipGetLastError(void)

Return last error returned by any HIP runtime API call and resets the stored error code to hipSuccess...

hipGetErrorName

const char * hipGetErrorName(hipError_t hip_error)

Return hip error as text string form.

hipExtGetLastError

hipError_t hipExtGetLastError(void)

Return last error returned by any HIP runtime API call and resets the stored error code to hipSuccess...

hipDrvGetErrorName

hipError_t hipDrvGetErrorName(hipError_t hipError, const char **errorString)

Return hip error as text string form.

hipEventSynchronize

hipError_t hipEventSynchronize(hipEvent_t event)

Wait for an event to complete.

hipEventQuery

hipError_t hipEventQuery(hipEvent_t event)

Query event status.

hipEventCreate

hipError_t hipEventCreate(hipEvent_t *event)

hipEventDestroy

hipError_t hipEventDestroy(hipEvent_t event)

Destroy the specified event.

hipEventRecordWithFlags

hipError_t hipEventRecordWithFlags(hipEvent_t event, hipStream_t stream, unsigned int flags)

Record an event in the specified stream.

hipEventRecord

hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream=NULL)

Record an event in the specified stream.

hipEventElapsedTime

hipError_t hipEventElapsedTime(float *ms, hipEvent_t start, hipEvent_t stop)

Return the elapsed time between two events.

hipEventCreateWithFlags

hipError_t hipEventCreateWithFlags(hipEvent_t *event, unsigned flags)

Create an event with the specified flags.

hipFuncGetAttributes

hipError_t hipFuncGetAttributes(struct hipFuncAttributes *attr, const void *func)

Find out attributes for a given function.

hipLaunchKernelExC

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.

hipExtLaunchMultiKernelMultiDevice

hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams *launchParamsList, int numDevices, unsigned int flags)

Launches kernels on multiple devices and guarantees all specified kernels are dispatched on respectiv...

hipModuleLaunchKernel

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 kernelp...

hipFuncSetSharedMemConfig

hipError_t hipFuncSetSharedMemConfig(const void *func, hipSharedMemConfig config)

Set shared memory configuation for a specific function.

hipFuncGetAttribute

hipError_t hipFuncGetAttribute(int *value, hipFunction_attribute attrib, hipFunction_t hfunc)

Find out a specific attribute for a given function.

hipFuncSetAttribute

hipError_t hipFuncSetAttribute(const void *func, hipFuncAttribute attr, int value)

Set attribute for a specific function.

hipDrvLaunchKernelEx

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.

hipFuncSetCacheConfig

hipError_t hipFuncSetCacheConfig(const void *func, hipFuncCache_t config)

Set Cache configuration for a specific function.

hipDestroyExternalMemory

hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem)

Destroys an external memory object.

hipImportExternalSemaphore

hipError_t hipImportExternalSemaphore(hipExternalSemaphore_t *extSem_out, const hipExternalSemaphoreHandleDesc *semHandleDesc)

Imports an external semaphore.

hipImportExternalMemory

hipError_t hipImportExternalMemory(hipExternalMemory_t *extMem_out, const hipExternalMemoryHandleDesc *memHandleDesc)

Imports an external memory object.

hipDestroyExternalSemaphore

hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem)

Destroys an external semaphore object and releases any references to the underlying resource....

hipWaitExternalSemaphoresAsync

hipError_t hipWaitExternalSemaphoresAsync(const hipExternalSemaphore_t *extSemArray, const hipExternalSemaphoreWaitParams *paramsArray, unsigned int numExtSems, hipStream_t stream)

Waits on a set of external semaphore objects.

hipSignalExternalSemaphoresAsync

hipError_t hipSignalExternalSemaphoresAsync(const hipExternalSemaphore_t *extSemArray, const hipExternalSemaphoreSignalParams *paramsArray, unsigned int numExtSems, hipStream_t stream)

Signals a set of external semaphore objects.

hipExternalMemoryGetMappedMipmappedArray

hipError_t hipExternalMemoryGetMappedMipmappedArray(hipMipmappedArray_t *mipmap, hipExternalMemory_t extMem, const hipExternalMemoryMipmappedArrayDesc *mipmapDesc)

Maps a mipmapped array onto an external memory object.

hipExternalMemoryGetMappedBuffer

hipError_t hipExternalMemoryGetMappedBuffer(void **devPtr, hipExternalMemory_t extMem, const hipExternalMemoryBufferDesc *bufferDesc)

Maps a buffer onto an imported memory object.

hipLimit_t

hipLimit_t

Definition: hip_runtime_api.h:724

hipMemRangeHandleType

hipMemRangeHandleType

Definition: hip_runtime_api.h:2007

hipMemAllocationHandleType

hipMemAllocationHandleType

Definition: hip_runtime_api.h:1221

hipGraphicsResource_t

hipGraphicsResource * hipGraphicsResource_t

Definition: hip_runtime_api.h:1444

hipCtx_t

struct ihipCtx_t * hipCtx_t

Definition: hip_runtime_api.h:671

__dparm

#define __dparm(x)

Definition: hip_runtime_api.h:653

hipStream_t

struct ihipStream_t * hipStream_t

Definition: hip_runtime_api.h:685

hipGraphInstantiateResult

hipGraphInstantiateResult

Definition: hip_runtime_api.h:1721

hipDevice_t

int hipDevice_t

Definition: hip_runtime_api.h:673

hipAccessProperty

hipAccessProperty

Definition: hip_runtime_api.h:1522

hipLinkState_t

struct ihipLinkState_t * hipLinkState_t

Definition: hip_runtime_api.h:696

hipGraphDependencyType

hipGraphDependencyType

Definition: hip_runtime_api.h:1943

hipMemRangeAttribute

hipMemRangeAttribute

Definition: hip_runtime_api.h:1115

hipMemAttachSingle

#define hipMemAttachSingle

Definition: hip_runtime_api.h:877

hipMemoryAdvise

hipMemoryAdvise

Definition: hip_runtime_api.h:1082

hipArrayDefault

#define hipArrayDefault

Definition: hip_runtime_api.h:936

hipSharedMemConfig

hipSharedMemConfig

Definition: hip_runtime_api.h:1273

hipKernelNodeAttrValue

#define hipKernelNodeAttrValue

Definition: hip_runtime_api.h:1624

hipComputeMode

hipComputeMode

Definition: hip_runtime_api.h:613

hipEvent_t

struct ihipEvent_t * hipEvent_t

Definition: hip_runtime_api.h:716

hipStreamCaptureMode

hipStreamCaptureMode

Definition: hip_runtime_api.h:1653

hipStreamBatchMemOpType

hipStreamBatchMemOpType

Definition: hip_runtime_api.h:957

hipDriverProcAddressQueryResult

hipDriverProcAddressQueryResult

Definition: hip_runtime_api.h:607

HIP_DEPRECATED_MSG

#define HIP_DEPRECATED_MSG

Definition: hip_runtime_api.h:645

hipLaunchAttributeID

hipLaunchAttributeID

Definition: hip_runtime_api.h:1570

hipKernel_t

struct ihipKernel_t * hipKernel_t

Definition: hip_runtime_api.h:698

hipSynchronizationPolicy

hipSynchronizationPolicy

Definition: hip_runtime_api.h:1560

hipGraphNodeType

hipGraphNodeType

Definition: hip_runtime_api.h:1468

hipExternalMemoryHandleType

hipExternalMemoryHandleType

Definition: hip_runtime_api.h:1318

hipMemAttachGlobal

#define hipMemAttachGlobal

Definition: hip_runtime_api.h:871

hipLibrary_t

struct ihipLibrary_t * hipLibrary_t

Definition: hip_runtime_api.h:697

hipFuncAttribute

hipFuncAttribute

Definition: hip_runtime_api.h:1254

hipExternalSemaphoreHandleType

hipExternalSemaphoreHandleType

Definition: hip_runtime_api.h:1356

hipLaunchMemSyncDomain

hipLaunchMemSyncDomain

Definition: hip_runtime_api.h:1551

hipDeviceP2PAttr

hipDeviceP2PAttr

Definition: hip_runtime_api.h:674

hipGraphDebugDotFlags

hipGraphDebugDotFlags

Definition: hip_runtime_api.h:1699

hipUserObjectRetainFlags

hipUserObjectRetainFlags

Definition: hip_runtime_api.h:1684

hipStreamAttrID

#define hipStreamAttrID

Definition: hip_runtime_api.h:1604

hipError_t

enum __HIP_NODISCARD hipError_t hipError_t

Definition: hip_runtime_api.h:305

hipHostAllocDefault

#define hipHostAllocDefault

Definition: hip_runtime_api.h:813

hipHostFn_t

void(* hipHostFn_t)(void *userData)

Definition: hip_runtime_api.h:1487

hipOccupancyDefault

#define hipOccupancyDefault

Definition: hip_runtime_api.h:941

hipStreamUpdateCaptureDependenciesFlags

hipStreamUpdateCaptureDependenciesFlags

Definition: hip_runtime_api.h:1665

hipGraph_t

struct ihipGraph * hipGraph_t

Definition: hip_runtime_api.h:1449

hipChooseDevice

#define hipChooseDevice

Definition: hip_runtime_api.h:105

hipMemHandleType

hipMemHandleType

Definition: hip_runtime_api.h:1803

hipFlushGPUDirectRDMAWritesOptions

hipFlushGPUDirectRDMAWritesOptions

Definition: hip_runtime_api.h:620

hipFuncCache_t

hipFuncCache_t

Definition: hip_runtime_api.h:1264

hipUserObjectFlags

hipUserObjectFlags

Definition: hip_runtime_api.h:1680

__HIP_NODISCARD

#define __HIP_NODISCARD

Definition: hip_runtime_api.h:295

hipGraphMemAttributeType

hipGraphMemAttributeType

Definition: hip_runtime_api.h:1670

hipMemPoolAttr

hipMemPoolAttr

Definition: hip_runtime_api.h:1130

hipDriverEntryPointQueryResult

hipDriverEntryPointQueryResult

Definition: hip_runtime_api.h:680

hipMemRangeFlags

hipMemRangeFlags

Definition: hip_runtime_api.h:2015

hipDeviceProp_t

#define hipDeviceProp_t

Definition: hip_runtime_api.h:104

hipModule_t

struct ihipModule_t * hipModule_t

Definition: hip_runtime_api.h:694

hipUserObject_t

struct hipUserObject * hipUserObject_t

Definition: hip_runtime_api.h:1462

hipMemOperationType

hipMemOperationType

Definition: hip_runtime_api.h:1810

hipExternalSemaphore_t

void * hipExternalSemaphore_t

Definition: hip_runtime_api.h:1381

hipGraphicsRegisterFlags

hipGraphicsRegisterFlags

Definition: hip_runtime_api.h:1432

hipStreamAttrValue

#define hipStreamAttrValue

Definition: hip_runtime_api.h:1611

hipMemRangeCoherencyMode

hipMemRangeCoherencyMode

Definition: hip_runtime_api.h:1103

hipMemAccessFlags

hipMemAccessFlags

Definition: hip_runtime_api.h:1190

hipMemAllocationGranularity_flags

hipMemAllocationGranularity_flags

Definition: hip_runtime_api.h:1795

hipGraphExec_t

struct hipGraphExec * hipGraphExec_t

Definition: hip_runtime_api.h:1457

hipGraphExecUpdateResult

hipGraphExecUpdateResult

Definition: hip_runtime_api.h:1638

hipFunction_t

struct ihipModuleSymbol_t * hipFunction_t

Definition: hip_runtime_api.h:695

hipKernelNodeAttrID

#define hipKernelNodeAttrID

Definition: hip_runtime_api.h:1616

hipExternalMemory_t

void * hipExternalMemory_t

Definition: hip_runtime_api.h:1355

hipStreamCaptureStatus

hipStreamCaptureStatus

Definition: hip_runtime_api.h:1658

hipDeviceAttribute_t

hipDeviceAttribute_t

Definition: hip_runtime_api.h:427

hipGPUDirectRDMAWritesOrdering

hipGPUDirectRDMAWritesOrdering

Definition: hip_runtime_api.h:625

hipGetDeviceProperties

#define hipGetDeviceProperties

Definition: hip_runtime_api.h:103

hipHostMallocDefault

#define hipHostMallocDefault

Definition: hip_runtime_api.h:817

HIP_DEPRECATED

#define HIP_DEPRECATED(msg)

Definition: hip_runtime_api.h:643

hipGraphicsResource

struct _hipGraphicsResource hipGraphicsResource

Definition: hip_runtime_api.h:1442

hipMemAllocationType

hipMemAllocationType

Definition: hip_runtime_api.h:1208

hipGraphNode_t

struct hipGraphNode * hipGraphNode_t

Definition: hip_runtime_api.h:1453

hipMemGenericAllocationHandle_t

struct ihipMemGenericAllocationHandle * hipMemGenericAllocationHandle_t

Definition: hip_runtime_api.h:1790

hipMemoryType

hipMemoryType

Definition: hip_runtime_api.h:263

hipGraphInstantiateFlags

hipGraphInstantiateFlags

Definition: hip_runtime_api.h:1688

HIP_IPC_HANDLE_SIZE

#define HIP_IPC_HANDLE_SIZE

Definition: hip_runtime_api.h:687

hipMemPool_t

struct ihipMemPoolHandle_t * hipMemPool_t

Definition: hip_runtime_api.h:702

hipArraySparseSubresourceType

hipArraySparseSubresourceType

Definition: hip_runtime_api.h:1818

hipExtLimitScratchMin

@ hipExtLimitScratchMin

Definition: hip_runtime_api.h:732

hipLimitMallocHeapSize

@ hipLimitMallocHeapSize

Definition: hip_runtime_api.h:730

hipLimitStackSize

@ hipLimitStackSize

Definition: hip_runtime_api.h:725

hipLimitRange

@ hipLimitRange

Supported limit range.

Definition: hip_runtime_api.h:740

hipLimitPrintfFifoSize

@ hipLimitPrintfFifoSize

Definition: hip_runtime_api.h:728

hipExtLimitScratchMax

@ hipExtLimitScratchMax

Definition: hip_runtime_api.h:734

hipExtLimitScratchCurrent

@ hipExtLimitScratchCurrent

Definition: hip_runtime_api.h:736

hipMemRangeHandleTypeMax

@ hipMemRangeHandleTypeMax

Definition: hip_runtime_api.h:2009

hipMemRangeHandleTypeDmaBufFd

@ hipMemRangeHandleTypeDmaBufFd

Definition: hip_runtime_api.h:2008

hipMemHandleTypeWin32

@ hipMemHandleTypeWin32

Allows a Win32 NT handle for exporting. (HANDLE)

Definition: hip_runtime_api.h:1225

hipMemHandleTypeWin32Kmt

@ hipMemHandleTypeWin32Kmt

Allows a Win32 KMT handle for exporting. (D3DKMT_HANDLE)

Definition: hip_runtime_api.h:1226

hipMemHandleTypeNone

@ hipMemHandleTypeNone

Does not allow any export mechanism.

Definition: hip_runtime_api.h:1222

hipMemHandleTypePosixFileDescriptor

@ hipMemHandleTypePosixFileDescriptor

Allows a file descriptor for exporting. Permitted only on POSIX systems.

Definition: hip_runtime_api.h:1223

hipGraphInstantiateNodeOperationNotSupported

@ hipGraphInstantiateNodeOperationNotSupported

Definition: hip_runtime_api.h:1727

hipGraphInstantiateMultipleDevicesNotSupported

@ hipGraphInstantiateMultipleDevicesNotSupported

Definition: hip_runtime_api.h:1729

hipGraphInstantiateError

@ hipGraphInstantiateError

Definition: hip_runtime_api.h:1723

hipGraphInstantiateInvalidStructure

@ hipGraphInstantiateInvalidStructure

Definition: hip_runtime_api.h:1725

hipGraphInstantiateSuccess

@ hipGraphInstantiateSuccess

Definition: hip_runtime_api.h:1722

hipAccessPropertyNormal

@ hipAccessPropertyNormal

Normal cache persistence.

Definition: hip_runtime_api.h:1523

hipAccessPropertyPersisting

@ hipAccessPropertyPersisting

Persisting access is more likely to persist in cache.

Definition: hip_runtime_api.h:1525

hipAccessPropertyStreaming

@ hipAccessPropertyStreaming

Streaming access is less likely to persist from cache.

Definition: hip_runtime_api.h:1524

hipGraphDependencyTypeDefault

@ hipGraphDependencyTypeDefault

Definition: hip_runtime_api.h:1944

hipGraphDependencyTypeProgrammatic

@ hipGraphDependencyTypeProgrammatic

Definition: hip_runtime_api.h:1945

hipMemRangeAttributeLastPrefetchLocation

@ hipMemRangeAttributeLastPrefetchLocation

Definition: hip_runtime_api.h:1121

hipMemRangeAttributePreferredLocation

@ hipMemRangeAttributePreferredLocation

The preferred location of the range.

Definition: hip_runtime_api.h:1118

hipMemRangeAttributeAccessedBy

@ hipMemRangeAttributeAccessedBy

Definition: hip_runtime_api.h:1119

hipMemRangeAttributeReadMostly

@ hipMemRangeAttributeReadMostly

Definition: hip_runtime_api.h:1116

hipMemRangeAttributeCoherencyMode

@ hipMemRangeAttributeCoherencyMode

Definition: hip_runtime_api.h:1123

hipMemAdviseUnsetAccessedBy

@ hipMemAdviseUnsetAccessedBy

Definition: hip_runtime_api.h:1091

hipMemAdviseUnsetCoarseGrain

@ hipMemAdviseUnsetCoarseGrain

Restores cache coherency policy back to fine-grain.

Definition: hip_runtime_api.h:1098

hipMemAdviseSetCoarseGrain

@ hipMemAdviseSetCoarseGrain

Definition: hip_runtime_api.h:1093

hipMemAdviseUnsetPreferredLocation

@ hipMemAdviseUnsetPreferredLocation

Clear the preferred location for the data.

Definition: hip_runtime_api.h:1088

hipMemAdviseSetAccessedBy

@ hipMemAdviseSetAccessedBy

Definition: hip_runtime_api.h:1089

hipMemAdviseSetPreferredLocation

@ hipMemAdviseSetPreferredLocation

Definition: hip_runtime_api.h:1086

hipMemAdviseSetReadMostly

@ hipMemAdviseSetReadMostly

Definition: hip_runtime_api.h:1083

hipMemAdviseUnsetReadMostly

@ hipMemAdviseUnsetReadMostly

Undo the effect of hipMemAdviseSetReadMostly.

Definition: hip_runtime_api.h:1085

hipSharedMemBankSizeFourByte

@ hipSharedMemBankSizeFourByte

Definition: hip_runtime_api.h:1275

hipSharedMemBankSizeEightByte

@ hipSharedMemBankSizeEightByte

Definition: hip_runtime_api.h:1277

hipSharedMemBankSizeDefault

@ hipSharedMemBankSizeDefault

The compiler selects a device-specific value for the banking.

Definition: hip_runtime_api.h:1274

hipComputeModeProhibited

@ hipComputeModeProhibited

Definition: hip_runtime_api.h:616

hipComputeModeExclusive

@ hipComputeModeExclusive

Definition: hip_runtime_api.h:615

hipComputeModeDefault

@ hipComputeModeDefault

Definition: hip_runtime_api.h:614

hipComputeModeExclusiveProcess

@ hipComputeModeExclusiveProcess

Definition: hip_runtime_api.h:617

hipStreamCaptureModeRelaxed

@ hipStreamCaptureModeRelaxed

Definition: hip_runtime_api.h:1656

hipStreamCaptureModeThreadLocal

@ hipStreamCaptureModeThreadLocal

Definition: hip_runtime_api.h:1655

hipStreamCaptureModeGlobal

@ hipStreamCaptureModeGlobal

Definition: hip_runtime_api.h:1654

hipStreamMemOpWriteValue64

@ hipStreamMemOpWriteValue64

Definition: hip_runtime_api.h:961

hipStreamMemOpBarrier

@ hipStreamMemOpBarrier

Currently not supported.

Definition: hip_runtime_api.h:962

hipStreamMemOpWriteValue32

@ hipStreamMemOpWriteValue32

Definition: hip_runtime_api.h:959

hipStreamMemOpWaitValue32

@ hipStreamMemOpWaitValue32

Definition: hip_runtime_api.h:958

hipStreamMemOpWaitValue64

@ hipStreamMemOpWaitValue64

Definition: hip_runtime_api.h:960

hipStreamMemOpFlushRemoteWrites

@ hipStreamMemOpFlushRemoteWrites

Currently not supported.

Definition: hip_runtime_api.h:963

HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND

@ HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND

Definition: hip_runtime_api.h:609

HIP_GET_PROC_ADDRESS_SUCCESS

@ HIP_GET_PROC_ADDRESS_SUCCESS

Definition: hip_runtime_api.h:608

HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT

@ HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT

Definition: hip_runtime_api.h:610

hipLaunchAttributePriority

@ hipLaunchAttributePriority

Valid for graph node, streams, launches.

Definition: hip_runtime_api.h:1574

hipLaunchAttributeMax

@ hipLaunchAttributeMax

Definition: hip_runtime_api.h:1577

hipLaunchAttributeMemSyncDomain

@ hipLaunchAttributeMemSyncDomain

Valid for streams, graph nodes, launches.

Definition: hip_runtime_api.h:1576

hipLaunchAttributeMemSyncDomainMap

@ hipLaunchAttributeMemSyncDomainMap

Valid for streams, graph nodes, launches.

Definition: hip_runtime_api.h:1575

hipLaunchAttributeSynchronizationPolicy

@ hipLaunchAttributeSynchronizationPolicy

Valid for streams.

Definition: hip_runtime_api.h:1573

hipLaunchAttributeAccessPolicyWindow

@ hipLaunchAttributeAccessPolicyWindow

Valid for Streams, graph nodes, launches.

Definition: hip_runtime_api.h:1571

hipLaunchAttributeCooperative

@ hipLaunchAttributeCooperative

Valid for graph nodes, launches.

Definition: hip_runtime_api.h:1572

hipSyncPolicyYield

@ hipSyncPolicyYield

Definition: hip_runtime_api.h:1563

hipSyncPolicyBlockingSync

@ hipSyncPolicyBlockingSync

Definition: hip_runtime_api.h:1564

hipSyncPolicyAuto

@ hipSyncPolicyAuto

Definition: hip_runtime_api.h:1561

hipSyncPolicySpin

@ hipSyncPolicySpin

Definition: hip_runtime_api.h:1562

hipGraphNodeTypeBatchMemOp

@ hipGraphNodeTypeBatchMemOp

BatchMemOp node.

Definition: hip_runtime_api.h:1483

hipGraphNodeTypeGraph

@ hipGraphNodeTypeGraph

Node which executes an embedded graph.

Definition: hip_runtime_api.h:1473

hipGraphNodeTypeMemset

@ hipGraphNodeTypeMemset

Memset node.

Definition: hip_runtime_api.h:1471

hipGraphNodeTypeEventRecord

@ hipGraphNodeTypeEventRecord

External event record node.

Definition: hip_runtime_api.h:1476

hipGraphNodeTypeExtSemaphoreSignal

@ hipGraphNodeTypeExtSemaphoreSignal

External Semaphore signal node.

Definition: hip_runtime_api.h:1477

hipGraphNodeTypeMemcpy

@ hipGraphNodeTypeMemcpy

Memcpy node.

Definition: hip_runtime_api.h:1470

hipGraphNodeTypeWaitEvent

@ hipGraphNodeTypeWaitEvent

External event wait node.

Definition: hip_runtime_api.h:1475

hipGraphNodeTypeCount

@ hipGraphNodeTypeCount

Definition: hip_runtime_api.h:1484

hipGraphNodeTypeKernel

@ hipGraphNodeTypeKernel

GPU kernel node.

Definition: hip_runtime_api.h:1469

hipGraphNodeTypeHost

@ hipGraphNodeTypeHost

Host (executable) node.

Definition: hip_runtime_api.h:1472

hipGraphNodeTypeMemAlloc

@ hipGraphNodeTypeMemAlloc

Memory alloc node.

Definition: hip_runtime_api.h:1479

hipGraphNodeTypeMemFree

@ hipGraphNodeTypeMemFree

Memory free node.

Definition: hip_runtime_api.h:1480

hipGraphNodeTypeMemcpyFromSymbol

@ hipGraphNodeTypeMemcpyFromSymbol

MemcpyFromSymbol node.

Definition: hip_runtime_api.h:1481

hipGraphNodeTypeMemcpyToSymbol

@ hipGraphNodeTypeMemcpyToSymbol

MemcpyToSymbol node.

Definition: hip_runtime_api.h:1482

hipGraphNodeTypeEmpty

@ hipGraphNodeTypeEmpty

Empty (no-op) node.

Definition: hip_runtime_api.h:1474

hipGraphNodeTypeExtSemaphoreWait

@ hipGraphNodeTypeExtSemaphoreWait

External Semaphore wait node.

Definition: hip_runtime_api.h:1478

hipExternalMemoryHandleTypeD3D11Resource

@ hipExternalMemoryHandleTypeD3D11Resource

Definition: hip_runtime_api.h:1324

hipExternalMemoryHandleTypeD3D12Resource

@ hipExternalMemoryHandleTypeD3D12Resource

Definition: hip_runtime_api.h:1323

hipExternalMemoryHandleTypeNvSciBuf

@ hipExternalMemoryHandleTypeNvSciBuf

Definition: hip_runtime_api.h:1326

hipExternalMemoryHandleTypeOpaqueFd

@ hipExternalMemoryHandleTypeOpaqueFd

Definition: hip_runtime_api.h:1319

hipExternalMemoryHandleTypeD3D12Heap

@ hipExternalMemoryHandleTypeD3D12Heap

Definition: hip_runtime_api.h:1322

hipExternalMemoryHandleTypeOpaqueWin32Kmt

@ hipExternalMemoryHandleTypeOpaqueWin32Kmt

Definition: hip_runtime_api.h:1321

hipExternalMemoryHandleTypeOpaqueWin32

@ hipExternalMemoryHandleTypeOpaqueWin32

Definition: hip_runtime_api.h:1320

hipExternalMemoryHandleTypeD3D11ResourceKmt

@ hipExternalMemoryHandleTypeD3D11ResourceKmt

Definition: hip_runtime_api.h:1325

hipFuncAttributePreferredSharedMemoryCarveout

@ hipFuncAttributePreferredSharedMemoryCarveout

Sets the percentage of total shared memory allocated as the shared memory carveout.

Definition: hip_runtime_api.h:1257

hipFuncAttributeMaxDynamicSharedMemorySize

@ hipFuncAttributeMaxDynamicSharedMemorySize

The maximum number of bytes requested for dynamically allocated shared memory.

Definition: hip_runtime_api.h:1255

hipFuncAttributeMax

@ hipFuncAttributeMax

Definition: hip_runtime_api.h:1259

hipExternalSemaphoreHandleTypeNvSciSync

@ hipExternalSemaphoreHandleTypeNvSciSync

Definition: hip_runtime_api.h:1362

hipExternalSemaphoreHandleTypeKeyedMutexKmt

@ hipExternalSemaphoreHandleTypeKeyedMutexKmt

Definition: hip_runtime_api.h:1364

hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

@ hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

Definition: hip_runtime_api.h:1359

hipExternalSemaphoreHandleTypeKeyedMutex

@ hipExternalSemaphoreHandleTypeKeyedMutex

Definition: hip_runtime_api.h:1363

hipExternalSemaphoreHandleTypeD3D11Fence

@ hipExternalSemaphoreHandleTypeD3D11Fence

Definition: hip_runtime_api.h:1361

hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

@ hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

Definition: hip_runtime_api.h:1366

hipExternalSemaphoreHandleTypeOpaqueFd

@ hipExternalSemaphoreHandleTypeOpaqueFd

Definition: hip_runtime_api.h:1357

hipExternalSemaphoreHandleTypeOpaqueWin32

@ hipExternalSemaphoreHandleTypeOpaqueWin32

Definition: hip_runtime_api.h:1358

hipExternalSemaphoreHandleTypeTimelineSemaphoreFd

@ hipExternalSemaphoreHandleTypeTimelineSemaphoreFd

Definition: hip_runtime_api.h:1365

hipExternalSemaphoreHandleTypeD3D12Fence

@ hipExternalSemaphoreHandleTypeD3D12Fence

Definition: hip_runtime_api.h:1360

hipLaunchMemSyncDomainRemote

@ hipLaunchMemSyncDomainRemote

Definition: hip_runtime_api.h:1553

hipLaunchMemSyncDomainDefault

@ hipLaunchMemSyncDomainDefault

Definition: hip_runtime_api.h:1552

hipDevP2PAttrAccessSupported

@ hipDevP2PAttrAccessSupported

Definition: hip_runtime_api.h:676

hipDevP2PAttrHipArrayAccessSupported

@ hipDevP2PAttrHipArrayAccessSupported

Definition: hip_runtime_api.h:678

hipDevP2PAttrNativeAtomicSupported

@ hipDevP2PAttrNativeAtomicSupported

Definition: hip_runtime_api.h:677

hipDevP2PAttrPerformanceRank

@ hipDevP2PAttrPerformanceRank

Definition: hip_runtime_api.h:675

hipGraphDebugDotFlagsKernelNodeAttributes

@ hipGraphDebugDotFlagsKernelNodeAttributes

Definition: hip_runtime_api.h:1712

hipGraphDebugDotFlagsMemsetNodeParams

@ hipGraphDebugDotFlagsMemsetNodeParams

Definition: hip_runtime_api.h:1704

hipGraphDebugDotFlagsKernelNodeParams

@ hipGraphDebugDotFlagsKernelNodeParams

Definition: hip_runtime_api.h:1702

hipGraphDebugDotFlagsExtSemasWaitNodeParams

@ hipGraphDebugDotFlagsExtSemasWaitNodeParams

Definition: hip_runtime_api.h:1710

hipGraphDebugDotFlagsHandles

@ hipGraphDebugDotFlagsHandles

Definition: hip_runtime_api.h:1714

hipGraphDebugDotFlagsExtSemasSignalNodeParams

@ hipGraphDebugDotFlagsExtSemasSignalNodeParams

Definition: hip_runtime_api.h:1708

hipGraphDebugDotFlagsHostNodeParams

@ hipGraphDebugDotFlagsHostNodeParams

Definition: hip_runtime_api.h:1705

hipGraphDebugDotFlagsEventNodeParams

@ hipGraphDebugDotFlagsEventNodeParams

Definition: hip_runtime_api.h:1706

hipGraphDebugDotFlagsVerbose

@ hipGraphDebugDotFlagsVerbose

Definition: hip_runtime_api.h:1700

hipGraphDebugDotFlagsMemcpyNodeParams

@ hipGraphDebugDotFlagsMemcpyNodeParams

Definition: hip_runtime_api.h:1703

hipGraphUserObjectMove

@ hipGraphUserObjectMove

Add new reference or retain.

Definition: hip_runtime_api.h:1685

hipStreamAddCaptureDependencies

@ hipStreamAddCaptureDependencies

Add new nodes to the dependency set.

Definition: hip_runtime_api.h:1666

hipStreamSetCaptureDependencies

@ hipStreamSetCaptureDependencies

Replace the dependency set with the new nodes.

Definition: hip_runtime_api.h:1667

hipMemHandleTypeGeneric

@ hipMemHandleTypeGeneric

Generic handle type.

Definition: hip_runtime_api.h:1804

hipFlushGPUDirectRDMAWritesOptionHost

@ hipFlushGPUDirectRDMAWritesOptionHost

Definition: hip_runtime_api.h:621

hipFlushGPUDirectRDMAWritesOptionMemOps

@ hipFlushGPUDirectRDMAWritesOptionMemOps

Definition: hip_runtime_api.h:622

hipFuncCachePreferNone

@ hipFuncCachePreferNone

no preference for shared memory or L1 (default)

Definition: hip_runtime_api.h:1265

hipFuncCachePreferEqual

@ hipFuncCachePreferEqual

prefer equal size L1 cache and shared memory

Definition: hip_runtime_api.h:1268

hipFuncCachePreferL1

@ hipFuncCachePreferL1

prefer larger L1 cache and smaller shared memory

Definition: hip_runtime_api.h:1267

hipFuncCachePreferShared

@ hipFuncCachePreferShared

prefer larger shared memory and smaller L1 cache

Definition: hip_runtime_api.h:1266

hipUserObjectNoDestructorSync

@ hipUserObjectNoDestructorSync

Destructor execution is not synchronized.

Definition: hip_runtime_api.h:1681

hipGraphMemAttrReservedMemHigh

@ hipGraphMemAttrReservedMemHigh

Definition: hip_runtime_api.h:1677

hipGraphMemAttrUsedMemCurrent

@ hipGraphMemAttrUsedMemCurrent

Amount of memory, in bytes, currently associated with graphs.

Definition: hip_runtime_api.h:1671

hipGraphMemAttrUsedMemHigh

@ hipGraphMemAttrUsedMemHigh

Definition: hip_runtime_api.h:1673

hipGraphMemAttrReservedMemCurrent

@ hipGraphMemAttrReservedMemCurrent

Definition: hip_runtime_api.h:1675

hipMemPoolAttrUsedMemCurrent

@ hipMemPoolAttrUsedMemCurrent

Definition: hip_runtime_api.h:1177

hipMemPoolAttrReservedMemHigh

@ hipMemPoolAttrReservedMemHigh

Definition: hip_runtime_api.h:1172

hipMemPoolAttrReservedMemCurrent

@ hipMemPoolAttrReservedMemCurrent

Definition: hip_runtime_api.h:1166

hipMemPoolAttrReleaseThreshold

@ hipMemPoolAttrReleaseThreshold

Definition: hip_runtime_api.h:1161

hipMemPoolAttrUsedMemHigh

@ hipMemPoolAttrUsedMemHigh

Definition: hip_runtime_api.h:1183

hipMemPoolReuseAllowInternalDependencies

@ hipMemPoolReuseAllowInternalDependencies

Definition: hip_runtime_api.h:1152

hipMemPoolReuseFollowEventDependencies

@ hipMemPoolReuseFollowEventDependencies

Definition: hip_runtime_api.h:1139

hipMemPoolReuseAllowOpportunistic

@ hipMemPoolReuseAllowOpportunistic

Definition: hip_runtime_api.h:1145

hipDriverEntryPointSuccess

@ hipDriverEntryPointSuccess

Definition: hip_runtime_api.h:681

hipDriverEntryPointSymbolNotFound

@ hipDriverEntryPointSymbolNotFound

Definition: hip_runtime_api.h:682

hipDriverEntryPointVersionNotSufficent

@ hipDriverEntryPointVersionNotSufficent

Definition: hip_runtime_api.h:683

hipMemRangeFlagsMax

@ hipMemRangeFlagsMax

Definition: hip_runtime_api.h:2017

hipMemRangeFlagDmaBufMappingTypePcie

@ hipMemRangeFlagDmaBufMappingTypePcie

Definition: hip_runtime_api.h:2016

hipMemOperationTypeMap

@ hipMemOperationTypeMap

Map operation.

Definition: hip_runtime_api.h:1811

hipMemOperationTypeUnmap

@ hipMemOperationTypeUnmap

Unmap operation.

Definition: hip_runtime_api.h:1812

hipGraphicsRegisterFlagsReadOnly

@ hipGraphicsRegisterFlagsReadOnly

HIP will not write to this registered resource.

Definition: hip_runtime_api.h:1434

hipGraphicsRegisterFlagsTextureGather

@ hipGraphicsRegisterFlagsTextureGather

HIP will perform texture gather operations on this registered resource.

Definition: hip_runtime_api.h:1438

hipGraphicsRegisterFlagsWriteDiscard

@ hipGraphicsRegisterFlagsWriteDiscard

HIP will only write and will not read from this registered resource.

Definition: hip_runtime_api.h:1435

hipGraphicsRegisterFlagsNone

@ hipGraphicsRegisterFlagsNone

Definition: hip_runtime_api.h:1433

hipGraphicsRegisterFlagsSurfaceLoadStore

@ hipGraphicsRegisterFlagsSurfaceLoadStore

HIP will bind this resource to a surface.

Definition: hip_runtime_api.h:1437

hipMemRangeCoherencyModeFineGrain

@ hipMemRangeCoherencyModeFineGrain

Definition: hip_runtime_api.h:1104

hipMemRangeCoherencyModeIndeterminate

@ hipMemRangeCoherencyModeIndeterminate

Definition: hip_runtime_api.h:1108

hipMemRangeCoherencyModeCoarseGrain

@ hipMemRangeCoherencyModeCoarseGrain

Definition: hip_runtime_api.h:1106

hipMemAccessFlagsProtRead

@ hipMemAccessFlagsProtRead

Set the address range read accessible.

Definition: hip_runtime_api.h:1192

hipMemAccessFlagsProtNone

@ hipMemAccessFlagsProtNone

Default, make the address range not accessible.

Definition: hip_runtime_api.h:1191

hipMemAccessFlagsProtReadWrite

@ hipMemAccessFlagsProtReadWrite

Set the address range read-write accessible.

Definition: hip_runtime_api.h:1193

hipMemAllocationGranularityMinimum

@ hipMemAllocationGranularityMinimum

Minimum granularity.

Definition: hip_runtime_api.h:1796

hipMemAllocationGranularityRecommended

@ hipMemAllocationGranularityRecommended

Recommended granularity for performance.

Definition: hip_runtime_api.h:1797

hipGraphExecUpdateErrorNotSupported

@ hipGraphExecUpdateErrorNotSupported

The update failed because something about the node is not supported.

Definition: hip_runtime_api.h:1648

hipGraphExecUpdateErrorNodeTypeChanged

@ hipGraphExecUpdateErrorNodeTypeChanged

The update failed because a node type changed.

Definition: hip_runtime_api.h:1643

hipGraphExecUpdateErrorTopologyChanged

@ hipGraphExecUpdateErrorTopologyChanged

The update failed because the topology changed.

Definition: hip_runtime_api.h:1642

hipGraphExecUpdateErrorUnsupportedFunctionChange

@ hipGraphExecUpdateErrorUnsupportedFunctionChange

Definition: hip_runtime_api.h:1650

hipGraphExecUpdateError

@ hipGraphExecUpdateError

Definition: hip_runtime_api.h:1640

hipGraphExecUpdateErrorFunctionChanged

@ hipGraphExecUpdateErrorFunctionChanged

The update failed because the function of a kernel node changed.

Definition: hip_runtime_api.h:1644

hipGraphExecUpdateSuccess

@ hipGraphExecUpdateSuccess

The update succeeded.

Definition: hip_runtime_api.h:1639

hipGraphExecUpdateErrorParametersChanged

@ hipGraphExecUpdateErrorParametersChanged

The update failed because the parameters changed in a way that is not supported.

Definition: hip_runtime_api.h:1646

hipStreamCaptureStatusInvalidated

@ hipStreamCaptureStatusInvalidated

Definition: hip_runtime_api.h:1661

hipStreamCaptureStatusNone

@ hipStreamCaptureStatusNone

Stream is not capturing.

Definition: hip_runtime_api.h:1659

hipStreamCaptureStatusActive

@ hipStreamCaptureStatusActive

Stream is actively capturing.

Definition: hip_runtime_api.h:1660

hipDeviceAttributeDirectManagedMemAccessFromHost

@ hipDeviceAttributeDirectManagedMemAccessFromHost

Definition: hip_runtime_api.h:452

hipDeviceAttributeSurfaceAlignment

@ hipDeviceAttributeSurfaceAlignment

Alignment requirement for surfaces.

Definition: hip_runtime_api.h:542

hipDeviceAttributeMaxGridDimX

@ hipDeviceAttributeMaxGridDimX

Max grid size in width.

Definition: hip_runtime_api.h:473

hipDeviceAttributeMaxSurfaceCubemapLayered

@ hipDeviceAttributeMaxSurfaceCubemapLayered

Definition: hip_runtime_api.h:482

hipDeviceAttributeMaxSurface3D

@ hipDeviceAttributeMaxSurface3D

Maximum dimension (width, height, depth) of 3D surface.

Definition: hip_runtime_api.h:480

hipDeviceAttributeMaxPitch

@ hipDeviceAttributeMaxPitch

Maximum pitch in bytes allowed by memory copies.

Definition: hip_runtime_api.h:507

hipDeviceAttributeTccDriver

@ hipDeviceAttributeTccDriver

Cuda only. Whether device is a Tesla device using TCC driver.

Definition: hip_runtime_api.h:543

hipDeviceAttributeHostNativeAtomicSupported

@ hipDeviceAttributeHostNativeAtomicSupported

Definition: hip_runtime_api.h:455

hipDeviceAttributePageableMemoryAccessUsesHostPageTables

@ hipDeviceAttributePageableMemoryAccessUsesHostPageTables

Definition: hip_runtime_api.h:520

hipDeviceAttributeUnused5

@ hipDeviceAttributeUnused5

Previously hipDeviceAttributeGcnArchName.

Definition: hip_runtime_api.h:572

hipDeviceAttributeMaxBlockDimY

@ hipDeviceAttributeMaxBlockDimY

Max block size in height.

Definition: hip_runtime_api.h:471

hipDeviceAttributeMaxSurfaceCubemap

@ hipDeviceAttributeMaxSurfaceCubemap

Cuda only. Maximum dimensions of Cubemap surface.

Definition: hip_runtime_api.h:481

hipDeviceAttributePageableMemoryAccess

@ hipDeviceAttributePageableMemoryAccess

Definition: hip_runtime_api.h:518

hipDeviceAttributeClockRate

@ hipDeviceAttributeClockRate

Peak clock frequency in kilohertz.

Definition: hip_runtime_api.h:440

hipDeviceAttributeCudaCompatibleEnd

@ hipDeviceAttributeCudaCompatibleEnd

Definition: hip_runtime_api.h:563

hipDeviceAttributeMaxTexture1DMipmap

@ hipDeviceAttributeMaxTexture1DMipmap

Maximum size of 1D mipmapped texture.

Definition: hip_runtime_api.h:489

hipDeviceAttributeComputeCapabilityMajor

@ hipDeviceAttributeComputeCapabilityMajor

Major compute capability version number.

Definition: hip_runtime_api.h:467

hipDeviceAttributeGlobalL1CacheSupported

@ hipDeviceAttributeGlobalL1CacheSupported

Device supports caching globals in L1.

Definition: hip_runtime_api.h:454

hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

Definition: hip_runtime_api.h:584

hipDeviceAttributeAccessPolicyMaxWindowSize

@ hipDeviceAttributeAccessPolicyMaxWindowSize

Definition: hip_runtime_api.h:432

hipDeviceAttributeMaxTexture3DHeight

@ hipDeviceAttributeMaxTexture3DHeight

Maximum dimension height of 3D texture.

Definition: hip_runtime_api.h:499

hipDeviceAttributeComputeCapabilityMinor

@ hipDeviceAttributeComputeCapabilityMinor

Minor compute capability version number.

Definition: hip_runtime_api.h:510

hipDeviceAttributeNumberOfXccs

@ hipDeviceAttributeNumberOfXccs

The number of XCC(s) on the device.

Definition: hip_runtime_api.h:596

hipDeviceAttributeMaxTextureCubemap

@ hipDeviceAttributeMaxTextureCubemap

Maximum dimensions of Cubemap texture.

Definition: hip_runtime_api.h:502

hipDeviceAttributeDeviceOverlap

@ hipDeviceAttributeDeviceOverlap

Definition: hip_runtime_api.h:450

hipDeviceAttributeMaxTexture2DLinear

@ hipDeviceAttributeMaxTexture2DLinear

Definition: hip_runtime_api.h:495

hipDeviceAttributeMaxSurface2D

@ hipDeviceAttributeMaxSurface2D

Maximum dimension (width, height) of 2D surface.

Definition: hip_runtime_api.h:478

hipDeviceAttributeMaxSurface1DLayered

@ hipDeviceAttributeMaxSurface1DLayered

Cuda only. Maximum dimensions of 1D layered surface.

Definition: hip_runtime_api.h:477

hipDeviceAttributeHdpRegFlushCntl

@ hipDeviceAttributeHdpRegFlushCntl

Address of the HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition: hip_runtime_api.h:574

hipDeviceAttributeMaxAvailableVgprsPerThread

@ hipDeviceAttributeMaxAvailableVgprsPerThread

Definition: hip_runtime_api.h:597

hipDeviceAttributeComputeMode

@ hipDeviceAttributeComputeMode

Compute mode that device is currently in.

Definition: hip_runtime_api.h:441

hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

Definition: hip_runtime_api.h:575

hipDeviceAttributeAsicRevision

@ hipDeviceAttributeAsicRevision

Revision of the GPU in this device.

Definition: hip_runtime_api.h:588

hipDeviceAttributeUnused4

@ hipDeviceAttributeUnused4

Previously hipDeviceAttributeGcnArch.

Definition: hip_runtime_api.h:571

hipDeviceAttributeCooperativeMultiDeviceLaunch

@ hipDeviceAttributeCooperativeMultiDeviceLaunch

Definition: hip_runtime_api.h:448

hipDeviceAttributeMaxTexture2DHeight

@ hipDeviceAttributeMaxTexture2DHeight

Maximum dimension hight of 2D texture.

Definition: hip_runtime_api.h:491

hipDeviceAttributePersistingL2CacheMaxSize

@ hipDeviceAttributePersistingL2CacheMaxSize

Maximum l2 persisting lines capacity in bytes.

Definition: hip_runtime_api.h:527

hipDeviceAttributeEccEnabled

@ hipDeviceAttributeEccEnabled

Whether ECC support is enabled.

Definition: hip_runtime_api.h:430

hipDeviceAttributeCanUseHostPointerForRegisteredMem

@ hipDeviceAttributeCanUseHostPointerForRegisteredMem

Definition: hip_runtime_api.h:437

hipDeviceAttributePciBusId

@ hipDeviceAttributePciBusId

PCI Bus ID.

Definition: hip_runtime_api.h:522

hipDeviceAttributeL2CacheSize

@ hipDeviceAttributeL2CacheSize

Definition: hip_runtime_api.h:460

hipDeviceAttributeKernelExecTimeout

@ hipDeviceAttributeKernelExecTimeout

Run time limit for kernels executed on the device.

Definition: hip_runtime_api.h:459

hipDeviceAttributeMaxThreadsDim

@ hipDeviceAttributeMaxThreadsDim

Maximum dimension of a block.

Definition: hip_runtime_api.h:504

hipDeviceAttributeSingleToDoublePrecisionPerfRatio

@ hipDeviceAttributeSingleToDoublePrecisionPerfRatio

Definition: hip_runtime_api.h:539

hipDeviceAttributeMaxGridDimY

@ hipDeviceAttributeMaxGridDimY

Max grid size in height.

Definition: hip_runtime_api.h:474

hipDeviceAttributeMultiprocessorCount

@ hipDeviceAttributeMultiprocessorCount

Definition: hip_runtime_api.h:513

hipDeviceAttributeAmdSpecificBegin

@ hipDeviceAttributeAmdSpecificBegin

Definition: hip_runtime_api.h:564

hipDeviceAttributeMaxRegistersPerMultiprocessor

@ hipDeviceAttributeMaxRegistersPerMultiprocessor

32-bit registers available per block.

Definition: hip_runtime_api.h:531

hipDeviceAttributeIsMultiGpuBoard

@ hipDeviceAttributeIsMultiGpuBoard

Multiple GPU devices.

Definition: hip_runtime_api.h:458

hipDeviceAttributeSharedMemPerBlockOptin

@ hipDeviceAttributeSharedMemPerBlockOptin

Definition: hip_runtime_api.h:536

hipDeviceAttributeMaxSurface2DLayered

@ hipDeviceAttributeMaxSurface2DLayered

Cuda only. Maximum dimensions of 2D layered surface.

Definition: hip_runtime_api.h:479

hipDeviceAttributeAmdSpecificEnd

@ hipDeviceAttributeAmdSpecificEnd

Definition: hip_runtime_api.h:602

hipDeviceAttributeMemoryClockRate

@ hipDeviceAttributeMemoryClockRate

Peak memory clock frequency in kilohertz.

Definition: hip_runtime_api.h:509

hipDeviceAttributeMaxGridDimZ

@ hipDeviceAttributeMaxGridDimZ

Max grid size in depth.

Definition: hip_runtime_api.h:475

hipDeviceAttributeHdpMemFlushCntl

@ hipDeviceAttributeHdpMemFlushCntl

Address of the HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition: hip_runtime_api.h:573

hipDeviceAttributeUnused2

@ hipDeviceAttributeUnused2

Previously hipDeviceAttributeUuid.

Definition: hip_runtime_api.h:551

hipDeviceAttributeFineGrainSupport

@ hipDeviceAttributeFineGrainSupport

'1' if Device supports fine grain, '0' otherwise

Definition: hip_runtime_api.h:594

hipDeviceAttributeCooperativeLaunch

@ hipDeviceAttributeCooperativeLaunch

Support cooperative launch.

Definition: hip_runtime_api.h:447

hipDeviceAttributeUnifiedAddressing

@ hipDeviceAttributeUnifiedAddressing

Definition: hip_runtime_api.h:549

hipDeviceAttributeAsyncEngineCount

@ hipDeviceAttributeAsyncEngineCount

Asynchronous engines number.

Definition: hip_runtime_api.h:434

hipDeviceAttributeMultiGpuBoardGroupID

@ hipDeviceAttributeMultiGpuBoardGroupID

Definition: hip_runtime_api.h:511

hipDeviceAttributeStreamPrioritiesSupported

@ hipDeviceAttributeStreamPrioritiesSupported

Whether to support stream priorities.

Definition: hip_runtime_api.h:541

hipDeviceAttributeMaxSharedMemoryPerBlock

@ hipDeviceAttributeMaxSharedMemoryPerBlock

Definition: hip_runtime_api.h:534

hipDeviceAttributeLocalL1CacheSupported

@ hipDeviceAttributeLocalL1CacheSupported

caching locals in L1 is supported

Definition: hip_runtime_api.h:462

hipDeviceAttributeCanUseStreamWaitValue

@ hipDeviceAttributeCanUseStreamWaitValue

Definition: hip_runtime_api.h:589

hipDeviceAttributeMaxRegistersPerBlock

@ hipDeviceAttributeMaxRegistersPerBlock

Definition: hip_runtime_api.h:528

hipDeviceAttributeMaxThreadsPerBlock

@ hipDeviceAttributeMaxThreadsPerBlock

Maximum number of threads per block.

Definition: hip_runtime_api.h:505

hipDeviceAttributePciDomainId

@ hipDeviceAttributePciDomainId

PCI Domain Id.

Definition: hip_runtime_api.h:524

hipDeviceAttributeMemoryBusWidth

@ hipDeviceAttributeMemoryBusWidth

Global memory bus width in bits.

Definition: hip_runtime_api.h:508

hipDeviceAttributeMemoryPoolSupportedHandleTypes

@ hipDeviceAttributeMemoryPoolSupportedHandleTypes

Definition: hip_runtime_api.h:558

hipDeviceAttributeComputePreemptionSupported

@ hipDeviceAttributeComputePreemptionSupported

Device supports Compute Preemption.

Definition: hip_runtime_api.h:442

hipDeviceAttributeMaxSurface1D

@ hipDeviceAttributeMaxSurface1D

Maximum size of 1D surface.

Definition: hip_runtime_api.h:476

hipDeviceAttributeUnused1

@ hipDeviceAttributeUnused1

Previously hipDeviceAttributeName.

Definition: hip_runtime_api.h:517

hipDeviceAttributeMaxTexture3DAlt

@ hipDeviceAttributeMaxTexture3DAlt

Maximum dimensions of alternate 3D texture.

Definition: hip_runtime_api.h:501

hipDeviceAttributeMaxTexture1DLinear

@ hipDeviceAttributeMaxTexture1DLinear

Definition: hip_runtime_api.h:486

hipDeviceAttributeMaxTexture2DGather

@ hipDeviceAttributeMaxTexture2DGather

Definition: hip_runtime_api.h:492

hipDeviceAttributeWallClockRate

@ hipDeviceAttributeWallClockRate

Constant frequency of wall clock in kilohertz.

Definition: hip_runtime_api.h:595

hipDeviceAttributePciDeviceId

@ hipDeviceAttributePciDeviceId

PCI Device ID. Returns pcie slot id.

Definition: hip_runtime_api.h:523

hipDeviceAttributeCanMapHostMemory

@ hipDeviceAttributeCanMapHostMemory

Definition: hip_runtime_api.h:435

hipDeviceAttributeMaxTexture1DWidth

@ hipDeviceAttributeMaxTexture1DWidth

Maximum size of 1D texture.

Definition: hip_runtime_api.h:484

hipDeviceAttributeConcurrentManagedAccess

@ hipDeviceAttributeConcurrentManagedAccess

Definition: hip_runtime_api.h:445

hipDeviceAttributeVendorSpecificBegin

@ hipDeviceAttributeVendorSpecificBegin

Definition: hip_runtime_api.h:603

hipDeviceAttributeManagedMemory

@ hipDeviceAttributeManagedMemory

Device supports allocating managed memory on this system.

Definition: hip_runtime_api.h:468

hipDeviceAttributeHostNumaId

@ hipDeviceAttributeHostNumaId

Definition: hip_runtime_api.h:560

hipDeviceAttributeIntegrated

@ hipDeviceAttributeIntegrated

Device is integrated GPU.

Definition: hip_runtime_api.h:457

hipDeviceAttributeMaxTexture2DLayered

@ hipDeviceAttributeMaxTexture2DLayered

Maximum dimensions of 2D layered texture.

Definition: hip_runtime_api.h:494

hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

Definition: hip_runtime_api.h:578

hipDeviceAttributeMaxTexture3DDepth

@ hipDeviceAttributeMaxTexture3DDepth

Maximum dimension depth of 3D texture.

Definition: hip_runtime_api.h:500

hipDeviceAttributePciChipId

@ hipDeviceAttributePciChipId

GPU Manufacturer device id.

Definition: hip_runtime_api.h:600

hipDeviceAttributeImageSupport

@ hipDeviceAttributeImageSupport

'1' if Device supports image, '0' otherwise.

Definition: hip_runtime_api.h:591

hipDeviceAttributeTotalGlobalMem

@ hipDeviceAttributeTotalGlobalMem

Global memory available on devicice.

Definition: hip_runtime_api.h:548

hipDeviceAttributeMaxBlocksPerMultiProcessor

@ hipDeviceAttributeMaxBlocksPerMultiProcessor

Max block size per multiprocessor.

Definition: hip_runtime_api.h:469

hipDeviceAttributeIsLargeBar

@ hipDeviceAttributeIsLargeBar

Whether it is LargeBar.

Definition: hip_runtime_api.h:587

hipDeviceAttributeMaxTexture2DWidth

@ hipDeviceAttributeMaxTexture2DWidth

Maximum dimension width of 2D texture.

Definition: hip_runtime_api.h:490

hipDeviceAttributeMaxBlockDimX

@ hipDeviceAttributeMaxBlockDimX

Max block size in width.

Definition: hip_runtime_api.h:470

hipDeviceAttributeMaxTexture3DWidth

@ hipDeviceAttributeMaxTexture3DWidth

Maximum dimension width of 3D texture.

Definition: hip_runtime_api.h:498

hipDeviceAttributeUnused3

@ hipDeviceAttributeUnused3

Previously hipDeviceAttributeArch.

Definition: hip_runtime_api.h:569

hipDeviceAttributeTotalConstantMemory

@ hipDeviceAttributeTotalConstantMemory

Constant memory size in bytes.

Definition: hip_runtime_api.h:547

hipDeviceAttributeTextureAlignment

@ hipDeviceAttributeTextureAlignment

Alignment requirement for textures.

Definition: hip_runtime_api.h:544

hipDeviceAttributeMaxTexture1DLayered

@ hipDeviceAttributeMaxTexture1DLayered

Maximum dimensions of 1D layered texture.

Definition: hip_runtime_api.h:485

hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

@ hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

Maximum Shared Memory PerMultiprocessor.

Definition: hip_runtime_api.h:570

hipDeviceAttributeReservedSharedMemPerBlock

@ hipDeviceAttributeReservedSharedMemPerBlock

Definition: hip_runtime_api.h:532

hipDeviceAttributeCudaCompatibleBegin

@ hipDeviceAttributeCudaCompatibleBegin

Definition: hip_runtime_api.h:428

hipDeviceAttributeConcurrentKernels

@ hipDeviceAttributeConcurrentKernels

Definition: hip_runtime_api.h:443

hipDeviceAttributeLuid

@ hipDeviceAttributeLuid

Definition: hip_runtime_api.h:463

hipDeviceAttributePciDomainID

@ hipDeviceAttributePciDomainID

PCI Domain ID, for backward compatibility.

Definition: hip_runtime_api.h:525

hipDeviceAttributeMaxThreadsPerMultiProcessor

@ hipDeviceAttributeMaxThreadsPerMultiProcessor

Maximum resident threads per multiprocessor.

Definition: hip_runtime_api.h:506

hipDeviceAttributeTexturePitchAlignment

@ hipDeviceAttributeTexturePitchAlignment

Definition: hip_runtime_api.h:545

hipDeviceAttributePhysicalMultiProcessorCount

@ hipDeviceAttributePhysicalMultiProcessorCount

Definition: hip_runtime_api.h:592

hipDeviceAttributeHostRegisterSupported

@ hipDeviceAttributeHostRegisterSupported

Definition: hip_runtime_api.h:556

hipDeviceAttributeSharedMemPerMultiprocessor

@ hipDeviceAttributeSharedMemPerMultiprocessor

Shared memory available per multiprocessor.

Definition: hip_runtime_api.h:538

hipDeviceAttributeLuidDeviceNodeMask

@ hipDeviceAttributeLuidDeviceNodeMask

Definition: hip_runtime_api.h:465

hipDeviceAttributeMaxTextureCubemapLayered

@ hipDeviceAttributeMaxTextureCubemapLayered

Maximum dimensions of Cubemap layered texture.

Definition: hip_runtime_api.h:503

hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

Definition: hip_runtime_api.h:581

hipDeviceAttributeVirtualMemoryManagementSupported

@ hipDeviceAttributeVirtualMemoryManagementSupported

Definition: hip_runtime_api.h:554

hipDeviceAttributeMemoryPoolsSupported

@ hipDeviceAttributeMemoryPoolsSupported

Device supports HIP Stream Ordered Memory Allocator.

Definition: hip_runtime_api.h:553

hipDeviceAttributeClockInstructionRate

@ hipDeviceAttributeClockInstructionRate

Definition: hip_runtime_api.h:566

hipDeviceAttributeMaxTexture2DMipmap

@ hipDeviceAttributeMaxTexture2DMipmap

Maximum dimensions of 2D mipmapped texture.

Definition: hip_runtime_api.h:497

hipDeviceAttributeMaxBlockDimZ

@ hipDeviceAttributeMaxBlockDimZ

Max block size in depth.

Definition: hip_runtime_api.h:472

hipDeviceAttributeWarpSize

@ hipDeviceAttributeWarpSize

Warp size in threads.

Definition: hip_runtime_api.h:552

hipGPUDirectRDMAWritesOrderingOwner

@ hipGPUDirectRDMAWritesOrderingOwner

Definition: hip_runtime_api.h:627

hipGPUDirectRDMAWritesOrderingNone

@ hipGPUDirectRDMAWritesOrderingNone

Definition: hip_runtime_api.h:626

hipGPUDirectRDMAWritesOrderingAllDevices

@ hipGPUDirectRDMAWritesOrderingAllDevices

Definition: hip_runtime_api.h:628

hipMemAllocationTypeMax

@ hipMemAllocationTypeMax

Definition: hip_runtime_api.h:1215

hipMemAllocationTypePinned

@ hipMemAllocationTypePinned

Definition: hip_runtime_api.h:1213

hipMemAllocationTypeUncached

@ hipMemAllocationTypeUncached

Definition: hip_runtime_api.h:1214

hipMemAllocationTypeInvalid

@ hipMemAllocationTypeInvalid

Definition: hip_runtime_api.h:1209

hipMemoryTypeDevice

@ hipMemoryTypeDevice

Definition: hip_runtime_api.h:266

hipMemoryTypeHost

@ hipMemoryTypeHost

Memory is physically located on host.

Definition: hip_runtime_api.h:265

hipMemoryTypeUnregistered

@ hipMemoryTypeUnregistered

Unregistered memory.

Definition: hip_runtime_api.h:264

hipMemoryTypeArray

@ hipMemoryTypeArray

Definition: hip_runtime_api.h:271

hipMemoryTypeManaged

@ hipMemoryTypeManaged

Definition: hip_runtime_api.h:268

hipMemoryTypeUnified

@ hipMemoryTypeUnified

unified address space

Definition: hip_runtime_api.h:273

hipGraphInstantiateFlagAutoFreeOnLaunch

@ hipGraphInstantiateFlagAutoFreeOnLaunch

Automatically free memory allocated in a graph before relaunching.

Definition: hip_runtime_api.h:1689

hipGraphInstantiateFlagUseNodePriority

@ hipGraphInstantiateFlagUseNodePriority

Definition: hip_runtime_api.h:1694

hipGraphInstantiateFlagUpload

@ hipGraphInstantiateFlagUpload

Automatically upload the graph after instantiation.

Definition: hip_runtime_api.h:1691

hipGraphInstantiateFlagDeviceLaunch

@ hipGraphInstantiateFlagDeviceLaunch

Instantiate the graph to be launched from the device.

Definition: hip_runtime_api.h:1692

hipArraySparseSubresourceTypeSparseLevel

@ hipArraySparseSubresourceTypeSparseLevel

Sparse level.

Definition: hip_runtime_api.h:1819

hipArraySparseSubresourceTypeMiptail

@ hipArraySparseSubresourceTypeMiptail

Miptail.

Definition: hip_runtime_api.h:1820

hipGraphKernelNodeSetParams

hipError_t hipGraphKernelNodeSetParams(hipGraphNode_t node, const hipKernelNodeParams *pNodeParams)

Sets a kernel node's parameters.

hipGraphMemFreeNodeGetParams

hipError_t hipGraphMemFreeNodeGetParams(hipGraphNode_t node, void *dev_ptr)

Returns parameters for memory free node.

hipDrvGraphExecMemsetNodeSetParams

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.

hipGraphNodeGetDependencies

hipError_t hipGraphNodeGetDependencies(hipGraphNode_t node, hipGraphNode_t *pDependencies, size_t *pNumDependencies)

Returns a node's dependencies.

hipGraphCreate

hipError_t hipGraphCreate(hipGraph_t *pGraph, unsigned int flags)

Creates a graph.

hipGraphAddMemcpyNode1D

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.

hipDrvGraphMemcpyNodeGetParams

hipError_t hipDrvGraphMemcpyNodeGetParams(hipGraphNode_t hNode, HIP_MEMCPY3D *nodeParams)

Gets a memcpy node's parameters.

hipDeviceSetGraphMemAttribute

hipError_t hipDeviceSetGraphMemAttribute(int device, hipGraphMemAttributeType attr, void *value)

Set the mem attribute for graphs.

hipGraphMemcpyNodeSetParams

hipError_t hipGraphMemcpyNodeSetParams(hipGraphNode_t node, const hipMemcpy3DParms *pNodeParams)

Sets a memcpy node's parameters.

hipUserObjectCreate

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.

hipGraphExecUpdate

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.

hipGraphNodeFindInClone

hipError_t hipGraphNodeFindInClone(hipGraphNode_t *pNode, hipGraphNode_t originalNode, hipGraph_t clonedGraph)

Finds a cloned version of a node.

hipGraphAddEventWaitNode

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.

hipGraphMemcpyNodeSetParamsToSymbol

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.

hipStreamIsCapturing

hipError_t hipStreamIsCapturing(hipStream_t stream, hipStreamCaptureStatus *pCaptureStatus)

Get stream's capture state.

hipGraphNodeGetEnabled

hipError_t hipGraphNodeGetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, unsigned int *isEnabled)

Query whether a node in the given graphExec is enabled.

hipGraphAddChildGraphNode

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.

hipGraphExternalSemaphoresSignalNodeSetParams

hipError_t hipGraphExternalSemaphoresSignalNodeSetParams(hipGraphNode_t hNode, const hipExternalSemaphoreSignalNodeParams *nodeParams)

Updates node parameters in the external semaphore signal node.

hipGraphDestroyNode

hipError_t hipGraphDestroyNode(hipGraphNode_t node)

Remove a node from the graph.

hipGraphMemcpyNodeSetParamsFromSymbol

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.

hipGraphReleaseUserObject

hipError_t hipGraphReleaseUserObject(hipGraph_t graph, hipUserObject_t object, unsigned int count)

Release user object from graphs.

hipDrvGraphAddMemcpyNode

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.

hipGraphRemoveDependencies

hipError_t hipGraphRemoveDependencies(hipGraph_t graph, const hipGraphNode_t *from, const hipGraphNode_t *to, size_t numDependencies)

Removes dependency edges from a graph.

hipGraphMemcpyNodeSetParams1D

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.

hipGraphExecMemcpyNodeSetParams1D

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.

hipGraphExecDestroy

hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec)

Destroys an executable graph.

hipGraphAddExternalSemaphoresSignalNode

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.

hipGraphExecExternalSemaphoresWaitNodeSetParams

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.

hipGraphExecHostNodeSetParams

hipError_t hipGraphExecHostNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node, const hipHostNodeParams *pNodeParams)

Sets the parameters for a host node in the given graphExec.

hipGraphExecChildGraphNodeSetParams

hipError_t hipGraphExecChildGraphNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node, hipGraph_t childGraph)

Updates node parameters in the child graph node in the given graphExec.

hipStreamGetCaptureInfo

hipError_t hipStreamGetCaptureInfo(hipStream_t stream, hipStreamCaptureStatus *pCaptureStatus, unsigned long long *pId)

Get capture status of a stream.

hipGraphAddDependencies

hipError_t hipGraphAddDependencies(hipGraph_t graph, const hipGraphNode_t *from, const hipGraphNode_t *to, size_t numDependencies)

Adds dependency edges to a graph.

hipDrvGraphAddMemFreeNode

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.

hipGraphExecKernelNodeSetParams

hipError_t hipGraphExecKernelNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node, const hipKernelNodeParams *pNodeParams)

Sets the parameters for a kernel node in the given graphExec.

hipGraphNodeGetDependentNodes

hipError_t hipGraphNodeGetDependentNodes(hipGraphNode_t node, hipGraphNode_t *pDependentNodes, size_t *pNumDependentNodes)

Returns a node's dependent nodes.

hipDeviceGetGraphMemAttribute

hipError_t hipDeviceGetGraphMemAttribute(int device, hipGraphMemAttributeType attr, void *value)

Get the mem attribute for graphs.

hipGraphHostNodeGetParams

hipError_t hipGraphHostNodeGetParams(hipGraphNode_t node, hipHostNodeParams *pNodeParams)

Returns a host node's parameters.

hipGraphInstantiateWithFlags

hipError_t hipGraphInstantiateWithFlags(hipGraphExec_t *pGraphExec, hipGraph_t graph, unsigned long long flags)

Creates an executable graph from a graph.

hipGraphExternalSemaphoresSignalNodeGetParams

hipError_t hipGraphExternalSemaphoresSignalNodeGetParams(hipGraphNode_t hNode, hipExternalSemaphoreSignalNodeParams *params_out)

Returns external semaphore signal node params.

hipGraphUpload

hipError_t hipGraphUpload(hipGraphExec_t graphExec, hipStream_t stream)

Uploads an executable graph to a stream.

hipDrvGraphAddMemsetNode

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.

hipGraphExecExternalSemaphoresSignalNodeSetParams

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.

hipGraphExecMemcpyNodeSetParamsToSymbol

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.

hipUserObjectRelease

hipError_t hipUserObjectRelease(hipUserObject_t object, unsigned int count)

Release number of references to resource.

hipGraphKernelNodeGetParams

hipError_t hipGraphKernelNodeGetParams(hipGraphNode_t node, hipKernelNodeParams *pNodeParams)

Gets kernel node's parameters.

hipGraphAddMemcpyNodeFromSymbol

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.

hipGraphKernelNodeCopyAttributes

hipError_t hipGraphKernelNodeCopyAttributes(hipGraphNode_t hSrc, hipGraphNode_t hDst)

Copies attributes from source node to destination node.

hipGraphAddMemFreeNode

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.

hipDrvGraphMemcpyNodeSetParams

hipError_t hipDrvGraphMemcpyNodeSetParams(hipGraphNode_t hNode, const HIP_MEMCPY3D *nodeParams)

Sets a memcpy node's parameters.

hipGraphMemcpyNodeGetParams

hipError_t hipGraphMemcpyNodeGetParams(hipGraphNode_t node, hipMemcpy3DParms *pNodeParams)

Gets a memcpy node's parameters.

hipGraphNodeSetParams

hipError_t hipGraphNodeSetParams(hipGraphNode_t node, hipGraphNodeParams *nodeParams)

Updates parameters of a graph's node.

hipGraphAddEventRecordNode

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.

hipDrvGraphExecMemcpyNodeSetParams

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.

hipStreamBeginCapture

hipError_t hipStreamBeginCapture(hipStream_t stream, hipStreamCaptureMode mode)

Begins graph capture on a stream.

hipStreamEndCapture

hipError_t hipStreamEndCapture(hipStream_t stream, hipGraph_t *pGraph)

Ends capture on a stream, returning the captured graph.

hipGraphExecGetFlags

hipError_t hipGraphExecGetFlags(hipGraphExec_t graphExec, unsigned long long *flags)

Return the flags of an executable graph.

hipUserObjectRetain

hipError_t hipUserObjectRetain(hipUserObject_t object, unsigned int count)

Retain number of references to resource.

hipGraphNodeGetType

hipError_t hipGraphNodeGetType(hipGraphNode_t node, hipGraphNodeType *pType)

Returns a node's type.

hipGraphNodeSetEnabled

hipError_t hipGraphNodeSetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, unsigned int isEnabled)

Enables or disables the specified node in the given graphExec.

hipGraphExecMemcpyNodeSetParams

hipError_t hipGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node, hipMemcpy3DParms *pNodeParams)

Sets the parameters of a memcpy node in the given graphExec.

hipGraphExecNodeSetParams

hipError_t hipGraphExecNodeSetParams(hipGraphExec_t graphExec, hipGraphNode_t node, hipGraphNodeParams *nodeParams)

Updates parameters of an executable graph's node.

hipGraphHostNodeSetParams

hipError_t hipGraphHostNodeSetParams(hipGraphNode_t node, const hipHostNodeParams *pNodeParams)

Sets a host node's parameters.

hipGraphMemAllocNodeGetParams

hipError_t hipGraphMemAllocNodeGetParams(hipGraphNode_t node, hipMemAllocNodeParams *pNodeParams)

Returns parameters for memory allocation node.

hipGraphInstantiateWithParams

hipError_t hipGraphInstantiateWithParams(hipGraphExec_t *pGraphExec, hipGraph_t graph, hipGraphInstantiateParams *instantiateParams)

Creates an executable graph from a graph.

hipGraphExecEventRecordNodeSetEvent

hipError_t hipGraphExecEventRecordNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, hipEvent_t event)

Sets the event for an event record node in the given graphExec.

hipGraphExternalSemaphoresWaitNodeSetParams

hipError_t hipGraphExternalSemaphoresWaitNodeSetParams(hipGraphNode_t hNode, const hipExternalSemaphoreWaitNodeParams *nodeParams)

Updates node parameters in the external semaphore wait node.

hipGraphMemsetNodeGetParams

hipError_t hipGraphMemsetNodeGetParams(hipGraphNode_t node, hipMemsetParams *pNodeParams)

Gets a memset node's parameters.

hipGraphChildGraphNodeGetGraph

hipError_t hipGraphChildGraphNodeGetGraph(hipGraphNode_t node, hipGraph_t *pGraph)

Gets a handle to the embedded graph of a child graph node.

hipGraphKernelNodeGetAttribute

hipError_t hipGraphKernelNodeGetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr, hipKernelNodeAttrValue *value)

Gets a node's attribute.

hipThreadExchangeStreamCaptureMode

hipError_t hipThreadExchangeStreamCaptureMode(hipStreamCaptureMode *mode)

Swaps the stream capture mode of a thread.

hipGraphLaunch

hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream)

Launches an executable graph in the specified stream.

hipGraphDebugDotPrint

hipError_t hipGraphDebugDotPrint(hipGraph_t graph, const char *path, unsigned int flags)

Write a DOT file describing graph structure.

hipGraphExecMemsetNodeSetParams

hipError_t hipGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node, const hipMemsetParams *pNodeParams)

Sets the parameters for a memset node in the given graphExec.

hipGraphGetEdges

hipError_t hipGraphGetEdges(hipGraph_t graph, hipGraphNode_t *from, hipGraphNode_t *to, size_t *numEdges)

Returns a graph's dependency edges.

hipGraphAddKernelNode

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.

hipGraphExecEventWaitNodeSetEvent

hipError_t hipGraphExecEventWaitNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, hipEvent_t event)

Sets the event for an event record node in the given graphExec.

hipStreamGetCaptureInfo_v2

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.

hipStreamBeginCaptureToGraph

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.

hipGraphAddExternalSemaphoresWaitNode

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.

hipGraphEventWaitNodeSetEvent

hipError_t hipGraphEventWaitNodeSetEvent(hipGraphNode_t node, hipEvent_t event)

Sets an event wait node's event.

hipGraphEventRecordNodeSetEvent

hipError_t hipGraphEventRecordNodeSetEvent(hipGraphNode_t node, hipEvent_t event)

Sets an event record node's event.

hipGraphEventWaitNodeGetEvent

hipError_t hipGraphEventWaitNodeGetEvent(hipGraphNode_t node, hipEvent_t *event_out)

Returns the event associated with an event wait node.

hipGraphKernelNodeSetAttribute

hipError_t hipGraphKernelNodeSetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr, const hipKernelNodeAttrValue *value)

Sets a node's attribute.

hipGraphMemsetNodeSetParams

hipError_t hipGraphMemsetNodeSetParams(hipGraphNode_t node, const hipMemsetParams *pNodeParams)

Sets a memset node's parameters.

hipGraphEventRecordNodeGetEvent

hipError_t hipGraphEventRecordNodeGetEvent(hipGraphNode_t node, hipEvent_t *event_out)

Returns the event associated with an event record node.

hipGraphAddEmptyNode

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.

hipGraphAddMemcpyNodeToSymbol

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.

hipGraphDestroy

hipError_t hipGraphDestroy(hipGraph_t graph)

Destroys a graph.

hipGraphRetainUserObject

hipError_t hipGraphRetainUserObject(hipGraph_t graph, hipUserObject_t object, unsigned int count, unsigned int flags)

Retain user object for graphs.

hipGraphExecMemcpyNodeSetParamsFromSymbol

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.

hipGraphAddMemAllocNode

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.

hipGraphAddHostNode

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.

hipGraphAddNode

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.

hipGraphGetNodes

hipError_t hipGraphGetNodes(hipGraph_t graph, hipGraphNode_t *nodes, size_t *numNodes)

Returns a graph's nodes.

hipGraphAddMemsetNode

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.

hipStreamUpdateCaptureDependencies

hipError_t hipStreamUpdateCaptureDependencies(hipStream_t stream, hipGraphNode_t *dependencies, size_t numDependencies, unsigned int flags)

Update the set of dependencies in a capturing stream.

hipGraphInstantiate

hipError_t hipGraphInstantiate(hipGraphExec_t *pGraphExec, hipGraph_t graph, hipGraphNode_t *pErrorNode, char *pLogBuffer, size_t bufferSize)

Creates an executable graph from a graph.

hipDeviceGraphMemTrim

hipError_t hipDeviceGraphMemTrim(int device)

Free unused memory reserved for graphs on a specific device and return it back to the OS.

hipGraphExternalSemaphoresWaitNodeGetParams

hipError_t hipGraphExternalSemaphoresWaitNodeGetParams(hipGraphNode_t hNode, hipExternalSemaphoreWaitNodeParams *params_out)

Returns external semaphore wait node params.

hipGraphClone

hipError_t hipGraphClone(hipGraph_t *pGraphClone, hipGraph_t originalGraph)

Clones a graph.

hipGraphGetRootNodes

hipError_t hipGraphGetRootNodes(hipGraph_t graph, hipGraphNode_t *pRootNodes, size_t *pNumRootNodes)

Returns a graph's root nodes.

hipGraphAddMemcpyNode

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.

hipGraphicsUnregisterResource

hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource)

Unregisters a graphics resource.

hipGraphicsUnmapResources

hipError_t hipGraphicsUnmapResources(int count, hipGraphicsResource_t *resources, hipStream_t stream)

Unmaps graphics resources.

hipGraphicsSubResourceGetMappedArray

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.

hipGraphicsResourceGetMappedPointer

hipError_t hipGraphicsResourceGetMappedPointer(void **devPtr, size_t *size, hipGraphicsResource_t resource)

Gets device accessible address of a graphics resource.

hipGraphicsMapResources

hipError_t hipGraphicsMapResources(int count, hipGraphicsResource_t *resources, hipStream_t stream)

Maps a graphics resource for access.

hipLibraryOption

hipLibraryOption

Definition: linker_types.h:124

hipJitOption

hipJitOption

Definition: linker_types.h:47

hipJitInputType

hipJitInputType

Definition: linker_types.h:92

hipHostFree

hipError_t hipHostFree(void *ptr)

Free memory allocated by the HIP-Clang hip host memory allocation API This API performs an implicit h...

hipMallocHost

hipError_t hipMallocHost(void **ptr, size_t size)

Allocate pinned host memory [Deprecated].

hipMemcpyToArray

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].

hipMemcpyFromArray

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].

hipMemAllocHost

hipError_t hipMemAllocHost(void **ptr, size_t size)

Allocate pinned host memory [Deprecated].

hipMemcpyAtoA

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.

hipHostAlloc

hipError_t hipHostAlloc(void **ptr, size_t size, unsigned int flags)

Allocate device accessible page locked host memory.

hipMemcpy3DBatchAsync

hipError_t hipMemcpy3DBatchAsync(size_t numOps, struct hipMemcpy3DBatchOp *opList, size_t *failIdx, unsigned long long flags, hipStream_t stream)

Perform Batch of 3D copies.

hipMemcpy2DArrayToArray

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.

hipMemsetD8Async

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 va...

hipMemcpyAtoHAsync

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.

hipFreeHost

hipError_t hipFreeHost(void *ptr)

Frees page-locked memory This API performs an implicit hipDeviceSynchronize() call....

hipMemset2DAsync

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.

hipMemGetInfo

hipError_t hipMemGetInfo(size_t *free, size_t *total)

Query memory info.

hipExtMallocWithFlags

hipError_t hipExtMallocWithFlags(void **ptr, size_t sizeBytes, unsigned int flags)

Allocate memory on the default accelerator.

hipMemcpy3D

hipError_t hipMemcpy3D(const struct hipMemcpy3DParms *p)

Copies data between host and device.

hipMalloc3DArray

hipError_t hipMalloc3DArray(hipArray_t *array, const struct hipChannelFormatDesc *desc, struct hipExtent extent, unsigned int flags)

Allocate an array on the device.

hipArrayCreate

hipError_t hipArrayCreate(hipArray_t *pHandle, const HIP_ARRAY_DESCRIPTOR *pAllocateArray)

Create an array memory pointer on the device.

hipMemset3D

hipError_t hipMemset3D(hipPitchedPtr pitchedDevPtr, int value, hipExtent extent)

Fills synchronously the memory area pointed to by pitchedDevPtr with the constant value.

hipMemsetD16

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 v...

hipMemcpyAtoD

hipError_t hipMemcpyAtoD(hipDeviceptr_t dstDevice, hipArray_t srcArray, size_t srcOffset, size_t ByteCount)

Copies from one 1D array to device memory.

hipMalloc

hipError_t hipMalloc(void **ptr, size_t size)

Allocate memory on the default accelerator.

hipHostUnregister

hipError_t hipHostUnregister(void *hostPtr)

Un-register host pointer.

hipHostGetFlags

hipError_t hipHostGetFlags(unsigned int *flagsPtr, void *hostPtr)

Return flags associated with host pointer.

hipMemcpyFromSymbolAsync

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.

hipMemsetD2D32

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....

hipMemsetD32

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 time...

hipMemset3DAsync

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.

hipMemcpyFromSymbol

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.

hipDrvMemcpy3DAsync

hipError_t hipDrvMemcpy3DAsync(const HIP_MEMCPY3D *pCopy, hipStream_t stream)

Copies data between host and device asynchronously.

hipMemsetD2D32Async

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....

hipArray3DGetDescriptor

hipError_t hipArray3DGetDescriptor(HIP_ARRAY3D_DESCRIPTOR *pArrayDescriptor, hipArray_t array)

Gets a 3D array descriptor.

hipMemcpy2DAsync

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.

hipArrayGetDescriptor

hipError_t hipArrayGetDescriptor(HIP_ARRAY_DESCRIPTOR *pArrayDescriptor, hipArray_t array)

Gets a 1D or 2D array descriptor.

hipFree

hipError_t hipFree(void *ptr)

Free memory allocated by the HIP-Clang hip memory allocation API. This API performs an implicit hipDe...

hipMemcpyHtoAAsync

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.

hipMemsetD16Async

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 v...

hipGetProcAddress

hipError_t hipGetProcAddress(const char *symbol, void **pfn, int hipVersion, uint64_t flags, hipDriverProcAddressQueryResult *symbolStatus)

Gets the pointer of requested HIP driver function.

hipPointerGetAttributes

hipError_t hipPointerGetAttributes(hipPointerAttribute_t *attributes, const void *ptr)

Returns attributes for the specified pointer.

hipMallocPitch

hipError_t hipMallocPitch(void **ptr, size_t *pitch, size_t width, size_t height)

hipMemcpy3DPeer

hipError_t hipMemcpy3DPeer(hipMemcpy3DPeerParms *p)

Performs 3D memory copies between devices This API is asynchronous with respect to host.

hipMemcpyDtoD

hipError_t hipMemcpyDtoD(hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes)

Copy data from Device to Device.

hipMallocArray

hipError_t hipMallocArray(hipArray_t *array, const hipChannelFormatDesc *desc, size_t width, size_t height, unsigned int flags)

Allocate an array on the device.

hipMemcpy2D

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.

hipHostGetDevicePointer

hipError_t hipHostGetDevicePointer(void **devPtr, void *hstPtr, unsigned int flags)

Get Device pointer from Host Pointer allocated through hipHostMalloc.

hipMemcpyDtoA

hipError_t hipMemcpyDtoA(hipArray_t dstArray, size_t dstOffset, hipDeviceptr_t srcDevice, size_t ByteCount)

Copies from device memory to a 1D array.

hipMemcpy2DFromArrayAsync

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.

hipMemsetD2D16Async

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....

hipMemcpy2DFromArray

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.

hipMemcpy3DAsync

hipError_t hipMemcpy3DAsync(const struct hipMemcpy3DParms *p, hipStream_t stream)

Copies data between host and device asynchronously.

hipArray3DCreate

hipError_t hipArray3DCreate(hipArray_t *array, const HIP_ARRAY3D_DESCRIPTOR *pAllocateArray)

Create a 3D array memory pointer on the device.

hipArrayGetInfo

hipError_t hipArrayGetInfo(hipChannelFormatDesc *desc, hipExtent *extent, unsigned int *flags, hipArray_t array)

Gets info about the specified array.

hipDrvMemcpy3D

hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D *pCopy)

Copies data between host and device.

hipMemcpyParam2D

hipError_t hipMemcpyParam2D(const hip_Memcpy2D *pCopy)

Copies memory for 2D arrays.

hipMemcpyHtoA

hipError_t hipMemcpyHtoA(hipArray_t dstArray, size_t dstOffset, const void *srcHost, size_t count)

Copies data between host and device.

hipMemcpyToSymbolAsync

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.

hipHostMalloc

hipError_t hipHostMalloc(void **ptr, size_t size, unsigned int flags)

Allocates device accessible page locked (pinned) host memory.

hipMemsetD2D8

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....

hipMemcpy2DToArrayAsync

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.

hipHostRegister

hipError_t hipHostRegister(void *hostPtr, size_t sizeBytes, unsigned int flags)

Register host memory so it can be accessed from the current device.

hipMemsetD2D16

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....

hipMemcpyBatchAsync

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.

hipMemcpyAtoH

hipError_t hipMemcpyAtoH(void *dst, hipArray_t srcArray, size_t srcOffset, size_t count)

Copies data between host and device.

hipMemcpyToSymbol

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...

hipMemcpy

hipError_t hipMemcpy(void *dst, const void *src, size_t sizeBytes, hipMemcpyKind kind)

Copy data from src to dst.

hipMemset

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 va...

hipMemGetAddressRange

hipError_t hipMemGetAddressRange(hipDeviceptr_t *pbase, size_t *psize, hipDeviceptr_t dptr)

Get information on memory allocations.

hipMemcpy2DToArray

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.

hipMemcpyParam2DAsync

hipError_t hipMemcpyParam2DAsync(const hip_Memcpy2D *pCopy, hipStream_t stream)

Copies memory for 2D arrays.

hipDrvPointerGetAttributes

hipError_t hipDrvPointerGetAttributes(unsigned int numAttributes, hipPointer_attribute *attributes, void **data, hipDeviceptr_t ptr)

Returns information about the specified pointer.[BETA].

hipMalloc3D

hipError_t hipMalloc3D(hipPitchedPtr *pitchedDevPtr, hipExtent extent)

Create a 3D memory pointer on the device.

hipPointerSetAttribute

hipError_t hipPointerSetAttribute(const void *value, hipPointer_attribute attribute, hipDeviceptr_t ptr)

Sets information on the specified pointer.[BETA].

hipMemcpyDtoDAsync

hipError_t hipMemcpyDtoDAsync(hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes, hipStream_t stream)

Copy data from Device to Device asynchronously.

hipMemAllocPitch

hipError_t hipMemAllocPitch(hipDeviceptr_t *dptr, size_t *pitch, size_t widthInBytes, size_t height, unsigned int elementSizeBytes)

hipMemsetD8

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 va...

hipMemcpyAsync

hipError_t hipMemcpyAsync(void *dst, const void *src, size_t sizeBytes, hipMemcpyKind kind, hipStream_t stream)

Copies data from src to dst asynchronously.

hipMemcpyDtoHAsync

hipError_t hipMemcpyDtoHAsync(void *dst, hipDeviceptr_t src, size_t sizeBytes, hipStream_t stream)

Copy data from Device to Host asynchronously.

hipFreeArray

hipError_t hipFreeArray(hipArray_t array)

Frees an array on the device.

hipMemcpyHtoD

hipError_t hipMemcpyHtoD(hipDeviceptr_t dst, const void *src, size_t sizeBytes)

Copy data from Host to Device.

hipMemsetD32Async

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...

hipMemset2D

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.

hipGetSymbolSize

hipError_t hipGetSymbolSize(size_t *size, const void *symbol)

Gets the size of the given symbol on the device.

hipMemcpyDtoH

hipError_t hipMemcpyDtoH(void *dst, hipDeviceptr_t src, size_t sizeBytes)

Copy data from Device to Host.

hipMemcpyHtoDAsync

hipError_t hipMemcpyHtoDAsync(hipDeviceptr_t dst, const void *src, size_t sizeBytes, hipStream_t stream)

Copy data from Host to Device asynchronously.

hipMemsetAsync

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 val...

hipMemcpyWithStream

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 multip...

hipGetSymbolAddress

hipError_t hipGetSymbolAddress(void **devPtr, const void *symbol)

Gets device pointer associated with symbol on the device.

hipPointerGetAttribute

hipError_t hipPointerGetAttribute(void *data, hipPointer_attribute attribute, hipDeviceptr_t ptr)

Returns information about the specified pointer.[BETA].

hipMemsetD2D8Async

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....

hipMemcpy3DPeerAsync

hipError_t hipMemcpy3DPeerAsync(hipMemcpy3DPeerParms *p, hipStream_t stream)

Performs 3D memory copies between devices asynchronously.

hipMemPtrGetInfo

hipError_t hipMemPtrGetInfo(void *ptr, size_t *size)

Get allocated memory size via memory pointer.

hipArrayDestroy

hipError_t hipArrayDestroy(hipArray_t array)

Destroy an array memory pointer on the device.

hipMemPrefetchAsync

hipError_t hipMemPrefetchAsync(const void *dev_ptr, size_t count, int device, hipStream_t stream)

Prefetches memory to the specified destination device using HIP.

hipMemPrefetchAsync_v2

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.

hipMemRangeGetAttributes

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.

hipMemAdvise

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.

hipMemRangeGetAttribute

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.

hipMallocManaged

hipError_t hipMallocManaged(void **dev_ptr, size_t size, unsigned int flags)

Allocates memory that will be automatically managed by HIP.

hipStreamAttachMemAsync

hipError_t hipStreamAttachMemAsync(hipStream_t stream, void *dev_ptr, size_t length, unsigned int flags)

Attach memory to a stream asynchronously in HIP.

hipMemAdvise_v2

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.

hipModuleLaunchCooperativeKernelMultiDevice

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 execut...

hipLaunchCooperativeKernelMultiDevice

hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams *launchParamsList, int numDevices, unsigned int flags)

Launches kernels on multiple devices where thread blocks can cooperate and synchronize as they execut...

hipModuleLaunchCooperativeKernel

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 kernelP...

hipLaunchCooperativeKernel

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 kernelp...

hipModuleGetTexRef

hipError_t hipModuleGetTexRef(textureReference **texRef, hipModule_t hmod, const char *name)

returns the handle of the texture reference with the name from the module.

hipLinkComplete

hipError_t hipLinkComplete(hipLinkState_t state, void **hipBinOut, size_t *sizeOut)

Completes the linking of the given program.

hipModuleGetFunctionCount

hipError_t hipModuleGetFunctionCount(unsigned int *count, hipModule_t mod)

Returns the number of functions within a module.

hipModuleLoad

hipError_t hipModuleLoad(hipModule_t *module, const char *fname)

Loads code object from file into a module the currrent context.

hipModuleGetGlobal

hipError_t hipModuleGetGlobal(hipDeviceptr_t *dptr, size_t *bytes, hipModule_t hmod, const char *name)

Returns a global pointer from a module.

hipModuleLoadDataEx

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....

hipLibraryUnload

hipError_t hipLibraryUnload(hipLibrary_t library)

Unload HIP Library.

hipLinkAddFile

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.

hipGetFuncBySymbol

hipError_t hipGetFuncBySymbol(hipFunction_t *functionPtr, const void *symbolPtr)

Gets pointer to device entry function that matches entry function symbolPtr.

hipLinkDestroy

hipError_t hipLinkDestroy(hipLinkState_t state)

Deletes the linker instance.

hipLibraryLoadFromFile

hipError_t hipLibraryLoadFromFile(hipLibrary_t *library, const char *fileName, hipJitOption *jitOptions, void **jitOptionsValues, unsigned int numJitOptions, hipLibraryOption *libraryOptions, void **libraryOptionValues, unsigned int numLibraryOptions)

Load hip Library from file.

hipMemGetHandleForAddressRange

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.

hipLibraryEnumerateKernels

hipError_t hipLibraryEnumerateKernels(hipKernel_t *kernels, unsigned int numKernels, hipLibrary_t library)

Retrieve kernel handles within a library.

hipLibraryGetKernel

hipError_t hipLibraryGetKernel(hipKernel_t *pKernel, hipLibrary_t library, const char *name)

Get Kernel object from library.

hipKernelGetName

hipError_t hipKernelGetName(const char **name, hipKernel_t kernel)

Returns a Kernel Name.

hipModuleGetFunction

hipError_t hipModuleGetFunction(hipFunction_t *function, hipModule_t module, const char *kname)

Function with kname will be extracted if present in module.

hipLinkCreate

hipError_t hipLinkCreate(unsigned int numOptions, hipJitOption *options, void **optionValues, hipLinkState_t *stateOut)

Creates a linker instance with options.

hipGetDriverEntryPoint

hipError_t hipGetDriverEntryPoint(const char *symbol, void **funcPtr, unsigned long long flags, hipDriverEntryPointQueryResult *driverStatus)

Gets function pointer of a requested HIP API.

hipModuleLoadData

hipError_t hipModuleLoadData(hipModule_t *module, const void *image)

builds module from code object data which resides in host memory.

hipLibraryGetKernelCount

hipError_t hipLibraryGetKernelCount(unsigned int *count, hipLibrary_t library)

Get Kernel count in library.

hipModuleLoadFatBinary

hipError_t hipModuleLoadFatBinary(hipModule_t *module, const void *fatbin)

Loads fatbin object.

hipLibraryLoadData

hipError_t hipLibraryLoadData(hipLibrary_t *library, const void *code, hipJitOption *jitOptions, void **jitOptionsValues, unsigned int numJitOptions, hipLibraryOption *libraryOptions, void **libraryOptionValues, unsigned int numLibraryOptions)

Load hip Library from inmemory object.

hipModuleUnload

hipError_t hipModuleUnload(hipModule_t module)

Frees the module.

hipKernelGetLibrary

hipError_t hipKernelGetLibrary(hipLibrary_t *library, hipKernel_t kernel)

Returns a Library Handle.

hipLinkAddData

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.

hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags

hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, const void *f, int blockSize, size_t dynSharedMemPerBlk, unsigned int flags)

Returns occupancy for a device function.

hipOccupancyAvailableDynamicSMemPerBlock

hipError_t hipOccupancyAvailableDynamicSMemPerBlock(size_t *dynamicSmemSize, const void *f, int numBlocks, int blockSize)

Returns dynamic shared memory available per block when launching numBlocks blocks on SM.

hipModuleOccupancyMaxPotentialBlockSize

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

hipOccupancyMaxActiveBlocksPerMultiprocessor

hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, const void *f, int blockSize, size_t dynSharedMemPerBlk)

Returns occupancy for a device function.

hipOccupancyMaxPotentialBlockSize

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

hipModuleOccupancyMaxActiveBlocksPerMultiprocessor

hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, hipFunction_t f, int blockSize, size_t dynSharedMemPerBlk)

Returns occupancy for a device function.

hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags

hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, hipFunction_t f, int blockSize, size_t dynSharedMemPerBlk, unsigned int flags)

Returns occupancy for a device function.

hipModuleOccupancyMaxPotentialBlockSizeWithFlags

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

hipDeviceCanAccessPeer

hipError_t hipDeviceCanAccessPeer(int *canAccessPeer, int deviceId, int peerDeviceId)

Determines if a device can access a peer device's memory.

hipDeviceEnablePeerAccess

hipError_t hipDeviceEnablePeerAccess(int peerDeviceId, unsigned int flags)

Enables direct access to memory allocations on a peer device.

hipMemcpyPeer

hipError_t hipMemcpyPeer(void *dst, int dstDeviceId, const void *src, int srcDeviceId, size_t sizeBytes)

Copies memory between two peer accessible devices.

hipMemcpyPeerAsync

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.

hipDeviceDisablePeerAccess

hipError_t hipDeviceDisablePeerAccess(int peerDeviceId)

Disables direct access to memory allocations on a peer device.

hipProfilerStart

hipError_t hipProfilerStart()

Start recording of profiling information [Deprecated] When using this API, start the profiler with pr...

hipProfilerStop

hipError_t hipProfilerStop()

Stop recording of profiling information [Deprecated] When using this API, start the profiler with pro...

hipStreamGetId

hipError_t hipStreamGetId(hipStream_t stream, unsigned long long *streamId)

Queries the Id of a stream.

hipDeviceGetStreamPriorityRange

hipError_t hipDeviceGetStreamPriorityRange(int *leastPriority, int *greatestPriority)

Returns numerical values that correspond to the least and greatest stream priority.

hipStreamDestroy

hipError_t hipStreamDestroy(hipStream_t stream)

Destroys the specified stream.

hipStreamGetFlags

hipError_t hipStreamGetFlags(hipStream_t stream, unsigned int *flags)

Returns flags associated with this stream.

hipStreamAddCallback

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 comple...

hipStreamCopyAttributes

hipError_t hipStreamCopyAttributes(hipStream_t dst, hipStream_t src)

Copies attributes from source stream to destination stream.

hipStreamCallback_t

void(* hipStreamCallback_t)(hipStream_t stream, hipError_t status, void *userData)

Definition: hip_runtime_api.h:3017

hipStreamGetDevice

hipError_t hipStreamGetDevice(hipStream_t stream, hipDevice_t *device)

Gets the device associated with the stream.

hipStreamQuery

hipError_t hipStreamQuery(hipStream_t stream)

Returns hipSuccess if all of the operations in the specified stream have completed,...

hipStreamSynchronize

hipError_t hipStreamSynchronize(hipStream_t stream)

Waits for all commands in the stream to complete.

hipStreamSetAttribute

hipError_t hipStreamSetAttribute(hipStream_t stream, hipStreamAttrID attr, const hipStreamAttrValue *value)

Sets stream attribute. Updated attribute is applied to work submitted to the stream.

hipStreamWaitEvent

hipError_t hipStreamWaitEvent(hipStream_t stream, hipEvent_t event, unsigned int flags)

Makes the specified compute stream wait for the specified event.

hipStreamCreateWithPriority

hipError_t hipStreamCreateWithPriority(hipStream_t *stream, unsigned int flags, int priority)

Creates an asynchronous stream with the specified priority.

hipExtStreamCreateWithCUMask

hipError_t hipExtStreamCreateWithCUMask(hipStream_t *stream, uint32_t cuMaskSize, const uint32_t *cuMask)

Creates an asynchronous stream with the specified CU mask.

hipStreamGetPriority

hipError_t hipStreamGetPriority(hipStream_t stream, int *priority)

Queries the priority of a stream.

hipExtStreamGetCUMask

hipError_t hipExtStreamGetCUMask(hipStream_t stream, uint32_t cuMaskSize, uint32_t *cuMask)

Gets CU mask associated with an asynchronous stream.

hipStreamGetAttribute

hipError_t hipStreamGetAttribute(hipStream_t stream, hipStreamAttrID attr, hipStreamAttrValue *value_out)

queries stream attribute.

hipStreamCreateWithFlags

hipError_t hipStreamCreateWithFlags(hipStream_t *stream, unsigned int flags)

Creates an asynchronous stream with flag.

hipStreamCreate

hipError_t hipStreamCreate(hipStream_t *stream)

Creates an asynchronous stream.

hipStreamWriteValue64

hipError_t hipStreamWriteValue64(hipStream_t stream, void *ptr, uint64_t value, unsigned int flags)

Enqueues a write command to the stream.[BETA].

hipStreamWriteValue32

hipError_t hipStreamWriteValue32(hipStream_t stream, void *ptr, uint32_t value, unsigned int flags)

Enqueues a write command to the stream.[BETA].

hipGraphExecBatchMemOpNodeSetParams

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].

hipGraphAddBatchMemOpNode

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].

hipStreamWaitValue64

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].

hipGraphBatchMemOpNodeGetParams

hipError_t hipGraphBatchMemOpNodeGetParams(hipGraphNode_t hNode, hipBatchMemOpNodeParams *nodeParams_out)

Returns a batch mem op node's parameters.[BETA].

hipStreamBatchMemOp

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].

hipGraphBatchMemOpNodeSetParams

hipError_t hipGraphBatchMemOpNodeSetParams(hipGraphNode_t hNode, hipBatchMemOpNodeParams *nodeParams)

Sets the batch mem op node's parameters.[BETA].

hipStreamWaitValue32

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].

hipMemPoolImportPointer

hipError_t hipMemPoolImportPointer(void **dev_ptr, hipMemPool_t mem_pool, hipMemPoolPtrExportData *export_data)

Import a memory pool allocation from another process.

hipMemPoolImportFromShareableHandle

hipError_t hipMemPoolImportFromShareableHandle(hipMemPool_t *mem_pool, void *shared_handle, hipMemAllocationHandleType handle_type, unsigned int flags)

Imports a memory pool from a shared handle.

hipMallocFromPoolAsync

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.

hipFreeAsync

hipError_t hipFreeAsync(void *dev_ptr, hipStream_t stream)

Frees memory with stream ordered semantics.

hipMemPoolTrimTo

hipError_t hipMemPoolTrimTo(hipMemPool_t mem_pool, size_t min_bytes_to_hold)

Releases freed memory back to the OS.

hipMemPoolCreate

hipError_t hipMemPoolCreate(hipMemPool_t *mem_pool, const hipMemPoolProps *pool_props)

Creates a memory pool.

hipMemPoolSetAccess

hipError_t hipMemPoolSetAccess(hipMemPool_t mem_pool, const hipMemAccessDesc *desc_list, size_t count)

Controls visibility of the specified pool between devices.

hipMemPoolDestroy

hipError_t hipMemPoolDestroy(hipMemPool_t mem_pool)

Destroys the specified memory pool.

hipMemPoolSetAttribute

hipError_t hipMemPoolSetAttribute(hipMemPool_t mem_pool, hipMemPoolAttr attr, void *value)

Sets attributes of a memory pool.

hipMemPoolGetAttribute

hipError_t hipMemPoolGetAttribute(hipMemPool_t mem_pool, hipMemPoolAttr attr, void *value)

Gets attributes of a memory pool.

hipMemPoolExportToShareableHandle

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.

hipMemPoolExportPointer

hipError_t hipMemPoolExportPointer(hipMemPoolPtrExportData *export_data, void *dev_ptr)

Export data to share a memory pool allocation between processes.

hipMallocAsync

hipError_t hipMallocAsync(void **dev_ptr, size_t size, hipStream_t stream)

Allocates memory with stream ordered semantics.

hipMemPoolGetAccess

hipError_t hipMemPoolGetAccess(hipMemAccessFlags *flags, hipMemPool_t mem_pool, hipMemLocation *location)

Returns the accessibility of a pool from a device.

hipDestroySurfaceObject

hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject)

Destroy a surface object.

hipCreateSurfaceObject

hipError_t hipCreateSurfaceObject(hipSurfaceObject_t *pSurfObject, const hipResourceDesc *pResDesc)

Create a surface object.

hipTexRefGetFilterMode

hipError_t hipTexRefGetFilterMode(enum hipTextureFilterMode *pfm, const textureReference *texRef)

Gets filter mode for a texture reference [Deprecated].

hipBindTextureToMipmappedArray

hipError_t hipBindTextureToMipmappedArray(const textureReference *tex, hipMipmappedArray_const_t mipmappedArray, const hipChannelFormatDesc *desc)

Binds a mipmapped array to a texture [Deprecated].

hipTexRefGetMipmapLevelClamp

hipError_t hipTexRefGetMipmapLevelClamp(float *pminMipmapLevelClamp, float *pmaxMipmapLevelClamp, const textureReference *texRef)

Gets the minimum and maximum mipmap level clamps for a texture reference [Deprecated].

hipTexRefGetAddressMode

hipError_t hipTexRefGetAddressMode(enum hipTextureAddressMode *pam, const textureReference *texRef, int dim)

Gets the address mode for a texture reference [Deprecated].

hipTexRefGetFlags

hipError_t hipTexRefGetFlags(unsigned int *pFlags, const textureReference *texRef)

Gets flags for a texture reference [Deprecated].

hipTexRefSetAddress

hipError_t hipTexRefSetAddress(size_t *ByteOffset, textureReference *texRef, hipDeviceptr_t dptr, size_t bytes)

Sets an bound address for a texture reference [Deprecated].

hipTexRefSetFilterMode

hipError_t hipTexRefSetFilterMode(textureReference *texRef, enum hipTextureFilterMode fm)

Set filter mode for a texture reference [Deprecated].

hipTexRefSetMipmappedArray

hipError_t hipTexRefSetMipmappedArray(textureReference *texRef, struct hipMipmappedArray *mipmappedArray, unsigned int Flags)

Binds mipmapped array to a texture reference [Deprecated].

hipTexRefGetMipmapFilterMode

hipError_t hipTexRefGetMipmapFilterMode(enum hipTextureFilterMode *pfm, const textureReference *texRef)

Gets the mipmap filter mode for a texture reference [Deprecated].

hipGetTextureAlignmentOffset

hipError_t hipGetTextureAlignmentOffset(size_t *offset, const textureReference *texref)

Get the offset of the alignment in a texture [Deprecated].

hipBindTexture2D

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].

hipTexRefGetMaxAnisotropy

hipError_t hipTexRefGetMaxAnisotropy(int *pmaxAnsio, const textureReference *texRef)

Gets the maximum anisotropy for a texture reference [Deprecated].

hipBindTexture

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].

hipUnbindTexture

hipError_t hipUnbindTexture(const textureReference *tex)

Unbinds a texture [Deprecated].

hipTexRefGetBorderColor

hipError_t hipTexRefGetBorderColor(float *pBorderColor, const textureReference *texRef)

Gets the border color used by a texture reference [Deprecated].

hipTexRefSetFormat

hipError_t hipTexRefSetFormat(textureReference *texRef, hipArray_Format fmt, int NumPackedComponents)

Set format for a texture reference [Deprecated].

hipTexRefGetAddress

hipError_t hipTexRefGetAddress(hipDeviceptr_t *dev_ptr, const textureReference *texRef)

Gets the address for a texture reference [Deprecated].

hipTexRefGetArray

hipError_t hipTexRefGetArray(hipArray_t *pArray, const textureReference *texRef)

Gets the array bound to a texture reference [Deprecated].

hipTexRefSetFlags

hipError_t hipTexRefSetFlags(textureReference *texRef, unsigned int Flags)

Set flags for a texture reference [Deprecated].

hipTexRefSetAddressMode

hipError_t hipTexRefSetAddressMode(textureReference *texRef, int dim, enum hipTextureAddressMode am)

Sets address mode for a texture reference [Deprecated].

hipTexRefGetMipMappedArray

hipError_t hipTexRefGetMipMappedArray(hipMipmappedArray_t *pArray, const textureReference *texRef)

Gets the mipmapped array bound to a texture reference [Deprecated].

hipTexRefSetMaxAnisotropy

hipError_t hipTexRefSetMaxAnisotropy(textureReference *texRef, unsigned int maxAniso)

Sets the maximum anisotropy for a texture reference [Deprecated].

hipTexRefSetMipmapLevelClamp

hipError_t hipTexRefSetMipmapLevelClamp(textureReference *texRef, float minMipMapLevelClamp, float maxMipMapLevelClamp)

Sets mipmap level clamp for a texture reference [Deprecated].

hipTexRefSetBorderColor

hipError_t hipTexRefSetBorderColor(textureReference *texRef, float *pBorderColor)

Sets border color for a texture reference [Deprecated].

hipTexRefSetArray

hipError_t hipTexRefSetArray(textureReference *tex, hipArray_const_t array, unsigned int flags)

Binds an array as a texture reference [Deprecated].

hipTexRefSetMipmapLevelBias

hipError_t hipTexRefSetMipmapLevelBias(textureReference *texRef, float bias)

Sets mipmap level bias for a texture reference [Deprecated].

hipTexRefGetMipmapLevelBias

hipError_t hipTexRefGetMipmapLevelBias(float *pbias, const textureReference *texRef)

Gets the mipmap level bias for a texture reference [Deprecated].

hipBindTextureToArray

hipError_t hipBindTextureToArray(const textureReference *tex, hipArray_const_t array, const hipChannelFormatDesc *desc)

Binds a memory area to a texture [Deprecated].

hipGetTextureReference

hipError_t hipGetTextureReference(const textureReference **texref, const void *symbol)

Gets the texture reference related with the symbol [Deprecated].

hipTexRefSetAddress2D

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].

hipTexRefSetMipmapFilterMode

hipError_t hipTexRefSetMipmapFilterMode(textureReference *texRef, enum hipTextureFilterMode fm)

Sets mipmap filter mode for a texture reference [Deprecated].

hipTexRefGetFormat

hipError_t hipTexRefGetFormat(hipArray_Format *pFormat, int *pNumChannels, const textureReference *texRef)

Gets texture format for a texture reference [Deprecated].

hipFreeMipmappedArray

hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray)

Frees a mipmapped array on the device.

hipGetMipmappedArrayLevel

hipError_t hipGetMipmappedArrayLevel(hipArray_t *levelArray, hipMipmappedArray_const_t mipmappedArray, unsigned int level)

Gets a mipmap level of a HIP mipmapped array.

hipMipmappedArrayGetLevel

hipError_t hipMipmappedArrayGetLevel(hipArray_t *pLevelArray, hipMipmappedArray_t hMipMappedArray, unsigned int level)

Get a mipmapped array on a mipmapped level.

hipMipmappedArrayDestroy

hipError_t hipMipmappedArrayDestroy(hipMipmappedArray_t hMipmappedArray)

Destroy a mipmapped array.

hipTexObjectCreate

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.

hipGetTextureObjectResourceDesc

hipError_t hipGetTextureObjectResourceDesc(hipResourceDesc *pResDesc, hipTextureObject_t textureObject)

Gets resource descriptor for the texture object.

hipGetTextureObjectResourceViewDesc

hipError_t hipGetTextureObjectResourceViewDesc(struct hipResourceViewDesc *pResViewDesc, hipTextureObject_t textureObject)

Gets resource view descriptor for the texture object.

hipTexObjectGetTextureDesc

hipError_t hipTexObjectGetTextureDesc(HIP_TEXTURE_DESC *pTexDesc, hipTextureObject_t texObject)

Gets texture descriptor of a texture object.

hipCreateTextureObject

hipError_t hipCreateTextureObject(hipTextureObject_t *pTexObject, const hipResourceDesc *pResDesc, const hipTextureDesc *pTexDesc, const struct hipResourceViewDesc *pResViewDesc)

Creates a texture object.

hipTexObjectDestroy

hipError_t hipTexObjectDestroy(hipTextureObject_t texObject)

Destroys a texture object.

hipMipmappedArrayCreate

hipError_t hipMipmappedArrayCreate(hipMipmappedArray_t *pHandle, HIP_ARRAY3D_DESCRIPTOR *pMipmappedArrayDesc, unsigned int numMipmapLevels)

Create a mipmapped array.

hipGetChannelDesc

hipError_t hipGetChannelDesc(hipChannelFormatDesc *desc, hipArray_const_t array)

Gets the channel descriptor in an array.

hipTexObjectGetResourceDesc

hipError_t hipTexObjectGetResourceDesc(HIP_RESOURCE_DESC *pResDesc, hipTextureObject_t texObject)

Gets resource descriptor of a texture object.

hipTexObjectGetResourceViewDesc

hipError_t hipTexObjectGetResourceViewDesc(HIP_RESOURCE_VIEW_DESC *pResViewDesc, hipTextureObject_t texObject)

Gets resource view descriptor of a texture object.

hipMallocMipmappedArray

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.

hipDestroyTextureObject

hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject)

Destroys a texture object.

hipGetTextureObjectTextureDesc

hipError_t hipGetTextureObjectTextureDesc(hipTextureDesc *pTexDesc, hipTextureObject_t textureObject)

Gets texture descriptor for the texture object.

hipMemAddressFree

hipError_t hipMemAddressFree(void *devPtr, size_t size)

Frees an address range reservation made via hipMemAddressReserve.

hipMemExportToShareableHandle

hipError_t hipMemExportToShareableHandle(void *shareableHandle, hipMemGenericAllocationHandle_t handle, hipMemAllocationHandleType handleType, unsigned long long flags)

Exports an allocation to a requested shareable handle type.

hipMemGetAccess

hipError_t hipMemGetAccess(unsigned long long *flags, const hipMemLocation *location, void *ptr)

Get the access flags set for the given location and ptr.

hipMemSetAccess

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.

hipMemRelease

hipError_t hipMemRelease(hipMemGenericAllocationHandle_t handle)

Release a memory handle representing a memory allocation which was previously allocated through hipMe...

hipMemUnmap

hipError_t hipMemUnmap(void *ptr, size_t size)

Unmap memory allocation of a given address range.

hipMemGetAllocationGranularity

hipError_t hipMemGetAllocationGranularity(size_t *granularity, const hipMemAllocationProp *prop, hipMemAllocationGranularity_flags option)

Calculates either the minimal or recommended granularity.

hipMemRetainAllocationHandle

hipError_t hipMemRetainAllocationHandle(hipMemGenericAllocationHandle_t *handle, void *addr)

Returns the allocation handle of the backing memory allocation given the address.

hipMemCreate

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.

hipMemMap

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.

hipMemAddressReserve

hipError_t hipMemAddressReserve(void **ptr, size_t size, size_t alignment, void *addr, unsigned long long flags)

Reserves an address range.

hipMemGetAllocationPropertiesFromHandle

hipError_t hipMemGetAllocationPropertiesFromHandle(hipMemAllocationProp *prop, hipMemGenericAllocationHandle_t handle)

Retrieve the property structure of the given handle.

hipMemMapArrayAsync

hipError_t hipMemMapArrayAsync(hipArrayMapInfo *mapInfoList, unsigned int count, hipStream_t stream)

Maps or unmaps subregions of sparse HIP arrays and sparse HIP mipmapped arrays.

hipMemImportFromShareableHandle

hipError_t hipMemImportFromShareableHandle(hipMemGenericAllocationHandle_t *handle, void *osHandle, hipMemAllocationHandleType shHandleType)

Imports an allocation from a requested shareable handle type.

hip_common.h

hipErrorIllegalAddress

hipErrorIllegalAddress

Definition: hip_runtime_api.h:365

hipErrorMemoryAllocation

hipErrorMemoryAllocation

Memory allocation error.

Definition: hip_runtime_api.h:311

hipErrorNotFound

hipErrorNotFound

Not found.

Definition: hip_runtime_api.h:360

hipErrorProfilerDisabled

hipErrorProfilerDisabled

Definition: hip_runtime_api.h:316

hipErrorInvalidDevicePointer

hipErrorInvalidDevicePointer

Invalid Device Pointer.

Definition: hip_runtime_api.h:323

HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

@ HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

Definition: hip_runtime_api.h:53

HIP_ERROR_INVALID_VALUE

@ HIP_ERROR_INVALID_VALUE

Definition: hip_runtime_api.h:51

HIP_SUCCESS

@ HIP_SUCCESS

Definition: hip_runtime_api.h:50

HIP_ERROR_NOT_INITIALIZED

@ HIP_ERROR_NOT_INITIALIZED

Definition: hip_runtime_api.h:52

hipErrorRuntimeMemory

hipErrorRuntimeMemory

Definition: hip_runtime_api.h:414

hipErrorInvalidImage

hipErrorInvalidImage

Invalid image.

Definition: hip_runtime_api.h:331

hipErrorPeerAccessUnsupported

hipErrorPeerAccessUnsupported

Definition: hip_runtime_api.h:348

hipErrorArrayIsMapped

hipErrorArrayIsMapped

Definition: hip_runtime_api.h:338

hipErrorStreamCaptureIsolation

hipErrorStreamCaptureIsolation

Definition: hip_runtime_api.h:393

hipErrorInvalidKernelFile

hipErrorInvalidKernelFile

In CUDA DRV, it is CUDA_ERROR_INVALID_PTX.

Definition: hip_runtime_api.h:349

hipErrorNotMapped

hipErrorNotMapped

Definition: hip_runtime_api.h:342

hipErrorGraphExecUpdateFailure

hipErrorGraphExecUpdateFailure

Definition: hip_runtime_api.h:406

hipErrorNotInitialized

hipErrorNotInitialized

Invalid not initialized.

Definition: hip_runtime_api.h:312

hipErrorInvalidResourceHandle

hipErrorInvalidResourceHandle

Resource handle (hipEvent_t or hipStream_t) invalid.

Definition: hip_runtime_api.h:358

hipErrorSharedObjectInitFailed

hipErrorSharedObjectInitFailed

Failed to initialize shared object.

Definition: hip_runtime_api.h:354

hipErrorInvalidPitchValue

hipErrorInvalidPitchValue

Invalid pitch value.

Definition: hip_runtime_api.h:321

hipErrorNoBinaryForGpu

hipErrorNoBinaryForGpu

Definition: hip_runtime_api.h:340

hipErrorInvalidContext

hipErrorInvalidContext

Produced when input context is invalid.

Definition: hip_runtime_api.h:332

hipErrorStreamCaptureUnsupported

hipErrorStreamCaptureUnsupported

Definition: hip_runtime_api.h:384

hipErrorPeerAccessNotEnabled

hipErrorPeerAccessNotEnabled

Peer access was never enabled from the current device.

Definition: hip_runtime_api.h:370

hipErrorOperatingSystem

hipErrorOperatingSystem

Not the correct operating system.

Definition: hip_runtime_api.h:355

hipErrorStreamCaptureUnjoined

hipErrorStreamCaptureUnjoined

Definition: hip_runtime_api.h:391

hipErrorInitializationError

hipErrorInitializationError

Definition: hip_runtime_api.h:314

hipErrorNotMappedAsPointer

hipErrorNotMappedAsPointer

Definition: hip_runtime_api.h:344

hipErrorPriorLaunchFailure

hipErrorPriorLaunchFailure

Definition: hip_runtime_api.h:327

hipErrorContextIsDestroyed

hipErrorContextIsDestroyed

The context is already destroyed.

Definition: hip_runtime_api.h:372

hipErrorInvalidValue

hipErrorInvalidValue

Definition: hip_runtime_api.h:307

hipErrorLaunchTimeOut

hipErrorLaunchTimeOut

Timeout for the launch.

Definition: hip_runtime_api.h:367

hipErrorUnmapFailed

hipErrorUnmapFailed

Definition: hip_runtime_api.h:337

hipErrorSetOnActiveProcess

hipErrorSetOnActiveProcess

The process is active.

Definition: hip_runtime_api.h:371

hipErrorFileNotFound

hipErrorFileNotFound

the file is not found.

Definition: hip_runtime_api.h:352

hipErrorLaunchFailure

hipErrorLaunchFailure

An exception occurred on the device while executing a kernel.

Definition: hip_runtime_api.h:378

hipErrorInvalidDevice

hipErrorInvalidDevice

DeviceID must be in range from 0 to compute-devices.

Definition: hip_runtime_api.h:330

hipErrorUnsupportedLimit

hipErrorUnsupportedLimit

Unsupported limit.

Definition: hip_runtime_api.h:346

hipErrorMapBufferObjectFailed

hipErrorMapBufferObjectFailed

Produced when the IPC memory attach failed from ROCr.

Definition: hip_runtime_api.h:336

hipErrorHostMemoryAlreadyRegistered

hipErrorHostMemoryAlreadyRegistered

Definition: hip_runtime_api.h:374

hipErrorMissingConfiguration

hipErrorMissingConfiguration

Definition: hip_runtime_api.h:326

hipErrorSharedObjectSymbolNotFound

hipErrorSharedObjectSymbolNotFound

Definition: hip_runtime_api.h:353

hipErrorECCNotCorrectable

hipErrorECCNotCorrectable

Definition: hip_runtime_api.h:345

hipErrorStreamCaptureWrongThread

hipErrorStreamCaptureWrongThread

Definition: hip_runtime_api.h:402

hipErrorAssert

hipErrorAssert

Produced when the kernel calls assert.

Definition: hip_runtime_api.h:373

hipErrorContextAlreadyInUse

hipErrorContextAlreadyInUse

The context is already in use.

Definition: hip_runtime_api.h:347

hipErrorNotReady

hipErrorNotReady

Definition: hip_runtime_api.h:361

hipErrorInvalidSource

hipErrorInvalidSource

Invalid source.

Definition: hip_runtime_api.h:351

hipErrorLaunchOutOfResources

hipErrorLaunchOutOfResources

Out of resources error.

Definition: hip_runtime_api.h:366

hipErrorInvalidDeviceFunction

hipErrorInvalidDeviceFunction

Invalid device function.

Definition: hip_runtime_api.h:328

hipErrorCooperativeLaunchTooLarge

hipErrorCooperativeLaunchTooLarge

Definition: hip_runtime_api.h:379

hipErrorAlreadyMapped

hipErrorAlreadyMapped

Definition: hip_runtime_api.h:339

hipErrorProfilerNotInitialized

hipErrorProfilerNotInitialized

Definition: hip_runtime_api.h:317

hipErrorProfilerAlreadyStarted

hipErrorProfilerAlreadyStarted

Definition: hip_runtime_api.h:318

hipErrorInvalidChannelDescriptor

hipErrorInvalidChannelDescriptor

Invalid channel descriptor.

Definition: hip_runtime_api.h:410

hipErrorNoDevice

hipErrorNoDevice

Call to hipGetDeviceCount returned 0 devices.

Definition: hip_runtime_api.h:329

hipErrorMapFailed

hipErrorMapFailed

Definition: hip_runtime_api.h:334

hipErrorStreamCaptureInvalidated

hipErrorStreamCaptureInvalidated

Definition: hip_runtime_api.h:386

hipErrorProfilerAlreadyStopped

hipErrorProfilerAlreadyStopped

Definition: hip_runtime_api.h:319

hipErrorDeinitialized

hipErrorDeinitialized

Deinitialized.

Definition: hip_runtime_api.h:315

hipErrorPeerAccessAlreadyEnabled

hipErrorPeerAccessAlreadyEnabled

Definition: hip_runtime_api.h:368

hipErrorNotMappedAsArray

hipErrorNotMappedAsArray

Definition: hip_runtime_api.h:343

hipErrorNotSupported

hipErrorNotSupported

Produced when the hip API is not supported/implemented.

Definition: hip_runtime_api.h:383

hipErrorInvalidConfiguration

hipErrorInvalidConfiguration

Invalide configuration.

Definition: hip_runtime_api.h:320

hipErrorStreamCaptureImplicit

hipErrorStreamCaptureImplicit

Definition: hip_runtime_api.h:397

hipErrorStreamCaptureMerge

hipErrorStreamCaptureMerge

Definition: hip_runtime_api.h:388

hipErrorInvalidGraphicsContext

hipErrorInvalidGraphicsContext

Definition: hip_runtime_api.h:350

hipErrorIllegalState

hipErrorIllegalState

Resource required is not in a valid state to perform operation.

Definition: hip_runtime_api.h:359

hipErrorOutOfMemory

hipErrorOutOfMemory

out of memory range.

Definition: hip_runtime_api.h:309

hipErrorInvalidSymbol

hipErrorInvalidSymbol

Invalid symbol.

Definition: hip_runtime_api.h:322

hipSuccess

hipSuccess

Successful completion.

Definition: hip_runtime_api.h:306

hipErrorUnknown

hipErrorUnknown

Unknown error.

Definition: hip_runtime_api.h:412

hipErrorInvalidHandle

hipErrorInvalidHandle

Invalide handle.

Definition: hip_runtime_api.h:356

hipErrorStreamCaptureUnmatched

hipErrorStreamCaptureUnmatched

The capture was not initiated in this stream.

Definition: hip_runtime_api.h:390

hipErrorCapturedEvent

hipErrorCapturedEvent

Definition: hip_runtime_api.h:400

hipErrorAlreadyAcquired

hipErrorAlreadyAcquired

Definition: hip_runtime_api.h:341

hipErrorInsufficientDriver

hipErrorInsufficientDriver

Definition: hip_runtime_api.h:325

hipErrorHostMemoryNotRegistered

hipErrorHostMemoryNotRegistered

Definition: hip_runtime_api.h:376

hipErrorInvalidTexture

hipErrorInvalidTexture

Invalid texture.

Definition: hip_runtime_api.h:411

hipErrorRuntimeOther

hipErrorRuntimeOther

Definition: hip_runtime_api.h:416

hipErrorContextAlreadyCurrent

hipErrorContextAlreadyCurrent

Definition: hip_runtime_api.h:333

hipErrorInvalidMemcpyDirection

hipErrorInvalidMemcpyDirection

Invalid memory copy direction.

Definition: hip_runtime_api.h:324

linker_types.h

hip_impl

Definition: hip_runtime_api.h:661

hip_impl::hip_init

hipError_t hip_init()

HIP_ARRAY3D_DESCRIPTOR

Definition: driver_types.h:103

HIP_ARRAY_DESCRIPTOR

Definition: driver_types.h:93

HIP_LAUNCH_CONFIG

Definition: hip_runtime_api.h:1991

HIP_LAUNCH_CONFIG::gridDimZ

unsigned int gridDimZ

Grid depth in blocks.

Definition: hip_runtime_api.h:1994

HIP_LAUNCH_CONFIG::sharedMemBytes

unsigned int sharedMemBytes

Dynamic shared-memory size in bytes per block.

Definition: hip_runtime_api.h:1998

HIP_LAUNCH_CONFIG::blockDimY

unsigned int blockDimY

Thread block dimension in Y.

Definition: hip_runtime_api.h:1996

HIP_LAUNCH_CONFIG::hStream

hipStream_t hStream

HIP stream identifier.

Definition: hip_runtime_api.h:1999

HIP_LAUNCH_CONFIG::attrs

hipLaunchAttribute * attrs

Attribute list.

Definition: hip_runtime_api.h:2000

HIP_LAUNCH_CONFIG::blockDimZ

unsigned int blockDimZ

Thread block dimension in Z.

Definition: hip_runtime_api.h:1997

HIP_LAUNCH_CONFIG::numAttrs

unsigned int numAttrs

Number of attributes.

Definition: hip_runtime_api.h:2001

HIP_LAUNCH_CONFIG::gridDimX

unsigned int gridDimX

Grid width in blocks.

Definition: hip_runtime_api.h:1992

HIP_LAUNCH_CONFIG::gridDimY

unsigned int gridDimY

Grid height in blocks.

Definition: hip_runtime_api.h:1993

HIP_LAUNCH_CONFIG::blockDimX

unsigned int blockDimX

Thread block dimension in X.

Definition: hip_runtime_api.h:1995

HIP_MEMCPY3D

Definition: driver_types.h:424

HIP_RESOURCE_DESC

Definition: driver_types.h:313

HIP_RESOURCE_VIEW_DESC

Definition: driver_types.h:358

HIP_TEXTURE_DESC

Definition: driver_types.h:191

dim3

Definition: hip_runtime_api.h:1283

dim3::y

uint32_t y

y

Definition: hip_runtime_api.h:1285

dim3::z

uint32_t z

z

Definition: hip_runtime_api.h:1286

dim3::x

uint32_t x

x

Definition: hip_runtime_api.h:1284

dim3::dim3

constexpr dim3(uint32_t _x=1, uint32_t _y=1, uint32_t _z=1)

Definition: hip_runtime_api.h:1288

hip_Memcpy2D

Definition: driver_types.h:115

hipAccessPolicyWindow

Definition: hip_runtime_api.h:1532

hipAccessPolicyWindow::hitProp

hipAccessProperty hitProp

hipAccessProperty set for hit

Definition: hip_runtime_api.h:1534

hipAccessPolicyWindow::missProp

hipAccessProperty missProp

hipAccessProperty set for miss

Definition: hip_runtime_api.h:1536

hipAccessPolicyWindow::hitRatio

float hitRatio

hitRatio specifies percentage of lines assigned hitProp

Definition: hip_runtime_api.h:1535

hipAccessPolicyWindow::base_ptr

void * base_ptr

Starting address of the access policy window.

Definition: hip_runtime_api.h:1533

hipAccessPolicyWindow::num_bytes

size_t num_bytes

Size in bytes of the window policy.

Definition: hip_runtime_api.h:1537

hipArrayMapInfo

Definition: hip_runtime_api.h:1826

hipArrayMapInfo::level

unsigned int level

For mipmapped arrays must be a valid mipmap level. For arrays must be zero.

Definition: hip_runtime_api.h:1836

hipArrayMapInfo::flags

unsigned int flags

flags for future use, must be zero now.

Definition: hip_runtime_api.h:1860

hipArrayMapInfo::subresourceType

hipArraySparseSubresourceType subresourceType

Sparse subresource type.

Definition: hip_runtime_api.h:1832

hipArrayMapInfo::extentDepth

unsigned int extentDepth

Depth in elements.

Definition: hip_runtime_api.h:1844

hipArrayMapInfo::offsetX

unsigned int offsetX

X offset in elements.

Definition: hip_runtime_api.h:1839

hipArrayMapInfo::array

hipArray_t array

Definition: hip_runtime_api.h:1830

hipArrayMapInfo::resourceType

hipResourceType resourceType

Resource type.

Definition: hip_runtime_api.h:1827

hipArrayMapInfo::memOperationType

hipMemOperationType memOperationType

Memory operation type.

Definition: hip_runtime_api.h:1853

hipArrayMapInfo::miptail

struct hipArrayMapInfo::@35::@38 miptail

hipArrayMapInfo::reserved

unsigned int reserved[2]

Reserved for future use, must be zero now.

Definition: hip_runtime_api.h:1861

hipArrayMapInfo::extentWidth

unsigned int extentWidth

Width in elements.

Definition: hip_runtime_api.h:1842

hipArrayMapInfo::sparseLevel

struct hipArrayMapInfo::@35::@37 sparseLevel

hipArrayMapInfo::extentHeight

unsigned int extentHeight

Height in elements.

Definition: hip_runtime_api.h:1843

hipArrayMapInfo::offsetY

unsigned int offsetY

Y offset in elements.

Definition: hip_runtime_api.h:1840

hipArrayMapInfo::memHandleType

hipMemHandleType memHandleType

Memory handle type.

Definition: hip_runtime_api.h:1854

hipArrayMapInfo::memHandle

hipMemGenericAllocationHandle_t memHandle

Definition: hip_runtime_api.h:1856

hipArrayMapInfo::mipmap

hipMipmappedArray mipmap

Definition: hip_runtime_api.h:1829

hipArrayMapInfo::subresource

union hipArrayMapInfo::@35 subresource

hipArrayMapInfo::layer

unsigned int layer

For layered arrays must be a valid layer index. Otherwise, must be zero.

Definition: hip_runtime_api.h:1838

hipArrayMapInfo::deviceBitMask

unsigned int deviceBitMask

Device ordinal bit mask.

Definition: hip_runtime_api.h:1859

hipArrayMapInfo::size

unsigned long long size

Extent in bytes.

Definition: hip_runtime_api.h:1850

hipArrayMapInfo::offset

unsigned long long offset

Offset within mip tail.

Definition: hip_runtime_api.h:1849

hipArrayMapInfo::offsetZ

unsigned int offsetZ

Z offset in elements.

Definition: hip_runtime_api.h:1841

hipArrayMapInfo::resource

union hipArrayMapInfo::@34 resource

hipBatchMemOpNodeParams

Structure representing node parameters for batch memory operations in HIP graphs.

Definition: hip_runtime_api.h:1062

hipBatchMemOpNodeParams::paramArray

hipStreamBatchMemOpParams * paramArray

Definition: hip_runtime_api.h:1065

hipBatchMemOpNodeParams::count

unsigned int count

Definition: hip_runtime_api.h:1064

hipBatchMemOpNodeParams::flags

unsigned int flags

Definition: hip_runtime_api.h:1066

hipBatchMemOpNodeParams::ctx

hipCtx_t ctx

Definition: hip_runtime_api.h:1063

hipChannelFormatDesc

Definition: driver_types.h:59

hipChildGraphNodeParams

Definition: hip_runtime_api.h:1876

hipChildGraphNodeParams::graph

hipGraph_t graph

Definition: hip_runtime_api.h:1877

hipDeviceArch_t

Definition: hip_runtime_api.h:65

hipDeviceArch_t::hasSharedInt64Atomics

unsigned hasSharedInt64Atomics

64-bit integer atomics for shared memory.

Definition: hip_runtime_api.h:75

hipDeviceArch_t::hasSharedInt32Atomics

unsigned hasSharedInt32Atomics

32-bit integer atomics for shared memory.

Definition: hip_runtime_api.h:69

hipDeviceArch_t::hasFloatAtomicAdd

unsigned hasFloatAtomicAdd

32-bit float atomic add in global and shared memory.

Definition: hip_runtime_api.h:71

hipDeviceArch_t::hasDoubles

unsigned hasDoubles

Double-precision floating point.

Definition: hip_runtime_api.h:78

hipDeviceArch_t::hasWarpVote

unsigned hasWarpVote

Warp vote instructions (__any, __all).

Definition: hip_runtime_api.h:81

hipDeviceArch_t::hasWarpShuffle

unsigned hasWarpShuffle

Warp shuffle operations. (__shfl_*).

Definition: hip_runtime_api.h:83

hipDeviceArch_t::hasGlobalInt32Atomics

unsigned hasGlobalInt32Atomics

32-bit integer atomics for global memory.

Definition: hip_runtime_api.h:67

hipDeviceArch_t::hasGlobalFloatAtomicExch

unsigned hasGlobalFloatAtomicExch

32-bit float atomic exch for global memory.

Definition: hip_runtime_api.h:68

hipDeviceArch_t::hasDynamicParallelism

unsigned hasDynamicParallelism

Dynamic parallelism.

Definition: hip_runtime_api.h:93

hipDeviceArch_t::hasSurfaceFuncs

unsigned hasSurfaceFuncs

Surface functions.

Definition: hip_runtime_api.h:91

hipDeviceArch_t::has3dGrid

unsigned has3dGrid

Grid and group dims are 3D (rather than 2D).

Definition: hip_runtime_api.h:92

hipDeviceArch_t::hasFunnelShift

unsigned hasFunnelShift

Funnel two words into one with shift&mask caps.

Definition: hip_runtime_api.h:84

hipDeviceArch_t::hasThreadFenceSystem

unsigned hasThreadFenceSystem

__threadfence_system.

Definition: hip_runtime_api.h:87

hipDeviceArch_t::hasGlobalInt64Atomics

unsigned hasGlobalInt64Atomics

64-bit integer atomics for global memory.

Definition: hip_runtime_api.h:74

hipDeviceArch_t::hasSyncThreadsExt

unsigned hasSyncThreadsExt

__syncthreads_count, syncthreads_and, syncthreads_or.

Definition: hip_runtime_api.h:88

hipDeviceArch_t::hasWarpBallot

unsigned hasWarpBallot

Warp ballot instructions (__ballot).

Definition: hip_runtime_api.h:82

hipDeviceArch_t::hasSharedFloatAtomicExch

unsigned hasSharedFloatAtomicExch

32-bit float atomic exch for shared memory.

Definition: hip_runtime_api.h:70

hipDeviceProp_t

Definition: hip_runtime_api.h:111

hipDeviceProp_t::ECCEnabled

int ECCEnabled

Device has ECC support enabled.

Definition: hip_runtime_api.h:171

hipDeviceProp_t::ipcEventSupported

int ipcEventSupported

Device supports IPC events.

Definition: hip_runtime_api.h:225

hipDeviceProp_t::computePreemptionSupported

int computePreemptionSupported

Is compute preemption supported on the device.

Definition: hip_runtime_api.h:197

hipDeviceProp_t::maxTexture1DLinear

int maxTexture1DLinear

Maximum size for 1D textures bound to linear memory.

Definition: hip_runtime_api.h:150

hipDeviceProp_t::timelineSemaphoreInteropSupported

int timelineSemaphoreInteropSupported

Indicates external timeline semaphore support.

Definition: hip_runtime_api.h:215

hipDeviceProp_t::pciBusID

int pciBusID

PCI Bus ID.

Definition: hip_runtime_api.h:172

hipDeviceProp_t::maxTexture1D

int maxTexture1D

Maximum number of elements in 1D images.

Definition: hip_runtime_api.h:148

hipDeviceProp_t::memoryBusWidth

int memoryBusWidth

Global memory bus width in bits.

Definition: hip_runtime_api.h:179

hipDeviceProp_t::maxTexture2DMipmap

int maxTexture2DMipmap[2]

Maximum number of elements in 2D array mipmap of images.

Definition: hip_runtime_api.h:152

hipDeviceProp_t::clockRate

int clockRate

Max clock frequency of the multiProcessors in khz.

Definition: hip_runtime_api.h:125

hipDeviceProp_t::maxThreadsPerMultiProcessor

int maxThreadsPerMultiProcessor

Maximum resident threads per multi-processor.

Definition: hip_runtime_api.h:182

hipDeviceProp_t::l2CacheSize

int l2CacheSize

L2 cache size.

Definition: hip_runtime_api.h:180

hipDeviceProp_t::deferredMappingHipArraySupported

int deferredMappingHipArraySupported

Definition: hip_runtime_api.h:223

hipDeviceProp_t::asyncEngineCount

int asyncEngineCount

Number of async engines.

Definition: hip_runtime_api.h:176

hipDeviceProp_t::accessPolicyMaxWindowSize

int accessPolicyMaxWindowSize

Max value of access policy window.

Definition: hip_runtime_api.h:209

hipDeviceProp_t::totalConstMem

size_t totalConstMem

Definition: hip_runtime_api.h:126

hipDeviceProp_t::memoryPoolsSupported

int memoryPoolsSupported

Indicates if device supports hipMallocAsync and hipMemPool APIs.

Definition: hip_runtime_api.h:216

hipDeviceProp_t::unifiedFunctionPointers

int unifiedFunctionPointers

Indicates device supports unified function pointers.

Definition: hip_runtime_api.h:227

hipDeviceProp_t::maxTexture2DGather

int maxTexture2DGather[2]

Maximum 2D tex dimensions if gather has to be performed.

Definition: hip_runtime_api.h:154

hipDeviceProp_t::memPitch

size_t memPitch

Definition: hip_runtime_api.h:120

hipDeviceProp_t::gpuDirectRDMAWritesOrdering

int gpuDirectRDMAWritesOrdering

value of hipGPUDirectRDMAWritesOrdering

Definition: hip_runtime_api.h:220

hipDeviceProp_t::uuid

hipUUID uuid

UUID of a device.

Definition: hip_runtime_api.h:113

hipDeviceProp_t::sharedMemPerBlock

size_t sharedMemPerBlock

Size of shared memory per block (in bytes).

Definition: hip_runtime_api.h:117

hipDeviceProp_t::gpuDirectRDMAFlushWritesOptions

unsigned int gpuDirectRDMAFlushWritesOptions

Definition: hip_runtime_api.h:218

hipDeviceProp_t::surfaceAlignment

size_t surfaceAlignment

Alignment requirement for surface.

Definition: hip_runtime_api.h:169

hipDeviceProp_t::reserved

int reserved[63]

CUDA Reserved.

Definition: hip_runtime_api.h:228

hipDeviceProp_t::maxTexture2DLayered

int maxTexture2DLayered[3]

Maximum number of elements in 2D array images.

Definition: hip_runtime_api.h:160

hipDeviceProp_t::streamPrioritiesSupported

int streamPrioritiesSupported

Device supports stream priority.

Definition: hip_runtime_api.h:183

hipDeviceProp_t::cooperativeMultiDeviceLaunch

int cooperativeMultiDeviceLaunch

Definition: hip_runtime_api.h:201

hipDeviceProp_t::hostRegisterSupported

int hostRegisterSupported

Device supports hipHostRegister.

Definition: hip_runtime_api.h:211

hipDeviceProp_t::pageableMemoryAccess

int pageableMemoryAccess

Definition: hip_runtime_api.h:193

hipDeviceProp_t::name

char name[256]

Device name.

Definition: hip_runtime_api.h:112

hipDeviceProp_t::textureAlignment

size_t textureAlignment

Alignment requirement for textures.

Definition: hip_runtime_api.h:137

hipDeviceProp_t::globalL1CacheSupported

int globalL1CacheSupported

Indicates globals are cached in L1.

Definition: hip_runtime_api.h:184

hipDeviceProp_t::hostNativeAtomicSupported

int hostNativeAtomicSupported

Link between host and device supports native atomics.

Definition: hip_runtime_api.h:191

hipDeviceProp_t::maxSurfaceCubemapLayered

int maxSurfaceCubemapLayered[2]

Maximum cubemap layered surface size.

Definition: hip_runtime_api.h:168

hipDeviceProp_t::maxTextureCubemapLayered

int maxTextureCubemapLayered[2]

Maximum cubemaps layered texture dims.

Definition: hip_runtime_api.h:161

hipDeviceProp_t::sharedMemPerBlockOptin

size_t sharedMemPerBlockOptin

Per device m ax shared mem per block usable by special opt in.

Definition: hip_runtime_api.h:203

hipDeviceProp_t::sharedMemPerMultiprocessor

size_t sharedMemPerMultiprocessor

Amount of shared memory available per multiprocessor.

Definition: hip_runtime_api.h:186

hipDeviceProp_t::singleToDoublePrecisionPerfRatio

int singleToDoublePrecisionPerfRatio

Deprecated. CUDA only.

Definition: hip_runtime_api.h:192

hipDeviceProp_t::maxSurface2D

int maxSurface2D[2]

Maximum 2D surface size.

Definition: hip_runtime_api.h:163

hipDeviceProp_t::memoryClockRate

int memoryClockRate

Max global memory clock frequency in khz.

Definition: hip_runtime_api.h:178

hipDeviceProp_t::maxTexture2DLinear

int maxTexture2DLinear[3]

Maximum 2D tex dimensions if tex are bound to pitched memory.

Definition: hip_runtime_api.h:153

hipDeviceProp_t::sparseHipArraySupported

int sparseHipArraySupported

Indicates if device supports sparse hip arrays.

Definition: hip_runtime_api.h:212

hipDeviceProp_t::clockInstructionRate

int clockInstructionRate

Definition: hip_runtime_api.h:235

hipDeviceProp_t::localL1CacheSupported

int localL1CacheSupported

Locals are cahced in L1.

Definition: hip_runtime_api.h:185

hipDeviceProp_t::regsPerMultiprocessor

int regsPerMultiprocessor

registers available per multiprocessor

Definition: hip_runtime_api.h:187

hipDeviceProp_t::regsPerBlock

int regsPerBlock

Registers per block.

Definition: hip_runtime_api.h:118

hipDeviceProp_t::maxTexture2D

int maxTexture2D[2]

Maximum dimensions (width, height) of 2D images, in image elements.

Definition: hip_runtime_api.h:151

hipDeviceProp_t::cooperativeLaunch

int cooperativeLaunch

HIP device supports cooperative launch.

Definition: hip_runtime_api.h:200

hipDeviceProp_t::maxTexture3D

int maxTexture3D[3]

Definition: hip_runtime_api.h:155

hipDeviceProp_t::directManagedMemAccessFromHost

int directManagedMemAccessFromHost

Definition: hip_runtime_api.h:206

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedFunc

int cooperativeMultiDeviceUnmatchedFunc

Definition: hip_runtime_api.h:240

hipDeviceProp_t::deviceOverlap

int deviceOverlap

Deprecated. Use asyncEngineCount instead.

Definition: hip_runtime_api.h:139

hipDeviceProp_t::pageableMemoryAccessUsesHostPageTables

int pageableMemoryAccessUsesHostPageTables

Definition: hip_runtime_api.h:204

hipDeviceProp_t::hdpRegFlushCntl

unsigned int * hdpRegFlushCntl

Addres of HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition: hip_runtime_api.h:239

hipDeviceProp_t::maxThreadsDim

int maxThreadsDim[3]

Max number of threads in each dimension (XYZ) of a block.

Definition: hip_runtime_api.h:123

hipDeviceProp_t::unifiedAddressing

int unifiedAddressing

Does device and host share unified address space.

Definition: hip_runtime_api.h:177

hipDeviceProp_t::multiGpuBoardGroupID

int multiGpuBoardGroupID

Unique identifier for a group of devices on same multiboard GPU.

Definition: hip_runtime_api.h:190

hipDeviceProp_t::isMultiGpuBoard

int isMultiGpuBoard

1 if device is on a multi-GPU board, 0 if not.

Definition: hip_runtime_api.h:189

hipDeviceProp_t::canUseHostPointerForRegisteredMem

int canUseHostPointerForRegisteredMem

Definition: hip_runtime_api.h:198

hipDeviceProp_t::maxTexture1DLayered

int maxTexture1DLayered[2]

Maximum number of elements in 1D array images.

Definition: hip_runtime_api.h:159

hipDeviceProp_t::pciDomainID

int pciDomainID

PCI Domain ID.

Definition: hip_runtime_api.h:174

hipDeviceProp_t::maxSharedMemoryPerMultiProcessor

size_t maxSharedMemoryPerMultiProcessor

Maximum Shared Memory Per CU. HIP Only.

Definition: hip_runtime_api.h:234

hipDeviceProp_t::maxTextureCubemap

int maxTextureCubemap

Maximum cubemap texture dims.

Definition: hip_runtime_api.h:158

hipDeviceProp_t::hipReserved

int hipReserved[32]

Reserved for adding new entries for HIP/CUDA.

Definition: hip_runtime_api.h:230

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedGridDim

int cooperativeMultiDeviceUnmatchedGridDim

Definition: hip_runtime_api.h:243

hipDeviceProp_t::gpuDirectRDMASupported

int gpuDirectRDMASupported

Indicates device support of RDMA APIs.

Definition: hip_runtime_api.h:217

hipDeviceProp_t::minor

int minor

Definition: hip_runtime_api.h:132

hipDeviceProp_t::gcnArchName

char gcnArchName[256]

AMD GCN Arch Name. HIP Only.

Definition: hip_runtime_api.h:233

hipDeviceProp_t::luid

char luid[8]

8-byte unique identifier. Only valid on windows

Definition: hip_runtime_api.h:114

hipDeviceProp_t::kernelExecTimeoutEnabled

int kernelExecTimeoutEnabled

Run time limit for kernels executed on the device.

Definition: hip_runtime_api.h:144

hipDeviceProp_t::memoryPoolSupportedHandleTypes

unsigned int memoryPoolSupportedHandleTypes

Bitmask of handle types support with mempool based IPC.

Definition: hip_runtime_api.h:222

hipDeviceProp_t::hdpMemFlushCntl

unsigned int * hdpMemFlushCntl

Addres of HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition: hip_runtime_api.h:238

hipDeviceProp_t::concurrentManagedAccess

int concurrentManagedAccess

Definition: hip_runtime_api.h:195

hipDeviceProp_t::integrated

int integrated

APU vs dGPU.

Definition: hip_runtime_api.h:145

hipDeviceProp_t::canMapHostMemory

int canMapHostMemory

Check whether HIP can map host memory.

Definition: hip_runtime_api.h:146

hipDeviceProp_t::reservedSharedMemPerBlock

size_t reservedSharedMemPerBlock

Shared memory reserved by driver per block.

Definition: hip_runtime_api.h:210

hipDeviceProp_t::maxSurfaceCubemap

int maxSurfaceCubemap

Maximum cubemap surface size.

Definition: hip_runtime_api.h:167

hipDeviceProp_t::maxSurface3D

int maxSurface3D[3]

Maximum 3D surface size.

Definition: hip_runtime_api.h:164

hipDeviceProp_t::asicRevision

int asicRevision

Revision of the GPU in this device.

Definition: hip_runtime_api.h:253

hipDeviceProp_t::totalGlobalMem

size_t totalGlobalMem

Size of global memory region (in bytes).

Definition: hip_runtime_api.h:116

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedBlockDim

int cooperativeMultiDeviceUnmatchedBlockDim

Definition: hip_runtime_api.h:246

hipDeviceProp_t::maxSurface1DLayered

int maxSurface1DLayered[2]

Maximum 1D layered surface size.

Definition: hip_runtime_api.h:165

hipDeviceProp_t::persistingL2CacheMaxSize

int persistingL2CacheMaxSize

Device's max L2 persisting lines in bytes.

Definition: hip_runtime_api.h:181

hipDeviceProp_t::maxSurface1D

int maxSurface1D

Maximum 1D surface size.

Definition: hip_runtime_api.h:162

hipDeviceProp_t::concurrentKernels

int concurrentKernels

Device can possibly execute multiple kernels concurrently.

Definition: hip_runtime_api.h:170

hipDeviceProp_t::isLargeBar

int isLargeBar

1: if it is a large PCI bar device, else 0

Definition: hip_runtime_api.h:252

hipDeviceProp_t::clusterLaunch

int clusterLaunch

Device supports cluster launch.

Definition: hip_runtime_api.h:226

hipDeviceProp_t::maxTexture1DMipmap

int maxTexture1DMipmap

Maximum 1D mipmap texture size.

Definition: hip_runtime_api.h:149

hipDeviceProp_t::multiProcessorCount

int multiProcessorCount

Definition: hip_runtime_api.h:140

hipDeviceProp_t::maxTexture3DAlt

int maxTexture3DAlt[3]

Maximum alternate 3D texture dims.

Definition: hip_runtime_api.h:157

hipDeviceProp_t::maxGridSize

int maxGridSize[3]

Max grid dimensions (XYZ).

Definition: hip_runtime_api.h:124

hipDeviceProp_t::pciDeviceID

int pciDeviceID

PCI Device ID.

Definition: hip_runtime_api.h:173

hipDeviceProp_t::maxBlocksPerMultiProcessor

int maxBlocksPerMultiProcessor

Max number of blocks on CU.

Definition: hip_runtime_api.h:208

hipDeviceProp_t::computeMode

int computeMode

Compute mode.

Definition: hip_runtime_api.h:147

hipDeviceProp_t::maxSurface2DLayered

int maxSurface2DLayered[3]

Maximum 2D layared surface size.

Definition: hip_runtime_api.h:166

hipDeviceProp_t::major

int major

Definition: hip_runtime_api.h:128

hipDeviceProp_t::warpSize

int warpSize

Warp size.

Definition: hip_runtime_api.h:119

hipDeviceProp_t::tccDriver

int tccDriver

1:If device is Tesla device using TCC driver, else 0

Definition: hip_runtime_api.h:175

hipDeviceProp_t::luidDeviceNodeMask

unsigned int luidDeviceNodeMask

LUID node mask.

Definition: hip_runtime_api.h:115

hipDeviceProp_t::hostRegisterReadOnlySupported

int hostRegisterReadOnlySupported

Definition: hip_runtime_api.h:213

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedSharedMem

int cooperativeMultiDeviceUnmatchedSharedMem

Definition: hip_runtime_api.h:249

hipDeviceProp_t::maxThreadsPerBlock

int maxThreadsPerBlock

Max work items per work group or workgroup max size.

Definition: hip_runtime_api.h:122

hipDeviceProp_t::arch

hipDeviceArch_t arch

Architectural feature flags. New for HIP.

Definition: hip_runtime_api.h:237

hipDeviceProp_t::managedMemory

int managedMemory

Device supports allocating managed memory on this system.

Definition: hip_runtime_api.h:188

hipDeviceProp_t::texturePitchAlignment

size_t texturePitchAlignment

Pitch alignment requirement for texture references bound to.

Definition: hip_runtime_api.h:138

hipEventRecordNodeParams

Definition: hip_runtime_api.h:1891

hipEventRecordNodeParams::event

hipEvent_t event

The event to be recorded when node executes.

Definition: hip_runtime_api.h:1892

hipEventWaitNodeParams

Definition: hip_runtime_api.h:1884

hipEventWaitNodeParams::event

hipEvent_t event

Event to wait on.

Definition: hip_runtime_api.h:1885

hipExtent

Definition: driver_types.h:394

hipExternalMemoryBufferDesc

Definition: hip_runtime_api.h:1342

hipExternalMemoryBufferDesc::flags

unsigned int flags

Definition: hip_runtime_api.h:1345

hipExternalMemoryBufferDesc::offset

unsigned long long offset

Definition: hip_runtime_api.h:1343

hipExternalMemoryBufferDesc::size

unsigned long long size

Definition: hip_runtime_api.h:1344

hipExternalMemoryHandleDesc

Definition: hip_runtime_api.h:1328

hipExternalMemoryHandleDesc::flags

unsigned int flags

Definition: hip_runtime_api.h:1339

hipExternalMemoryHandleDesc::name

const void * name

Definition: hip_runtime_api.h:1334

hipExternalMemoryHandleDesc::fd

int fd

Definition: hip_runtime_api.h:1331

hipExternalMemoryHandleDesc::size

unsigned long long size

Definition: hip_runtime_api.h:1338

hipExternalMemoryHandleDesc::type

hipExternalMemoryHandleType type

Definition: hip_runtime_api.h:1329

hipExternalMemoryHandleDesc::nvSciBufObject

const void * nvSciBufObject

Definition: hip_runtime_api.h:1336

hipExternalMemoryHandleDesc::handle

void * handle

Definition: hip_runtime_api.h:1333

hipExternalMemoryMipmappedArrayDesc

Definition: hip_runtime_api.h:1348

hipExternalMemoryMipmappedArrayDesc::extent

hipExtent extent

Definition: hip_runtime_api.h:1351

hipExternalMemoryMipmappedArrayDesc::numLevels

unsigned int numLevels

Definition: hip_runtime_api.h:1353

hipExternalMemoryMipmappedArrayDesc::flags

unsigned int flags

Definition: hip_runtime_api.h:1352

hipExternalMemoryMipmappedArrayDesc::offset

unsigned long long offset

Definition: hip_runtime_api.h:1349

hipExternalMemoryMipmappedArrayDesc::formatDesc

hipChannelFormatDesc formatDesc

Definition: hip_runtime_api.h:1350

hipExternalSemaphoreHandleDesc

Definition: hip_runtime_api.h:1368

hipExternalSemaphoreHandleDesc::flags

unsigned int flags

Definition: hip_runtime_api.h:1378

hipExternalSemaphoreHandleDesc::name

const void * name

Definition: hip_runtime_api.h:1374

hipExternalSemaphoreHandleDesc::NvSciSyncObj

const void * NvSciSyncObj

Definition: hip_runtime_api.h:1376

hipExternalSemaphoreHandleDesc::type

hipExternalSemaphoreHandleType type

Definition: hip_runtime_api.h:1369

hipExternalSemaphoreHandleDesc::handle

void * handle

Definition: hip_runtime_api.h:1373

hipExternalSemaphoreHandleDesc::fd

int fd

Definition: hip_runtime_api.h:1371

hipExternalSemaphoreSignalNodeParams

Definition: hip_runtime_api.h:1766

hipExternalSemaphoreSignalNodeParams::paramsArray

const hipExternalSemaphoreSignalParams * paramsArray

Total number of handles and parameters contained in extSemArray and paramsArray.

Definition: hip_runtime_api.h:1770

hipExternalSemaphoreSignalNodeParams::extSemArray

hipExternalSemaphore_t * extSemArray

< Array containing external semaphore handles.

Definition: hip_runtime_api.h:1768

hipExternalSemaphoreSignalNodeParams::numExtSems

unsigned int numExtSems

Definition: hip_runtime_api.h:1772

hipExternalSemaphoreSignalParams

Definition: hip_runtime_api.h:1382

hipExternalSemaphoreSignalParams::reserved

unsigned long long reserved

Definition: hip_runtime_api.h:1389

hipExternalSemaphoreSignalParams::value

unsigned long long value

Definition: hip_runtime_api.h:1385

hipExternalSemaphoreSignalParams::fence

void * fence

Definition: hip_runtime_api.h:1388

hipExternalSemaphoreSignalParams::flags

unsigned int flags

Definition: hip_runtime_api.h:1396

hipExternalSemaphoreSignalParams::key

unsigned long long key

Definition: hip_runtime_api.h:1392

hipExternalSemaphoreWaitNodeParams

Definition: hip_runtime_api.h:1778

hipExternalSemaphoreWaitNodeParams::numExtSems

unsigned int numExtSems

Definition: hip_runtime_api.h:1784

hipExternalSemaphoreWaitNodeParams::paramsArray

const hipExternalSemaphoreWaitParams * paramsArray

Total number of handles and parameters contained in extSemArray and paramsArray.

Definition: hip_runtime_api.h:1782

hipExternalSemaphoreWaitNodeParams::extSemArray

hipExternalSemaphore_t * extSemArray

< Array containing external semaphore handles.

Definition: hip_runtime_api.h:1780

hipExternalSemaphoreWaitParams

Definition: hip_runtime_api.h:1402

hipExternalSemaphoreWaitParams::value

unsigned long long value

Definition: hip_runtime_api.h:1405

hipExternalSemaphoreWaitParams::fence

void * fence

Definition: hip_runtime_api.h:1408

hipExternalSemaphoreWaitParams::timeoutMs

unsigned int timeoutMs

Definition: hip_runtime_api.h:1413

hipExternalSemaphoreWaitParams::key

unsigned long long key

Definition: hip_runtime_api.h:1412

hipExternalSemaphoreWaitParams::flags

unsigned int flags

Definition: hip_runtime_api.h:1417

hipExternalSemaphoreWaitParams::reserved

unsigned long long reserved

Definition: hip_runtime_api.h:1409

hipFuncAttributes

Definition: hip_runtime_api.h:704

hipFuncAttributes::cacheModeCA

int cacheModeCA

Definition: hip_runtime_api.h:706

hipFuncAttributes::binaryVersion

int binaryVersion

Definition: hip_runtime_api.h:705

hipFuncAttributes::constSizeBytes

size_t constSizeBytes

Definition: hip_runtime_api.h:707

hipFuncAttributes::preferredShmemCarveout

int preferredShmemCarveout

Definition: hip_runtime_api.h:712

hipFuncAttributes::sharedSizeBytes

size_t sharedSizeBytes

Definition: hip_runtime_api.h:714

hipFuncAttributes::maxDynamicSharedSizeBytes

int maxDynamicSharedSizeBytes

Definition: hip_runtime_api.h:709

hipFuncAttributes::ptxVersion

int ptxVersion

Definition: hip_runtime_api.h:713

hipFuncAttributes::numRegs

int numRegs

Definition: hip_runtime_api.h:711

hipFuncAttributes::localSizeBytes

size_t localSizeBytes

Definition: hip_runtime_api.h:708

hipFuncAttributes::maxThreadsPerBlock

int maxThreadsPerBlock

Definition: hip_runtime_api.h:710

hipFunctionLaunchParams

Definition: hip_runtime_api.h:1306

hipFunctionLaunchParams::gridDimX

unsigned int gridDimX

Width(X) of grid in blocks.

Definition: hip_runtime_api.h:1308

hipFunctionLaunchParams::blockDimX

unsigned int blockDimX

X dimension of each thread block.

Definition: hip_runtime_api.h:1311

hipFunctionLaunchParams::hStream

hipStream_t hStream

Stream identifier.

Definition: hip_runtime_api.h:1315

hipFunctionLaunchParams::blockDimY

unsigned int blockDimY

Y dimension of each thread block.

Definition: hip_runtime_api.h:1312

hipFunctionLaunchParams::gridDimY

unsigned int gridDimY

Height(Y) of grid in blocks.

Definition: hip_runtime_api.h:1309

hipFunctionLaunchParams::gridDimZ

unsigned int gridDimZ

Depth(Z) of grid in blocks.

Definition: hip_runtime_api.h:1310

hipFunctionLaunchParams::sharedMemBytes

unsigned int sharedMemBytes

Shared memory.

Definition: hip_runtime_api.h:1314

hipFunctionLaunchParams::blockDimZ

unsigned int blockDimZ

Z dimension of each thread block.

Definition: hip_runtime_api.h:1313

hipFunctionLaunchParams::kernelParams

void ** kernelParams

Kernel parameters.

Definition: hip_runtime_api.h:1316

hipGraphEdgeData

Definition: hip_runtime_api.h:1948

hipGraphEdgeData::to_port

unsigned char to_port

Currently no node types define non-zero ports. This field must be set to zero.

Definition: hip_runtime_api.h:1959

hipGraphEdgeData::reserved

unsigned char reserved[5]

These bytes are unused and must be zeroed.

Definition: hip_runtime_api.h:1957

hipGraphEdgeData::type

unsigned char type

This should be populated with a value from hipGraphDependencyType.

Definition: hip_runtime_api.h:1960

hipGraphEdgeData::from_port

unsigned char from_port

Definition: hip_runtime_api.h:1950

hipGraphInstantiateParams

Definition: hip_runtime_api.h:1736

hipGraphInstantiateParams::result_out

hipGraphInstantiateResult result_out

Definition: hip_runtime_api.h:1739

hipGraphInstantiateParams::uploadStream

hipStream_t uploadStream

Definition: hip_runtime_api.h:1741

hipGraphInstantiateParams::errNode_out

hipGraphNode_t errNode_out

Definition: hip_runtime_api.h:1737

hipGraphInstantiateParams::flags

unsigned long long flags

Definition: hip_runtime_api.h:1738

hipGraphNodeParams

Definition: hip_runtime_api.h:1905

hipGraphNodeParams::type

hipGraphNodeType type

Definition: hip_runtime_api.h:1906

hipGraphNodeParams::reserved0

int reserved0[3]

Definition: hip_runtime_api.h:1907

hipGraphNodeParams::alloc

hipMemAllocNodeParams alloc

Definition: hip_runtime_api.h:1919

hipGraphNodeParams::reserved1

long long reserved1[29]

Definition: hip_runtime_api.h:1909

hipGraphNodeParams::eventRecord

hipEventRecordNodeParams eventRecord

Definition: hip_runtime_api.h:1916

hipGraphNodeParams::extSemSignal

hipExternalSemaphoreSignalNodeParams extSemSignal

Definition: hip_runtime_api.h:1917

hipGraphNodeParams::free

hipMemFreeNodeParams free

Definition: hip_runtime_api.h:1920

hipGraphNodeParams::graph

hipChildGraphNodeParams graph

Definition: hip_runtime_api.h:1914

hipGraphNodeParams::extSemWait

hipExternalSemaphoreWaitNodeParams extSemWait

Definition: hip_runtime_api.h:1918

hipGraphNodeParams::memset

hipMemsetParams memset

Definition: hip_runtime_api.h:1912

hipGraphNodeParams::host

hipHostNodeParams host

Definition: hip_runtime_api.h:1913

hipGraphNodeParams::reserved2

long long reserved2

Definition: hip_runtime_api.h:1923

hipGraphNodeParams::kernel

hipKernelNodeParams kernel

Definition: hip_runtime_api.h:1910

hipGraphNodeParams::eventWait

hipEventWaitNodeParams eventWait

Definition: hip_runtime_api.h:1915

hipGraphNodeParams::memcpy

hipMemcpyNodeParams memcpy

Definition: hip_runtime_api.h:1911

hipHostNodeParams

Definition: hip_runtime_api.h:1488

hipHostNodeParams::fn

hipHostFn_t fn

Definition: hip_runtime_api.h:1489

hipHostNodeParams::userData

void * userData

Definition: hip_runtime_api.h:1490

hipIpcEventHandle_t

Definition: hip_runtime_api.h:691

hipIpcMemHandle_t

Definition: hip_runtime_api.h:688

hipKernelNodeParams

Definition: hip_runtime_api.h:1492

hipKernelNodeParams::gridDim

dim3 gridDim

Definition: hip_runtime_api.h:1496

hipKernelNodeParams::sharedMemBytes

unsigned int sharedMemBytes

Definition: hip_runtime_api.h:1498

hipKernelNodeParams::blockDim

dim3 blockDim

Definition: hip_runtime_api.h:1493

hipKernelNodeParams::kernelParams

void ** kernelParams

Definition: hip_runtime_api.h:1497

hipKernelNodeParams::extra

void ** extra

Definition: hip_runtime_api.h:1494

hipKernelNodeParams::func

void * func

Definition: hip_runtime_api.h:1495

hipLaunchAttribute

Definition: hip_runtime_api.h:1967

hipLaunchAttribute::val

hipLaunchAttributeValue val

Value associated with the launch attribute.

Definition: hip_runtime_api.h:1971

hipLaunchAttribute::id

hipLaunchAttributeID id

Identifier of the launch attribute.

Definition: hip_runtime_api.h:1968

hipLaunchAttribute::value

hipLaunchAttributeValue value

Value associated with the launch attribute.

Definition: hip_runtime_api.h:1972

hipLaunchConfig_t

Definition: hip_runtime_api.h:1979

hipLaunchConfig_t::blockDim

dim3 blockDim

Block dimensions.

Definition: hip_runtime_api.h:1981

hipLaunchConfig_t::gridDim

dim3 gridDim

Grid dimensions.

Definition: hip_runtime_api.h:1980

hipLaunchConfig_t::numAttrs

unsigned int numAttrs

Number of attributes.

Definition: hip_runtime_api.h:1985

hipLaunchConfig_t::stream

hipStream_t stream

Stream identifier.

Definition: hip_runtime_api.h:1983

hipLaunchConfig_t::dynamicSmemBytes

size_t dynamicSmemBytes

Dynamic shared-memory size per thread block.

Definition: hip_runtime_api.h:1982

hipLaunchConfig_t::attrs

hipLaunchAttribute * attrs

Attributes list.

Definition: hip_runtime_api.h:1984

hipLaunchMemSyncDomainMap

Definition: hip_runtime_api.h:1543

hipLaunchMemSyncDomainMap::remote

unsigned char remote

Definition: hip_runtime_api.h:1545

hipLaunchMemSyncDomainMap::default_

unsigned char default_

Definition: hip_runtime_api.h:1544

hipLaunchParams

Definition: hip_runtime_api.h:1295

hipLaunchParams::sharedMem

size_t sharedMem

Shared memory.

Definition: hip_runtime_api.h:1300

hipLaunchParams::args

void ** args

Arguments.

Definition: hip_runtime_api.h:1299

hipLaunchParams::blockDim

dim3 blockDim

Block dimensions.

Definition: hip_runtime_api.h:1298

hipLaunchParams::gridDim

dim3 gridDim

Grid dimensions.

Definition: hip_runtime_api.h:1297

hipLaunchParams::func

void * func

Device function symbol.

Definition: hip_runtime_api.h:1296

hipLaunchParams::stream

hipStream_t stream

Stream identifier.

Definition: hip_runtime_api.h:1301

hipMemAccessDesc

Definition: hip_runtime_api.h:1201

hipMemAccessDesc::flags

hipMemAccessFlags flags

Accessibility flags to set.

Definition: hip_runtime_api.h:1203

hipMemAccessDesc::location

hipMemLocation location

Location on which the accessibility has to change.

Definition: hip_runtime_api.h:1202

hipMemAllocNodeParams

Definition: hip_runtime_api.h:1509

hipMemAllocNodeParams::accessDescs

const hipMemAccessDesc * accessDescs

The number of memory access descriptors.

Definition: hip_runtime_api.h:1512

hipMemAllocNodeParams::bytesize

size_t bytesize

The size of the requested allocation in bytes.

Definition: hip_runtime_api.h:1515

hipMemAllocNodeParams::poolProps

hipMemPoolProps poolProps

Definition: hip_runtime_api.h:1510

hipMemAllocNodeParams::accessDescCount

size_t accessDescCount

Definition: hip_runtime_api.h:1513

hipMemAllocNodeParams::dptr

void * dptr

Returned device address of the allocation.

Definition: hip_runtime_api.h:1516

hipMemAllocationProp

Definition: hip_runtime_api.h:1748

hipMemAllocationProp::win32HandleMetaData

void * win32HandleMetaData

Metadata for Win32 handles.

Definition: hip_runtime_api.h:1755

hipMemAllocationProp::type

hipMemAllocationType type

Memory allocation type.

Definition: hip_runtime_api.h:1749

hipMemAllocationProp::allocFlags

struct hipMemAllocationProp::@33 allocFlags

hipMemAllocationProp::gpuDirectRDMACapable

unsigned char gpuDirectRDMACapable

RDMA capable.

Definition: hip_runtime_api.h:1758

hipMemAllocationProp::requestedHandleTypes

hipMemAllocationHandleType requestedHandleTypes

Requested handle types.

Definition: hip_runtime_api.h:1752

hipMemAllocationProp::usage

unsigned short usage

Usage.

Definition: hip_runtime_api.h:1759

hipMemAllocationProp::requestedHandleType

hipMemAllocationHandleType requestedHandleType

Requested handle type.

Definition: hip_runtime_api.h:1751

hipMemAllocationProp::location

hipMemLocation location

Memory location.

Definition: hip_runtime_api.h:1754

hipMemAllocationProp::compressionType

unsigned char compressionType

Compression type.

Definition: hip_runtime_api.h:1757

hipMemFreeNodeParams

Definition: hip_runtime_api.h:1898

hipMemFreeNodeParams::dptr

void * dptr

the pointer to be freed

Definition: hip_runtime_api.h:1899

hipMemLocation

Definition: driver_types.h:466

hipMemPoolProps

Definition: hip_runtime_api.h:1231

hipMemPoolProps::maxSize

size_t maxSize

Maximum pool size. When set to 0, defaults to a system dependent value.

Definition: hip_runtime_api.h:1241

hipMemPoolProps::reserved

unsigned char reserved[56]

Reserved for future use, must be 0.

Definition: hip_runtime_api.h:1242

hipMemPoolProps::location

hipMemLocation location

Location where allocations should reside.

Definition: hip_runtime_api.h:1236

hipMemPoolProps::handleTypes

hipMemAllocationHandleType handleTypes

Handle types that will be supported by allocations from the pool.

Definition: hip_runtime_api.h:1235

hipMemPoolProps::allocType

hipMemAllocationType allocType

Allocation type. Currently must be specified as hipMemAllocationTypePinned.

Definition: hip_runtime_api.h:1233

hipMemPoolProps::win32SecurityAttributes

void * win32SecurityAttributes

Definition: hip_runtime_api.h:1240

hipMemPoolPtrExportData

Definition: hip_runtime_api.h:1247

hipMemPoolPtrExportData::reserved

unsigned char reserved[64]

Definition: hip_runtime_api.h:1248

hipMemcpy3DBatchOp

Definition: driver_types.h:543

hipMemcpy3DParms

Definition: driver_types.h:411

hipMemcpy3DPeerParms

Definition: driver_types.h:551

hipMemcpyAttributes

Definition: driver_types.h:497

hipMemcpyNodeParams

Definition: hip_runtime_api.h:1867

hipMemcpyNodeParams::reserved

int reserved[3]

Must be zero.

Definition: hip_runtime_api.h:1869

hipMemcpyNodeParams::flags

int flags

Must be zero.

Definition: hip_runtime_api.h:1868

hipMemcpyNodeParams::copyParams

hipMemcpy3DParms copyParams

Params set for the memory copy.

Definition: hip_runtime_api.h:1870

hipMemsetParams

Definition: hip_runtime_api.h:1500

hipMemsetParams::dst

void * dst

Definition: hip_runtime_api.h:1501

hipMemsetParams::value

unsigned int value

Definition: hip_runtime_api.h:1505

hipMemsetParams::elementSize

unsigned int elementSize

Definition: hip_runtime_api.h:1502

hipMemsetParams::width

size_t width

Definition: hip_runtime_api.h:1506

hipMemsetParams::pitch

size_t pitch

Definition: hip_runtime_api.h:1504

hipMemsetParams::height

size_t height

Definition: hip_runtime_api.h:1503

hipMipmappedArray

Definition: driver_types.h:137

hipPitchedPtr

Definition: driver_types.h:385

hipPointerAttribute_t

Definition: hip_runtime_api.h:280

hipPointerAttribute_t::device

int device

Definition: hip_runtime_api.h:282

hipPointerAttribute_t::hostPointer

void * hostPointer

Definition: hip_runtime_api.h:284

hipPointerAttribute_t::type

enum hipMemoryType type

Definition: hip_runtime_api.h:281

hipPointerAttribute_t::isManaged

int isManaged

Definition: hip_runtime_api.h:285

hipPointerAttribute_t::devicePointer

void * devicePointer

Definition: hip_runtime_api.h:283

hipPointerAttribute_t::allocationFlags

unsigned allocationFlags

Definition: hip_runtime_api.h:286

hipResourceDesc

Definition: driver_types.h:286

hipResourceViewDesc

Definition: driver_types.h:345

hipStreamBatchMemOpParams::hipStreamMemOpFlushRemoteWritesParams_t

Definition: hip_runtime_api.h:1024

hipStreamBatchMemOpParams::hipStreamMemOpFlushRemoteWritesParams_t::flags

unsigned int flags

Definition: hip_runtime_api.h:1026

hipStreamBatchMemOpParams::hipStreamMemOpFlushRemoteWritesParams_t::operation

hipStreamBatchMemOpType operation

Definition: hip_runtime_api.h:1025

hipStreamBatchMemOpParams::hipStreamMemOpMemoryBarrierParams_t

Definition: hip_runtime_api.h:1028

hipStreamBatchMemOpParams::hipStreamMemOpMemoryBarrierParams_t::flags

unsigned int flags

Definition: hip_runtime_api.h:1030

hipStreamBatchMemOpParams::hipStreamMemOpMemoryBarrierParams_t::operation

hipStreamBatchMemOpType operation

Definition: hip_runtime_api.h:1029

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t

Definition: hip_runtime_api.h:1004

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::operation

hipStreamBatchMemOpType operation

Definition: hip_runtime_api.h:1005

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::value64

uint64_t value64

Definition: hip_runtime_api.h:1009

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::address

hipDeviceptr_t address

Definition: hip_runtime_api.h:1006

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::alias

hipDeviceptr_t alias

Not valid for AMD backend. Initial value is unimportant.

Definition: hip_runtime_api.h:1012

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::value

uint32_t value

Definition: hip_runtime_api.h:1008

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::flags

unsigned int flags

Definition: hip_runtime_api.h:1011

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t

Definition: hip_runtime_api.h:1014

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::address

hipDeviceptr_t address

Definition: hip_runtime_api.h:1016

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::alias

hipDeviceptr_t alias

Not valid for AMD backend. Initial value is unimportant.

Definition: hip_runtime_api.h:1022

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::value

uint32_t value

Definition: hip_runtime_api.h:1018

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::operation

hipStreamBatchMemOpType operation

Definition: hip_runtime_api.h:1015

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::flags

unsigned int flags

Definition: hip_runtime_api.h:1021

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::value64

uint64_t value64

Definition: hip_runtime_api.h:1019

hipTextureDesc

Definition: texture_types.h:116

hipUUID

Definition: hip_runtime_api.h:96

texture

Definition: texture_types.h:147

textureReference

Definition: texture_types.h:95

surface_types.h

Defines surface types for HIP runtime.

hipSurfaceObject_t

struct __hip_surface * hipSurfaceObject_t

Definition: surface_types.h:43

texture_types.h

hipTextureObject_t

struct __hip_texture * hipTextureObject_t

Definition: texture_types.h:70

hipTextureAddressMode

hipTextureAddressMode

Definition: texture_types.h:75

hipTextureFilterMode

hipTextureFilterMode

Definition: texture_types.h:85

hipLaunchAttributeValue

Definition: hip_runtime_api.h:1584

hipLaunchAttributeValue::priority

int priority

Definition: hip_runtime_api.h:1590

hipLaunchAttributeValue::pad

char pad[64]

64 byte padding

Definition: hip_runtime_api.h:1585

hipLaunchAttributeValue::memSyncDomain

hipLaunchMemSyncDomain memSyncDomain

Value of launch attribute hipLaunchAttributeMemSyncDomain.

Definition: hip_runtime_api.h:1598

hipLaunchAttributeValue::cooperative

int cooperative

Definition: hip_runtime_api.h:1588

hipLaunchAttributeValue::accessPolicyWindow

hipAccessPolicyWindow accessPolicyWindow

Value of launch attribute hipLaunchAttributeAccessPolicyWindow.

Definition: hip_runtime_api.h:1587

hipLaunchAttributeValue::syncPolicy

hipSynchronizationPolicy syncPolicy

Definition: hip_runtime_api.h:1593

hipLaunchAttributeValue::memSyncDomainMap

hipLaunchMemSyncDomainMap memSyncDomainMap

Value of launch attribute hipLaunchAttributeMemSyncDomainMap.

Definition: hip_runtime_api.h:1596

hipStreamBatchMemOpParams

Union representing batch memory operation parameters for HIP streams.

Definition: hip_runtime_api.h:1002

hipStreamBatchMemOpParams::operation

hipStreamBatchMemOpType operation

Definition: hip_runtime_api.h:1003