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) Advanced Micro Devices, Inc., or its affiliates.

3 *

4 * SPDX-License-Identifier: MIT

5 */

6

15#ifndef HIP_INCLUDE_HIP_HIP_RUNTIME_API_H

16#define HIP_INCLUDE_HIP_HIP_RUNTIME_API_H

17

18#if __cplusplus

19#include <climits>

20#include <cstdint>

21#include <cstdlib>

22#include <utility>

23#else

24#include <limits.h>

25#include <stdint.h>

26#include <stdlib.h>

27#endif

28

29#include <hip/hip_version.h>

30#include <hip/hip_common.h>

31#include <hip/linker_types.h>

32

33#if HIP_FORCE_API_VERSION > HIP_API_VERSION

34# error "HIP_FORCE_API_VERSION is newer than the installed HIP headers"

35#endif

36

37enum {

38 HIP_SUCCESS = 0,

39 HIP_ERROR_INVALID_VALUE,

40 HIP_ERROR_NOT_INITIALIZED,

41 HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

42};

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

53typedef struct {

54 // 32-bit Atomics

55 unsigned hasGlobalInt32Atomics : 1;

56 unsigned hasGlobalFloatAtomicExch : 1;

57 unsigned hasSharedInt32Atomics : 1;

58 unsigned hasSharedFloatAtomicExch : 1;

59 unsigned hasFloatAtomicAdd : 1;

60

61 // 64-bit Atomics

62 unsigned hasGlobalInt64Atomics : 1;

63 unsigned hasSharedInt64Atomics : 1;

64

65 // Doubles

66 unsigned hasDoubles : 1;

67

68 // Warp cross-lane operations

69 unsigned hasWarpVote : 1;

70 unsigned hasWarpBallot : 1;

71 unsigned hasWarpShuffle : 1;

72 unsigned hasFunnelShift : 1;

73

74 // Sync

75 unsigned hasThreadFenceSystem : 1;

76 unsigned hasSyncThreadsExt : 1;

77

78 // Misc

79 unsigned hasSurfaceFuncs : 1;

80 unsigned has3dGrid : 1;

81 unsigned hasDynamicParallelism : 1;

82} hipDeviceArch_t;

83

84typedef struct hipUUID_t {

85 char bytes[16];

86} hipUUID;

87

88//---

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

90

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

92// we can make that yield a warning

93#if __cplusplus >= 201703L

94#define __HIP_NODISCARD [[nodiscard]]

95#else

96#define __HIP_NODISCARD

97#endif

98

99#if defined(_MSC_VER) && (_MSC_VER >= 1800)

100#define UINT32_BASE :uint32_t

101#else

102#define UINT32_BASE

103#endif

104

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

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

111

112typedef enum __HIP_NODISCARD hipError_t UINT32_BASE {

113 hipSuccess = 0,

114 hipErrorInvalidValue = 1,

116 hipErrorOutOfMemory = 2,

117 // Deprecated

118 hipErrorMemoryAllocation = 2,

119 hipErrorNotInitialized = 3,

120 // Deprecated

121 hipErrorInitializationError = 3,

122 hipErrorDeinitialized = 4,

123 hipErrorProfilerDisabled = 5,

124 hipErrorProfilerNotInitialized = 6,

125 hipErrorProfilerAlreadyStarted = 7,

126 hipErrorProfilerAlreadyStopped = 8,

127 hipErrorInvalidConfiguration = 9,

128 hipErrorInvalidPitchValue = 12,

129 hipErrorInvalidSymbol = 13,

130 hipErrorInvalidDevicePointer = 17,

131 hipErrorInvalidMemcpyDirection = 21,

132 hipErrorInsufficientDriver = 35,

133 hipErrorMissingConfiguration = 52,

134 hipErrorPriorLaunchFailure = 53,

135 hipErrorInvalidDeviceFunction = 98,

136 hipErrorNoDevice = 100,

137 hipErrorInvalidDevice = 101,

138 hipErrorInvalidImage = 200,

139 hipErrorInvalidContext = 201,

140 hipErrorContextAlreadyCurrent = 202,

141 hipErrorMapFailed = 205,

142 // Deprecated

143 hipErrorMapBufferObjectFailed = 205,

144 hipErrorUnmapFailed = 206,

145 hipErrorArrayIsMapped = 207,

146 hipErrorAlreadyMapped = 208,

147 hipErrorNoBinaryForGpu = 209,

148 hipErrorAlreadyAcquired = 210,

149 hipErrorNotMapped = 211,

150 hipErrorNotMappedAsArray = 212,

151 hipErrorNotMappedAsPointer = 213,

152 hipErrorECCNotCorrectable = 214,

153 hipErrorUnsupportedLimit = 215,

154 hipErrorContextAlreadyInUse = 216,

155 hipErrorPeerAccessUnsupported = 217,

156 hipErrorInvalidKernelFile = 218,

157 hipErrorInvalidGraphicsContext = 219,

158 hipErrorInvalidSource = 300,

159 hipErrorFileNotFound = 301,

160 hipErrorSharedObjectSymbolNotFound = 302,

161 hipErrorSharedObjectInitFailed = 303,

162 hipErrorOperatingSystem = 304,

163 hipErrorInvalidHandle = 400,

164 // Deprecated

165 hipErrorInvalidResourceHandle = 400,

166 hipErrorIllegalState = 401,

167 hipErrorNotFound = 500,

168 hipErrorNotReady = 600,

172 hipErrorIllegalAddress = 700,

173 hipErrorLaunchOutOfResources = 701,

174 hipErrorLaunchTimeOut = 702,

175 hipErrorPeerAccessAlreadyEnabled = 704,

177 hipErrorPeerAccessNotEnabled = 705,

178 hipErrorSetOnActiveProcess = 708,

179 hipErrorContextIsDestroyed = 709,

180 hipErrorAssert = 710,

181 hipErrorHostMemoryAlreadyRegistered = 712,

183 hipErrorHostMemoryNotRegistered = 713,

185 hipErrorLaunchFailure = 719,

186 hipErrorCooperativeLaunchTooLarge = 720,

190 hipErrorNotSupported = 801,

191 hipErrorStreamCaptureUnsupported = 900,

193 hipErrorStreamCaptureInvalidated = 901,

195 hipErrorStreamCaptureMerge = 902,

197 hipErrorStreamCaptureUnmatched = 903,

198 hipErrorStreamCaptureUnjoined = 904,

200 hipErrorStreamCaptureIsolation = 905,

204 hipErrorStreamCaptureImplicit = 906,

207 hipErrorCapturedEvent = 907,

209 hipErrorStreamCaptureWrongThread = 908,

213 hipErrorGraphExecUpdateFailure = 910,

217 hipErrorInvalidChannelDescriptor = 911,

218 hipErrorInvalidTexture = 912,

219 hipErrorInvalidResourceType = 914,

220 hipErrorInvalidResourceConfiguration = 915,

222 hipErrorStreamDetached = 916,

223 hipErrorUnknown = 999,

224 // HSA Runtime Error Codes start here.

225 hipErrorRuntimeMemory = 1052,

227 hipErrorRuntimeOther = 1053,

229 hipErrorInvalidClusterSize = 1054,

232 hipErrorTbd

233} hipError_t;

234

235#undef __HIP_NODISCARD

236#undef UINT32_BASE

237

238/*

239 Versioning struct. Because each public API must use the versioned struct to

240 ensure ABI compatibility, we must typedef the actual struct name here.

241*/

242

243#if HIP_FORCE_API_VERSION < 600

244

245#include <hip/hip_deprecated.h>

246// Legacy version, HIP_ABI_IMPL is on the latest version, so it must not see this.

247typedef hipDeviceProp_tR0000 hipDeviceProp_t;

248// Dummy struct for hip_prof_str.h

249typedef struct hipDeviceProp_tR0600 {} hipDeviceProp_tR0600;

250

251#endif

252

253#if HIP_FORCE_API_VERSION >= 600

254// Latest version.

255

260typedef struct hipDeviceProp_t {

261 char name[256];

262 hipUUID uuid;

263 char luid[8];

264 unsigned int luidDeviceNodeMask;

265 size_t totalGlobalMem;

266 size_t sharedMemPerBlock;

267 int regsPerBlock;

268 int warpSize;

269 size_t memPitch;

271 int maxThreadsPerBlock;

272 int maxThreadsDim[3];

273 int maxGridSize[3];

274 int clockRate;

275 size_t totalConstMem;

277 int major;

281 int minor;

286 size_t textureAlignment;

287 size_t texturePitchAlignment;

288 int deviceOverlap;

289 int multiProcessorCount;

293 int kernelExecTimeoutEnabled;

294 int integrated;

295 int canMapHostMemory;

296 int computeMode;

297 int maxTexture1D;

298 int maxTexture1DMipmap;

299 int maxTexture1DLinear;

300 int maxTexture2D[2];

301 int maxTexture2DMipmap[2];

302 int maxTexture2DLinear[3];

303 int maxTexture2DGather[2];

304 int maxTexture3D[3];

306 int maxTexture3DAlt[3];

307 int maxTextureCubemap;

308 int maxTexture1DLayered[2];

309 int maxTexture2DLayered[3];

310 int maxTextureCubemapLayered[2];

311 int maxSurface1D;

312 int maxSurface2D[2];

313 int maxSurface3D[3];

314 int maxSurface1DLayered[2];

315 int maxSurface2DLayered[3];

316 int maxSurfaceCubemap;

317 int maxSurfaceCubemapLayered[2];

318 size_t surfaceAlignment;

319 int concurrentKernels;

320 int ECCEnabled;

321 int pciBusID;

322 int pciDeviceID;

323 int pciDomainID;

324 int tccDriver;

325 int asyncEngineCount;

326 int unifiedAddressing;

327 int memoryClockRate;

328 int memoryBusWidth;

329 int l2CacheSize;

330 int persistingL2CacheMaxSize;

331 int maxThreadsPerMultiProcessor;

332 int streamPrioritiesSupported;

333 int globalL1CacheSupported;

334 int localL1CacheSupported;

335 size_t sharedMemPerMultiprocessor;

336 int regsPerMultiprocessor;

337 int managedMemory;

338 int isMultiGpuBoard;

339 int multiGpuBoardGroupID;

340 int hostNativeAtomicSupported;

341 int singleToDoublePrecisionPerfRatio;

342 int pageableMemoryAccess;

344 int concurrentManagedAccess;

346 int computePreemptionSupported;

347 int canUseHostPointerForRegisteredMem;

349 int cooperativeLaunch;

350 int cooperativeMultiDeviceLaunch;

352 size_t sharedMemPerBlockOptin;

353 int pageableMemoryAccessUsesHostPageTables;

355 int directManagedMemAccessFromHost;

357 int maxBlocksPerMultiProcessor;

358 int accessPolicyMaxWindowSize;

359 size_t reservedSharedMemPerBlock;

360 int hostRegisterSupported;

361 int sparseHipArraySupported;

362 int hostRegisterReadOnlySupported;

364 int timelineSemaphoreInteropSupported;

365 int memoryPoolsSupported;

366 int gpuDirectRDMASupported;

367 unsigned int gpuDirectRDMAFlushWritesOptions;

369 int gpuDirectRDMAWritesOrdering;

370 unsigned int

371 memoryPoolSupportedHandleTypes;

372 int deferredMappingHipArraySupported;

374 int ipcEventSupported;

375 int clusterLaunch;

376 int unifiedFunctionPointers;

377 int reserved[63];

378

379 int hipReserved[32];

380

381 /* HIP Only struct members */

382 char gcnArchName[256];

383 size_t maxSharedMemoryPerMultiProcessor;

384 int clockInstructionRate;

386 hipDeviceArch_t arch;

387 unsigned int* hdpMemFlushCntl;

388 unsigned int* hdpRegFlushCntl;

389 int cooperativeMultiDeviceUnmatchedFunc;

392 int cooperativeMultiDeviceUnmatchedGridDim;

395 int cooperativeMultiDeviceUnmatchedBlockDim;

398 int cooperativeMultiDeviceUnmatchedSharedMem;

401 int isLargeBar;

402 int asicRevision;

403} hipDeviceProp_t;

404

405// Latest version, HIP_ABI_IMPL should see this.

406typedef hipDeviceProp_t hipDeviceProp_tR0600;

407#endif

408

416typedef enum hipMemoryType {

417 hipMemoryTypeUnregistered = 0,

418 hipMemoryTypeHost = 1,

419 hipMemoryTypeDevice = 2,

421 hipMemoryTypeManaged = 3,

424 hipMemoryTypeArray = 10,

426 hipMemoryTypeUnified = 11

427

428} hipMemoryType;

429

433typedef struct hipPointerAttribute_t {

434 enum hipMemoryType type;

435 int device;

436 void* devicePointer;

437 void* hostPointer;

438 int isManaged;

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

440 /* peers? */

441} hipPointerAttribute_t;

442

447typedef enum hipDeviceAttribute_t {

448 hipDeviceAttributeCudaCompatibleBegin = 0,

449

450 hipDeviceAttributeEccEnabled =

451 hipDeviceAttributeCudaCompatibleBegin,

452 hipDeviceAttributeAccessPolicyMaxWindowSize,

454 hipDeviceAttributeAsyncEngineCount,

455 hipDeviceAttributeCanMapHostMemory,

457 hipDeviceAttributeCanUseHostPointerForRegisteredMem,

460 hipDeviceAttributeClockRate,

461 hipDeviceAttributeComputeMode,

462 hipDeviceAttributeComputePreemptionSupported,

463 hipDeviceAttributeConcurrentKernels,

465 hipDeviceAttributeConcurrentManagedAccess,

467 hipDeviceAttributeCooperativeLaunch,

468 hipDeviceAttributeCooperativeMultiDeviceLaunch,

470 hipDeviceAttributeDeviceOverlap,

472 hipDeviceAttributeDirectManagedMemAccessFromHost,

474 hipDeviceAttributeGlobalL1CacheSupported,

475 hipDeviceAttributeHostNativeAtomicSupported,

477 hipDeviceAttributeIntegrated,

478 hipDeviceAttributeIsMultiGpuBoard,

479 hipDeviceAttributeKernelExecTimeout,

480 hipDeviceAttributeL2CacheSize,

482 hipDeviceAttributeLocalL1CacheSupported,

483 hipDeviceAttributeLuid,

485 hipDeviceAttributeLuidDeviceNodeMask,

487 hipDeviceAttributeComputeCapabilityMajor,

488 hipDeviceAttributeManagedMemory,

489 hipDeviceAttributeMaxBlocksPerMultiProcessor,

490 hipDeviceAttributeMaxBlockDimX,

491 hipDeviceAttributeMaxBlockDimY,

492 hipDeviceAttributeMaxBlockDimZ,

493 hipDeviceAttributeMaxGridDimX,

494 hipDeviceAttributeMaxGridDimY,

495 hipDeviceAttributeMaxGridDimZ,

496 hipDeviceAttributeMaxSurface1D,

497 hipDeviceAttributeMaxSurface1DLayered,

498 hipDeviceAttributeMaxSurface2D,

499 hipDeviceAttributeMaxSurface2DLayered,

500 hipDeviceAttributeMaxSurface3D,

501 hipDeviceAttributeMaxSurfaceCubemap,

502 hipDeviceAttributeMaxSurfaceCubemapLayered,

504 hipDeviceAttributeMaxTexture1DWidth,

505 hipDeviceAttributeMaxTexture1DLayered,

506 hipDeviceAttributeMaxTexture1DLinear,

509 hipDeviceAttributeMaxTexture1DMipmap,

510 hipDeviceAttributeMaxTexture2DWidth,

511 hipDeviceAttributeMaxTexture2DHeight,

512 hipDeviceAttributeMaxTexture2DGather,

514 hipDeviceAttributeMaxTexture2DLayered,

515 hipDeviceAttributeMaxTexture2DLinear,

517 hipDeviceAttributeMaxTexture2DMipmap,

518 hipDeviceAttributeMaxTexture3DWidth,

519 hipDeviceAttributeMaxTexture3DHeight,

520 hipDeviceAttributeMaxTexture3DDepth,

521 hipDeviceAttributeMaxTexture3DAlt,

522 hipDeviceAttributeMaxTextureCubemap,

523 hipDeviceAttributeMaxTextureCubemapLayered,

524 hipDeviceAttributeMaxThreadsDim,

525 hipDeviceAttributeMaxThreadsPerBlock,

526 hipDeviceAttributeMaxThreadsPerMultiProcessor,

527 hipDeviceAttributeMaxPitch,

528 hipDeviceAttributeMemoryBusWidth,

529 hipDeviceAttributeMemoryClockRate,

530 hipDeviceAttributeComputeCapabilityMinor,

531 hipDeviceAttributeMultiGpuBoardGroupID,

533 hipDeviceAttributeMultiprocessorCount,

537 hipDeviceAttributeUnused1,

538 hipDeviceAttributePageableMemoryAccess,

540 hipDeviceAttributePageableMemoryAccessUsesHostPageTables,

542 hipDeviceAttributePciBusId,

543 hipDeviceAttributePciDeviceId,

544 hipDeviceAttributePciDomainId,

545 hipDeviceAttributePciDomainID =

546 hipDeviceAttributePciDomainId,

547 hipDeviceAttributePersistingL2CacheMaxSize,

548 hipDeviceAttributeMaxRegistersPerBlock,

551 hipDeviceAttributeMaxRegistersPerMultiprocessor,

552 hipDeviceAttributeReservedSharedMemPerBlock,

554 hipDeviceAttributeMaxSharedMemoryPerBlock,

556 hipDeviceAttributeSharedMemPerBlockOptin,

558 hipDeviceAttributeSharedMemPerMultiprocessor,

559 hipDeviceAttributeSingleToDoublePrecisionPerfRatio,

561 hipDeviceAttributeStreamPrioritiesSupported,

562 hipDeviceAttributeSurfaceAlignment,

563 hipDeviceAttributeTccDriver,

564 hipDeviceAttributeTextureAlignment,

565 hipDeviceAttributeTexturePitchAlignment,

567 hipDeviceAttributeTotalConstantMemory,

568 hipDeviceAttributeTotalGlobalMem,

569 hipDeviceAttributeUnifiedAddressing,

571 hipDeviceAttributeUnused2,

572 hipDeviceAttributeWarpSize,

573 hipDeviceAttributeMemoryPoolsSupported,

574 hipDeviceAttributeVirtualMemoryManagementSupported,

576 hipDeviceAttributeHostRegisterSupported,

578 hipDeviceAttributeMemoryPoolSupportedHandleTypes,

580 hipDeviceAttributeHostNumaId,

582 hipDeviceAttributeDmaBufSupported,

583 hipDeviceAttributeGPUDirectRDMAWithHipVMMSupported,

586 hipDeviceAttributeHandleTypeFabricSupported,

587 hipDeviceAttributeHostAllocDmaBufSupported,

588

589 hipDeviceAttributeCudaCompatibleEnd = 9999,

590 hipDeviceAttributeAmdSpecificBegin = 10000,

591

592 hipDeviceAttributeClockInstructionRate =

593 hipDeviceAttributeAmdSpecificBegin,

595 hipDeviceAttributeUnused3,

596 hipDeviceAttributeMaxSharedMemoryPerMultiprocessor,

597 hipDeviceAttributeUnused4,

598 hipDeviceAttributeUnused5,

599 hipDeviceAttributeHdpMemFlushCntl,

600 hipDeviceAttributeHdpRegFlushCntl,

601 hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc,

604 hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim,

607 hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim,

610 hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem,

613 hipDeviceAttributeIsLargeBar,

614 hipDeviceAttributeAsicRevision,

615 hipDeviceAttributeCanUseStreamWaitValue,

617 hipDeviceAttributeImageSupport,

618 hipDeviceAttributePhysicalMultiProcessorCount,

620 hipDeviceAttributeFineGrainSupport,

621 hipDeviceAttributeWallClockRate,

622 hipDeviceAttributeNumberOfXccs,

629 hipDeviceAttributeMaxAvailableVgprsPerThread,

632 hipDeviceAttributePciChipId,

633 hipDeviceAttributeExpertSchedMode,

635 hipDeviceAttributeMaxDynDataPrefetchRegions,

637

638 hipDeviceAttributeAmdSpecificEnd = 19999,

639 hipDeviceAttributeVendorSpecificBegin = 20000,

640 // Extended attributes for vendors

641} hipDeviceAttribute_t;

642

643// Flags that can be used with hipGetProcAddress.

647#define HIP_GET_PROC_ADDRESS_DEFAULT 0x0

648

650#define HIP_GET_PROC_ADDRESS_LEGACY_STREAM 0x1

651

654#define HIP_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM 0x2

655

656typedef enum hipDriverProcAddressQueryResult {

657 HIP_GET_PROC_ADDRESS_SUCCESS = 0,

658 HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND = 1,

659 HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT = 2

660} hipDriverProcAddressQueryResult;

661

662enum hipComputeMode {

663 hipComputeModeDefault = 0,

664 hipComputeModeExclusive = 1,

665 hipComputeModeProhibited = 2,

666 hipComputeModeExclusiveProcess = 3

667};

668

669enum hipFlushGPUDirectRDMAWritesOptions {

670 hipFlushGPUDirectRDMAWritesOptionHost = 1 << 0,

671 hipFlushGPUDirectRDMAWritesOptionMemOps = 1 << 1

672};

673

674enum hipGPUDirectRDMAWritesOrdering {

675 hipGPUDirectRDMAWritesOrderingNone = 0,

676 hipGPUDirectRDMAWritesOrderingOwner = 100,

677 hipGPUDirectRDMAWritesOrderingAllDevices = 200

678};

679

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

681

682#ifndef GENERIC_GRID_LAUNCH

683#define GENERIC_GRID_LAUNCH 1

684#endif

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

686#include <hip/driver_types.h>

687#include <hip/texture_types.h>

688#include <hip/surface_types.h>

689

690#if defined(HIP_ABI_IMPL)

691// Nothing is deprecated if we are implementing the HIP ABI.

692#define HIP_DEPRECATED(x)

693#elif defined(_MSC_VER)

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

695#else // !defined(_MSC_VER)

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

697#endif // !defined(_MSC_VER)

698

699#define HIP_DEPRECATED_MSG \

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

701 "details please refer " \

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

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

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

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

706#ifdef __cplusplus

707#define __dparm(x) = x

708#else

709#define __dparm(x)

710#endif

711#ifdef __GNUC__

712#pragma GCC visibility push(default)

713#endif

714#ifdef __cplusplus

715namespace hip_impl {

716hipError_t hip_init();

717} // namespace hip_impl

718#endif

719// Structure definitions:

720#ifdef __cplusplus

721extern "C" {

722#endif

723//---

724// API-visible structures

725typedef struct ihipCtx_t* hipCtx_t;

726typedef struct ihipExecutionCtx_t* hipExecutionCtx_t;

727typedef struct ihipDevResourceDesc_t* hipDevResourceDesc_t;

728typedef enum hipDevResourceType {

729 hipDevResourceTypeInvalid = 0,

730 hipDevResourceTypeSm = 1,

731 hipDevResourceTypeWorkqueueConfig = 1000,

732 hipDevResourceTypeWorkqueue = 10000,

733} hipDevResourceType;

734typedef enum hipDevSmResourceGroup_flags {

735 hipDevSmResourceGroupDefault = 0,

736 hipDevSmResourceGroupBackfill = 0x1,

737} hipDevSmResourceGroup_flags;

738typedef enum hipDevSmResourceSplitByCount_flags {

739 hipDevSmResourceSplitIgnoreSmCoscheduling = 0x1,

740 hipDevSmResourceSplitMaxPotentialClusterSize = 0x2,

741} hipDevSmResourceSplitByCount_flags;

742typedef enum hipDevWorkqueueConfigScope {

743 hipDevWorkqueueConfigScopeDeviceCtx = 0,

744 hipDevWorkqueueConfigScopeGreenCtxBalanced = 1,

745} hipDevWorkqueueConfigScope;

746

747#define HIP_RESOURCE_ABI_BYTES 40

748

749typedef struct hipDevSmResource {

750 unsigned int smCount;

751 unsigned int minSmPartitionSize;

752 unsigned int smCoscheduledAlignment;

753 unsigned int flags;

754} hipDevSmResource;

755

756typedef struct hipDevWorkqueueConfigResource {

757 int device;

758 unsigned int wqConcurrencyLimit;

759 hipDevWorkqueueConfigScope sharingScope;

760} hipDevWorkqueueConfigResource;

761

762typedef struct hipDevWorkqueueResource {

763 unsigned char reserved[HIP_RESOURCE_ABI_BYTES];

764} hipDevWorkqueueResource;

765

766typedef struct hipDevResource_st {

767 hipDevResourceType type;

768 unsigned char _internal_padding[92];

769 union {

770 hipDevSmResource sm;

771 hipDevWorkqueueConfigResource wqConfig;

772 hipDevWorkqueueResource wq;

773 unsigned char _oversize[HIP_RESOURCE_ABI_BYTES];

774 };

775 struct hipDevResource_st* nextResource;

776} hipDevResource;

777

778typedef struct hipDevSmResourceGroupParams_st {

779 unsigned int smCount;

780 unsigned int coscheduledSmCount;

781 unsigned int preferredCoscheduledSmCount;

782 unsigned int flags;

783 unsigned int reserved[12];

784} hipDevSmResourceGroupParams;

785

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

787typedef int hipDevice_t;

788typedef enum hipDeviceP2PAttr {

789 hipDevP2PAttrPerformanceRank = 0,

790 hipDevP2PAttrAccessSupported,

791 hipDevP2PAttrNativeAtomicSupported,

792 hipDevP2PAttrHipArrayAccessSupported

793} hipDeviceP2PAttr;

794typedef enum hipDriverEntryPointQueryResult {

795 hipDriverEntryPointSuccess = 0,

796 hipDriverEntryPointSymbolNotFound = 1,

797 hipDriverEntryPointVersionNotSufficent = 2

798} hipDriverEntryPointQueryResult;

799typedef struct ihipStream_t* hipStream_t;

800#define hipIpcMemLazyEnablePeerAccess 0x01

801#define HIP_IPC_HANDLE_SIZE 64

802typedef struct hipIpcMemHandle_st {

803 char reserved[HIP_IPC_HANDLE_SIZE];

804} hipIpcMemHandle_t;

805typedef struct hipIpcEventHandle_st {

806 char reserved[HIP_IPC_HANDLE_SIZE];

807} hipIpcEventHandle_t;

808typedef struct hipMemFabricHandle_st {

809 unsigned char data[HIP_IPC_HANDLE_SIZE];

810} hipMemFabricHandle_t;

811typedef struct ihipModule_t* hipModule_t;

812typedef struct ihipModuleSymbol_t* hipFunction_t;

813typedef struct ihipLinkState_t* hipLinkState_t;

814typedef struct ihipLibrary_t* hipLibrary_t;

815typedef struct ihipKernel_t* hipKernel_t;

819typedef struct ihipMemPoolHandle_t* hipMemPool_t;

820

821typedef struct hipFuncAttributes {

822 int binaryVersion;

823 int cacheModeCA;

824 size_t constSizeBytes;

825 size_t localSizeBytes;

826 int maxDynamicSharedSizeBytes;

827 int maxThreadsPerBlock;

828 int numRegs;

829 int preferredShmemCarveout;

830 int ptxVersion;

831 size_t sharedSizeBytes;

832} hipFuncAttributes;

833typedef struct ihipEvent_t* hipEvent_t;

834

841enum hipLimit_t {

842 hipLimitStackSize = 0x0,

845 hipLimitPrintfFifoSize = 0x01,

847 hipLimitMallocHeapSize = 0x02,

849 hipExtLimitScratchMin = 0x1000,

851 hipExtLimitScratchMax = 0x1001,

853 hipExtLimitScratchCurrent = 0x1002,

857 hipLimitRange

858};

859

863// Flags that can be used with hipStreamCreateWithFlags.

865#define hipStreamDefault 0x00

866

868#define hipStreamNonBlocking 0x01

869

870// Flags that can be used with hipEventCreateWithFlags.

872#define hipEventDefault 0x0

873

875#define hipEventBlockingSync 0x1

876

878#define hipEventDisableTiming 0x2

879

881#define hipEventInterprocess 0x4

882

883// Flags that can be used with hipEventRecordWithFlags.

885#define hipEventRecordDefault 0x00

886

888#define hipEventRecordExternal 0x01

889

890//Flags that can be used with hipStreamWaitEvent.

892#define hipEventWaitDefault 0x00

893

895#define hipEventWaitExternal 0x01

896

905#define hipEventDisableSystemFence 0x20000000

906

909#define hipEventReleaseToDevice 0x40000000

910

913#define hipEventReleaseToSystem 0x80000000

914

915// Flags that can be used with hipGetDriverEntryPoint.

919#define hipEnableDefault 0x0

920

922#define hipEnableLegacyStream 0x1

923

926#define hipEnablePerThreadDefaultStream 0x2

927

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

930#define hipHostAllocDefault 0x0

931

934#define hipHostMallocDefault 0x0

935

937#define hipHostAllocPortable 0x1

938

941#define hipHostMallocPortable 0x1

942

945#define hipHostAllocMapped 0x2

946

950#define hipHostMallocMapped 0x2

951

957#define hipHostAllocWriteCombined 0x4

958

965#define hipHostMallocWriteCombined 0x4

966

972#define hipHostMallocUncached 0x10000000

973#define hipHostAllocUncached hipHostMallocUncached

974

979#define hipHostMallocNumaUser 0x20000000

980

982#define hipHostMallocCoherent 0x40000000

983

985#define hipHostMallocNonCoherent 0x80000000

986

988#define hipMemAttachGlobal 0x01

989

991#define hipMemAttachHost 0x02

992

994#define hipMemAttachSingle 0x04

995

996#define hipDeviceMallocDefault 0x0

997

999#define hipDeviceMallocFinegrained 0x1

1000

1002#define hipMallocSignalMemory 0x2

1003

1005#define hipDeviceMallocUncached 0x3

1006

1008#define hipDeviceMallocContiguous 0x4

1009

1010// Flags that can be used with hipHostRegister.

1012#define hipHostRegisterDefault 0x0

1013

1015#define hipHostRegisterPortable 0x1

1016

1019#define hipHostRegisterMapped 0x2

1020

1025#define hipHostRegisterIoMemory 0x4

1026

1028#define hipHostRegisterReadOnly 0x08

1029

1031#define hipExtHostRegisterCoarseGrained 0x8

1032

1036#define hipExtHostRegisterUncached 0x80000000

1037

1039#define hipDeviceScheduleAuto 0x0

1040

1043#define hipDeviceScheduleSpin 0x1

1044

1047#define hipDeviceScheduleYield 0x2

1048#define hipDeviceScheduleBlockingSync 0x4

1049#define hipDeviceScheduleMask 0x7

1050#define hipDeviceMapHost 0x8

1051#define hipDeviceLmemResizeToMax 0x10

1053#define hipInitDeviceFlagsAreValid 0x1

1055#define hipArrayDefault 0x00

1056#define hipArrayLayered 0x01

1057#define hipArraySurfaceLoadStore 0x02

1058#define hipArrayCubemap 0x04

1059#define hipArrayTextureGather 0x08

1060#define hipOccupancyDefault 0x00

1061#define hipOccupancyDisableCachingOverride 0x01

1062#define hipCooperativeLaunchMultiDeviceNoPreSync 0x01

1063#define hipCooperativeLaunchMultiDeviceNoPostSync 0x02

1064#define hipCpuDeviceId ((int)-1)

1065#define hipInvalidDeviceId ((int)-2)

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

1068#define hipExtAnyOrderLaunch 0x01

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

1070#define hipStreamWaitValueGte 0x0

1071#define hipStreamWaitValueEq 0x1

1072#define hipStreamWaitValueAnd 0x2

1073#define hipStreamWaitValueNor 0x3

1074// Flags to be used with hipStreamWriteValue32 and hipStreamWriteValue64.

1075#define hipStreamWriteValueDefault 0x0

1076#define hipExtStreamWriteValueIncrement 0x1000

1077#define hipExtStreamWriteValueDecrement 0x1001

1078

1080typedef enum hipStreamBatchMemOpType {

1081 hipStreamMemOpWaitValue32 = 0x1,

1082 hipStreamMemOpWriteValue32 = 0x2,

1083 hipStreamMemOpWaitValue64 = 0x4,

1084 hipStreamMemOpWriteValue64 = 0x5,

1085 hipStreamMemOpBarrier = 0x6,

1086 hipStreamMemOpFlushRemoteWrites = 0x3

1087} hipStreamBatchMemOpType;

1088

1125typedef union hipStreamBatchMemOpParams_union {

1126 hipStreamBatchMemOpType operation;

1127 struct hipStreamMemOpWaitValueParams_t {

1128 hipStreamBatchMemOpType operation;

1129 hipDeviceptr_t address;

1130 union {

1131 uint32_t value;

1132 uint64_t value64;

1133 };

1134 unsigned int flags;

1135 hipDeviceptr_t alias;

1136 } waitValue;

1137 struct hipStreamMemOpWriteValueParams_t {

1138 hipStreamBatchMemOpType operation;

1139 hipDeviceptr_t address;

1140 union {

1141 uint32_t value;

1142 uint64_t value64;

1143 };

1144 unsigned int flags;

1145 hipDeviceptr_t alias;

1146 } writeValue;

1147 struct hipStreamMemOpFlushRemoteWritesParams_t {

1148 hipStreamBatchMemOpType operation;

1149 unsigned int flags;

1150 } flushRemoteWrites;

1151 struct hipStreamMemOpMemoryBarrierParams_t {

1152 hipStreamBatchMemOpType operation;

1153 unsigned int flags;

1154 } memoryBarrier;

1155 uint64_t pad[6];

1156} hipStreamBatchMemOpParams;

1157

1185typedef struct hipBatchMemOpNodeParams {

1186 hipCtx_t ctx;

1187 unsigned int count;

1188 hipStreamBatchMemOpParams* paramArray;

1189 unsigned int flags;

1190} hipBatchMemOpNodeParams;

1191

1192// Stream per thread

1194#define hipStreamPerThread ((hipStream_t)2)

1195

1196#define hipStreamLegacy ((hipStream_t)1)

1197

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

1199#define hipExternalMemoryDedicated 0x1

1205typedef enum hipMemoryAdvise {

1206 hipMemAdviseSetReadMostly = 1,

1208 hipMemAdviseUnsetReadMostly = 2,

1209 hipMemAdviseSetPreferredLocation = 3,

1211 hipMemAdviseUnsetPreferredLocation = 4,

1212 hipMemAdviseSetAccessedBy = 5,

1214 hipMemAdviseUnsetAccessedBy = 6,

1216 hipMemAdviseSetCoarseGrain = 100,

1221 hipMemAdviseUnsetCoarseGrain = 101

1222} hipMemoryAdvise;

1226typedef enum hipMemRangeCoherencyMode {

1227 hipMemRangeCoherencyModeFineGrain = 0,

1229 hipMemRangeCoherencyModeCoarseGrain = 1,

1231 hipMemRangeCoherencyModeIndeterminate = 2

1234} hipMemRangeCoherencyMode;

1238typedef enum hipMemRangeAttribute {

1239 hipMemRangeAttributeReadMostly = 1,

1241 hipMemRangeAttributePreferredLocation = 2,

1242 hipMemRangeAttributeAccessedBy = 3,

1244 hipMemRangeAttributeLastPrefetchLocation = 4,

1246 hipMemRangeAttributeCoherencyMode = 100,

1248} hipMemRangeAttribute;

1249

1253typedef enum hipMemPoolAttr {

1262 hipMemPoolReuseFollowEventDependencies = 0x1,

1268 hipMemPoolReuseAllowOpportunistic = 0x2,

1275 hipMemPoolReuseAllowInternalDependencies = 0x3,

1284 hipMemPoolAttrReleaseThreshold = 0x4,

1289 hipMemPoolAttrReservedMemCurrent = 0x5,

1295 hipMemPoolAttrReservedMemHigh = 0x6,

1300 hipMemPoolAttrUsedMemCurrent = 0x7,

1306 hipMemPoolAttrUsedMemHigh = 0x8

1307} hipMemPoolAttr;

1308

1313typedef enum hipMemAccessFlags {

1314 hipMemAccessFlagsProtNone = 0,

1315 hipMemAccessFlagsProtRead = 1,

1316 hipMemAccessFlagsProtReadWrite = 3

1317} hipMemAccessFlags;

1324typedef struct hipMemAccessDesc {

1325 hipMemLocation location;

1326 hipMemAccessFlags flags;

1327} hipMemAccessDesc;

1331typedef enum hipMemAllocationType {

1332 hipMemAllocationTypeInvalid = 0x0,

1336 hipMemAllocationTypePinned = 0x1,

1337 hipMemAllocationTypeManaged = 0x2,

1338 hipMemAllocationTypeUncached = 0x40000000,

1339 hipMemAllocationTypeMax = 0x7FFFFFFF

1340} hipMemAllocationType;

1345typedef enum hipMemAllocationHandleType {

1346 hipMemHandleTypeNone = 0x0,

1347 hipMemHandleTypePosixFileDescriptor =

1348 0x1,

1349 hipMemHandleTypeWin32 = 0x2,

1350 hipMemHandleTypeWin32Kmt = 0x4,

1351 hipMemHandleTypeFabric = 0x8

1352} hipMemAllocationHandleType;

1356typedef struct hipMemPoolProps {

1357 hipMemAllocationType

1358 allocType;

1359 hipMemAllocationHandleType

1360 handleTypes;

1361 hipMemLocation location;

1365 void* win32SecurityAttributes;

1366 size_t maxSize;

1367 unsigned char reserved[56];

1368} hipMemPoolProps;

1372typedef struct hipMemPoolPtrExportData {

1373 unsigned char reserved[64];

1374} hipMemPoolPtrExportData;

1375

1379typedef enum hipFuncAttribute {

1380 hipFuncAttributeMaxDynamicSharedMemorySize = 8,

1381 hipFuncAttributePreferredSharedMemoryCarveout = 9,

1382 hipFuncAttributeClusterDimMustBeSet = 10,

1383 hipFuncAttributeRequiredClusterWidth = 11,

1384 hipFuncAttributeRequiredClusterHeight = 12,

1385 hipFuncAttributeRequiredClusterDepth = 13,

1386 hipFuncAttributeNonPortableClusterSizeAllowed = 14,

1387 hipFuncAttributeClusterSchedulingPolicyPreference = 15,

1388 hipFuncAttributeMax

1389} hipFuncAttribute;

1393typedef enum hipFuncCache_t {

1394 hipFuncCachePreferNone,

1395 hipFuncCachePreferShared,

1396 hipFuncCachePreferL1,

1397 hipFuncCachePreferEqual,

1398} hipFuncCache_t;

1402typedef enum hipSharedMemConfig {

1403 hipSharedMemBankSizeDefault,

1404 hipSharedMemBankSizeFourByte,

1406 hipSharedMemBankSizeEightByte

1408} hipSharedMemConfig;

1412typedef struct dim3 {

1413 uint32_t x;

1414 uint32_t y;

1415 uint32_t z;

1416#ifdef __cplusplus

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

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

1419#endif

1420} dim3;

1424typedef struct hipLaunchParams_t {

1425 void* func;

1426 dim3 gridDim;

1427 dim3 blockDim;

1428 void** args;

1429 size_t sharedMem;

1430 hipStream_t stream;

1431} hipLaunchParams;

1435typedef struct hipFunctionLaunchParams_t {

1436 hipFunction_t function;

1437 unsigned int gridDimX;

1438 unsigned int gridDimY;

1439 unsigned int gridDimZ;

1440 unsigned int blockDimX;

1441 unsigned int blockDimY;

1442 unsigned int blockDimZ;

1443 unsigned int sharedMemBytes;

1444 hipStream_t hStream;

1445 void** kernelParams;

1446} hipFunctionLaunchParams;

1447typedef enum hipExternalMemoryHandleType_enum {

1448 hipExternalMemoryHandleTypeOpaqueFd = 1,

1449 hipExternalMemoryHandleTypeOpaqueWin32 = 2,

1450 hipExternalMemoryHandleTypeOpaqueWin32Kmt = 3,

1451 hipExternalMemoryHandleTypeD3D12Heap = 4,

1452 hipExternalMemoryHandleTypeD3D12Resource = 5,

1453 hipExternalMemoryHandleTypeD3D11Resource = 6,

1454 hipExternalMemoryHandleTypeD3D11ResourceKmt = 7,

1455 hipExternalMemoryHandleTypeNvSciBuf = 8

1456} hipExternalMemoryHandleType;

1457typedef struct hipExternalMemoryHandleDesc_st {

1458 hipExternalMemoryHandleType type;

1459 union {

1460 int fd;

1461 struct {

1462 void* handle;

1463 const void* name;

1464 } win32;

1465 const void* nvSciBufObject;

1466 } handle;

1467 unsigned long long size;

1468 unsigned int flags;

1469 unsigned int reserved[16];

1470} hipExternalMemoryHandleDesc;

1471typedef struct hipExternalMemoryBufferDesc_st {

1472 unsigned long long offset;

1473 unsigned long long size;

1474 unsigned int flags;

1475 unsigned int reserved[16];

1476} hipExternalMemoryBufferDesc;

1477typedef struct hipExternalMemoryMipmappedArrayDesc_st {

1478 unsigned long long offset;

1479 hipChannelFormatDesc formatDesc;

1480 hipExtent extent;

1481 unsigned int flags;

1482 unsigned int numLevels;

1483} hipExternalMemoryMipmappedArrayDesc;

1484typedef void* hipExternalMemory_t;

1485typedef enum hipExternalSemaphoreHandleType_enum {

1486 hipExternalSemaphoreHandleTypeOpaqueFd = 1,

1487 hipExternalSemaphoreHandleTypeOpaqueWin32 = 2,

1488 hipExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3,

1489 hipExternalSemaphoreHandleTypeD3D12Fence = 4,

1490 hipExternalSemaphoreHandleTypeD3D11Fence = 5,

1491 hipExternalSemaphoreHandleTypeNvSciSync = 6,

1492 hipExternalSemaphoreHandleTypeKeyedMutex = 7,

1493 hipExternalSemaphoreHandleTypeKeyedMutexKmt = 8,

1494 hipExternalSemaphoreHandleTypeTimelineSemaphoreFd = 9,

1495 hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = 10

1496} hipExternalSemaphoreHandleType;

1497typedef struct hipExternalSemaphoreHandleDesc_st {

1498 hipExternalSemaphoreHandleType type;

1499 union {

1500 int fd;

1501 struct {

1502 void* handle;

1503 const void* name;

1504 } win32;

1505 const void* NvSciSyncObj;

1506 } handle;

1507 unsigned int flags;

1508 unsigned int reserved[16];

1509} hipExternalSemaphoreHandleDesc;

1510typedef void* hipExternalSemaphore_t;

1511typedef struct hipExternalSemaphoreSignalParams_st {

1512 struct {

1513 struct {

1514 unsigned long long value;

1515 } fence;

1516 union {

1517 void* fence;

1518 unsigned long long reserved;

1519 } nvSciSync;

1520 struct {

1521 unsigned long long key;

1522 } keyedMutex;

1523 unsigned int reserved[12];

1524 } params;

1525 unsigned int flags;

1526 unsigned int reserved[16];

1527} hipExternalSemaphoreSignalParams;

1531typedef struct hipExternalSemaphoreWaitParams_st {

1532 struct {

1533 struct {

1534 unsigned long long value;

1535 } fence;

1536 union {

1537 void* fence;

1538 unsigned long long reserved;

1539 } nvSciSync;

1540 struct {

1541 unsigned long long key;

1542 unsigned int timeoutMs;

1543 } keyedMutex;

1544 unsigned int reserved[10];

1545 } params;

1546 unsigned int flags;

1547 unsigned int reserved[16];

1548} hipExternalSemaphoreWaitParams;

1549

1550#if __HIP_HAS_GET_PCH

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

1556#endif

1557

1561typedef enum hipGraphicsRegisterFlags {

1562 hipGraphicsRegisterFlagsNone = 0,

1563 hipGraphicsRegisterFlagsReadOnly = 1,

1564 hipGraphicsRegisterFlagsWriteDiscard =

1565 2,

1566 hipGraphicsRegisterFlagsSurfaceLoadStore = 4,

1567 hipGraphicsRegisterFlagsTextureGather =

1568 8

1569} hipGraphicsRegisterFlags;

1570

1571typedef struct _hipGraphicsResource hipGraphicsResource;

1572

1573typedef hipGraphicsResource* hipGraphicsResource_t;

1574

1578typedef struct ihipGraph* hipGraph_t;

1582typedef struct hipGraphNode* hipGraphNode_t;

1586typedef struct hipGraphExec* hipGraphExec_t;

1587

1591typedef struct hipUserObject* hipUserObject_t;

1592

1593

1597typedef enum hipGraphNodeType {

1598 hipGraphNodeTypeKernel = 0,

1599 hipGraphNodeTypeMemcpy = 1,

1600 hipGraphNodeTypeMemset = 2,

1601 hipGraphNodeTypeHost = 3,

1602 hipGraphNodeTypeGraph = 4,

1603 hipGraphNodeTypeEmpty = 5,

1604 hipGraphNodeTypeWaitEvent = 6,

1605 hipGraphNodeTypeEventRecord = 7,

1606 hipGraphNodeTypeExtSemaphoreSignal = 8,

1607 hipGraphNodeTypeExtSemaphoreWait = 9,

1608 hipGraphNodeTypeMemAlloc = 10,

1609 hipGraphNodeTypeMemFree = 11,

1610 hipGraphNodeTypeMemcpyFromSymbol = 12,

1611 hipGraphNodeTypeMemcpyToSymbol = 13,

1612 hipGraphNodeTypeBatchMemOp = 14,

1613 hipGraphNodeTypeCount

1614} hipGraphNodeType;

1615

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

1617typedef struct hipHostNodeParams {

1618 hipHostFn_t fn;

1619 void* userData;

1620} hipHostNodeParams;

1621typedef struct hipKernelNodeParams {

1622 dim3 blockDim;

1623 void** extra;

1624 void* func;

1625 dim3 gridDim;

1626 void** kernelParams;

1627 unsigned int sharedMemBytes;

1628} hipKernelNodeParams;

1629typedef struct hipMemsetParams {

1630 void* dst;

1631 unsigned int elementSize;

1632 size_t height;

1633 size_t pitch;

1634 unsigned int value;

1635 size_t width;

1636} hipMemsetParams;

1637

1638typedef struct hipMemAllocNodeParams {

1639 hipMemPoolProps poolProps;

1641 const hipMemAccessDesc* accessDescs;

1642 size_t accessDescCount;

1644 size_t bytesize;

1645 void* dptr;

1646} hipMemAllocNodeParams;

1647

1651typedef enum hipAccessProperty {

1652 hipAccessPropertyNormal = 0,

1653 hipAccessPropertyStreaming = 1,

1654 hipAccessPropertyPersisting = 2,

1655} hipAccessProperty;

1656

1657/***

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

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

1660 */

1661typedef struct hipAccessPolicyWindow {

1662 void* base_ptr;

1663 hipAccessProperty hitProp;

1664 float hitRatio;

1665 hipAccessProperty missProp;

1666 size_t num_bytes;

1667} hipAccessPolicyWindow;

1668

1672typedef struct hipLaunchMemSyncDomainMap {

1673 unsigned char default_;

1674 unsigned char remote;

1675} hipLaunchMemSyncDomainMap;

1676

1680typedef enum hipLaunchMemSyncDomain {

1681 hipLaunchMemSyncDomainDefault = 0,

1682 hipLaunchMemSyncDomainRemote = 1

1683} hipLaunchMemSyncDomain;

1684

1689typedef enum hipSynchronizationPolicy {

1690 hipSyncPolicyAuto = 1,

1691 hipSyncPolicySpin = 2,

1692 hipSyncPolicyYield = 3,

1693 hipSyncPolicyBlockingSync = 4

1694} hipSynchronizationPolicy;

1695/* Cluster scheduling policies passed to hipFuncSetAttribute

1696*/

1697typedef enum hipClusterSchedulingPolicy {

1698 hipClusterSchedulingPolicyDefault = 0,

1699 hipClusterSchedulingPolicySpread = 1,

1700 hipClusterSchedulingPolicyLoadBalancing =

1701 2,

1702} hipClusterSchedulingPolicy;

1703

1707typedef enum hipExtDynDataPrefetchTemporal {

1708 hipExtDynDataPrefetchTemporalRegular = 0,

1709 hipExtDynDataPrefetchTemporalHigh = 1,

1710} hipExtDynDataPrefetchTemporal;

1711

1720typedef struct hipExtDynDataPrefetchRegion {

1721 void* address;

1722 size_t stride;

1723 size_t width;

1724 size_t height;

1725} hipExtDynDataPrefetchRegion;

1726

1732#define HIP_EXT_DYN_DATA_PREFETCH_MAX_REGIONS 2

1733

1744typedef struct hipExtDynDataPrefetchConfig {

1745 unsigned int numRegions;

1746 hipExtDynDataPrefetchTemporal temporal;

1747 hipExtDynDataPrefetchRegion regions[HIP_EXT_DYN_DATA_PREFETCH_MAX_REGIONS];

1748} hipExtDynDataPrefetchConfig;

1749

1753typedef enum hipLaunchAttributeID {

1754 hipLaunchAttributeIgnore = 0,

1755 hipLaunchAttributeAccessPolicyWindow = 1,

1756 hipLaunchAttributeCooperative = 2,

1757 hipLaunchAttributeSynchronizationPolicy = 3,

1758 hipLaunchAttributeClusterDimension = 4,

1759 hipLaunchAttributeClusterSchedulingPolicyPreference = 5,

1760 hipLaunchAttributePriority = 8,

1761 hipLaunchAttributeMemSyncDomainMap = 9,

1762 hipLaunchAttributeMemSyncDomain = 10,

1763 hipLaunchAttributeExtDynDataPrefetch = 1024,

1764 hipLaunchAttributeMax

1765} hipLaunchAttributeID;

1766

1767

1771typedef union hipLaunchAttributeValue {

1772 char pad[64];

1773 hipAccessPolicyWindow

1774 accessPolicyWindow;

1775 int cooperative;

1777 int priority;

1779 hipSynchronizationPolicy

1780 syncPolicy;

1782 hipLaunchMemSyncDomainMap

1783 memSyncDomainMap;

1784 hipLaunchMemSyncDomain

1785 memSyncDomain;

1798 struct {

1799 unsigned int x;

1800 unsigned int y;

1801 unsigned int z;

1802 } clusterDim;

1803

1804 hipClusterSchedulingPolicy clusterSchedulingPolicyPreference;

1806 const hipExtDynDataPrefetchConfig* dynDataPrefetch;

1807} hipLaunchAttributeValue;

1808

1812#define hipStreamAttrID hipLaunchAttributeID

1813#define hipStreamAttributeAccessPolicyWindow hipLaunchAttributeAccessPolicyWindow

1814#define hipStreamAttributeSynchronizationPolicy hipLaunchAttributeSynchronizationPolicy

1815#define hipStreamAttributeMemSyncDomainMap hipLaunchAttributeMemSyncDomainMap

1816#define hipStreamAttributeMemSyncDomain hipLaunchAttributeMemSyncDomain

1817#define hipStreamAttributePriority hipLaunchAttributePriority

1818

1819#define hipStreamAttrValue hipLaunchAttributeValue

1820

1824#define hipKernelNodeAttrID hipLaunchAttributeID

1825#define hipKernelNodeAttributeAccessPolicyWindow hipLaunchAttributeAccessPolicyWindow

1826#define hipKernelNodeAttributeCooperative hipLaunchAttributeCooperative

1827#define hipKernelNodeAttributePriority hipLaunchAttributePriority

1828

1832#define hipKernelNodeAttrValue hipLaunchAttributeValue

1833

1837#define hipDrvLaunchAttributeCooperative hipLaunchAttributeCooperative

1838

1839#define hipDrvLaunchAttributeID hipLaunchAttributeID

1840#define hipDrvLaunchAttributeValue hipLaunchAttributeValue

1841#define hipDrvLaunchAttribute hipLaunchAttribute

1842

1846typedef enum hipGraphExecUpdateResult {

1847 hipGraphExecUpdateSuccess = 0x0,

1848 hipGraphExecUpdateError = 0x1,

1850 hipGraphExecUpdateErrorTopologyChanged = 0x2,

1851 hipGraphExecUpdateErrorNodeTypeChanged = 0x3,

1852 hipGraphExecUpdateErrorFunctionChanged =

1853 0x4,

1854 hipGraphExecUpdateErrorParametersChanged =

1855 0x5,

1856 hipGraphExecUpdateErrorNotSupported =

1857 0x6,

1858 hipGraphExecUpdateErrorUnsupportedFunctionChange = 0x7

1859} hipGraphExecUpdateResult;

1860

1861typedef enum hipStreamCaptureMode {

1862 hipStreamCaptureModeGlobal = 0,

1863 hipStreamCaptureModeThreadLocal,

1864 hipStreamCaptureModeRelaxed

1865} hipStreamCaptureMode;

1866typedef enum hipStreamCaptureStatus {

1867 hipStreamCaptureStatusNone = 0,

1868 hipStreamCaptureStatusActive,

1869 hipStreamCaptureStatusInvalidated

1871} hipStreamCaptureStatus;

1872

1873typedef enum hipStreamUpdateCaptureDependenciesFlags {

1874 hipStreamAddCaptureDependencies = 0,

1875 hipStreamSetCaptureDependencies,

1876} hipStreamUpdateCaptureDependenciesFlags;

1877

1878typedef enum hipGraphMemAttributeType {

1879 hipGraphMemAttrUsedMemCurrent =

1880 0,

1881 hipGraphMemAttrUsedMemHigh,

1883 hipGraphMemAttrReservedMemCurrent,

1885 hipGraphMemAttrReservedMemHigh,

1887} hipGraphMemAttributeType;

1888typedef enum hipUserObjectFlags {

1889 hipUserObjectNoDestructorSync = 0x1,

1890} hipUserObjectFlags;

1891

1892typedef enum hipUserObjectRetainFlags {

1893 hipGraphUserObjectMove = 0x1,

1894} hipUserObjectRetainFlags;

1895

1896typedef enum hipGraphInstantiateFlags {

1897 hipGraphInstantiateFlagAutoFreeOnLaunch =

1898 1,

1899 hipGraphInstantiateFlagUpload = 2,

1900 hipGraphInstantiateFlagDeviceLaunch =

1901 4,

1902 hipGraphInstantiateFlagUseNodePriority =

1903 8,

1905} hipGraphInstantiateFlags;

1906

1907enum hipGraphDebugDotFlags {

1908 hipGraphDebugDotFlagsVerbose =

1909 1 << 0,

1910 hipGraphDebugDotFlagsKernelNodeParams = 1 << 2,

1911 hipGraphDebugDotFlagsMemcpyNodeParams = 1 << 3,

1912 hipGraphDebugDotFlagsMemsetNodeParams = 1 << 4,

1913 hipGraphDebugDotFlagsHostNodeParams = 1 << 5,

1914 hipGraphDebugDotFlagsEventNodeParams =

1915 1 << 6,

1916 hipGraphDebugDotFlagsExtSemasSignalNodeParams =

1917 1 << 7,

1918 hipGraphDebugDotFlagsExtSemasWaitNodeParams =

1919 1 << 8,

1920 hipGraphDebugDotFlagsKernelNodeAttributes =

1921 1 << 9,

1922 hipGraphDebugDotFlagsHandles =

1923 1 << 10

1924};

1925

1929typedef enum hipGraphInstantiateResult {

1930 hipGraphInstantiateSuccess = 0,

1931 hipGraphInstantiateError = 1,

1933 hipGraphInstantiateInvalidStructure = 2,

1935 hipGraphInstantiateNodeOperationNotSupported = 3,

1937 hipGraphInstantiateMultipleDevicesNotSupported = 4,

1939} hipGraphInstantiateResult;

1940

1944typedef struct hipGraphInstantiateParams {

1945 hipGraphNode_t errNode_out;

1946 unsigned long long flags;

1947 hipGraphInstantiateResult result_out;

1949 hipStream_t uploadStream;

1950} hipGraphInstantiateParams;

1951

1952

1956typedef struct hipMemAllocationProp {

1957 hipMemAllocationType type;

1958 union {

1959 hipMemAllocationHandleType requestedHandleType;

1960 hipMemAllocationHandleType requestedHandleTypes;

1961 };

1962 hipMemLocation location;

1963 void* win32HandleMetaData;

1964 struct {

1965 unsigned char compressionType;

1966 unsigned char gpuDirectRDMACapable;

1967 unsigned short usage;

1968 } allocFlags;

1969} hipMemAllocationProp;

1970

1974typedef struct hipExternalSemaphoreSignalNodeParams {

1976 hipExternalSemaphore_t* extSemArray;

1978 const hipExternalSemaphoreSignalParams* paramsArray;

1980 unsigned int numExtSems;

1981} hipExternalSemaphoreSignalNodeParams;

1982

1986typedef struct hipExternalSemaphoreWaitNodeParams {

1988 hipExternalSemaphore_t* extSemArray;

1990 const hipExternalSemaphoreWaitParams* paramsArray;

1992 unsigned int numExtSems;

1993} hipExternalSemaphoreWaitNodeParams;

1994

1998typedef struct ihipMemGenericAllocationHandle* hipMemGenericAllocationHandle_t;

1999

2003typedef enum hipMemAllocationGranularity_flags {

2004 hipMemAllocationGranularityMinimum = 0x0,

2005 hipMemAllocationGranularityRecommended = 0x1

2006} hipMemAllocationGranularity_flags;

2007

2011typedef enum hipMemHandleType {

2012 hipMemHandleTypeGeneric = 0x0

2013} hipMemHandleType;

2014

2018typedef enum hipMemOperationType {

2019 hipMemOperationTypeMap = 0x1,

2020 hipMemOperationTypeUnmap = 0x2

2021} hipMemOperationType;

2022

2026typedef enum hipArraySparseSubresourceType {

2027 hipArraySparseSubresourceTypeSparseLevel = 0x0,

2028 hipArraySparseSubresourceTypeMiptail = 0x1

2029} hipArraySparseSubresourceType;

2030

2034typedef struct hipArrayMapInfo {

2035 hipResourceType resourceType;

2036 union {

2037 hipMipmappedArray mipmap;

2038 hipArray_t array;

2039 } resource;

2040 hipArraySparseSubresourceType subresourceType;

2041 union {

2042 struct {

2043 unsigned int

2044 level;

2045 unsigned int

2046 layer;

2047 unsigned int offsetX;

2048 unsigned int offsetY;

2049 unsigned int offsetZ;

2050 unsigned int extentWidth;

2051 unsigned int extentHeight;

2052 unsigned int extentDepth;

2053 } sparseLevel;

2054 struct {

2055 unsigned int

2056 layer;

2057 unsigned long long offset;

2058 unsigned long long size;

2059 } miptail;

2060 } subresource;

2061 hipMemOperationType memOperationType;

2062 hipMemHandleType memHandleType;

2063 union {

2064 hipMemGenericAllocationHandle_t memHandle;

2065 } memHandle;

2066 unsigned long long offset;

2067 unsigned int deviceBitMask;

2068 unsigned int flags;

2069 unsigned int reserved[2];

2070} hipArrayMapInfo;

2071

2075typedef struct hipMemcpyNodeParams {

2076 int flags;

2077 int reserved[3];

2078 hipMemcpy3DParms copyParams;

2079} hipMemcpyNodeParams;

2080

2084typedef struct hipChildGraphNodeParams {

2085 hipGraph_t graph;

2087} hipChildGraphNodeParams;

2088

2092typedef struct hipEventWaitNodeParams {

2093 hipEvent_t event;

2094} hipEventWaitNodeParams;

2095

2099typedef struct hipEventRecordNodeParams {

2100 hipEvent_t event;

2101} hipEventRecordNodeParams;

2102

2106typedef struct hipMemFreeNodeParams {

2107 void* dptr;

2108} hipMemFreeNodeParams;

2109

2113typedef struct hipGraphNodeParams {

2114 hipGraphNodeType type;

2115 int reserved0[3];

2116 union {

2117 long long reserved1[29];

2118 hipKernelNodeParams kernel;

2119 hipMemcpyNodeParams memcpy;

2120 hipMemsetParams memset;

2121 hipHostNodeParams host;

2122 hipChildGraphNodeParams graph;

2123 hipEventWaitNodeParams eventWait;

2124 hipEventRecordNodeParams eventRecord;

2125 hipExternalSemaphoreSignalNodeParams extSemSignal;

2126 hipExternalSemaphoreWaitNodeParams extSemWait;

2127 hipMemAllocNodeParams alloc;

2128 hipMemFreeNodeParams free;

2129 };

2130

2131 long long reserved2;

2132} hipGraphNodeParams;

2133

2137#define hipGraphKernelNodePortDefault 0

2138

2142#define hipGraphKernelNodePortLaunchCompletion 2

2143

2149#define hipGraphKernelNodePortProgrammatic 1

2150

2151typedef enum hipGraphDependencyType {

2152 hipGraphDependencyTypeDefault = 0,

2153 hipGraphDependencyTypeProgrammatic = 1

2154} hipGraphDependencyType;

2155

2156typedef struct hipGraphEdgeData {

2157 unsigned char

2158 from_port;

2165 unsigned char reserved[5];

2166 unsigned char

2167 to_port;

2168 unsigned char type;

2169} hipGraphEdgeData;

2170

2171

2175typedef struct hipLaunchAttribute_st {

2176 hipLaunchAttributeID id;

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

2178 union {

2179 hipLaunchAttributeValue val;

2180 hipLaunchAttributeValue value;

2181 };

2182} hipLaunchAttribute;

2183

2187typedef struct hipLaunchConfig_st {

2188 dim3 gridDim;

2189 dim3 blockDim;

2190 size_t dynamicSmemBytes;

2191 hipStream_t stream;

2192 hipLaunchAttribute* attrs;

2193 unsigned int numAttrs;

2194} hipLaunchConfig_t;

2195

2199typedef struct HIP_LAUNCH_CONFIG_st {

2200 unsigned int gridDimX;

2201 unsigned int gridDimY;

2202 unsigned int gridDimZ;

2203 unsigned int blockDimX;

2204 unsigned int blockDimY;

2205 unsigned int blockDimZ;

2206 unsigned int sharedMemBytes;

2207 hipStream_t hStream;

2208 hipLaunchAttribute* attrs;

2209 unsigned int numAttrs;

2210} HIP_LAUNCH_CONFIG;

2211

2215typedef struct hipArrayMemoryRequirements {

2216 size_t alignment;

2217 size_t size;

2218} hipArrayMemoryRequirements;

2219

2223typedef enum hipMemRangeHandleType {

2224 hipMemRangeHandleTypeDmaBufFd = 0x1,

2225 hipMemRangeHandleTypeMax = 0x7fffffff

2226} hipMemRangeHandleType;

2227

2231typedef enum hipMemRangeFlags {

2232 hipMemRangeFlagDmaBufMappingTypePcie = 0x1,

2233 hipMemRangeFlagsMax = 0x7fffffff

2234} hipMemRangeFlags;

2235

2236

2237// Doxygen end group GlobalDefs

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

2270hipError_t hipInit(unsigned int flags);

2271

2289hipError_t hipDriverGetVersion(int* driverVersion);

2304hipError_t hipRuntimeGetVersion(int* runtimeVersion);

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

2313

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

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

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

2357hipError_t hipDeviceGetLuid(char* luid, unsigned int* deviceNodeMask, hipDevice_t device);

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

2368 int dstDevice);

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

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

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

2394// doxygen end initialization

2413hipError_t hipDeviceSynchronize(void);

2425hipError_t hipDeviceReset(void);

2457hipError_t hipSetDevice(int deviceId);

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

2484hipError_t hipGetDevice(int* deviceId);

2497hipError_t hipGetDeviceCount(int* count);

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

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

2544hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool);

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

2565

2566// hipDeviceProp_t and hipGetDeviceProperties/hipChooseDevice are versioned.

2567// See HIP_FORCE_API_VERSION in hip_common.h.

2568

2569#if HIP_FORCE_API_VERSION >= 600

2570

2571hipError_t hipGetDevicePropertiesR0600(hipDeviceProp_tR0600* prop, int deviceId);

2572

2586static inline hipError_t hipGetDeviceProperties(hipDeviceProp_t* prop, int deviceId) {

2587 return hipGetDevicePropertiesR0600(prop, deviceId);

2588}

2589

2590#endif

2591

2592

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

2610 int device);

2622hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig);

2633hipError_t hipDeviceGetCacheConfig(hipFuncCache_t* cacheConfig);

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

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

2679hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig* pConfig);

2687hipError_t hipGetDeviceFlags(unsigned int* flags);

2699hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config);

2731hipError_t hipSetDeviceFlags(unsigned flags);

2732

2733#if HIP_FORCE_API_VERSION >= 600

2734hipError_t hipChooseDeviceR0600(int* device, const hipDeviceProp_tR0600* prop);

2735

2744static inline hipError_t hipChooseDevice(int* device, const hipDeviceProp_t* prop) {

2745 return hipChooseDeviceR0600(device, prop);

2746}

2747

2748#endif

2749

2774hipError_t hipInitDevice(int device, unsigned int deviceFlags, unsigned int flags);

2775

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

2790 uint32_t* hopcount);

2791// TODO: implement IPC apis

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

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

2869hipError_t hipIpcCloseMemHandle(void* devPtr);

2870

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

2888

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

2908

2909// end doxygen Device

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

2934

2950hipError_t hipKernelSetAttribute(hipFunction_attribute attrib, int value, hipKernel_t kernel, hipDevice_t dev);

2951

2960hipError_t hipKernelGetFunction(hipFunction_t* pFunc, hipKernel_t kernel);

2961

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

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

2988// doxygen end execution

3010hipError_t hipGetLastError(void);

3011

3023hipError_t hipExtGetLastError(void);

3024

3035hipError_t hipPeekAtLastError(void);

3044const char* hipGetErrorName(hipError_t hip_error);

3053const char* hipGetErrorString(hipError_t hipError);

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

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

3074// end doxygen Error

3107hipError_t hipStreamCreate(hipStream_t* stream);

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

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

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

3187hipError_t hipStreamDestroy(hipStream_t stream);

3203hipError_t hipStreamQuery(hipStream_t stream);

3225hipError_t hipStreamSynchronize(hipStream_t stream);

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

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

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

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

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

3314hipError_t hipExtStreamCreateWithCUMask(hipStream_t* stream, uint32_t cuMaskSize,

3315 const uint32_t* cuMask);

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

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

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

3349 unsigned int flags);

3350

3358hipError_t hipStreamSetAttribute(hipStream_t stream, hipStreamAttrID attr,

3359 const hipStreamAttrValue* value);

3360

3368hipError_t hipStreamGetAttribute(hipStream_t stream, hipStreamAttrID attr,

3369 hipStreamAttrValue* value_out);

3370

3377hipError_t hipStreamCopyAttributes(hipStream_t dst, hipStream_t src);

3378

3379// end doxygen Stream

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

3428 uint32_t mask __dparm(0xFFFFFFFF));

3429

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

3467 uint64_t mask __dparm(0xFFFFFFFFFFFFFFFF));

3468

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

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

3511

3531hipError_t hipStreamBatchMemOp(hipStream_t stream, unsigned int count,

3532 hipStreamBatchMemOpParams* paramArray, unsigned int flags);

3533

3551hipError_t hipGraphAddBatchMemOpNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

3552 const hipGraphNode_t* dependencies, size_t numDependencies,

3553 const hipBatchMemOpNodeParams* nodeParams);

3554

3575hipError_t hipGraphBatchMemOpNodeGetParams(hipGraphNode_t hNode,

3576 hipBatchMemOpNodeParams* nodeParams_out);

3577

3595hipError_t hipGraphBatchMemOpNodeSetParams(hipGraphNode_t hNode,

3596 hipBatchMemOpNodeParams* nodeParams);

3597

3617hipError_t hipGraphExecBatchMemOpNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

3618 const hipBatchMemOpNodeParams* nodeParams);

3619

3620// end doxygen Stream Memory Operations

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

3668hipError_t hipEventCreate(hipEvent_t* event);

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

3706 unsigned int flags __dparm(0));

3737#ifdef __cplusplus

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

3739#else

3740hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream);

3741#endif

3758hipError_t hipEventDestroy(hipEvent_t event);

3777hipError_t hipEventSynchronize(hipEvent_t event);

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

3823hipError_t hipEventQuery(hipEvent_t event);

3824// end doxygen Events

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

3856 hipDeviceptr_t ptr);

3857

3858

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

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

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

3911 void** data, hipDeviceptr_t ptr);

3935hipError_t hipImportExternalSemaphore(hipExternalSemaphore_t* extSem_out,

3936 const hipExternalSemaphoreHandleDesc* semHandleDesc);

3952hipError_t hipSignalExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

3953 const hipExternalSemaphoreSignalParams* paramsArray,

3954 unsigned int numExtSems, hipStream_t stream);

3970hipError_t hipWaitExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

3971 const hipExternalSemaphoreWaitParams* paramsArray,

3972 unsigned int numExtSems, hipStream_t stream);

3986hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem);

3987

3999hipError_t hipImportExternalMemory(hipExternalMemory_t* extMem_out,

4000 const hipExternalMemoryHandleDesc* memHandleDesc);

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

4013 const hipExternalMemoryBufferDesc* bufferDesc);

4023hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem);

4038hipError_t hipExternalMemoryGetMappedMipmappedArray(

4039 hipMipmappedArray_t* mipmap, hipExternalMemory_t extMem,

4040 const hipExternalMemoryMipmappedArrayDesc* mipmapDesc);

4041// end of external resource

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

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

4079

4080

4103HIP_DEPRECATED("use hipHostMalloc instead")

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

4117HIP_DEPRECATED("use hipHostMalloc instead")

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

4119// end doxygen deprecated management memory

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

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

4192 unsigned int flags __dparm(hipMemAttachGlobal));

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

4206 hipStream_t stream __dparm(0));

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

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

4222

4239hipError_t hipMemPrefetchBatchAsync(void** dev_ptrs, size_t* sizes, size_t count,

4240 hipMemLocation* prefetch_locs, size_t* prefetch_loc_idxs,

4241 size_t num_prefetch_locs, unsigned long long flags,

4242 hipStream_t stream);

4267hipError_t hipMemDiscardBatchAsync(void** dev_ptrs, size_t* sizes, size_t count,

4268 unsigned long long flags, hipStream_t stream);

4289hipError_t hipDrvMemDiscardBatchAsync(hipDeviceptr_t* dptrs, size_t* sizes, size_t count,

4290 unsigned long long flags, hipStream_t stream);

4320hipError_t hipMemDiscardAndPrefetchBatchAsync(void** dptrs, size_t* sizes, size_t count,

4321 hipMemLocation* prefetchLocs,

4322 size_t* prefetchLocIdxs,

4323 size_t numPrefetchLocs,

4324 unsigned long long flags, hipStream_t stream);

4343hipError_t hipDrvMemDiscardAndPrefetchBatchAsync(hipDeviceptr_t* dptrs, size_t* sizes, size_t count,

4344 hipMemLocation* prefetchLocs,

4345 size_t* prefetchLocIdxs,

4346 size_t numPrefetchLocs,

4347 unsigned long long flags, hipStream_t stream);

4348

4349// Deprecated since 800. Introduced in 700.

4350#if (HIP_FORCE_API_VERSION >= 700 && HIP_FORCE_API_VERSION < 800) || defined(HIP_ABI_IMPL)

4351

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

4372 hipMemLocation location);

4373

4374#endif

4375

4376// Deprecated since 800.

4377#if HIP_FORCE_API_VERSION < 800 || defined(HIP_ABI_IMPL)

4378

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

4399

4400#endif

4401

4402// Latest

4403#if HIP_FORCE_API_VERSION >= 800 && !defined(HIP_ABI_IMPL)

4404

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

4406 hipMemLocation location);

4407

4428static inline hipError_t hipMemAdvise(const void* dev_ptr, size_t count, hipMemoryAdvise advice,

4429 hipMemLocation location) {

4430 return hipMemAdvise_v2(dev_ptr, count, advice, location);

4431}

4432

4433#endif

4434

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

4450 const void* dev_ptr, size_t count);

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

4468 hipMemRangeAttribute* attributes, size_t num_attributes,

4469 const void* dev_ptr, size_t count);

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

4486 unsigned int flags __dparm(hipMemAttachSingle));

4487// end doxygen Managed Memory

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

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

4600hipError_t hipMemPoolTrimTo(hipMemPool_t mem_pool, size_t min_bytes_to_hold);

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

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

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

4699 size_t count);

4719hipError_t hipMemPoolGetAccess(hipMemAccessFlags* flags, hipMemPool_t mem_pool,

4720 hipMemLocation* location);

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

4773hipError_t hipMemPoolDestroy(hipMemPool_t mem_pool);

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

4810 hipStream_t stream);

4837hipError_t hipMemPoolExportToShareableHandle(void* shared_handle, hipMemPool_t mem_pool,

4838 hipMemAllocationHandleType handle_type,

4839 unsigned int flags);

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

4864 hipMemAllocationHandleType handle_type,

4865 unsigned int flags);

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

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

4915 hipMemPoolPtrExportData* export_data);

4921hipError_t hipMemSetMemPool(hipMemLocation* location, hipMemAllocationType type, hipMemPool_t pool);

4927hipError_t hipMemGetMemPool(hipMemPool_t* pool, hipMemLocation* location,

4928 hipMemAllocationType type);

4929

4941hipError_t hipMemGetDefaultMemPool(hipMemPool_t* memPool, hipMemLocation* location,

4942 hipMemAllocationType type);

4943

4944// Doxygen end of Stream Ordered Memory Allocator

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

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

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

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

5049hipError_t hipHostUnregister(void* hostPtr);

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

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

5092 unsigned int elementSizeBytes);

5106hipError_t hipFree(void* ptr);

5118hipError_t hipFreeHost(void* ptr);

5135hipError_t hipHostFree(void* ptr);

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

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

5184 hipStream_t stream);

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

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

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

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

5258 size_t ByteCount);

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

5278 size_t ByteCount);

5279

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

5300 size_t srcOffset, size_t ByteCount);

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

5320 hipStream_t stream);

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

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

5359 hipStream_t stream);

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

5380 size_t ByteCount, hipStream_t stream);

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

5401 size_t ByteCount, hipStream_t stream);

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

5419 const char* name);

5420

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

5431

5432

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

5443

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

5464 hipDriverProcAddressQueryResult* symbolStatus);

5465

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

5488 size_t offset __dparm(0),

5489 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice));

5490

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

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

5506

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

5520 size_t offset __dparm(0),

5521 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost));

5522

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

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

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

5567 hipStream_t stream __dparm(0));

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

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

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

5604 hipStream_t stream __dparm(0));

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

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

5631 hipStream_t stream __dparm(0));

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

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

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

5674 hipStream_t stream __dparm(0));

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

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

5698 hipStream_t stream __dparm(0));

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

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

5718 hipStream_t stream __dparm(0));

5719

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

5732 size_t height);

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

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

5747

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

5760 size_t height);

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

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

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

5787 size_t height);

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

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

5802

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

5820

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

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

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

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

5867hipError_t hipArrayDestroy(hipArray_t array);

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

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

5898hipError_t hipFreeArray(hipArray_t array);

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

5911 struct hipExtent extent, unsigned int flags);

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

5925 hipArray_t array);

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

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

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

5997 size_t height, hipMemcpyKind kind);

6007hipError_t hipMemcpyParam2D(const hip_Memcpy2D* pCopy);

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

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

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

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

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

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

6099 size_t spitch, size_t width, size_t height, hipMemcpyKind kind,

6100 hipStream_t stream __dparm(0));

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

6120 hipArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc,

6121 size_t width, size_t height, hipMemcpyKind kind);

6140HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6142 size_t count, hipMemcpyKind kind);

6161HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6163 size_t count, hipMemcpyKind kind);

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

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

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

6202 size_t hOffset, size_t width, size_t height,

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

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

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

6242hipError_t hipMemcpy3D(const struct hipMemcpy3DParms* p);

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

6265hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D* pCopy);

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

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

6291

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

6308 hipMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs,

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

6310

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

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

6325

6334hipError_t hipMemcpy3DPeer(hipMemcpy3DPeerParms* p);

6335

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

6345

6361hipError_t hipMipmappedArrayGetMemoryRequirements(hipArrayMemoryRequirements* memoryRequirements,

6362 hipMipmappedArray_t mipmap, hipDevice_t device);

6363// doxygen end Memory

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

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

6424hipError_t hipDeviceDisablePeerAccess(int peerDeviceId);

6425

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

6438 size_t sizeBytes);

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

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

6453

6454// doxygen end PeerToPeer

6475hipError_t hipDeviceGetDevResource(hipDevice_t device, hipDevResource* resource,

6476 hipDevResourceType type);

6477

6493hipError_t hipDevSmResourceSplitByCount(hipDevResource* result, unsigned int* nbGroups,

6494 const hipDevResource* input, hipDevResource* remainder,

6495 unsigned int flags, unsigned int minCount);

6496

6513hipError_t hipDevSmResourceSplit(hipDevResource* result, unsigned int nbGroups,

6514 const hipDevResource* input, hipDevResource* remainder,

6515 unsigned int flags,

6516 hipDevSmResourceGroupParams* groupParams);

6517

6528hipError_t hipDevResourceGenerateDesc(hipDevResourceDesc_t* phDesc, hipDevResource* resources,

6529 unsigned int nbResources);

6530

6542hipError_t hipGreenCtxCreate(hipExecutionCtx_t* ctx, hipDevResourceDesc_t desc, int device,

6543 unsigned int flags);

6544

6552hipError_t hipExecutionCtxDestroy(hipExecutionCtx_t ctx);

6553

6562hipError_t hipDeviceGetExecutionCtx(hipExecutionCtx_t* ctx, int device);

6563

6574hipError_t hipExecutionCtxStreamCreate(hipStream_t* stream, hipExecutionCtx_t greenctx,

6575 unsigned int flags, int priority);

6576

6586hipError_t hipExecutionCtxGetDevResource(hipExecutionCtx_t ctx, hipDevResource* resource,

6587 hipDevResourceType type);

6588

6597hipError_t hipExecutionCtxGetDevice(int* device, hipExecutionCtx_t ctx);

6598

6607hipError_t hipExecutionCtxGetId(hipExecutionCtx_t ctx, unsigned long long* ctxId);

6608

6618hipError_t hipStreamGetDevResource(hipStream_t hStream, hipDevResource* resource,

6619 hipDevResourceType type);

6620

6629hipError_t hipExecutionCtxRecordEvent(hipExecutionCtx_t ctx, hipEvent_t event);

6630

6638hipError_t hipExecutionCtxSynchronize(hipExecutionCtx_t ctx);

6639

6648hipError_t hipExecutionCtxWaitEvent(hipExecutionCtx_t ctx, hipEvent_t event);

6690HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6705HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6706hipError_t hipCtxDestroy(hipCtx_t ctx);

6720HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6721hipError_t hipCtxPopCurrent(hipCtx_t* ctx);

6735HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6736hipError_t hipCtxPushCurrent(hipCtx_t ctx);

6750HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6751hipError_t hipCtxSetCurrent(hipCtx_t ctx);

6765HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6766hipError_t hipCtxGetCurrent(hipCtx_t* ctx);

6780HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6781hipError_t hipCtxGetDevice(hipDevice_t* device);

6802HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6820HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6821hipError_t hipCtxGetCacheConfig(hipFuncCache_t* cacheConfig);

6838HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6839hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig);

6856HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6857hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config);

6874HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6875hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig* pConfig);

6890HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6891hipError_t hipCtxSynchronize(void);

6905HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6906hipError_t hipCtxGetFlags(unsigned int* flags);

6929HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6950HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6951hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx);

6952

6968HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6985HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6986hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev);

7001HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7016HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7017hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev);

7032HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7034// doxygen end Context Management

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

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

7082hipError_t hipModuleUnload(hipModule_t module);

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

7094

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

7105

7116hipError_t hipModuleEnumerateFunctions(hipFunction_t* functions, unsigned int numFunctions,

7117 hipModule_t mod);

7118

7146hipError_t hipKernelGetAttribute(int* pi, hipFunction_attribute attrib, hipKernel_t kernel,

7147 hipDevice_t dev);

7148

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

7163 void** jitOptionsValues, unsigned int numJitOptions,

7164 hipLibraryOption* libraryOptions, void** libraryOptionValues,

7165 unsigned int numLibraryOptions);

7166

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

7181 hipJitOption* jitOptions, void** jitOptionsValues,

7182 unsigned int numJitOptions, hipLibraryOption* libraryOptions,

7183 void** libraryOptionValues, unsigned int numLibraryOptions);

7184

7191hipError_t hipLibraryUnload(hipLibrary_t library);

7192

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

7202

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

7211

7226hipError_t hipLibraryGetGlobal(void** dptr, size_t* bytes, hipLibrary_t library,

7227 const char* name);

7228

7245hipError_t hipLibraryGetManaged(void** dptr, size_t* bytes, hipLibrary_t library,

7246 const char* name);

7247

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

7257 hipLibrary_t library);

7258

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

7267

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

7276

7287hipError_t hipKernelGetParamInfo(hipKernel_t kernel, size_t paramIndex, size_t* paramOffset,

7288 size_t* paramSize);

7289

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

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

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

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

7331 hipDriverEntryPointQueryResult* driverStatus);

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

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

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

7379 hipJitOption* options, void** optionValues);

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

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

7400 void** optionValues);

7401

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

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

7420

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

7436

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

7449 hipLinkState_t* stateOut);

7458hipError_t hipLinkDestroy(hipLinkState_t state);

7459

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

7489 unsigned int gridDimZ, unsigned int blockDimX,

7490 unsigned int blockDimY, unsigned int blockDimZ,

7491 unsigned int sharedMemBytes, hipStream_t stream,

7492 void** kernelParams, void** extra);

7521hipError_t hipModuleLaunchCooperativeKernel(hipFunction_t f, unsigned int gridDimX,

7522 unsigned int gridDimY, unsigned int gridDimZ,

7523 unsigned int blockDimX, unsigned int blockDimY,

7524 unsigned int blockDimZ, unsigned int sharedMemBytes,

7525 hipStream_t stream, void** kernelParams);

7540hipError_t hipModuleLaunchCooperativeKernelMultiDevice(hipFunctionLaunchParams* launchParamsList,

7541 unsigned int numDevices, unsigned int flags);

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

7563 void** kernelParams, unsigned int sharedMemBytes,

7564 hipStream_t stream);

7576hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList, int numDevices,

7577 unsigned int flags);

7578

7579// Doxygen end group ModuleCooperativeG

7593hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList, int numDevices,

7594 unsigned int flags);

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

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

7625 void** extra);

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

7641 hipMemRangeHandleType handleType,

7642 unsigned long long flags);

7643// doxygen end Module

7671// TODO - Match CUoccupancyB2DSize

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

7673 size_t dynSharedMemPerBlk, int blockSizeLimit);

7689// TODO - Match CUoccupancyB2DSize

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

7691 hipFunction_t f,

7692 size_t dynSharedMemPerBlk,

7693 int blockSizeLimit, unsigned int flags);

7703hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, hipFunction_t f,

7704 int blockSize,

7705 size_t dynSharedMemPerBlk);

7716hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

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

7728 int blockSize, size_t dynSharedMemPerBlk);

7739hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

7741 unsigned int flags __dparm(hipOccupancyDefault));

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

7757 size_t dynSharedMemPerBlk, int blockSizeLimit);

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

7774 int numBlocks, int blockSize);

7785hipError_t hipOccupancyMaxActiveClusters(int* numClusters, const void* f,

7786 const hipLaunchConfig_t* config);

7797hipError_t hipOccupancyMaxPotentialClusterSize(int* clusterSize, const void* f,

7798 const hipLaunchConfig_t* config);

7799

7800// doxygen end Occupancy

7814// TODO - expand descriptions:

7821HIP_DEPRECATED("use roctracer/rocTX instead")

7822hipError_t hipProfilerStart();

7829HIP_DEPRECATED("use roctracer/rocTX instead")

7830hipError_t hipProfilerStop();

7831// doxygen end profiler

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

7859 hipStream_t stream __dparm(0));

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

7879hipError_t hipLaunchByPtr(const void* func);

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

7897 hipStream_t stream __dparm(0));

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

7918 hipStream_t* stream);

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

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

7937 hipStream_t stream __dparm(0));

7938

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

7966

7974hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D* pCopy);

7975// TODO: Move this to hip_ext.h

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

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

7999 hipEvent_t startEvent, hipEvent_t stopEvent, int flags);

8000// doxygen end Clang launch

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

8027 const hipTextureDesc* pTexDesc,

8028 const struct hipResourceViewDesc* pResViewDesc);

8029

8038hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject);

8039

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

8050

8060hipError_t hipGetTextureObjectResourceDesc(hipResourceDesc* pResDesc,

8061 hipTextureObject_t textureObject);

8062

8072hipError_t hipGetTextureObjectResourceViewDesc(struct hipResourceViewDesc* pResViewDesc,

8073 hipTextureObject_t textureObject);

8074

8084hipError_t hipGetTextureObjectTextureDesc(hipTextureDesc* pTexDesc,

8085 hipTextureObject_t textureObject);

8086

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

8099 const HIP_TEXTURE_DESC* pTexDesc,

8100 const HIP_RESOURCE_VIEW_DESC* pResViewDesc);

8101

8110hipError_t hipTexObjectDestroy(hipTextureObject_t texObject);

8111

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

8122

8132hipError_t hipTexObjectGetResourceViewDesc(HIP_RESOURCE_VIEW_DESC* pResViewDesc,

8133 hipTextureObject_t texObject);

8134

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

8145

8160hipError_t hipMallocMipmappedArray(hipMipmappedArray_t* mipmappedArray,

8161 const struct hipChannelFormatDesc* desc, struct hipExtent extent,

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

8163

8174hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray);

8175

8188hipError_t hipGetMipmappedArrayLevel(hipArray_t* levelArray,

8189 hipMipmappedArray_const_t mipmappedArray, unsigned int level);

8190

8202hipError_t hipMipmappedArrayCreate(hipMipmappedArray_t* pHandle,

8203 HIP_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc,

8204 unsigned int numMipmapLevels);

8205

8216hipError_t hipMipmappedArrayDestroy(hipMipmappedArray_t hMipmappedArray);

8217

8230hipError_t hipMipmappedArrayGetLevel(hipArray_t* pLevelArray, hipMipmappedArray_t hMipMappedArray,

8231 unsigned int level);

8232

8251HIP_DEPRECATED(HIP_DEPRECATED_MSG)

8252hipError_t hipBindTextureToMipmappedArray(const textureReference* tex,

8253 hipMipmappedArray_const_t mipmappedArray,

8254 const hipChannelFormatDesc* desc);

8255

8266HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8268

8279HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8281

8293HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8295

8307HIP_DEPRECATED(HIP_DEPRECATED_MSG)

8308hipError_t hipTexRefSetAddressMode(textureReference* texRef, int dim,

8309 enum hipTextureAddressMode am);

8322HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8335HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8348HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8362HIP_DEPRECATED(HIP_DEPRECATED_MSG)

8363hipError_t hipTexRefSetFormat(textureReference* texRef, hipArray_Format fmt,

8364 int NumPackedComponents);

8379HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

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

8398HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

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

8401 size_t pitch);

8414HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8416 const hipChannelFormatDesc* desc);

8428HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8440HIP_DEPRECATED(HIP_DEPRECATED_MSG)

8441hipError_t hipUnbindTexture(const textureReference* tex);

8453HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8467HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8469 int dim);

8481HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8494HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8508HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8510 const textureReference* texRef);

8522HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8535HIP_DEPRECATED(HIP_DEPRECATED_MSG)

8536hipError_t hipTexRefGetMipmapFilterMode(enum hipTextureFilterMode* pfm,

8537 const textureReference* texRef);

8549HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8563HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8565 const textureReference* texRef);

8577HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8592HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8594 size_t bytes);

8608HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8610 hipDeviceptr_t dptr, size_t Pitch);

8622HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8635HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8648HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8661HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8675HIP_DEPRECATED(HIP_DEPRECATED_MSG)

8676hipError_t hipTexRefSetMipmapLevelClamp(textureReference* texRef, float minMipMapLevelClamp,

8677 float maxMipMapLevelClamp);

8690HIP_DEPRECATED(HIP_DEPRECATED_MSG)

8691hipError_t hipTexRefSetMipmappedArray(textureReference* texRef,

8692 struct hipMipmappedArray* mipmappedArray, unsigned int Flags);

8693

8694// doxygen end deprecated texture management

8699// doxygen end Texture management

8711// This group is for HIPrtc

8712

8713// doxygen end Runtime

8732const char* hipApiName(uint32_t id);

8741const char* hipKernelNameRef(const hipFunction_t f);

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

8760int hipGetStreamDeviceId(hipStream_t stream);

8761

8762// doxygen end Callback

8784hipError_t hipStreamBeginCapture(hipStream_t stream, hipStreamCaptureMode mode);

8785

8805hipError_t hipStreamBeginCaptureToGraph(hipStream_t stream, hipGraph_t graph,

8806 const hipGraphNode_t* dependencies,

8807 const hipGraphEdgeData* dependencyData,

8808 size_t numDependencies, hipStreamCaptureMode mode);

8809

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

8820

8831hipError_t hipStreamGetCaptureInfo(hipStream_t stream, hipStreamCaptureStatus* pCaptureStatus,

8832 unsigned long long* pId);

8833

8848hipError_t hipStreamGetCaptureInfo_v2(hipStream_t stream, hipStreamCaptureStatus* captureStatus_out,

8849 unsigned long long* id_out __dparm(0),

8850 hipGraph_t* graph_out __dparm(0),

8851 const hipGraphNode_t** dependencies_out __dparm(0),

8852 size_t* numDependencies_out __dparm(0));

8853

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

8864

8876hipError_t hipStreamUpdateCaptureDependencies(hipStream_t stream, hipGraphNode_t* dependencies,

8877 size_t numDependencies,

8878 unsigned int flags __dparm(0));

8879

8887hipError_t hipThreadExchangeStreamCaptureMode(hipStreamCaptureMode* mode);

8888

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

8899

8908hipError_t hipGraphDestroy(hipGraph_t graph);

8909

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

8921 const hipGraphNode_t* to, size_t numDependencies);

8922

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

8934 const hipGraphNode_t* to, size_t numDependencies);

8935

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

8952 size_t* numEdges);

8953

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

8969

8984hipError_t hipGraphGetRootNodes(hipGraph_t graph, hipGraphNode_t* pRootNodes,

8985 size_t* pNumRootNodes);

8986

9001hipError_t hipGraphNodeGetDependencies(hipGraphNode_t node, hipGraphNode_t* pDependencies,

9002 size_t* pNumDependencies);

9003

9019hipError_t hipGraphNodeGetDependentNodes(hipGraphNode_t node, hipGraphNode_t* pDependentNodes,

9020 size_t* pNumDependentNodes);

9021

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

9031

9039hipError_t hipGraphDestroyNode(hipGraphNode_t node);

9040

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

9050

9060hipError_t hipGraphNodeFindInClone(hipGraphNode_t* pNode, hipGraphNode_t originalNode,

9061 hipGraph_t clonedGraph);

9062

9076hipError_t hipGraphInstantiate(hipGraphExec_t* pGraphExec, hipGraph_t graph,

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

9078

9089hipError_t hipGraphInstantiateWithFlags(hipGraphExec_t* pGraphExec, hipGraph_t graph,

9090 unsigned long long flags);

9091

9101hipError_t hipGraphInstantiateWithParams(hipGraphExec_t* pGraphExec, hipGraph_t graph,

9102 hipGraphInstantiateParams* instantiateParams);

9111hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream);

9112

9121hipError_t hipGraphUpload(hipGraphExec_t graphExec, hipStream_t stream);

9122

9134hipError_t hipGraphAddNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9135 const hipGraphNode_t* pDependencies, size_t numDependencies,

9136 hipGraphNodeParams* nodeParams);

9137

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

9147

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

9158

9169hipError_t hipGraphExecNodeSetParams(hipGraphExec_t graphExec, hipGraphNode_t node,

9170 hipGraphNodeParams* nodeParams);

9171

9180hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec);

9181

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

9194hipError_t hipGraphExecUpdate(hipGraphExec_t hGraphExec, hipGraph_t hGraph,

9195 hipGraphNode_t* hErrorNode_out,

9196 hipGraphExecUpdateResult* updateResult_out);

9197

9209hipError_t hipGraphAddKernelNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9210 const hipGraphNode_t* pDependencies, size_t numDependencies,

9211 const hipKernelNodeParams* pNodeParams);

9212

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

9222

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

9232

9242hipError_t hipGraphExecKernelNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

9243 const hipKernelNodeParams* pNodeParams);

9244

9257hipError_t hipDrvGraphAddMemcpyNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

9258 const hipGraphNode_t* dependencies, size_t numDependencies,

9259 const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);

9271hipError_t hipGraphAddMemcpyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9272 const hipGraphNode_t* pDependencies, size_t numDependencies,

9273 const hipMemcpy3DParms* pCopyParams);

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

9283

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

9293

9303hipError_t hipGraphKernelNodeSetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

9304 const hipKernelNodeAttrValue* value);

9314hipError_t hipGraphKernelNodeGetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

9315 hipKernelNodeAttrValue* value);

9325hipError_t hipGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

9326 hipMemcpy3DParms* pNodeParams);

9327

9342hipError_t hipGraphAddMemcpyNode1D(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9343 const hipGraphNode_t* pDependencies, size_t numDependencies,

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

9345

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

9358 size_t count, hipMemcpyKind kind);

9359

9373hipError_t hipGraphExecMemcpyNodeSetParams1D(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

9375 hipMemcpyKind kind);

9376

9392hipError_t hipGraphAddMemcpyNodeFromSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9393 const hipGraphNode_t* pDependencies,

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

9395 size_t count, size_t offset, hipMemcpyKind kind);

9396

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

9410 size_t count, size_t offset, hipMemcpyKind kind);

9411

9426hipError_t hipGraphExecMemcpyNodeSetParamsFromSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

9428 size_t offset, hipMemcpyKind kind);

9429

9445hipError_t hipGraphAddMemcpyNodeToSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9446 const hipGraphNode_t* pDependencies,

9447 size_t numDependencies, const void* symbol,

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

9449 hipMemcpyKind kind);

9450

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

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

9465 hipMemcpyKind kind);

9466

9467

9481hipError_t hipGraphExecMemcpyNodeSetParamsToSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

9482 const void* symbol, const void* src,

9483 size_t count, size_t offset, hipMemcpyKind kind);

9484

9496hipError_t hipGraphAddMemsetNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9497 const hipGraphNode_t* pDependencies, size_t numDependencies,

9498 const hipMemsetParams* pMemsetParams);

9499

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

9509

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

9519

9529hipError_t hipGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

9530 const hipMemsetParams* pNodeParams);

9531

9543hipError_t hipGraphAddHostNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9544 const hipGraphNode_t* pDependencies, size_t numDependencies,

9545 const hipHostNodeParams* pNodeParams);

9546

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

9556

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

9566

9576hipError_t hipGraphExecHostNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

9577 const hipHostNodeParams* pNodeParams);

9578

9590hipError_t hipGraphAddChildGraphNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9591 const hipGraphNode_t* pDependencies, size_t numDependencies,

9592 hipGraph_t childGraph);

9593

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

9603

9613hipError_t hipGraphExecChildGraphNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

9614 hipGraph_t childGraph);

9615

9626hipError_t hipGraphAddEmptyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9627 const hipGraphNode_t* pDependencies, size_t numDependencies);

9628

9629

9641hipError_t hipGraphAddEventRecordNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9642 const hipGraphNode_t* pDependencies, size_t numDependencies,

9643 hipEvent_t event);

9644

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

9654

9663hipError_t hipGraphEventRecordNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

9664

9674hipError_t hipGraphExecEventRecordNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9675 hipEvent_t event);

9676

9688hipError_t hipGraphAddEventWaitNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9689 const hipGraphNode_t* pDependencies, size_t numDependencies,

9690 hipEvent_t event);

9691

9692

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

9702

9711hipError_t hipGraphEventWaitNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

9712

9722hipError_t hipGraphExecEventWaitNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9723 hipEvent_t event);

9724

9737hipError_t hipGraphAddMemAllocNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9738 const hipGraphNode_t* pDependencies, size_t numDependencies,

9739 hipMemAllocNodeParams* pNodeParams);

9740

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

9750

9762hipError_t hipGraphAddMemFreeNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9763 const hipGraphNode_t* pDependencies, size_t numDependencies,

9764 void* dev_ptr);

9765

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

9775

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

9786

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

9797

9805hipError_t hipDeviceGraphMemTrim(int device);

9806

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

9819 unsigned int initialRefcount, unsigned int flags);

9820

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

9830

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

9840

9851hipError_t hipGraphRetainUserObject(hipGraph_t graph, hipUserObject_t object,

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

9853

9863hipError_t hipGraphReleaseUserObject(hipGraph_t graph, hipUserObject_t object,

9864 unsigned int count __dparm(1));

9865

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

9876

9890hipError_t hipGraphKernelNodeCopyAttributes(hipGraphNode_t hSrc, hipGraphNode_t hDst);

9891

9913hipError_t hipGraphNodeSetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9914 unsigned int isEnabled);

9934hipError_t hipGraphNodeGetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9935 unsigned int* isEnabled);

9936

9948hipError_t hipGraphAddExternalSemaphoresWaitNode(

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

9950 size_t numDependencies, const hipExternalSemaphoreWaitNodeParams* nodeParams);

9951

9963hipError_t hipGraphAddExternalSemaphoresSignalNode(

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

9965 size_t numDependencies, const hipExternalSemaphoreSignalNodeParams* nodeParams);

9974hipError_t hipGraphExternalSemaphoresSignalNodeSetParams(

9975 hipGraphNode_t hNode, const hipExternalSemaphoreSignalNodeParams* nodeParams);

9984hipError_t hipGraphExternalSemaphoresWaitNodeSetParams(

9985 hipGraphNode_t hNode, const hipExternalSemaphoreWaitNodeParams* nodeParams);

9994hipError_t hipGraphExternalSemaphoresSignalNodeGetParams(

9995 hipGraphNode_t hNode, hipExternalSemaphoreSignalNodeParams* params_out);

10004hipError_t hipGraphExternalSemaphoresWaitNodeGetParams(

10005 hipGraphNode_t hNode, hipExternalSemaphoreWaitNodeParams* params_out);

10015hipError_t hipGraphExecExternalSemaphoresSignalNodeSetParams(

10016 hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

10017 const hipExternalSemaphoreSignalNodeParams* nodeParams);

10027hipError_t hipGraphExecExternalSemaphoresWaitNodeSetParams(

10028 hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

10029 const hipExternalSemaphoreWaitNodeParams* nodeParams);

10030

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

10040

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

10050

10063hipError_t hipDrvGraphAddMemsetNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

10064 const hipGraphNode_t* dependencies, size_t numDependencies,

10065 const hipMemsetParams* memsetParams, hipCtx_t ctx);

10066

10078hipError_t hipDrvGraphAddMemFreeNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

10079 const hipGraphNode_t* dependencies, size_t numDependencies,

10080 hipDeviceptr_t dptr);

10081

10092hipError_t hipDrvGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

10093 const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);

10094

10105hipError_t hipDrvGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

10106 const hipMemsetParams* memsetParams, hipCtx_t ctx);

10107

10108// doxygen end graph API

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

10138

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

10152 unsigned long long flags);

10153

10171hipError_t hipMemCreate(hipMemGenericAllocationHandle_t* handle, size_t size,

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

10173

10185hipError_t hipMemExportToShareableHandle(void* shareableHandle,

10186 hipMemGenericAllocationHandle_t handle,

10187 hipMemAllocationHandleType handleType,

10188 unsigned long long flags);

10189

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

10201

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

10214 hipMemAllocationGranularity_flags option);

10215

10225hipError_t hipMemGetAllocationPropertiesFromHandle(hipMemAllocationProp* prop,

10226 hipMemGenericAllocationHandle_t handle);

10227

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

10239 hipMemAllocationHandleType shHandleType);

10240

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

10254 unsigned long long flags);

10255

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

10265 hipStream_t stream);

10266

10276hipError_t hipMemRelease(hipMemGenericAllocationHandle_t handle);

10277

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

10288

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

10302

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

10313

10314// doxygen end virtual memory management API

10336hipError_t hipGraphicsMapResources(int count, hipGraphicsResource_t* resources,

10337 hipStream_t stream __dparm(0));

10351hipError_t hipGraphicsSubResourceGetMappedArray(hipArray_t* array, hipGraphicsResource_t resource,

10352 unsigned int arrayIndex, unsigned int mipLevel);

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

10364 hipGraphicsResource_t resource);

10375hipError_t hipGraphicsUnmapResources(int count, hipGraphicsResource_t* resources,

10376 hipStream_t stream __dparm(0));

10385hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource);

10386// doxygen end GraphicsInterop

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

10420hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject);

10421// end of surface

10422

10423

10434hipError_t hipExtEnableLogging();

10445hipError_t hipExtDisableLogging();

10460hipError_t hipExtSetLoggingParams(size_t log_level, size_t log_size, size_t log_mask);

10461

10465#ifdef __cplusplus

10466} /* extern "c" */

10467#endif

10468#ifdef __cplusplus

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

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

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

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

10473 dynSharedMemPerBlk, blockSizeLimit);

10474}

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

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

10477 unsigned int flags = 0) {

10478 (void)flags;

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

10480 dynSharedMemPerBlk, blockSizeLimit);

10481}

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

10483

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

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

10495}

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

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

10508}

10509

10518template <typename T>

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

10520 size_t offset __dparm(0),

10521 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice)) {

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

10523}

10532template <typename T>

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

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

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

10536}

10544template <typename T>

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

10546 size_t offset __dparm(0),

10547 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost)) {

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

10549}

10557template <typename T>

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

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

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

10561}

10562

10574template <class T>

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

10576 size_t dynSharedMemPerBlk) {

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

10578 blockSize, dynSharedMemPerBlk);

10579}

10593template <class T> inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

10595 return hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

10597}

10620template <typename UnaryFunction, class T>

10621static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(

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

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

10624 if (min_grid_size == nullptr || block_size == nullptr ||

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

10626 return hipErrorInvalidValue;

10627 }

10628

10629 int dev;

10630 hipError_t status;

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

10632 return status;

10633 }

10634

10635 int max_threads_per_cu;

10636 if ((status = hipDeviceGetAttribute(&max_threads_per_cu,

10637 hipDeviceAttributeMaxThreadsPerMultiProcessor, dev)) !=

10638 hipSuccess) {

10639 return status;

10640 }

10641

10642 int warp_size;

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

10644 return status;

10645 }

10646

10647 int max_cu_count;

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

10649 hipSuccess) {

10650 return status;

10651 }

10652

10653 struct hipFuncAttributes attr;

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

10655 return status;

10656 }

10657

10658 // Initial limits for the execution

10659 const int func_max_threads_per_block = attr.maxThreadsPerBlock;

10660 if (block_size_limit == 0) {

10661 block_size_limit = func_max_threads_per_block;

10662 }

10663

10664 if (func_max_threads_per_block < block_size_limit) {

10665 block_size_limit = func_max_threads_per_block;

10666 }

10667

10668 const int block_size_limit_aligned =

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

10670

10671 // For maximum search

10672 int max_threads = 0;

10673 int max_block_size{};

10674 int max_num_blocks{};

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

10676 block_size_check_aligned -= warp_size) {

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

10678 int block_size_check =

10679 (block_size_limit < block_size_check_aligned) ? block_size_limit : block_size_check_aligned;

10680

10681 size_t dyn_smem_size = block_size_to_dynamic_smem_size(block_size_check);

10682 int optimal_blocks;

10683 if ((status = hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

10685 return status;

10686 }

10687

10688 int total_threads = block_size_check * optimal_blocks;

10689 if (total_threads > max_threads) {

10690 max_block_size = block_size_check;

10691 max_num_blocks = optimal_blocks;

10692 max_threads = total_threads;

10693 }

10694

10695 // Break if the logic reached possible maximum

10696 if (max_threads_per_cu == max_threads) {

10697 break;

10698 }

10699 }

10700

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

10702 *min_grid_size = max_num_blocks * max_cu_count;

10703 *block_size = max_block_size;

10704

10705 return status;

10706}

10707

10729template <typename UnaryFunction, class T>

10730static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMem(

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

10732 int block_size_limit = 0) {

10733 return hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(

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

10735}

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

10752 int* blockSize, F kernel,

10753 size_t dynSharedMemPerBlk,

10754 uint32_t blockSizeLimit) {

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

10756 dynSharedMemPerBlk, blockSizeLimit);

10757}

10758

10774template <typename F>

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

10776 int numBlocks, int blockSize) {

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

10778 numBlocks, blockSize);

10779}

10801template <class T>

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

10803 unsigned int sharedMemBytes, hipStream_t stream) {

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

10805 kernelParams, sharedMemBytes, stream);

10806}

10822template <class T>

10823inline hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

10824 unsigned int numDevices,

10825 unsigned int flags = 0) {

10826 return hipLaunchCooperativeKernelMultiDevice(launchParamsList, numDevices, flags);

10827}

10840template <class T>

10841inline hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

10842 unsigned int numDevices,

10843 unsigned int flags = 0) {

10844 return hipExtLaunchMultiKernelMultiDevice(launchParamsList, numDevices, flags);

10845}

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

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

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

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

10863}

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

10879static inline hipError_t

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

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

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

10883}

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

10900static inline hipError_t

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

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

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

10904}

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

10922static inline hipError_t

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

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

10925 size_t height, size_t pitch) {

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

10927}

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

10940static inline hipError_t

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

10942 struct hipChannelFormatDesc desc;

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

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

10945}

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

10959static inline hipError_t

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

10961 const struct hipChannelFormatDesc& desc) {

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

10963}

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

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

10977 hipMipmappedArray_const_t mipmappedArray) {

10978 struct hipChannelFormatDesc desc;

10979 hipArray_t levelArray;

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

10981 if (err != hipSuccess) {

10982 return err;

10983 }

10984 err = hipGetChannelDesc(&desc, levelArray);

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

10986}

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

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

11001 hipMipmappedArray_const_t mipmappedArray,

11002 const struct hipChannelFormatDesc& desc) {

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

11004}

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

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

11017 return hipUnbindTexture(&tex);

11018}

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

11043 hipStream_t stream) {

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

11045}

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

11057 hipMemPool_t mem_pool,

11058 hipStream_t stream) {

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

11060}

11071template <class T>

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

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

11074}

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

11086 hipMemPool_t mem_pool,

11087 hipStream_t stream) {

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

11089}

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

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

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

11106 Params&&... args) {

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

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

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

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

11111}

11117#endif // __cplusplus

11118

11119#ifdef __GNUC__

11120#pragma GCC visibility pop

11121#endif

11122

11123

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

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

11126#else

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

11128#endif

11129

11130

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

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

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

11145}

11157template <class T>

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

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

11160}

11173template <class T>

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

11175 unsigned int flags = hipHostMallocDefault) {

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

11177}

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

11191 unsigned int flags = hipHostAllocDefault) {

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

11193}

11208template <class T>

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

11210 unsigned int flags = hipMemAttachGlobal) {

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

11212}

11213

11214#endif

11215#endif

11216// doxygen end HIP API

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

11221

11222#if USE_PROF_API

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

11224#endif

driver_types.h

err

hipError_t err

Definition hip_runtime_api.h:10943

tex

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

Definition hip_runtime_api.h:10860

size

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

Definition hip_runtime_api.h:10861

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:10902

levelArray

hipArray_t levelArray

Definition hip_runtime_api.h:10979

dim

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

Definition hip_runtime_api.h:10878

mipmappedArray

readMode hipMipmappedArray_const_t mipmappedArray

Definition hip_runtime_api.h:10977

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:10902

devPtr

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

Definition hip_runtime_api.h:10861

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:10881

array

readMode hipArray_const_t array

Definition hip_runtime_api.h:10941

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:10902

hipApiName

const char * hipApiName(uint32_t id)

Returns HIP API name by ID.

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.

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

hipInitDevice

hipError_t hipInitDevice(int device, unsigned int deviceFlags, unsigned int flags)

Initialize the specified device to be used for GPU executions.

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.

hipGetDevicePropertiesR0600

hipError_t hipGetDevicePropertiesR0600(hipDeviceProp_tR0600 *prop, int deviceId)

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.

hipChooseDeviceR0600

hipError_t hipChooseDeviceR0600(int *device, const hipDeviceProp_tR0600 *prop)

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.

hipDeviceGetLuid

hipError_t hipDeviceGetLuid(char *luid, unsigned int *deviceNodeMask, hipDevice_t device)

Returns an LUID and device node mask for the 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:357

hipPointer_attribute

hipPointer_attribute

Definition driver_types.h:631

hipArray_t

struct hipArray * hipArray_t

Definition driver_types.h:59

hipDeviceptr_t

void * hipDeviceptr_t

Definition driver_types.h:30

hipFunction_attribute

hipFunction_attribute

Definition driver_types.h:604

hipArray_const_t

const struct hipArray * hipArray_const_t

Definition driver_types.h:60

hipArray_Format

hipArray_Format

Definition driver_types.h:64

hipResourceType

hipResourceType

Definition driver_types.h:143

hipMemcpyDeviceToHost

@ hipMemcpyDeviceToHost

Device-to-Host Copy.

Definition driver_types.h:360

hipMemcpyHostToDevice

@ hipMemcpyHostToDevice

Host-to-Device Copy.

Definition driver_types.h:359

HIP_ARRAY3D_DESCRIPTOR

Definition driver_types.h:87

HIP_ARRAY_DESCRIPTOR

Definition driver_types.h:77

HIP_MEMCPY3D

Definition driver_types.h:408

HIP_RESOURCE_DESC

Definition driver_types.h:297

HIP_RESOURCE_VIEW_DESC

Definition driver_types.h:342

HIP_TEXTURE_DESC

Definition driver_types.h:175

hip_Memcpy2D

Definition driver_types.h:99

hipChannelFormatDesc

Definition driver_types.h:43

hipExtent

Definition driver_types.h:378

hipMemLocation

Definition driver_types.h:450

hipMemcpy3DBatchOp

Definition driver_types.h:533

hipMemcpy3DParms

Definition driver_types.h:395

hipMemcpy3DPeerParms

Definition driver_types.h:541

hipMemcpyAttributes

Definition driver_types.h:487

hipMipmappedArray

Definition driver_types.h:121

hipPitchedPtr

Definition driver_types.h:369

hipResourceDesc

Definition driver_types.h:270

hipResourceViewDesc

Definition driver_types.h:329

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

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.

hipGetErrorName

const char * hipGetErrorName(hipError_t hip_error)

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.

hipDeviceGetExecutionCtx

hipError_t hipDeviceGetExecutionCtx(hipExecutionCtx_t *ctx, int device)

Returns the default execution context for a device.

hipExecutionCtxStreamCreate

hipError_t hipExecutionCtxStreamCreate(hipStream_t *stream, hipExecutionCtx_t greenctx, unsigned int flags, int priority)

Creates a stream on an execution context with specified flags and priority.

hipGreenCtxCreate

hipError_t hipGreenCtxCreate(hipExecutionCtx_t *ctx, hipDevResourceDesc_t desc, int device, unsigned int flags)

Creates a green context from a resource descriptor.

hipExecutionCtxGetDevice

hipError_t hipExecutionCtxGetDevice(int *device, hipExecutionCtx_t ctx)

Returns the device associated with an execution context.

hipExecutionCtxWaitEvent

hipError_t hipExecutionCtxWaitEvent(hipExecutionCtx_t ctx, hipEvent_t event)

Makes an execution context wait on an event.

hipExecutionCtxSynchronize

hipError_t hipExecutionCtxSynchronize(hipExecutionCtx_t ctx)

Blocks until all work on an execution context has completed.

hipDevResourceGenerateDesc

hipError_t hipDevResourceGenerateDesc(hipDevResourceDesc_t *phDesc, hipDevResource *resources, unsigned int nbResources)

Generates a resource descriptor from one or more device resources.

hipExecutionCtxRecordEvent

hipError_t hipExecutionCtxRecordEvent(hipExecutionCtx_t ctx, hipEvent_t event)

Records an event on an execution context.

hipExecutionCtxDestroy

hipError_t hipExecutionCtxDestroy(hipExecutionCtx_t ctx)

Destroys an execution context.

hipDevSmResourceSplitByCount

hipError_t hipDevSmResourceSplitByCount(hipDevResource *result, unsigned int *nbGroups, const hipDevResource *input, hipDevResource *remainder, unsigned int flags, unsigned int minCount)

Splits SM resources into groups containing the specified number of SMs.

hipDeviceGetDevResource

hipError_t hipDeviceGetDevResource(hipDevice_t device, hipDevResource *resource, hipDevResourceType type)

Gets device resource of a given type for a device.

hipExecutionCtxGetDevResource

hipError_t hipExecutionCtxGetDevResource(hipExecutionCtx_t ctx, hipDevResource *resource, hipDevResourceType type)

Returns the device resource of a given type for an execution context.

hipStreamGetDevResource

hipError_t hipStreamGetDevResource(hipStream_t hStream, hipDevResource *resource, hipDevResourceType type)

Returns the device resource of a given type for a stream.

hipDevSmResourceSplit

hipError_t hipDevSmResourceSplit(hipDevResource *result, unsigned int nbGroups, const hipDevResource *input, hipDevResource *remainder, unsigned int flags, hipDevSmResourceGroupParams *groupParams)

Splits SM resources into structured groups.

hipExecutionCtxGetId

hipError_t hipExecutionCtxGetId(hipExecutionCtx_t ctx, unsigned long long *ctxId)

Returns a unique identifier for an execution context.

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

hipKernelGetFunction

hipError_t hipKernelGetFunction(hipFunction_t *pFunc, hipKernel_t kernel)

Function will be extracted for specific kernel.

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.

hipKernelSetAttribute

hipError_t hipKernelSetAttribute(hipFunction_attribute attrib, int value, hipKernel_t kernel, hipDevice_t dev)

Set attribute for a specific kernel.

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.

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:1128

hipDeviceArch_t::hasSharedInt64Atomics

unsigned hasSharedInt64Atomics

64-bit integer atomics for shared memory.

Definition hip_runtime_api.h:63

hipDeviceProp_t::ECCEnabled

int ECCEnabled

Device has ECC support enabled.

Definition hip_runtime_api.h:320

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::address

hipDeviceptr_t address

Definition hip_runtime_api.h:1139

hipDeviceProp_t::ipcEventSupported

int ipcEventSupported

Device supports IPC events.

Definition hip_runtime_api.h:374

hipGraphNodeParams::type

hipGraphNodeType type

Definition hip_runtime_api.h:2114

hipDeviceProp_t::computePreemptionSupported

int computePreemptionSupported

Is compute preemption supported on the device.

Definition hip_runtime_api.h:346

hipExternalMemoryHandleDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1468

hipExternalSemaphoreHandleDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1507

hipDeviceProp_t::maxTexture1DLinear

int maxTexture1DLinear

Maximum size for 1D textures bound to linear memory.

Definition hip_runtime_api.h:299

hipGraphNodeParams::reserved0

int reserved0[3]

Definition hip_runtime_api.h:2115

hipLaunchAttributeValue::priority

int priority

Definition hip_runtime_api.h:1777

hipFunctionLaunchParams::gridDimX

unsigned int gridDimX

Width(X) of grid in blocks.

Definition hip_runtime_api.h:1437

hipFunctionLaunchParams::blockDimX

unsigned int blockDimX

X dimension of each thread block.

Definition hip_runtime_api.h:1440

hipMemAllocationProp::win32HandleMetaData

void * win32HandleMetaData

Metadata for Win32 handles.

Definition hip_runtime_api.h:1963

hipDeviceProp_t::timelineSemaphoreInteropSupported

int timelineSemaphoreInteropSupported

Indicates external timeline semaphore support.

Definition hip_runtime_api.h:364

hipPointerAttribute_t::device

int device

Definition hip_runtime_api.h:435

hipMemAllocationProp::type

hipMemAllocationType type

Memory allocation type.

Definition hip_runtime_api.h:1957

hipDeviceProp_t::pciBusID

int pciBusID

PCI Bus ID.

Definition hip_runtime_api.h:321

hipArrayMapInfo::flags

unsigned int flags

flags for future use, must be zero now.

Definition hip_runtime_api.h:2068

hipDeviceArch_t::hasSharedInt32Atomics

unsigned hasSharedInt32Atomics

32-bit integer atomics for shared memory.

Definition hip_runtime_api.h:57

hipDeviceProp_t::maxTexture1D

int maxTexture1D

Maximum number of elements in 1D images.

Definition hip_runtime_api.h:297

hipAccessPolicyWindow::hitProp

hipAccessProperty hitProp

hipAccessProperty set for hit

Definition hip_runtime_api.h:1663

hipPointerAttribute_t::hostPointer

void * hostPointer

Definition hip_runtime_api.h:437

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::address

hipDeviceptr_t address

Definition hip_runtime_api.h:1129

hipAccessPolicyWindow::missProp

hipAccessProperty missProp

hipAccessProperty set for miss

Definition hip_runtime_api.h:1665

hipDeviceProp_t::memoryBusWidth

int memoryBusWidth

Global memory bus width in bits.

Definition hip_runtime_api.h:328

hipDeviceProp_t::maxTexture2DMipmap

int maxTexture2DMipmap[2]

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

Definition hip_runtime_api.h:301

hipDevWorkqueueConfigResource::sharingScope

hipDevWorkqueueConfigScope sharingScope

Definition hip_runtime_api.h:759

hipDeviceProp_t::clockRate

int clockRate

Max clock frequency of the multiProcessors in khz.

Definition hip_runtime_api.h:274

hipExternalMemoryMipmappedArrayDesc::extent

hipExtent extent

Definition hip_runtime_api.h:1480

hipMemPoolProps::maxSize

size_t maxSize

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

Definition hip_runtime_api.h:1366

hipLaunchAttributeValue::pad

char pad[64]

64 byte padding

Definition hip_runtime_api.h:1772

hipDevSmResource::flags

unsigned int flags

Definition hip_runtime_api.h:753

hipDevSmResourceGroupParams::flags

unsigned int flags

Definition hip_runtime_api.h:782

hipDeviceArch_t::hasFloatAtomicAdd

unsigned hasFloatAtomicAdd

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

Definition hip_runtime_api.h:59

hipDeviceProp_t::maxThreadsPerMultiProcessor

int maxThreadsPerMultiProcessor

Maximum resident threads per multi-processor.

Definition hip_runtime_api.h:331

hipDeviceProp_t::l2CacheSize

int l2CacheSize

L2 cache size.

Definition hip_runtime_api.h:329

hipDeviceProp_t::deferredMappingHipArraySupported

int deferredMappingHipArraySupported

Definition hip_runtime_api.h:372

hipArrayMemoryRequirements::size

size_t size

Definition hip_runtime_api.h:2217

hipDeviceProp_t::asyncEngineCount

int asyncEngineCount

Number of async engines.

Definition hip_runtime_api.h:325

hipMemsetParams::dst

void * dst

Definition hip_runtime_api.h:1630

hipDeviceProp_t::accessPolicyMaxWindowSize

int accessPolicyMaxWindowSize

Max value of access policy window.

Definition hip_runtime_api.h:358

hipPointerAttribute_t::type

enum hipMemoryType type

Definition hip_runtime_api.h:434

hipStreamBatchMemOpParams::hipStreamMemOpFlushRemoteWritesParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:1149

hipDeviceProp_t::totalConstMem

size_t totalConstMem

Definition hip_runtime_api.h:275

hipDeviceProp_t::memoryPoolsSupported

int memoryPoolsSupported

Indicates if device supports hipMallocAsync and hipMemPool APIs.

Definition hip_runtime_api.h:365

hipLaunchConfig_t::blockDim

dim3 blockDim

Block dimensions.

Definition hip_runtime_api.h:2189

hipKernelNodeParams::gridDim

dim3 gridDim

Definition hip_runtime_api.h:1625

hipExternalSemaphoreSignalNodeParams::paramsArray

const hipExternalSemaphoreSignalParams * paramsArray

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

Definition hip_runtime_api.h:1978

hipExtDynDataPrefetchRegion::address

void * address

Base address (must be cache-line aligned)

Definition hip_runtime_api.h:1721

hipDevResource::nextResource

struct hipDevResource_st * nextResource

Definition hip_runtime_api.h:775

hipHostNodeParams::fn

hipHostFn_t fn

Definition hip_runtime_api.h:1618

hipDeviceProp_t::unifiedFunctionPointers

int unifiedFunctionPointers

Indicates device supports unified function pointers.

Definition hip_runtime_api.h:376

hipDeviceArch_t::hasDoubles

unsigned hasDoubles

Double-precision floating point.

Definition hip_runtime_api.h:66

hipDeviceProp_t::maxTexture2DGather

int maxTexture2DGather[2]

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

Definition hip_runtime_api.h:303

hipStreamBatchMemOpParams::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:1126

hipFuncAttributes::cacheModeCA

int cacheModeCA

Definition hip_runtime_api.h:823

hipDeviceProp_t::memPitch

size_t memPitch

Definition hip_runtime_api.h:269

hipExtDynDataPrefetchConfig::regions

hipExtDynDataPrefetchRegion regions[HIP_EXT_DYN_DATA_PREFETCH_MAX_REGIONS]

Prefetch regions.

Definition hip_runtime_api.h:1747

hipMemAccessDesc::flags

hipMemAccessFlags flags

Accessibility flags to set.

Definition hip_runtime_api.h:1326

hipExtDynDataPrefetchConfig::numRegions

unsigned int numRegions

Number of valid regions (1-max)

Definition hip_runtime_api.h:1745

hipChildGraphNodeParams::graph

hipGraph_t graph

Definition hip_runtime_api.h:2085

hipDeviceProp_t::gpuDirectRDMAWritesOrdering

int gpuDirectRDMAWritesOrdering

value of hipGPUDirectRDMAWritesOrdering

Definition hip_runtime_api.h:369

hipMemsetParams::value

unsigned int value

Definition hip_runtime_api.h:1634

hipDeviceArch_t::hasWarpVote

unsigned hasWarpVote

Warp vote instructions (__any, __all).

Definition hip_runtime_api.h:69

hipDevSmResource::smCount

unsigned int smCount

Definition hip_runtime_api.h:750

hipDeviceProp_t::uuid

hipUUID uuid

UUID of a device.

Definition hip_runtime_api.h:262

hipExternalMemoryMipmappedArrayDesc::numLevels

unsigned int numLevels

Definition hip_runtime_api.h:1482

hipKernelNodeParams::sharedMemBytes

unsigned int sharedMemBytes

Definition hip_runtime_api.h:1627

hipArrayMapInfo::subresource

union hipArrayMapInfo::@38 subresource

HIP_LAUNCH_CONFIG::gridDimZ

unsigned int gridDimZ

Grid depth in blocks.

Definition hip_runtime_api.h:2202

hipLaunchMemSyncDomainMap::remote

unsigned char remote

Definition hip_runtime_api.h:1674

hipDeviceProp_t::sharedMemPerBlock

size_t sharedMemPerBlock

Size of shared memory per block (in bytes).

Definition hip_runtime_api.h:266

hipAccessPolicyWindow::hitRatio

float hitRatio

hitRatio specifies percentage of lines assigned hitProp

Definition hip_runtime_api.h:1664

hipDeviceProp_t::gpuDirectRDMAFlushWritesOptions

unsigned int gpuDirectRDMAFlushWritesOptions

Definition hip_runtime_api.h:367

hipDeviceArch_t::hasWarpShuffle

unsigned hasWarpShuffle

Warp shuffle operations. (__shfl_*).

Definition hip_runtime_api.h:71

hipDeviceProp_t::surfaceAlignment

size_t surfaceAlignment

Alignment requirement for surface.

Definition hip_runtime_api.h:318

hipExtDynDataPrefetchRegion::width

size_t width

Width of each row in bytes (must be a multiple of cache line size)

Definition hip_runtime_api.h:1723

hipDeviceProp_t::reserved

int reserved[63]

CUDA Reserved.

Definition hip_runtime_api.h:377

hipDeviceProp_t::maxTexture2DLayered

int maxTexture2DLayered[3]

Maximum number of elements in 2D array images.

Definition hip_runtime_api.h:309

hipMemPoolProps::reserved

unsigned char reserved[56]

Reserved for future use, must be 0.

Definition hip_runtime_api.h:1367

hipArrayMapInfo::subresourceType

hipArraySparseSubresourceType subresourceType

Sparse subresource type.

Definition hip_runtime_api.h:2040

hipDeviceProp_t::streamPrioritiesSupported

int streamPrioritiesSupported

Device supports stream priority.

Definition hip_runtime_api.h:332

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:2167

hipExternalSemaphoreWaitNodeParams::numExtSems

unsigned int numExtSems

Definition hip_runtime_api.h:1992

hipGraphInstantiateParams::result_out

hipGraphInstantiateResult result_out

Definition hip_runtime_api.h:1947

hipDevWorkqueueConfigResource::wqConcurrencyLimit

unsigned int wqConcurrencyLimit

Definition hip_runtime_api.h:758

hipFunctionLaunchParams::function

hipFunction_t function

Kernel to launch.

Definition hip_runtime_api.h:1436

HIP_LAUNCH_CONFIG::sharedMemBytes

unsigned int sharedMemBytes

Dynamic shared-memory size in bytes per block.

Definition hip_runtime_api.h:2206

hipLaunchAttributeValue::dynDataPrefetch

const hipExtDynDataPrefetchConfig * dynDataPrefetch

Value of launch attribute hipLaunchAttributeExtDynDataPrefetch.

Definition hip_runtime_api.h:1806

hipKernelNodeParams::blockDim

dim3 blockDim

Definition hip_runtime_api.h:1622

hipDeviceProp_t::cooperativeMultiDeviceLaunch

int cooperativeMultiDeviceLaunch

Definition hip_runtime_api.h:350

hipDeviceProp_t::hostRegisterSupported

int hostRegisterSupported

Device supports hipHostRegister.

Definition hip_runtime_api.h:360

hipExternalMemoryMipmappedArrayDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1481

hipLaunchConfig_t::gridDim

dim3 gridDim

Grid dimensions.

Definition hip_runtime_api.h:2188

hipLaunchConfig_t::numAttrs

unsigned int numAttrs

Number of attributes.

Definition hip_runtime_api.h:2193

hipDevSmResource::smCoscheduledAlignment

unsigned int smCoscheduledAlignment

Definition hip_runtime_api.h:752

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::alias

hipDeviceptr_t alias

Not valid for AMD backend. Initial value is unimportant.

Definition hip_runtime_api.h:1135

hipFuncAttributes::binaryVersion

int binaryVersion

Definition hip_runtime_api.h:822

hipExternalSemaphoreSignalParams::flags

unsigned int flags

Definition hip_runtime_api.h:1525

hipHostNodeParams::userData

void * userData

Definition hip_runtime_api.h:1619

hipLaunchAttributeValue::memSyncDomain

hipLaunchMemSyncDomain memSyncDomain

Value of launch attribute hipLaunchAttributeMemSyncDomain.

Definition hip_runtime_api.h:1785

hipArrayMemoryRequirements::alignment

size_t alignment

Definition hip_runtime_api.h:2216

hipDeviceProp_t::pageableMemoryAccess

int pageableMemoryAccess

Definition hip_runtime_api.h:342

hipDeviceProp_t::name

char name[256]

Device name.

Definition hip_runtime_api.h:261

hipMemPoolPtrExportData::reserved

unsigned char reserved[64]

Definition hip_runtime_api.h:1373

hipDeviceProp_t::textureAlignment

size_t textureAlignment

Alignment requirement for textures.

Definition hip_runtime_api.h:286

hipStreamBatchMemOpParams::hipStreamMemOpFlushRemoteWritesParams_t::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:1148

hipStreamBatchMemOpParams::hipStreamMemOpMemoryBarrierParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:1153

hipExternalSemaphoreHandleDesc::type

hipExternalSemaphoreHandleType type

Definition hip_runtime_api.h:1498

hipDeviceProp_t::globalL1CacheSupported

int globalL1CacheSupported

Indicates globals are cached in L1.

Definition hip_runtime_api.h:333

hipFuncAttributes::constSizeBytes

size_t constSizeBytes

Definition hip_runtime_api.h:824

hipMemAllocNodeParams::accessDescs

const hipMemAccessDesc * accessDescs

The number of memory access descriptors.

Definition hip_runtime_api.h:1641

hipDeviceProp_t::hostNativeAtomicSupported

int hostNativeAtomicSupported

Link between host and device supports native atomics.

Definition hip_runtime_api.h:340

hipArrayMapInfo::resourceType

hipResourceType resourceType

Resource type.

Definition hip_runtime_api.h:2035

hipDeviceProp_t::maxSurfaceCubemapLayered

int maxSurfaceCubemapLayered[2]

Maximum cubemap layered surface size.

Definition hip_runtime_api.h:317

hipPointerAttribute_t::isManaged

int isManaged

Definition hip_runtime_api.h:438

hipExternalMemoryHandleDesc::size

unsigned long long size

Definition hip_runtime_api.h:1467

hipDeviceProp_t::maxTextureCubemapLayered

int maxTextureCubemapLayered[2]

Maximum cubemaps layered texture dims.

Definition hip_runtime_api.h:310

hipDeviceProp_t::sharedMemPerBlockOptin

size_t sharedMemPerBlockOptin

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

Definition hip_runtime_api.h:352

hipDeviceProp_t::sharedMemPerMultiprocessor

size_t sharedMemPerMultiprocessor

Amount of shared memory available per multiprocessor.

Definition hip_runtime_api.h:335

hipDeviceProp_t::singleToDoublePrecisionPerfRatio

int singleToDoublePrecisionPerfRatio

Deprecated. CUDA only.

Definition hip_runtime_api.h:341

hipArrayMapInfo::memOperationType

hipMemOperationType memOperationType

Memory operation type.

Definition hip_runtime_api.h:2061

HIP_LAUNCH_CONFIG::blockDimY

unsigned int blockDimY

Thread block dimension in Y.

Definition hip_runtime_api.h:2204

hipDeviceProp_t::maxSurface2D

int maxSurface2D[2]

Maximum 2D surface size.

Definition hip_runtime_api.h:312

hipDeviceProp_t::memoryClockRate

int memoryClockRate

Max global memory clock frequency in khz.

Definition hip_runtime_api.h:327

hipEventWaitNodeParams::event

hipEvent_t event

Event to wait on.

Definition hip_runtime_api.h:2093

hipDeviceProp_t::maxTexture2DLinear

int maxTexture2DLinear[3]

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

Definition hip_runtime_api.h:302

hipDeviceProp_t::sparseHipArraySupported

int sparseHipArraySupported

Indicates if device supports sparse hip arrays.

Definition hip_runtime_api.h:361

hipArrayMapInfo::reserved

unsigned int reserved[2]

Reserved for future use, must be zero now.

Definition hip_runtime_api.h:2069

hipDevSmResource::minSmPartitionSize

unsigned int minSmPartitionSize

Definition hip_runtime_api.h:751

hipMemAccessDesc::location

hipMemLocation location

Location on which the accessibility has to change.

Definition hip_runtime_api.h:1325

hipDeviceProp_t::clockInstructionRate

int clockInstructionRate

Definition hip_runtime_api.h:384

hipMemPoolProps::location

hipMemLocation location

Location where allocations should reside.

Definition hip_runtime_api.h:1361

hipDeviceProp_t::localL1CacheSupported

int localL1CacheSupported

Locals are cahced in L1.

Definition hip_runtime_api.h:334

hipDeviceProp_t::regsPerMultiprocessor

int regsPerMultiprocessor

registers available per multiprocessor

Definition hip_runtime_api.h:336

hipDeviceProp_t::regsPerBlock

int regsPerBlock

Registers per block.

Definition hip_runtime_api.h:267

hipLaunchConfig_t::stream

hipStream_t stream

Stream identifier.

Definition hip_runtime_api.h:2191

hipMemAllocNodeParams::bytesize

size_t bytesize

The size of the requested allocation in bytes.

Definition hip_runtime_api.h:1644

hipMemcpyNodeParams::reserved

int reserved[3]

Must be zero.

Definition hip_runtime_api.h:2077

hipDevSmResourceGroupParams::preferredCoscheduledSmCount

unsigned int preferredCoscheduledSmCount

Definition hip_runtime_api.h:781

hipExternalSemaphoreWaitNodeParams::paramsArray

const hipExternalSemaphoreWaitParams * paramsArray

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

Definition hip_runtime_api.h:1990

hipDeviceProp_t::maxTexture2D

int maxTexture2D[2]

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

Definition hip_runtime_api.h:300

hipFuncAttributes::preferredShmemCarveout

int preferredShmemCarveout

Definition hip_runtime_api.h:829

hipDeviceProp_t::cooperativeLaunch

int cooperativeLaunch

HIP device supports cooperative launch.

Definition hip_runtime_api.h:349

hipDeviceProp_t::maxTexture3D

int maxTexture3D[3]

Definition hip_runtime_api.h:304

hipMemPoolProps::handleTypes

hipMemAllocationHandleType handleTypes

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

Definition hip_runtime_api.h:1360

hipDeviceProp_t::directManagedMemAccessFromHost

int directManagedMemAccessFromHost

Definition hip_runtime_api.h:355

HIP_LAUNCH_CONFIG::hStream

hipStream_t hStream

HIP stream identifier.

Definition hip_runtime_api.h:2207

hipBatchMemOpNodeParams::paramArray

hipStreamBatchMemOpParams * paramArray

Definition hip_runtime_api.h:1188

HIP_LAUNCH_CONFIG::attrs

hipLaunchAttribute * attrs

Attribute list.

Definition hip_runtime_api.h:2208

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedFunc

int cooperativeMultiDeviceUnmatchedFunc

Definition hip_runtime_api.h:389

hipMemPoolProps::allocType

hipMemAllocationType allocType

Allocation type. Currently must be specified as hipMemAllocationTypePinned.

Definition hip_runtime_api.h:1358

hipDeviceProp_t::deviceOverlap

int deviceOverlap

Deprecated. Use asyncEngineCount instead.

Definition hip_runtime_api.h:288

hipDeviceProp_t::pageableMemoryAccessUsesHostPageTables

int pageableMemoryAccessUsesHostPageTables

Definition hip_runtime_api.h:353

hipLaunchAttributeValue::cooperative

int cooperative

Definition hip_runtime_api.h:1775

hipExternalSemaphoreWaitNodeParams::extSemArray

hipExternalSemaphore_t * extSemArray

< Array containing external semaphore handles.

Definition hip_runtime_api.h:1988

hipKernelNodeParams::kernelParams

void ** kernelParams

Definition hip_runtime_api.h:1626

hipDeviceProp_t::hdpRegFlushCntl

unsigned int * hdpRegFlushCntl

Addres of HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:388

hipDeviceArch_t::hasGlobalInt32Atomics

unsigned hasGlobalInt32Atomics

32-bit integer atomics for global memory.

Definition hip_runtime_api.h:55

hipLaunchAttributeValue::accessPolicyWindow

hipAccessPolicyWindow accessPolicyWindow

Value of launch attribute hipLaunchAttributeAccessPolicyWindow.

Definition hip_runtime_api.h:1774

hipLaunchConfig_t::dynamicSmemBytes

size_t dynamicSmemBytes

Dynamic shared-memory size per thread block.

Definition hip_runtime_api.h:2190

hipDeviceProp_t::maxThreadsDim

int maxThreadsDim[3]

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

Definition hip_runtime_api.h:272

hipDeviceArch_t::hasGlobalFloatAtomicExch

unsigned hasGlobalFloatAtomicExch

32-bit float atomic exch for global memory.

Definition hip_runtime_api.h:56

hipDeviceProp_t::unifiedAddressing

int unifiedAddressing

Does device and host share unified address space.

Definition hip_runtime_api.h:326

hipDeviceArch_t::hasDynamicParallelism

unsigned hasDynamicParallelism

Dynamic parallelism.

Definition hip_runtime_api.h:81

hipFunctionLaunchParams::hStream

hipStream_t hStream

Stream identifier.

Definition hip_runtime_api.h:1444

hipArrayMapInfo::memHandleType

hipMemHandleType memHandleType

Memory handle type.

Definition hip_runtime_api.h:2062

hipGraphEdgeData::reserved

unsigned char reserved[5]

These bytes are unused and must be zeroed.

Definition hip_runtime_api.h:2165

hipExternalMemoryMipmappedArrayDesc::offset

unsigned long long offset

Definition hip_runtime_api.h:1478

hipLaunchAttributeValue::clusterDim

struct hipLaunchAttributeValue::@33 clusterDim

Specifies the desired cluster dimensions for a kernel launch.

hipLaunchParams::sharedMem

size_t sharedMem

Shared memory.

Definition hip_runtime_api.h:1429

hipEventRecordNodeParams::event

hipEvent_t event

The event to be recorded when node executes.

Definition hip_runtime_api.h:2100

hipDeviceProp_t::multiGpuBoardGroupID

int multiGpuBoardGroupID

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

Definition hip_runtime_api.h:339

hipGraphInstantiateParams::uploadStream

hipStream_t uploadStream

Definition hip_runtime_api.h:1949

hipDeviceProp_t::isMultiGpuBoard

int isMultiGpuBoard

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

Definition hip_runtime_api.h:338

hipMemAllocNodeParams::poolProps

hipMemPoolProps poolProps

Definition hip_runtime_api.h:1639

hipDevSmResourceGroupParams::smCount

unsigned int smCount

Definition hip_runtime_api.h:779

hipFuncAttributes::sharedSizeBytes

size_t sharedSizeBytes

Definition hip_runtime_api.h:831

hipMemAllocNodeParams::accessDescCount

size_t accessDescCount

Definition hip_runtime_api.h:1642

hipFuncAttributes::maxDynamicSharedSizeBytes

int maxDynamicSharedSizeBytes

Definition hip_runtime_api.h:826

hipFunctionLaunchParams::blockDimY

unsigned int blockDimY

Y dimension of each thread block.

Definition hip_runtime_api.h:1441

hipDeviceProp_t::canUseHostPointerForRegisteredMem

int canUseHostPointerForRegisteredMem

Definition hip_runtime_api.h:347

hipGraphEdgeData::type

unsigned char type

This should be populated with a value from hipGraphDependencyType.

Definition hip_runtime_api.h:2168

hipDeviceArch_t::hasSurfaceFuncs

unsigned hasSurfaceFuncs

Surface functions.

Definition hip_runtime_api.h:79

hipDeviceProp_t::maxTexture1DLayered

int maxTexture1DLayered[2]

Maximum number of elements in 1D array images.

Definition hip_runtime_api.h:308

hipGraphInstantiateParams::errNode_out

hipGraphNode_t errNode_out

Definition hip_runtime_api.h:1945

hipDeviceProp_t::pciDomainID

int pciDomainID

PCI Domain ID.

Definition hip_runtime_api.h:323

hipExternalSemaphoreSignalNodeParams::extSemArray

hipExternalSemaphore_t * extSemArray

< Array containing external semaphore handles.

Definition hip_runtime_api.h:1976

hipDevSmResourceGroupParams::coscheduledSmCount

unsigned int coscheduledSmCount

Definition hip_runtime_api.h:780

hipDeviceProp_t::maxSharedMemoryPerMultiProcessor

size_t maxSharedMemoryPerMultiProcessor

Maximum Shared Memory Per CU. HIP Only.

Definition hip_runtime_api.h:383

hipDevWorkqueueConfigResource::device

int device

Definition hip_runtime_api.h:757

hipMemAllocationProp::location

hipMemLocation location

Memory location.

Definition hip_runtime_api.h:1962

hipExtDynDataPrefetchConfig::temporal

hipExtDynDataPrefetchTemporal temporal

Cache retention policy for prefetched data.

Definition hip_runtime_api.h:1746

hipDeviceProp_t::maxTextureCubemap

int maxTextureCubemap

Maximum cubemap texture dims.

Definition hip_runtime_api.h:307

HIP_LAUNCH_CONFIG::blockDimZ

unsigned int blockDimZ

Thread block dimension in Z.

Definition hip_runtime_api.h:2205

hipDeviceArch_t::has3dGrid

unsigned has3dGrid

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

Definition hip_runtime_api.h:80

hipExternalSemaphoreSignalNodeParams::numExtSems

unsigned int numExtSems

Definition hip_runtime_api.h:1980

hipExternalMemoryHandleDesc::type

hipExternalMemoryHandleType type

Definition hip_runtime_api.h:1458

hipFuncAttributes::ptxVersion

int ptxVersion

Definition hip_runtime_api.h:830

hipKernelNodeParams::extra

void ** extra

Definition hip_runtime_api.h:1623

hipGraphInstantiateParams::flags

unsigned long long flags

Definition hip_runtime_api.h:1946

hipBatchMemOpNodeParams::count

unsigned int count

Definition hip_runtime_api.h:1187

HIP_LAUNCH_CONFIG::numAttrs

unsigned int numAttrs

Number of attributes.

Definition hip_runtime_api.h:2209

hipDeviceArch_t::hasFunnelShift

unsigned hasFunnelShift

Funnel two words into one with shift&mask caps.

Definition hip_runtime_api.h:72

hipDeviceProp_t::hipReserved

int hipReserved[32]

Reserved for adding new entries for HIP/CUDA.

Definition hip_runtime_api.h:379

hipMemAllocNodeParams::dptr

void * dptr

Returned device address of the allocation.

Definition hip_runtime_api.h:1645

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::alias

hipDeviceptr_t alias

Not valid for AMD backend. Initial value is unimportant.

Definition hip_runtime_api.h:1145

hipMemsetParams::elementSize

unsigned int elementSize

Definition hip_runtime_api.h:1631

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedGridDim

int cooperativeMultiDeviceUnmatchedGridDim

Definition hip_runtime_api.h:392

hipExternalSemaphoreWaitParams::flags

unsigned int flags

Definition hip_runtime_api.h:1546

hipDeviceProp_t::gpuDirectRDMASupported

int gpuDirectRDMASupported

Indicates device support of RDMA APIs.

Definition hip_runtime_api.h:366

hipArrayMapInfo::resource

union hipArrayMapInfo::@37 resource

HIP_LAUNCH_CONFIG::gridDimX

unsigned int gridDimX

Grid width in blocks.

Definition hip_runtime_api.h:2200

hipDeviceProp_t::minor

int minor

Definition hip_runtime_api.h:281

hipDeviceProp_t::gcnArchName

char gcnArchName[256]

AMD GCN Arch Name. HIP Only.

Definition hip_runtime_api.h:382

hipPointerAttribute_t::devicePointer

void * devicePointer

Definition hip_runtime_api.h:436

hipDeviceProp_t::luid

char luid[8]

8-byte unique identifier. Only valid on windows

Definition hip_runtime_api.h:263

hipLaunchConfig_t::attrs

hipLaunchAttribute * attrs

Attributes list.

Definition hip_runtime_api.h:2192

hipDeviceProp_t::kernelExecTimeoutEnabled

int kernelExecTimeoutEnabled

Run time limit for kernels executed on the device.

Definition hip_runtime_api.h:293

hipKernelNodeParams::func

void * func

Definition hip_runtime_api.h:1624

hipDeviceProp_t::memoryPoolSupportedHandleTypes

unsigned int memoryPoolSupportedHandleTypes

Bitmask of handle types support with mempool based IPC.

Definition hip_runtime_api.h:371

hipDeviceProp_t::hdpMemFlushCntl

unsigned int * hdpMemFlushCntl

Addres of HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:387

hipDeviceProp_t::concurrentManagedAccess

int concurrentManagedAccess

Definition hip_runtime_api.h:344

hipDeviceProp_t::integrated

int integrated

APU vs dGPU.

Definition hip_runtime_api.h:294

hipDeviceProp_t::canMapHostMemory

int canMapHostMemory

Check whether HIP can map host memory.

Definition hip_runtime_api.h:295

hipDeviceArch_t::hasThreadFenceSystem

unsigned hasThreadFenceSystem

__threadfence_system.

Definition hip_runtime_api.h:75

hipMemcpyNodeParams::flags

int flags

Must be zero.

Definition hip_runtime_api.h:2076

hipDeviceProp_t::reservedSharedMemPerBlock

size_t reservedSharedMemPerBlock

Shared memory reserved by driver per block.

Definition hip_runtime_api.h:359

hipDevResource::type

hipDevResourceType type

Definition hip_runtime_api.h:767

hipDeviceProp_t::maxSurfaceCubemap

int maxSurfaceCubemap

Maximum cubemap surface size.

Definition hip_runtime_api.h:316

hipDeviceProp_t::maxSurface3D

int maxSurface3D[3]

Maximum 3D surface size.

Definition hip_runtime_api.h:313

hipLaunchParams::args

void ** args

Arguments.

Definition hip_runtime_api.h:1428

hipDeviceProp_t::asicRevision

int asicRevision

Revision of the GPU in this device.

Definition hip_runtime_api.h:402

hipGraphEdgeData::from_port

unsigned char from_port

Definition hip_runtime_api.h:2158

hipLaunchParams::blockDim

dim3 blockDim

Block dimensions.

Definition hip_runtime_api.h:1427

hipLaunchAttribute::id

hipLaunchAttributeID id

Identifier of the launch attribute.

Definition hip_runtime_api.h:2176

hipArrayMapInfo::deviceBitMask

unsigned int deviceBitMask

Device ordinal bit mask.

Definition hip_runtime_api.h:2067

hipFunctionLaunchParams::gridDimY

unsigned int gridDimY

Height(Y) of grid in blocks.

Definition hip_runtime_api.h:1438

hipDeviceProp_t::totalGlobalMem

size_t totalGlobalMem

Size of global memory region (in bytes).

Definition hip_runtime_api.h:265

hipMemsetParams::width

size_t width

Definition hip_runtime_api.h:1635

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedBlockDim

int cooperativeMultiDeviceUnmatchedBlockDim

Definition hip_runtime_api.h:395

hipFunctionLaunchParams::gridDimZ

unsigned int gridDimZ

Depth(Z) of grid in blocks.

Definition hip_runtime_api.h:1439

hipPointerAttribute_t::allocationFlags

unsigned allocationFlags

Definition hip_runtime_api.h:439

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:1138

hipFunctionLaunchParams::sharedMemBytes

unsigned int sharedMemBytes

Shared memory.

Definition hip_runtime_api.h:1443

hipBatchMemOpNodeParams::flags

unsigned int flags

Definition hip_runtime_api.h:1189

hipDeviceProp_t::maxSurface1DLayered

int maxSurface1DLayered[2]

Maximum 1D layered surface size.

Definition hip_runtime_api.h:314

hipDeviceArch_t::hasGlobalInt64Atomics

unsigned hasGlobalInt64Atomics

64-bit integer atomics for global memory.

Definition hip_runtime_api.h:62

hipDeviceProp_t::persistingL2CacheMaxSize

int persistingL2CacheMaxSize

Device's max L2 persisting lines in bytes.

Definition hip_runtime_api.h:330

hipDeviceProp_t::maxSurface1D

int maxSurface1D

Maximum 1D surface size.

Definition hip_runtime_api.h:311

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:1144

hipDeviceProp_t::concurrentKernels

int concurrentKernels

Device can possibly execute multiple kernels concurrently.

Definition hip_runtime_api.h:319

hipDeviceProp_t::isLargeBar

int isLargeBar

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

Definition hip_runtime_api.h:401

hipDeviceProp_t::clusterLaunch

int clusterLaunch

Device supports cluster launch.

Definition hip_runtime_api.h:375

hipFuncAttributes::numRegs

int numRegs

Definition hip_runtime_api.h:828

hipDeviceProp_t::maxTexture1DMipmap

int maxTexture1DMipmap

Maximum 1D mipmap texture size.

Definition hip_runtime_api.h:298

hipDeviceProp_t::multiProcessorCount

int multiProcessorCount

Definition hip_runtime_api.h:289

hipMemAllocationProp::allocFlags

struct hipMemAllocationProp::@36 allocFlags

hipGraphNodeParams::reserved2

long long reserved2

Definition hip_runtime_api.h:2131

hipDeviceArch_t::hasSyncThreadsExt

unsigned hasSyncThreadsExt

__syncthreads_count, syncthreads_and, syncthreads_or.

Definition hip_runtime_api.h:76

hipExternalMemoryBufferDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1474

hipDevWorkqueueResource::reserved

unsigned char reserved[HIP_RESOURCE_ABI_BYTES]

Definition hip_runtime_api.h:763

hipDeviceProp_t::maxTexture3DAlt

int maxTexture3DAlt[3]

Maximum alternate 3D texture dims.

Definition hip_runtime_api.h:306

hipMemFreeNodeParams::dptr

void * dptr

the pointer to be freed

Definition hip_runtime_api.h:2107

hipDeviceProp_t::maxGridSize

int maxGridSize[3]

Max grid dimensions (XYZ).

Definition hip_runtime_api.h:273

hipAccessPolicyWindow::base_ptr

void * base_ptr

Starting address of the access policy window.

Definition hip_runtime_api.h:1662

hipDeviceProp_t::pciDeviceID

int pciDeviceID

PCI Device ID.

Definition hip_runtime_api.h:322

hipDeviceProp_t::maxBlocksPerMultiProcessor

int maxBlocksPerMultiProcessor

Max number of blocks on CU.

Definition hip_runtime_api.h:357

hipStreamBatchMemOpParams::hipStreamMemOpMemoryBarrierParams_t::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:1152

hipDeviceProp_t::computeMode

int computeMode

Compute mode.

Definition hip_runtime_api.h:296

hipLaunchAttributeValue::syncPolicy

hipSynchronizationPolicy syncPolicy

Definition hip_runtime_api.h:1780

hipMemPoolProps::win32SecurityAttributes

void * win32SecurityAttributes

Definition hip_runtime_api.h:1365

hipFunctionLaunchParams::blockDimZ

unsigned int blockDimZ

Z dimension of each thread block.

Definition hip_runtime_api.h:1442

hipExtDynDataPrefetchRegion::height

size_t height

Number of rows to prefetch.

Definition hip_runtime_api.h:1724

hipLaunchAttributeValue::clusterSchedulingPolicyPreference

hipClusterSchedulingPolicy clusterSchedulingPolicyPreference

Definition hip_runtime_api.h:1804

hipDeviceProp_t::maxSurface2DLayered

int maxSurface2DLayered[3]

Maximum 2D layared surface size.

Definition hip_runtime_api.h:315

hipDeviceProp_t::major

int major

Definition hip_runtime_api.h:277

hipArrayMapInfo::memHandle

union hipArrayMapInfo::@39 memHandle

hipLaunchMemSyncDomainMap::default_

unsigned char default_

Definition hip_runtime_api.h:1673

hipBatchMemOpNodeParams::ctx

hipCtx_t ctx

Definition hip_runtime_api.h:1186

hipLaunchParams::gridDim

dim3 gridDim

Grid dimensions.

Definition hip_runtime_api.h:1426

hipLaunchParams::func

void * func

Device function symbol.

Definition hip_runtime_api.h:1425

hipMemcpyNodeParams::copyParams

hipMemcpy3DParms copyParams

Params set for the memory copy.

Definition hip_runtime_api.h:2078

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:1134

hipDeviceArch_t::hasWarpBallot

unsigned hasWarpBallot

Warp ballot instructions (__ballot).

Definition hip_runtime_api.h:70

HIP_LAUNCH_CONFIG::gridDimY

unsigned int gridDimY

Grid height in blocks.

Definition hip_runtime_api.h:2201

hipExternalMemoryBufferDesc::offset

unsigned long long offset

Definition hip_runtime_api.h:1472

hipDeviceProp_t::warpSize

int warpSize

Warp size.

Definition hip_runtime_api.h:268

hipDeviceProp_t::tccDriver

int tccDriver

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

Definition hip_runtime_api.h:324

hipDeviceProp_t::luidDeviceNodeMask

unsigned int luidDeviceNodeMask

LUID node mask.

Definition hip_runtime_api.h:264

hipMemsetParams::pitch

size_t pitch

Definition hip_runtime_api.h:1633

hipExternalMemoryMipmappedArrayDesc::formatDesc

hipChannelFormatDesc formatDesc

Definition hip_runtime_api.h:1479

hipMemsetParams::height

size_t height

Definition hip_runtime_api.h:1632

hipFunctionLaunchParams::kernelParams

void ** kernelParams

Kernel parameters.

Definition hip_runtime_api.h:1445

hipDeviceProp_t::hostRegisterReadOnlySupported

int hostRegisterReadOnlySupported

Definition hip_runtime_api.h:362

hipFuncAttributes::localSizeBytes

size_t localSizeBytes

Definition hip_runtime_api.h:825

hipExternalMemoryBufferDesc::size

unsigned long long size

Definition hip_runtime_api.h:1473

HIP_LAUNCH_CONFIG::blockDimX

unsigned int blockDimX

Thread block dimension in X.

Definition hip_runtime_api.h:2203

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedSharedMem

int cooperativeMultiDeviceUnmatchedSharedMem

Definition hip_runtime_api.h:398

hipArrayMapInfo::offset

unsigned long long offset

Offset within the memory.

Definition hip_runtime_api.h:2066

hipLaunchParams::stream

hipStream_t stream

Stream identifier.

Definition hip_runtime_api.h:1430

hipFuncAttributes::maxThreadsPerBlock

int maxThreadsPerBlock

Definition hip_runtime_api.h:827

hipExtDynDataPrefetchRegion::stride

size_t stride

Stride between row starts in bytes.

Definition hip_runtime_api.h:1722

hipDeviceProp_t::maxThreadsPerBlock

int maxThreadsPerBlock

Max work items per work group or workgroup max size.

Definition hip_runtime_api.h:271

hipAccessPolicyWindow::num_bytes

size_t num_bytes

Size in bytes of the window policy.

Definition hip_runtime_api.h:1666

hipDeviceProp_t::arch

hipDeviceArch_t arch

Architectural feature flags. New for HIP.

Definition hip_runtime_api.h:386

hipLaunchAttributeValue::memSyncDomainMap

hipLaunchMemSyncDomainMap memSyncDomainMap

Value of launch attribute hipLaunchAttributeMemSyncDomainMap.

Definition hip_runtime_api.h:1783

hipDeviceProp_t::managedMemory

int managedMemory

Device supports allocating managed memory on this system.

Definition hip_runtime_api.h:337

hipDeviceArch_t::hasSharedFloatAtomicExch

unsigned hasSharedFloatAtomicExch

32-bit float atomic exch for shared memory.

Definition hip_runtime_api.h:58

hipDeviceProp_t::texturePitchAlignment

size_t texturePitchAlignment

Pitch alignment requirement for texture references bound to.

Definition hip_runtime_api.h:287

hipLimit_t

hipLimit_t

Definition hip_runtime_api.h:841

hipMemRangeHandleType

hipMemRangeHandleType

Definition hip_runtime_api.h:2223

hipExecutionCtx_t

struct ihipExecutionCtx_t * hipExecutionCtx_t

Definition hip_runtime_api.h:726

hipMemAllocationHandleType

hipMemAllocationHandleType

Definition hip_runtime_api.h:1345

hipGraphicsResource_t

hipGraphicsResource * hipGraphicsResource_t

Definition hip_runtime_api.h:1573

hipError_t

enum __HIP_NODISCARD hipError_t UINT32_BASE hipError_t

hipCtx_t

struct ihipCtx_t * hipCtx_t

Definition hip_runtime_api.h:725

__dparm

#define __dparm(x)

Definition hip_runtime_api.h:707

hipStream_t

struct ihipStream_t * hipStream_t

Definition hip_runtime_api.h:799

hipGraphInstantiateResult

hipGraphInstantiateResult

Definition hip_runtime_api.h:1929

hipDevice_t

int hipDevice_t

Definition hip_runtime_api.h:787

hipAccessProperty

hipAccessProperty

Definition hip_runtime_api.h:1651

hipLinkState_t

struct ihipLinkState_t * hipLinkState_t

Definition hip_runtime_api.h:813

hipGraphDependencyType

hipGraphDependencyType

Definition hip_runtime_api.h:2151

hipMemRangeAttribute

hipMemRangeAttribute

Definition hip_runtime_api.h:1238

hipMemAttachSingle

#define hipMemAttachSingle

Definition hip_runtime_api.h:994

hipMemoryAdvise

hipMemoryAdvise

Definition hip_runtime_api.h:1205

hipArrayDefault

#define hipArrayDefault

Definition hip_runtime_api.h:1055

hipSharedMemConfig

hipSharedMemConfig

Definition hip_runtime_api.h:1402

hipKernelNodeAttrValue

#define hipKernelNodeAttrValue

Definition hip_runtime_api.h:1832

hipComputeMode

hipComputeMode

Definition hip_runtime_api.h:662

hipEvent_t

struct ihipEvent_t * hipEvent_t

Definition hip_runtime_api.h:833

hipStreamCaptureMode

hipStreamCaptureMode

Definition hip_runtime_api.h:1861

hipStreamBatchMemOpType

hipStreamBatchMemOpType

Definition hip_runtime_api.h:1080

hipDriverProcAddressQueryResult

hipDriverProcAddressQueryResult

Definition hip_runtime_api.h:656

HIP_DEPRECATED_MSG

#define HIP_DEPRECATED_MSG

Definition hip_runtime_api.h:699

hipLaunchAttributeID

hipLaunchAttributeID

Definition hip_runtime_api.h:1753

hipKernel_t

struct ihipKernel_t * hipKernel_t

Definition hip_runtime_api.h:815

hipSynchronizationPolicy

hipSynchronizationPolicy

Definition hip_runtime_api.h:1689

hipGraphNodeType

hipGraphNodeType

Definition hip_runtime_api.h:1597

hipExternalMemoryHandleType

hipExternalMemoryHandleType

Definition hip_runtime_api.h:1447

hipMemAttachGlobal

#define hipMemAttachGlobal

Definition hip_runtime_api.h:988

hipLibrary_t

struct ihipLibrary_t * hipLibrary_t

Definition hip_runtime_api.h:814

hipFuncAttribute

hipFuncAttribute

Definition hip_runtime_api.h:1379

hipExternalSemaphoreHandleType

hipExternalSemaphoreHandleType

Definition hip_runtime_api.h:1485

hipLaunchMemSyncDomain

hipLaunchMemSyncDomain

Definition hip_runtime_api.h:1680

hipDevResourceDesc_t

struct ihipDevResourceDesc_t * hipDevResourceDesc_t

Definition hip_runtime_api.h:727

hipDeviceP2PAttr

hipDeviceP2PAttr

Definition hip_runtime_api.h:788

hipGraphDebugDotFlags

hipGraphDebugDotFlags

Definition hip_runtime_api.h:1907

hipDevSmResourceGroup_flags

hipDevSmResourceGroup_flags

Definition hip_runtime_api.h:734

hipUserObjectRetainFlags

hipUserObjectRetainFlags

Definition hip_runtime_api.h:1892

hipStreamAttrID

#define hipStreamAttrID

Definition hip_runtime_api.h:1812

hipHostAllocDefault

#define hipHostAllocDefault

Definition hip_runtime_api.h:930

hipHostFn_t

void(* hipHostFn_t)(void *userData)

Definition hip_runtime_api.h:1616

hipOccupancyDefault

#define hipOccupancyDefault

Definition hip_runtime_api.h:1060

hipStreamUpdateCaptureDependenciesFlags

hipStreamUpdateCaptureDependenciesFlags

Definition hip_runtime_api.h:1873

hipGraph_t

struct ihipGraph * hipGraph_t

Definition hip_runtime_api.h:1578

hipMemHandleType

hipMemHandleType

Definition hip_runtime_api.h:2011

hipFlushGPUDirectRDMAWritesOptions

hipFlushGPUDirectRDMAWritesOptions

Definition hip_runtime_api.h:669

hipFuncCache_t

hipFuncCache_t

Definition hip_runtime_api.h:1393

hipUserObjectFlags

hipUserObjectFlags

Definition hip_runtime_api.h:1888

__HIP_NODISCARD

#define __HIP_NODISCARD

Definition hip_runtime_api.h:96

hipDevWorkqueueConfigScope

hipDevWorkqueueConfigScope

Definition hip_runtime_api.h:742

hipGraphMemAttributeType

hipGraphMemAttributeType

Definition hip_runtime_api.h:1878

hipMemPoolAttr

hipMemPoolAttr

Definition hip_runtime_api.h:1253

hipDriverEntryPointQueryResult

hipDriverEntryPointQueryResult

Definition hip_runtime_api.h:794

hipMemRangeFlags

hipMemRangeFlags

Definition hip_runtime_api.h:2231

hipDevSmResourceSplitByCount_flags

hipDevSmResourceSplitByCount_flags

Definition hip_runtime_api.h:738

HIP_RESOURCE_ABI_BYTES

#define HIP_RESOURCE_ABI_BYTES

Definition hip_runtime_api.h:747

UINT32_BASE

#define UINT32_BASE

Definition hip_runtime_api.h:102

hipModule_t

struct ihipModule_t * hipModule_t

Definition hip_runtime_api.h:811

hipUserObject_t

struct hipUserObject * hipUserObject_t

Definition hip_runtime_api.h:1591

hipMemOperationType

hipMemOperationType

Definition hip_runtime_api.h:2018

hipExternalSemaphore_t

void * hipExternalSemaphore_t

Definition hip_runtime_api.h:1510

hipGraphicsRegisterFlags

hipGraphicsRegisterFlags

Definition hip_runtime_api.h:1561

HIP_EXT_DYN_DATA_PREFETCH_MAX_REGIONS

#define HIP_EXT_DYN_DATA_PREFETCH_MAX_REGIONS

Definition hip_runtime_api.h:1732

hipStreamAttrValue

#define hipStreamAttrValue

Definition hip_runtime_api.h:1819

hipMemRangeCoherencyMode

hipMemRangeCoherencyMode

Definition hip_runtime_api.h:1226

hipMemAccessFlags

hipMemAccessFlags

Definition hip_runtime_api.h:1313

hipMemAllocationGranularity_flags

hipMemAllocationGranularity_flags

Definition hip_runtime_api.h:2003

hipExtDynDataPrefetchTemporal

hipExtDynDataPrefetchTemporal

Temporal locality hint for dynamic data prefetch.

Definition hip_runtime_api.h:1707

hipGraphExec_t

struct hipGraphExec * hipGraphExec_t

Definition hip_runtime_api.h:1586

hipGraphExecUpdateResult

hipGraphExecUpdateResult

Definition hip_runtime_api.h:1846

hipFunction_t

struct ihipModuleSymbol_t * hipFunction_t

Definition hip_runtime_api.h:812

hipKernelNodeAttrID

#define hipKernelNodeAttrID

Definition hip_runtime_api.h:1824

hipExternalMemory_t

void * hipExternalMemory_t

Definition hip_runtime_api.h:1484

hipStreamCaptureStatus

hipStreamCaptureStatus

Definition hip_runtime_api.h:1866

hipDeviceAttribute_t

hipDeviceAttribute_t

Definition hip_runtime_api.h:447

hipGPUDirectRDMAWritesOrdering

hipGPUDirectRDMAWritesOrdering

Definition hip_runtime_api.h:674

hipDeviceProp_tR0600

hipDeviceProp_t hipDeviceProp_tR0600

Definition hip_runtime_api.h:406

hipHostMallocDefault

#define hipHostMallocDefault

Definition hip_runtime_api.h:934

HIP_DEPRECATED

#define HIP_DEPRECATED(msg)

Definition hip_runtime_api.h:696

hipGraphicsResource

struct _hipGraphicsResource hipGraphicsResource

Definition hip_runtime_api.h:1571

hipMemAllocationType

hipMemAllocationType

Definition hip_runtime_api.h:1331

hipGraphNode_t

struct hipGraphNode * hipGraphNode_t

Definition hip_runtime_api.h:1582

hipMemGenericAllocationHandle_t

struct ihipMemGenericAllocationHandle * hipMemGenericAllocationHandle_t

Definition hip_runtime_api.h:1998

hipClusterSchedulingPolicy

hipClusterSchedulingPolicy

Definition hip_runtime_api.h:1697

hipMemoryType

hipMemoryType

Definition hip_runtime_api.h:416

hipGraphInstantiateFlags

hipGraphInstantiateFlags

Definition hip_runtime_api.h:1896

HIP_IPC_HANDLE_SIZE

#define HIP_IPC_HANDLE_SIZE

Definition hip_runtime_api.h:801

hipMemPool_t

struct ihipMemPoolHandle_t * hipMemPool_t

Definition hip_runtime_api.h:819

hipDevResourceType

hipDevResourceType

Definition hip_runtime_api.h:728

hipArraySparseSubresourceType

hipArraySparseSubresourceType

Definition hip_runtime_api.h:2026

hipExtLimitScratchMin

@ hipExtLimitScratchMin

Definition hip_runtime_api.h:849

hipLimitMallocHeapSize

@ hipLimitMallocHeapSize

Definition hip_runtime_api.h:847

hipLimitStackSize

@ hipLimitStackSize

Definition hip_runtime_api.h:842

hipLimitRange

@ hipLimitRange

Supported limit range.

Definition hip_runtime_api.h:857

hipLimitPrintfFifoSize

@ hipLimitPrintfFifoSize

Definition hip_runtime_api.h:845

hipExtLimitScratchMax

@ hipExtLimitScratchMax

Definition hip_runtime_api.h:851

hipExtLimitScratchCurrent

@ hipExtLimitScratchCurrent

Definition hip_runtime_api.h:853

hipMemRangeHandleTypeMax

@ hipMemRangeHandleTypeMax

Definition hip_runtime_api.h:2225

hipMemRangeHandleTypeDmaBufFd

@ hipMemRangeHandleTypeDmaBufFd

Definition hip_runtime_api.h:2224

hipMemHandleTypeWin32

@ hipMemHandleTypeWin32

Allows a Win32 NT handle for exporting. (HANDLE)

Definition hip_runtime_api.h:1349

hipMemHandleTypeWin32Kmt

@ hipMemHandleTypeWin32Kmt

Allows a Win32 KMT handle for exporting. (D3DKMT_HANDLE)

Definition hip_runtime_api.h:1350

hipMemHandleTypeNone

@ hipMemHandleTypeNone

Does not allow any export mechanism.

Definition hip_runtime_api.h:1346

hipMemHandleTypePosixFileDescriptor

@ hipMemHandleTypePosixFileDescriptor

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

Definition hip_runtime_api.h:1347

hipMemHandleTypeFabric

@ hipMemHandleTypeFabric

Allows a fabric handle to be used for exporting.

Definition hip_runtime_api.h:1351

hipGraphInstantiateNodeOperationNotSupported

@ hipGraphInstantiateNodeOperationNotSupported

Definition hip_runtime_api.h:1935

hipGraphInstantiateMultipleDevicesNotSupported

@ hipGraphInstantiateMultipleDevicesNotSupported

Definition hip_runtime_api.h:1937

hipGraphInstantiateError

@ hipGraphInstantiateError

Definition hip_runtime_api.h:1931

hipGraphInstantiateInvalidStructure

@ hipGraphInstantiateInvalidStructure

Definition hip_runtime_api.h:1933

hipGraphInstantiateSuccess

@ hipGraphInstantiateSuccess

Definition hip_runtime_api.h:1930

hipAccessPropertyNormal

@ hipAccessPropertyNormal

Normal cache persistence.

Definition hip_runtime_api.h:1652

hipAccessPropertyPersisting

@ hipAccessPropertyPersisting

Persisting access is more likely to persist in cache.

Definition hip_runtime_api.h:1654

hipAccessPropertyStreaming

@ hipAccessPropertyStreaming

Streaming access is less likely to persist from cache.

Definition hip_runtime_api.h:1653

hipGraphDependencyTypeDefault

@ hipGraphDependencyTypeDefault

Definition hip_runtime_api.h:2152

hipGraphDependencyTypeProgrammatic

@ hipGraphDependencyTypeProgrammatic

Definition hip_runtime_api.h:2153

hipMemRangeAttributeLastPrefetchLocation

@ hipMemRangeAttributeLastPrefetchLocation

Definition hip_runtime_api.h:1244

hipMemRangeAttributePreferredLocation

@ hipMemRangeAttributePreferredLocation

The preferred location of the range.

Definition hip_runtime_api.h:1241

hipMemRangeAttributeAccessedBy

@ hipMemRangeAttributeAccessedBy

Definition hip_runtime_api.h:1242

hipMemRangeAttributeReadMostly

@ hipMemRangeAttributeReadMostly

Definition hip_runtime_api.h:1239

hipMemRangeAttributeCoherencyMode

@ hipMemRangeAttributeCoherencyMode

Definition hip_runtime_api.h:1246

hipMemAdviseUnsetAccessedBy

@ hipMemAdviseUnsetAccessedBy

Definition hip_runtime_api.h:1214

hipMemAdviseUnsetCoarseGrain

@ hipMemAdviseUnsetCoarseGrain

Restores cache coherency policy back to fine-grain.

Definition hip_runtime_api.h:1221

hipMemAdviseSetCoarseGrain

@ hipMemAdviseSetCoarseGrain

Definition hip_runtime_api.h:1216

hipMemAdviseUnsetPreferredLocation

@ hipMemAdviseUnsetPreferredLocation

Clear the preferred location for the data.

Definition hip_runtime_api.h:1211

hipMemAdviseSetAccessedBy

@ hipMemAdviseSetAccessedBy

Definition hip_runtime_api.h:1212

hipMemAdviseSetPreferredLocation

@ hipMemAdviseSetPreferredLocation

Definition hip_runtime_api.h:1209

hipMemAdviseSetReadMostly

@ hipMemAdviseSetReadMostly

Definition hip_runtime_api.h:1206

hipMemAdviseUnsetReadMostly

@ hipMemAdviseUnsetReadMostly

Undo the effect of hipMemAdviseSetReadMostly.

Definition hip_runtime_api.h:1208

hipSharedMemBankSizeFourByte

@ hipSharedMemBankSizeFourByte

Definition hip_runtime_api.h:1404

hipSharedMemBankSizeEightByte

@ hipSharedMemBankSizeEightByte

Definition hip_runtime_api.h:1406

hipSharedMemBankSizeDefault

@ hipSharedMemBankSizeDefault

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

Definition hip_runtime_api.h:1403

hipComputeModeProhibited

@ hipComputeModeProhibited

Definition hip_runtime_api.h:665

hipComputeModeExclusive

@ hipComputeModeExclusive

Definition hip_runtime_api.h:664

hipComputeModeDefault

@ hipComputeModeDefault

Definition hip_runtime_api.h:663

hipComputeModeExclusiveProcess

@ hipComputeModeExclusiveProcess

Definition hip_runtime_api.h:666

hipStreamCaptureModeRelaxed

@ hipStreamCaptureModeRelaxed

Definition hip_runtime_api.h:1864

hipStreamCaptureModeThreadLocal

@ hipStreamCaptureModeThreadLocal

Definition hip_runtime_api.h:1863

hipStreamCaptureModeGlobal

@ hipStreamCaptureModeGlobal

Definition hip_runtime_api.h:1862

hipStreamMemOpWriteValue64

@ hipStreamMemOpWriteValue64

Definition hip_runtime_api.h:1084

hipStreamMemOpBarrier

@ hipStreamMemOpBarrier

Currently not supported.

Definition hip_runtime_api.h:1085

hipStreamMemOpWriteValue32

@ hipStreamMemOpWriteValue32

Definition hip_runtime_api.h:1082

hipStreamMemOpWaitValue32

@ hipStreamMemOpWaitValue32

Definition hip_runtime_api.h:1081

hipStreamMemOpWaitValue64

@ hipStreamMemOpWaitValue64

Definition hip_runtime_api.h:1083

hipStreamMemOpFlushRemoteWrites

@ hipStreamMemOpFlushRemoteWrites

Currently not supported.

Definition hip_runtime_api.h:1086

HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND

@ HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND

Definition hip_runtime_api.h:658

HIP_GET_PROC_ADDRESS_SUCCESS

@ HIP_GET_PROC_ADDRESS_SUCCESS

Definition hip_runtime_api.h:657

HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT

@ HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT

Definition hip_runtime_api.h:659

hipLaunchAttributePriority

@ hipLaunchAttributePriority

Valid for graph node, streams, launches.

Definition hip_runtime_api.h:1760

hipLaunchAttributeMax

@ hipLaunchAttributeMax

Definition hip_runtime_api.h:1764

hipLaunchAttributeClusterDimension

@ hipLaunchAttributeClusterDimension

Valid for graph nodes, launches.

Definition hip_runtime_api.h:1758

hipLaunchAttributeMemSyncDomain

@ hipLaunchAttributeMemSyncDomain

Valid for streams, graph nodes, launches.

Definition hip_runtime_api.h:1762

hipLaunchAttributeMemSyncDomainMap

@ hipLaunchAttributeMemSyncDomainMap

Valid for streams, graph nodes, launches.

Definition hip_runtime_api.h:1761

hipLaunchAttributeIgnore

@ hipLaunchAttributeIgnore

Ignored entry.

Definition hip_runtime_api.h:1754

hipLaunchAttributeSynchronizationPolicy

@ hipLaunchAttributeSynchronizationPolicy

Valid for streams.

Definition hip_runtime_api.h:1757

hipLaunchAttributeExtDynDataPrefetch

@ hipLaunchAttributeExtDynDataPrefetch

Valid for launches. Prefetch data into L2 before kernel execution.

Definition hip_runtime_api.h:1763

hipLaunchAttributeClusterSchedulingPolicyPreference

@ hipLaunchAttributeClusterSchedulingPolicyPreference

Valid for graph nodes, launches.

Definition hip_runtime_api.h:1759

hipLaunchAttributeAccessPolicyWindow

@ hipLaunchAttributeAccessPolicyWindow

Valid for Streams, graph nodes, launches.

Definition hip_runtime_api.h:1755

hipLaunchAttributeCooperative

@ hipLaunchAttributeCooperative

Valid for graph nodes, launches.

Definition hip_runtime_api.h:1756

hipSyncPolicyYield

@ hipSyncPolicyYield

Definition hip_runtime_api.h:1692

hipSyncPolicyBlockingSync

@ hipSyncPolicyBlockingSync

Definition hip_runtime_api.h:1693

hipSyncPolicyAuto

@ hipSyncPolicyAuto

Definition hip_runtime_api.h:1690

hipSyncPolicySpin

@ hipSyncPolicySpin

Definition hip_runtime_api.h:1691

hipGraphNodeTypeBatchMemOp

@ hipGraphNodeTypeBatchMemOp

BatchMemOp node.

Definition hip_runtime_api.h:1612

hipGraphNodeTypeGraph

@ hipGraphNodeTypeGraph

Node which executes an embedded graph.

Definition hip_runtime_api.h:1602

hipGraphNodeTypeMemset

@ hipGraphNodeTypeMemset

Memset node.

Definition hip_runtime_api.h:1600

hipGraphNodeTypeEventRecord

@ hipGraphNodeTypeEventRecord

External event record node.

Definition hip_runtime_api.h:1605

hipGraphNodeTypeExtSemaphoreSignal

@ hipGraphNodeTypeExtSemaphoreSignal

External Semaphore signal node.

Definition hip_runtime_api.h:1606

hipGraphNodeTypeMemcpy

@ hipGraphNodeTypeMemcpy

Memcpy node.

Definition hip_runtime_api.h:1599

hipGraphNodeTypeWaitEvent

@ hipGraphNodeTypeWaitEvent

External event wait node.

Definition hip_runtime_api.h:1604

hipGraphNodeTypeCount

@ hipGraphNodeTypeCount

Definition hip_runtime_api.h:1613

hipGraphNodeTypeKernel

@ hipGraphNodeTypeKernel

GPU kernel node.

Definition hip_runtime_api.h:1598

hipGraphNodeTypeHost

@ hipGraphNodeTypeHost

Host (executable) node.

Definition hip_runtime_api.h:1601

hipGraphNodeTypeMemAlloc

@ hipGraphNodeTypeMemAlloc

Memory alloc node.

Definition hip_runtime_api.h:1608

hipGraphNodeTypeMemFree

@ hipGraphNodeTypeMemFree

Memory free node.

Definition hip_runtime_api.h:1609

hipGraphNodeTypeMemcpyFromSymbol

@ hipGraphNodeTypeMemcpyFromSymbol

MemcpyFromSymbol node.

Definition hip_runtime_api.h:1610

hipGraphNodeTypeMemcpyToSymbol

@ hipGraphNodeTypeMemcpyToSymbol

MemcpyToSymbol node.

Definition hip_runtime_api.h:1611

hipGraphNodeTypeEmpty

@ hipGraphNodeTypeEmpty

Empty (no-op) node.

Definition hip_runtime_api.h:1603

hipGraphNodeTypeExtSemaphoreWait

@ hipGraphNodeTypeExtSemaphoreWait

External Semaphore wait node.

Definition hip_runtime_api.h:1607

hipExternalMemoryHandleTypeD3D11Resource

@ hipExternalMemoryHandleTypeD3D11Resource

Definition hip_runtime_api.h:1453

hipExternalMemoryHandleTypeD3D12Resource

@ hipExternalMemoryHandleTypeD3D12Resource

Definition hip_runtime_api.h:1452

hipExternalMemoryHandleTypeNvSciBuf

@ hipExternalMemoryHandleTypeNvSciBuf

Definition hip_runtime_api.h:1455

hipExternalMemoryHandleTypeOpaqueFd

@ hipExternalMemoryHandleTypeOpaqueFd

Definition hip_runtime_api.h:1448

hipExternalMemoryHandleTypeD3D12Heap

@ hipExternalMemoryHandleTypeD3D12Heap

Definition hip_runtime_api.h:1451

hipExternalMemoryHandleTypeOpaqueWin32Kmt

@ hipExternalMemoryHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:1450

hipExternalMemoryHandleTypeOpaqueWin32

@ hipExternalMemoryHandleTypeOpaqueWin32

Definition hip_runtime_api.h:1449

hipExternalMemoryHandleTypeD3D11ResourceKmt

@ hipExternalMemoryHandleTypeD3D11ResourceKmt

Definition hip_runtime_api.h:1454

hipFuncAttributeClusterSchedulingPolicyPreference

@ hipFuncAttributeClusterSchedulingPolicyPreference

The block scheduling policy of a function.

Definition hip_runtime_api.h:1387

hipFuncAttributePreferredSharedMemoryCarveout

@ hipFuncAttributePreferredSharedMemoryCarveout

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

Definition hip_runtime_api.h:1381

hipFuncAttributeRequiredClusterWidth

@ hipFuncAttributeRequiredClusterWidth

The required cluster width in blocks.

Definition hip_runtime_api.h:1383

hipFuncAttributeMaxDynamicSharedMemorySize

@ hipFuncAttributeMaxDynamicSharedMemorySize

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

Definition hip_runtime_api.h:1380

hipFuncAttributeMax

@ hipFuncAttributeMax

Definition hip_runtime_api.h:1388

hipFuncAttributeRequiredClusterDepth

@ hipFuncAttributeRequiredClusterDepth

The required cluster depth in blocks.

Definition hip_runtime_api.h:1385

hipFuncAttributeRequiredClusterHeight

@ hipFuncAttributeRequiredClusterHeight

The required cluster height in blocks.

Definition hip_runtime_api.h:1384

hipFuncAttributeClusterDimMustBeSet

@ hipFuncAttributeClusterDimMustBeSet

The kernel must launch with a valid cluster size specified.

Definition hip_runtime_api.h:1382

hipFuncAttributeNonPortableClusterSizeAllowed

@ hipFuncAttributeNonPortableClusterSizeAllowed

Is the function allowed to launch with non-portable cluster size.

Definition hip_runtime_api.h:1386

hipExternalSemaphoreHandleTypeNvSciSync

@ hipExternalSemaphoreHandleTypeNvSciSync

Definition hip_runtime_api.h:1491

hipExternalSemaphoreHandleTypeKeyedMutexKmt

@ hipExternalSemaphoreHandleTypeKeyedMutexKmt

Definition hip_runtime_api.h:1493

hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

@ hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:1488

hipExternalSemaphoreHandleTypeKeyedMutex

@ hipExternalSemaphoreHandleTypeKeyedMutex

Definition hip_runtime_api.h:1492

hipExternalSemaphoreHandleTypeD3D11Fence

@ hipExternalSemaphoreHandleTypeD3D11Fence

Definition hip_runtime_api.h:1490

hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

@ hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

Definition hip_runtime_api.h:1495

hipExternalSemaphoreHandleTypeOpaqueFd

@ hipExternalSemaphoreHandleTypeOpaqueFd

Definition hip_runtime_api.h:1486

hipExternalSemaphoreHandleTypeOpaqueWin32

@ hipExternalSemaphoreHandleTypeOpaqueWin32

Definition hip_runtime_api.h:1487

hipExternalSemaphoreHandleTypeTimelineSemaphoreFd

@ hipExternalSemaphoreHandleTypeTimelineSemaphoreFd

Definition hip_runtime_api.h:1494

hipExternalSemaphoreHandleTypeD3D12Fence

@ hipExternalSemaphoreHandleTypeD3D12Fence

Definition hip_runtime_api.h:1489

hipLaunchMemSyncDomainRemote

@ hipLaunchMemSyncDomainRemote

Definition hip_runtime_api.h:1682

hipLaunchMemSyncDomainDefault

@ hipLaunchMemSyncDomainDefault

Definition hip_runtime_api.h:1681

hipDevP2PAttrAccessSupported

@ hipDevP2PAttrAccessSupported

Definition hip_runtime_api.h:790

hipDevP2PAttrHipArrayAccessSupported

@ hipDevP2PAttrHipArrayAccessSupported

Definition hip_runtime_api.h:792

hipDevP2PAttrNativeAtomicSupported

@ hipDevP2PAttrNativeAtomicSupported

Definition hip_runtime_api.h:791

hipDevP2PAttrPerformanceRank

@ hipDevP2PAttrPerformanceRank

Definition hip_runtime_api.h:789

hipGraphDebugDotFlagsKernelNodeAttributes

@ hipGraphDebugDotFlagsKernelNodeAttributes

Definition hip_runtime_api.h:1920

hipGraphDebugDotFlagsMemsetNodeParams

@ hipGraphDebugDotFlagsMemsetNodeParams

Definition hip_runtime_api.h:1912

hipGraphDebugDotFlagsKernelNodeParams

@ hipGraphDebugDotFlagsKernelNodeParams

Definition hip_runtime_api.h:1910

hipGraphDebugDotFlagsExtSemasWaitNodeParams

@ hipGraphDebugDotFlagsExtSemasWaitNodeParams

Definition hip_runtime_api.h:1918

hipGraphDebugDotFlagsHandles

@ hipGraphDebugDotFlagsHandles

Definition hip_runtime_api.h:1922

hipGraphDebugDotFlagsExtSemasSignalNodeParams

@ hipGraphDebugDotFlagsExtSemasSignalNodeParams

Definition hip_runtime_api.h:1916

hipGraphDebugDotFlagsHostNodeParams

@ hipGraphDebugDotFlagsHostNodeParams

Definition hip_runtime_api.h:1913

hipGraphDebugDotFlagsEventNodeParams

@ hipGraphDebugDotFlagsEventNodeParams

Definition hip_runtime_api.h:1914

hipGraphDebugDotFlagsVerbose

@ hipGraphDebugDotFlagsVerbose

Definition hip_runtime_api.h:1908

hipGraphDebugDotFlagsMemcpyNodeParams

@ hipGraphDebugDotFlagsMemcpyNodeParams

Definition hip_runtime_api.h:1911

hipDevSmResourceGroupBackfill

@ hipDevSmResourceGroupBackfill

Definition hip_runtime_api.h:736

hipDevSmResourceGroupDefault

@ hipDevSmResourceGroupDefault

Definition hip_runtime_api.h:735

hipGraphUserObjectMove

@ hipGraphUserObjectMove

Add new reference or retain.

Definition hip_runtime_api.h:1893

hipStreamAddCaptureDependencies

@ hipStreamAddCaptureDependencies

Add new nodes to the dependency set.

Definition hip_runtime_api.h:1874

hipStreamSetCaptureDependencies

@ hipStreamSetCaptureDependencies

Replace the dependency set with the new nodes.

Definition hip_runtime_api.h:1875

hipMemHandleTypeGeneric

@ hipMemHandleTypeGeneric

Generic handle type.

Definition hip_runtime_api.h:2012

hipFlushGPUDirectRDMAWritesOptionHost

@ hipFlushGPUDirectRDMAWritesOptionHost

Definition hip_runtime_api.h:670

hipFlushGPUDirectRDMAWritesOptionMemOps

@ hipFlushGPUDirectRDMAWritesOptionMemOps

Definition hip_runtime_api.h:671

hipFuncCachePreferNone

@ hipFuncCachePreferNone

no preference for shared memory or L1 (default)

Definition hip_runtime_api.h:1394

hipFuncCachePreferEqual

@ hipFuncCachePreferEqual

prefer equal size L1 cache and shared memory

Definition hip_runtime_api.h:1397

hipFuncCachePreferL1

@ hipFuncCachePreferL1

prefer larger L1 cache and smaller shared memory

Definition hip_runtime_api.h:1396

hipFuncCachePreferShared

@ hipFuncCachePreferShared

prefer larger shared memory and smaller L1 cache

Definition hip_runtime_api.h:1395

hipUserObjectNoDestructorSync

@ hipUserObjectNoDestructorSync

Destructor execution is not synchronized.

Definition hip_runtime_api.h:1889

hipDevWorkqueueConfigScopeDeviceCtx

@ hipDevWorkqueueConfigScopeDeviceCtx

Definition hip_runtime_api.h:743

hipDevWorkqueueConfigScopeGreenCtxBalanced

@ hipDevWorkqueueConfigScopeGreenCtxBalanced

Definition hip_runtime_api.h:744

hipGraphMemAttrReservedMemHigh

@ hipGraphMemAttrReservedMemHigh

Definition hip_runtime_api.h:1885

hipGraphMemAttrUsedMemCurrent

@ hipGraphMemAttrUsedMemCurrent

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

Definition hip_runtime_api.h:1879

hipGraphMemAttrUsedMemHigh

@ hipGraphMemAttrUsedMemHigh

Definition hip_runtime_api.h:1881

hipGraphMemAttrReservedMemCurrent

@ hipGraphMemAttrReservedMemCurrent

Definition hip_runtime_api.h:1883

hipMemPoolAttrUsedMemCurrent

@ hipMemPoolAttrUsedMemCurrent

Definition hip_runtime_api.h:1300

hipMemPoolAttrReservedMemHigh

@ hipMemPoolAttrReservedMemHigh

Definition hip_runtime_api.h:1295

hipMemPoolAttrReservedMemCurrent

@ hipMemPoolAttrReservedMemCurrent

Definition hip_runtime_api.h:1289

hipMemPoolAttrReleaseThreshold

@ hipMemPoolAttrReleaseThreshold

Definition hip_runtime_api.h:1284

hipMemPoolAttrUsedMemHigh

@ hipMemPoolAttrUsedMemHigh

Definition hip_runtime_api.h:1306

hipMemPoolReuseAllowInternalDependencies

@ hipMemPoolReuseAllowInternalDependencies

Definition hip_runtime_api.h:1275

hipMemPoolReuseFollowEventDependencies

@ hipMemPoolReuseFollowEventDependencies

Definition hip_runtime_api.h:1262

hipMemPoolReuseAllowOpportunistic

@ hipMemPoolReuseAllowOpportunistic

Definition hip_runtime_api.h:1268

hipDriverEntryPointSuccess

@ hipDriverEntryPointSuccess

Definition hip_runtime_api.h:795

hipDriverEntryPointSymbolNotFound

@ hipDriverEntryPointSymbolNotFound

Definition hip_runtime_api.h:796

hipDriverEntryPointVersionNotSufficent

@ hipDriverEntryPointVersionNotSufficent

Definition hip_runtime_api.h:797

hipMemRangeFlagsMax

@ hipMemRangeFlagsMax

Definition hip_runtime_api.h:2233

hipMemRangeFlagDmaBufMappingTypePcie

@ hipMemRangeFlagDmaBufMappingTypePcie

Definition hip_runtime_api.h:2232

hipDevSmResourceSplitMaxPotentialClusterSize

@ hipDevSmResourceSplitMaxPotentialClusterSize

Definition hip_runtime_api.h:740

hipDevSmResourceSplitIgnoreSmCoscheduling

@ hipDevSmResourceSplitIgnoreSmCoscheduling

Definition hip_runtime_api.h:739

hipMemOperationTypeMap

@ hipMemOperationTypeMap

Map operation.

Definition hip_runtime_api.h:2019

hipMemOperationTypeUnmap

@ hipMemOperationTypeUnmap

Unmap operation.

Definition hip_runtime_api.h:2020

hipGraphicsRegisterFlagsReadOnly

@ hipGraphicsRegisterFlagsReadOnly

HIP will not write to this registered resource, read only.

Definition hip_runtime_api.h:1563

hipGraphicsRegisterFlagsTextureGather

@ hipGraphicsRegisterFlagsTextureGather

HIP will perform texture gather operations on this registered resource, read and write or read only.

Definition hip_runtime_api.h:1567

hipGraphicsRegisterFlagsWriteDiscard

@ hipGraphicsRegisterFlagsWriteDiscard

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

Definition hip_runtime_api.h:1564

hipGraphicsRegisterFlagsNone

@ hipGraphicsRegisterFlagsNone

Definition hip_runtime_api.h:1562

hipGraphicsRegisterFlagsSurfaceLoadStore

@ hipGraphicsRegisterFlagsSurfaceLoadStore

HIP will bind this resource to a surface, read and write.

Definition hip_runtime_api.h:1566

hipMemRangeCoherencyModeFineGrain

@ hipMemRangeCoherencyModeFineGrain

Definition hip_runtime_api.h:1227

hipMemRangeCoherencyModeIndeterminate

@ hipMemRangeCoherencyModeIndeterminate

Definition hip_runtime_api.h:1231

hipMemRangeCoherencyModeCoarseGrain

@ hipMemRangeCoherencyModeCoarseGrain

Definition hip_runtime_api.h:1229

hipMemAccessFlagsProtRead

@ hipMemAccessFlagsProtRead

Set the address range read accessible.

Definition hip_runtime_api.h:1315

hipMemAccessFlagsProtNone

@ hipMemAccessFlagsProtNone

Default, make the address range not accessible.

Definition hip_runtime_api.h:1314

hipMemAccessFlagsProtReadWrite

@ hipMemAccessFlagsProtReadWrite

Set the address range read-write accessible.

Definition hip_runtime_api.h:1316

hipMemAllocationGranularityMinimum

@ hipMemAllocationGranularityMinimum

Minimum granularity.

Definition hip_runtime_api.h:2004

hipMemAllocationGranularityRecommended

@ hipMemAllocationGranularityRecommended

Recommended granularity for performance.

Definition hip_runtime_api.h:2005

hipExtDynDataPrefetchTemporalRegular

@ hipExtDynDataPrefetchTemporalRegular

Regular temporal locality.

Definition hip_runtime_api.h:1708

hipExtDynDataPrefetchTemporalHigh

@ hipExtDynDataPrefetchTemporalHigh

High temporal locality (prefer caching)

Definition hip_runtime_api.h:1709

hipGraphExecUpdateErrorNotSupported

@ hipGraphExecUpdateErrorNotSupported

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

Definition hip_runtime_api.h:1856

hipGraphExecUpdateErrorNodeTypeChanged

@ hipGraphExecUpdateErrorNodeTypeChanged

The update failed because a node type changed.

Definition hip_runtime_api.h:1851

hipGraphExecUpdateErrorTopologyChanged

@ hipGraphExecUpdateErrorTopologyChanged

The update failed because the topology changed.

Definition hip_runtime_api.h:1850

hipGraphExecUpdateErrorUnsupportedFunctionChange

@ hipGraphExecUpdateErrorUnsupportedFunctionChange

Definition hip_runtime_api.h:1858

hipGraphExecUpdateError

@ hipGraphExecUpdateError

Definition hip_runtime_api.h:1848

hipGraphExecUpdateErrorFunctionChanged

@ hipGraphExecUpdateErrorFunctionChanged

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

Definition hip_runtime_api.h:1852

hipGraphExecUpdateSuccess

@ hipGraphExecUpdateSuccess

The update succeeded.

Definition hip_runtime_api.h:1847

hipGraphExecUpdateErrorParametersChanged

@ hipGraphExecUpdateErrorParametersChanged

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

Definition hip_runtime_api.h:1854

hipStreamCaptureStatusInvalidated

@ hipStreamCaptureStatusInvalidated

Definition hip_runtime_api.h:1869

hipStreamCaptureStatusNone

@ hipStreamCaptureStatusNone

Stream is not capturing.

Definition hip_runtime_api.h:1867

hipStreamCaptureStatusActive

@ hipStreamCaptureStatusActive

Stream is actively capturing.

Definition hip_runtime_api.h:1868

hipDeviceAttributeDirectManagedMemAccessFromHost

@ hipDeviceAttributeDirectManagedMemAccessFromHost

Definition hip_runtime_api.h:472

hipDeviceAttributeSurfaceAlignment

@ hipDeviceAttributeSurfaceAlignment

Alignment requirement for surfaces.

Definition hip_runtime_api.h:562

hipDeviceAttributeMaxGridDimX

@ hipDeviceAttributeMaxGridDimX

Max grid size in width.

Definition hip_runtime_api.h:493

hipDeviceAttributeMaxSurfaceCubemapLayered

@ hipDeviceAttributeMaxSurfaceCubemapLayered

Definition hip_runtime_api.h:502

hipDeviceAttributeMaxSurface3D

@ hipDeviceAttributeMaxSurface3D

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

Definition hip_runtime_api.h:500

hipDeviceAttributeMaxPitch

@ hipDeviceAttributeMaxPitch

Maximum pitch in bytes allowed by memory copies.

Definition hip_runtime_api.h:527

hipDeviceAttributeTccDriver

@ hipDeviceAttributeTccDriver

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

Definition hip_runtime_api.h:563

hipDeviceAttributeHostNativeAtomicSupported

@ hipDeviceAttributeHostNativeAtomicSupported

Definition hip_runtime_api.h:475

hipDeviceAttributePageableMemoryAccessUsesHostPageTables

@ hipDeviceAttributePageableMemoryAccessUsesHostPageTables

Definition hip_runtime_api.h:540

hipDeviceAttributeUnused5

@ hipDeviceAttributeUnused5

Previously hipDeviceAttributeGcnArchName.

Definition hip_runtime_api.h:598

hipDeviceAttributeMaxBlockDimY

@ hipDeviceAttributeMaxBlockDimY

Max block size in height.

Definition hip_runtime_api.h:491

hipDeviceAttributeMaxSurfaceCubemap

@ hipDeviceAttributeMaxSurfaceCubemap

Cuda only. Maximum dimensions of Cubemap surface.

Definition hip_runtime_api.h:501

hipDeviceAttributePageableMemoryAccess

@ hipDeviceAttributePageableMemoryAccess

Definition hip_runtime_api.h:538

hipDeviceAttributeClockRate

@ hipDeviceAttributeClockRate

Peak clock frequency in kilohertz.

Definition hip_runtime_api.h:460

hipDeviceAttributeCudaCompatibleEnd

@ hipDeviceAttributeCudaCompatibleEnd

Definition hip_runtime_api.h:589

hipDeviceAttributeMaxTexture1DMipmap

@ hipDeviceAttributeMaxTexture1DMipmap

Maximum size of 1D mipmapped texture.

Definition hip_runtime_api.h:509

hipDeviceAttributeComputeCapabilityMajor

@ hipDeviceAttributeComputeCapabilityMajor

Major compute capability version number.

Definition hip_runtime_api.h:487

hipDeviceAttributeGlobalL1CacheSupported

@ hipDeviceAttributeGlobalL1CacheSupported

Device supports caching globals in L1.

Definition hip_runtime_api.h:474

hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

Definition hip_runtime_api.h:610

hipDeviceAttributeAccessPolicyMaxWindowSize

@ hipDeviceAttributeAccessPolicyMaxWindowSize

Definition hip_runtime_api.h:452

hipDeviceAttributeMaxTexture3DHeight

@ hipDeviceAttributeMaxTexture3DHeight

Maximum dimension height of 3D texture.

Definition hip_runtime_api.h:519

hipDeviceAttributeComputeCapabilityMinor

@ hipDeviceAttributeComputeCapabilityMinor

Minor compute capability version number.

Definition hip_runtime_api.h:530

hipDeviceAttributeNumberOfXccs

@ hipDeviceAttributeNumberOfXccs

Definition hip_runtime_api.h:622

hipDeviceAttributeMaxTextureCubemap

@ hipDeviceAttributeMaxTextureCubemap

Maximum dimensions of Cubemap texture.

Definition hip_runtime_api.h:522

hipDeviceAttributeDeviceOverlap

@ hipDeviceAttributeDeviceOverlap

Definition hip_runtime_api.h:470

hipDeviceAttributeMaxTexture2DLinear

@ hipDeviceAttributeMaxTexture2DLinear

Definition hip_runtime_api.h:515

hipDeviceAttributeHostAllocDmaBufSupported

@ hipDeviceAttributeHostAllocDmaBufSupported

Device supports host-allocated DMABuf buffer sharing.

Definition hip_runtime_api.h:587

hipDeviceAttributeMaxSurface2D

@ hipDeviceAttributeMaxSurface2D

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

Definition hip_runtime_api.h:498

hipDeviceAttributeMaxSurface1DLayered

@ hipDeviceAttributeMaxSurface1DLayered

Cuda only. Maximum dimensions of 1D layered surface.

Definition hip_runtime_api.h:497

hipDeviceAttributeHdpRegFlushCntl

@ hipDeviceAttributeHdpRegFlushCntl

Address of the HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:600

hipDeviceAttributeMaxAvailableVgprsPerThread

@ hipDeviceAttributeMaxAvailableVgprsPerThread

Definition hip_runtime_api.h:629

hipDeviceAttributeComputeMode

@ hipDeviceAttributeComputeMode

Compute mode that device is currently in.

Definition hip_runtime_api.h:461

hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

Definition hip_runtime_api.h:601

hipDeviceAttributeAsicRevision

@ hipDeviceAttributeAsicRevision

Revision of the GPU in this device.

Definition hip_runtime_api.h:614

hipDeviceAttributeUnused4

@ hipDeviceAttributeUnused4

Previously hipDeviceAttributeGcnArch.

Definition hip_runtime_api.h:597

hipDeviceAttributeCooperativeMultiDeviceLaunch

@ hipDeviceAttributeCooperativeMultiDeviceLaunch

Definition hip_runtime_api.h:468

hipDeviceAttributeMaxTexture2DHeight

@ hipDeviceAttributeMaxTexture2DHeight

Maximum dimension hight of 2D texture.

Definition hip_runtime_api.h:511

hipDeviceAttributePersistingL2CacheMaxSize

@ hipDeviceAttributePersistingL2CacheMaxSize

Maximum l2 persisting lines capacity in bytes.

Definition hip_runtime_api.h:547

hipDeviceAttributeEccEnabled

@ hipDeviceAttributeEccEnabled

Whether ECC support is enabled.

Definition hip_runtime_api.h:450

hipDeviceAttributeDmaBufSupported

@ hipDeviceAttributeDmaBufSupported

Device supports DMABuf buffer sharing.

Definition hip_runtime_api.h:582

hipDeviceAttributeExpertSchedMode

@ hipDeviceAttributeExpertSchedMode

Definition hip_runtime_api.h:633

hipDeviceAttributeCanUseHostPointerForRegisteredMem

@ hipDeviceAttributeCanUseHostPointerForRegisteredMem

Definition hip_runtime_api.h:457

hipDeviceAttributePciBusId

@ hipDeviceAttributePciBusId

PCI Bus ID.

Definition hip_runtime_api.h:542

hipDeviceAttributeL2CacheSize

@ hipDeviceAttributeL2CacheSize

Definition hip_runtime_api.h:480

hipDeviceAttributeKernelExecTimeout

@ hipDeviceAttributeKernelExecTimeout

Run time limit for kernels executed on the device.

Definition hip_runtime_api.h:479

hipDeviceAttributeMaxThreadsDim

@ hipDeviceAttributeMaxThreadsDim

Maximum dimension of a block.

Definition hip_runtime_api.h:524

hipDeviceAttributeSingleToDoublePrecisionPerfRatio

@ hipDeviceAttributeSingleToDoublePrecisionPerfRatio

Definition hip_runtime_api.h:559

hipDeviceAttributeMaxGridDimY

@ hipDeviceAttributeMaxGridDimY

Max grid size in height.

Definition hip_runtime_api.h:494

hipDeviceAttributeMultiprocessorCount

@ hipDeviceAttributeMultiprocessorCount

Definition hip_runtime_api.h:533

hipDeviceAttributeAmdSpecificBegin

@ hipDeviceAttributeAmdSpecificBegin

Definition hip_runtime_api.h:590

hipDeviceAttributeMaxRegistersPerMultiprocessor

@ hipDeviceAttributeMaxRegistersPerMultiprocessor

32-bit registers available per block.

Definition hip_runtime_api.h:551

hipDeviceAttributeIsMultiGpuBoard

@ hipDeviceAttributeIsMultiGpuBoard

Multiple GPU devices.

Definition hip_runtime_api.h:478

hipDeviceAttributeSharedMemPerBlockOptin

@ hipDeviceAttributeSharedMemPerBlockOptin

Definition hip_runtime_api.h:556

hipDeviceAttributeMaxSurface2DLayered

@ hipDeviceAttributeMaxSurface2DLayered

Cuda only. Maximum dimensions of 2D layered surface.

Definition hip_runtime_api.h:499

hipDeviceAttributeAmdSpecificEnd

@ hipDeviceAttributeAmdSpecificEnd

Definition hip_runtime_api.h:638

hipDeviceAttributeMemoryClockRate

@ hipDeviceAttributeMemoryClockRate

Peak memory clock frequency in kilohertz.

Definition hip_runtime_api.h:529

hipDeviceAttributeMaxGridDimZ

@ hipDeviceAttributeMaxGridDimZ

Max grid size in depth.

Definition hip_runtime_api.h:495

hipDeviceAttributeHdpMemFlushCntl

@ hipDeviceAttributeHdpMemFlushCntl

Address of the HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:599

hipDeviceAttributeUnused2

@ hipDeviceAttributeUnused2

Previously hipDeviceAttributeUuid.

Definition hip_runtime_api.h:571

hipDeviceAttributeFineGrainSupport

@ hipDeviceAttributeFineGrainSupport

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

Definition hip_runtime_api.h:620

hipDeviceAttributeCooperativeLaunch

@ hipDeviceAttributeCooperativeLaunch

Support cooperative launch.

Definition hip_runtime_api.h:467

hipDeviceAttributeUnifiedAddressing

@ hipDeviceAttributeUnifiedAddressing

Definition hip_runtime_api.h:569

hipDeviceAttributeAsyncEngineCount

@ hipDeviceAttributeAsyncEngineCount

Asynchronous engines number.

Definition hip_runtime_api.h:454

hipDeviceAttributeMultiGpuBoardGroupID

@ hipDeviceAttributeMultiGpuBoardGroupID

Definition hip_runtime_api.h:531

hipDeviceAttributeStreamPrioritiesSupported

@ hipDeviceAttributeStreamPrioritiesSupported

Whether to support stream priorities.

Definition hip_runtime_api.h:561

hipDeviceAttributeMaxSharedMemoryPerBlock

@ hipDeviceAttributeMaxSharedMemoryPerBlock

Definition hip_runtime_api.h:554

hipDeviceAttributeLocalL1CacheSupported

@ hipDeviceAttributeLocalL1CacheSupported

caching locals in L1 is supported

Definition hip_runtime_api.h:482

hipDeviceAttributeCanUseStreamWaitValue

@ hipDeviceAttributeCanUseStreamWaitValue

Definition hip_runtime_api.h:615

hipDeviceAttributeMaxRegistersPerBlock

@ hipDeviceAttributeMaxRegistersPerBlock

Definition hip_runtime_api.h:548

hipDeviceAttributeMaxThreadsPerBlock

@ hipDeviceAttributeMaxThreadsPerBlock

Maximum number of threads per block.

Definition hip_runtime_api.h:525

hipDeviceAttributePciDomainId

@ hipDeviceAttributePciDomainId

PCI Domain Id.

Definition hip_runtime_api.h:544

hipDeviceAttributeMemoryBusWidth

@ hipDeviceAttributeMemoryBusWidth

Global memory bus width in bits.

Definition hip_runtime_api.h:528

hipDeviceAttributeMemoryPoolSupportedHandleTypes

@ hipDeviceAttributeMemoryPoolSupportedHandleTypes

Definition hip_runtime_api.h:578

hipDeviceAttributeComputePreemptionSupported

@ hipDeviceAttributeComputePreemptionSupported

Device supports Compute Preemption.

Definition hip_runtime_api.h:462

hipDeviceAttributeMaxSurface1D

@ hipDeviceAttributeMaxSurface1D

Maximum size of 1D surface.

Definition hip_runtime_api.h:496

hipDeviceAttributeUnused1

@ hipDeviceAttributeUnused1

Previously hipDeviceAttributeName.

Definition hip_runtime_api.h:537

hipDeviceAttributeMaxTexture3DAlt

@ hipDeviceAttributeMaxTexture3DAlt

Maximum dimensions of alternate 3D texture.

Definition hip_runtime_api.h:521

hipDeviceAttributeMaxTexture1DLinear

@ hipDeviceAttributeMaxTexture1DLinear

Definition hip_runtime_api.h:506

hipDeviceAttributeMaxTexture2DGather

@ hipDeviceAttributeMaxTexture2DGather

Definition hip_runtime_api.h:512

hipDeviceAttributeWallClockRate

@ hipDeviceAttributeWallClockRate

Constant frequency of wall clock in kilohertz.

Definition hip_runtime_api.h:621

hipDeviceAttributePciDeviceId

@ hipDeviceAttributePciDeviceId

PCI Device ID. Returns pcie slot id.

Definition hip_runtime_api.h:543

hipDeviceAttributeCanMapHostMemory

@ hipDeviceAttributeCanMapHostMemory

Definition hip_runtime_api.h:455

hipDeviceAttributeMaxTexture1DWidth

@ hipDeviceAttributeMaxTexture1DWidth

Maximum size of 1D texture.

Definition hip_runtime_api.h:504

hipDeviceAttributeConcurrentManagedAccess

@ hipDeviceAttributeConcurrentManagedAccess

Definition hip_runtime_api.h:465

hipDeviceAttributeVendorSpecificBegin

@ hipDeviceAttributeVendorSpecificBegin

Definition hip_runtime_api.h:639

hipDeviceAttributeManagedMemory

@ hipDeviceAttributeManagedMemory

Device supports allocating managed memory on this system.

Definition hip_runtime_api.h:488

hipDeviceAttributeHostNumaId

@ hipDeviceAttributeHostNumaId

Definition hip_runtime_api.h:580

hipDeviceAttributeIntegrated

@ hipDeviceAttributeIntegrated

Device is integrated GPU.

Definition hip_runtime_api.h:477

hipDeviceAttributeMaxTexture2DLayered

@ hipDeviceAttributeMaxTexture2DLayered

Maximum dimensions of 2D layered texture.

Definition hip_runtime_api.h:514

hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

Definition hip_runtime_api.h:604

hipDeviceAttributeMaxTexture3DDepth

@ hipDeviceAttributeMaxTexture3DDepth

Maximum dimension depth of 3D texture.

Definition hip_runtime_api.h:520

hipDeviceAttributePciChipId

@ hipDeviceAttributePciChipId

GPU Manufacturer device id.

Definition hip_runtime_api.h:632

hipDeviceAttributeImageSupport

@ hipDeviceAttributeImageSupport

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

Definition hip_runtime_api.h:617

hipDeviceAttributeTotalGlobalMem

@ hipDeviceAttributeTotalGlobalMem

Global memory available on devicice.

Definition hip_runtime_api.h:568

hipDeviceAttributeMaxBlocksPerMultiProcessor

@ hipDeviceAttributeMaxBlocksPerMultiProcessor

Max block size per multiprocessor.

Definition hip_runtime_api.h:489

hipDeviceAttributeHandleTypeFabricSupported

@ hipDeviceAttributeHandleTypeFabricSupported

Device supports exporting memory to a fabric handle.

Definition hip_runtime_api.h:586

hipDeviceAttributeIsLargeBar

@ hipDeviceAttributeIsLargeBar

Whether it is LargeBar.

Definition hip_runtime_api.h:613

hipDeviceAttributeMaxTexture2DWidth

@ hipDeviceAttributeMaxTexture2DWidth

Maximum dimension width of 2D texture.

Definition hip_runtime_api.h:510

hipDeviceAttributeMaxBlockDimX

@ hipDeviceAttributeMaxBlockDimX

Max block size in width.

Definition hip_runtime_api.h:490

hipDeviceAttributeMaxTexture3DWidth

@ hipDeviceAttributeMaxTexture3DWidth

Maximum dimension width of 3D texture.

Definition hip_runtime_api.h:518

hipDeviceAttributeUnused3

@ hipDeviceAttributeUnused3

Previously hipDeviceAttributeArch.

Definition hip_runtime_api.h:595

hipDeviceAttributeTotalConstantMemory

@ hipDeviceAttributeTotalConstantMemory

Constant memory size in bytes.

Definition hip_runtime_api.h:567

hipDeviceAttributeTextureAlignment

@ hipDeviceAttributeTextureAlignment

Alignment requirement for textures.

Definition hip_runtime_api.h:564

hipDeviceAttributeMaxTexture1DLayered

@ hipDeviceAttributeMaxTexture1DLayered

Maximum dimensions of 1D layered texture.

Definition hip_runtime_api.h:505

hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

@ hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

Maximum Shared Memory PerMultiprocessor.

Definition hip_runtime_api.h:596

hipDeviceAttributeGPUDirectRDMAWithHipVMMSupported

@ hipDeviceAttributeGPUDirectRDMAWithHipVMMSupported

Definition hip_runtime_api.h:583

hipDeviceAttributeReservedSharedMemPerBlock

@ hipDeviceAttributeReservedSharedMemPerBlock

Definition hip_runtime_api.h:552

hipDeviceAttributeCudaCompatibleBegin

@ hipDeviceAttributeCudaCompatibleBegin

Definition hip_runtime_api.h:448

hipDeviceAttributeConcurrentKernels

@ hipDeviceAttributeConcurrentKernels

Definition hip_runtime_api.h:463

hipDeviceAttributeLuid

@ hipDeviceAttributeLuid

Definition hip_runtime_api.h:483

hipDeviceAttributePciDomainID

@ hipDeviceAttributePciDomainID

PCI Domain ID, for backward compatibility.

Definition hip_runtime_api.h:545

hipDeviceAttributeMaxThreadsPerMultiProcessor

@ hipDeviceAttributeMaxThreadsPerMultiProcessor

Maximum resident threads per multiprocessor.

Definition hip_runtime_api.h:526

hipDeviceAttributeTexturePitchAlignment

@ hipDeviceAttributeTexturePitchAlignment

Definition hip_runtime_api.h:565

hipDeviceAttributePhysicalMultiProcessorCount

@ hipDeviceAttributePhysicalMultiProcessorCount

Definition hip_runtime_api.h:618

hipDeviceAttributeHostRegisterSupported

@ hipDeviceAttributeHostRegisterSupported

Definition hip_runtime_api.h:576

hipDeviceAttributeSharedMemPerMultiprocessor

@ hipDeviceAttributeSharedMemPerMultiprocessor

Shared memory available per multiprocessor.

Definition hip_runtime_api.h:558

hipDeviceAttributeLuidDeviceNodeMask

@ hipDeviceAttributeLuidDeviceNodeMask

Definition hip_runtime_api.h:485

hipDeviceAttributeMaxTextureCubemapLayered

@ hipDeviceAttributeMaxTextureCubemapLayered

Maximum dimensions of Cubemap layered texture.

Definition hip_runtime_api.h:523

hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

Definition hip_runtime_api.h:607

hipDeviceAttributeVirtualMemoryManagementSupported

@ hipDeviceAttributeVirtualMemoryManagementSupported

Definition hip_runtime_api.h:574

hipDeviceAttributeMemoryPoolsSupported

@ hipDeviceAttributeMemoryPoolsSupported

Device supports HIP Stream Ordered Memory Allocator.

Definition hip_runtime_api.h:573

hipDeviceAttributeClockInstructionRate

@ hipDeviceAttributeClockInstructionRate

Definition hip_runtime_api.h:592

hipDeviceAttributeMaxTexture2DMipmap

@ hipDeviceAttributeMaxTexture2DMipmap

Maximum dimensions of 2D mipmapped texture.

Definition hip_runtime_api.h:517

hipDeviceAttributeMaxDynDataPrefetchRegions

@ hipDeviceAttributeMaxDynDataPrefetchRegions

Definition hip_runtime_api.h:635

hipDeviceAttributeMaxBlockDimZ

@ hipDeviceAttributeMaxBlockDimZ

Max block size in depth.

Definition hip_runtime_api.h:492

hipDeviceAttributeWarpSize

@ hipDeviceAttributeWarpSize

Warp size in threads.

Definition hip_runtime_api.h:572

hipGPUDirectRDMAWritesOrderingOwner

@ hipGPUDirectRDMAWritesOrderingOwner

Definition hip_runtime_api.h:676

hipGPUDirectRDMAWritesOrderingNone

@ hipGPUDirectRDMAWritesOrderingNone

Definition hip_runtime_api.h:675

hipGPUDirectRDMAWritesOrderingAllDevices

@ hipGPUDirectRDMAWritesOrderingAllDevices

Definition hip_runtime_api.h:677

hipMemAllocationTypeManaged

@ hipMemAllocationTypeManaged

Definition hip_runtime_api.h:1337

hipMemAllocationTypeMax

@ hipMemAllocationTypeMax

Definition hip_runtime_api.h:1339

hipMemAllocationTypePinned

@ hipMemAllocationTypePinned

Definition hip_runtime_api.h:1336

hipMemAllocationTypeUncached

@ hipMemAllocationTypeUncached

Definition hip_runtime_api.h:1338

hipMemAllocationTypeInvalid

@ hipMemAllocationTypeInvalid

Definition hip_runtime_api.h:1332

hipClusterSchedulingPolicyDefault

@ hipClusterSchedulingPolicyDefault

the default scheduling policy

Definition hip_runtime_api.h:1698

hipClusterSchedulingPolicyLoadBalancing

@ hipClusterSchedulingPolicyLoadBalancing

Dynamically balance block assignment to optimize resource usage.

Definition hip_runtime_api.h:1700

hipClusterSchedulingPolicySpread

@ hipClusterSchedulingPolicySpread

distribute blocks evenly across cluster's CUs

Definition hip_runtime_api.h:1699

hipMemoryTypeDevice

@ hipMemoryTypeDevice

Definition hip_runtime_api.h:419

hipMemoryTypeHost

@ hipMemoryTypeHost

Memory is physically located on host.

Definition hip_runtime_api.h:418

hipMemoryTypeUnregistered

@ hipMemoryTypeUnregistered

Unregistered memory.

Definition hip_runtime_api.h:417

hipMemoryTypeArray

@ hipMemoryTypeArray

Definition hip_runtime_api.h:424

hipMemoryTypeManaged

@ hipMemoryTypeManaged

Definition hip_runtime_api.h:421

hipMemoryTypeUnified

@ hipMemoryTypeUnified

unified address space

Definition hip_runtime_api.h:426

hipGraphInstantiateFlagAutoFreeOnLaunch

@ hipGraphInstantiateFlagAutoFreeOnLaunch

Automatically free memory allocated in a graph before relaunching.

Definition hip_runtime_api.h:1897

hipGraphInstantiateFlagUseNodePriority

@ hipGraphInstantiateFlagUseNodePriority

Definition hip_runtime_api.h:1902

hipGraphInstantiateFlagUpload

@ hipGraphInstantiateFlagUpload

Automatically upload the graph after instantiation.

Definition hip_runtime_api.h:1899

hipGraphInstantiateFlagDeviceLaunch

@ hipGraphInstantiateFlagDeviceLaunch

Instantiate the graph to be launched from the device.

Definition hip_runtime_api.h:1900

hipDevResourceTypeWorkqueue

@ hipDevResourceTypeWorkqueue

Definition hip_runtime_api.h:732

hipDevResourceTypeSm

@ hipDevResourceTypeSm

Definition hip_runtime_api.h:730

hipDevResourceTypeInvalid

@ hipDevResourceTypeInvalid

Definition hip_runtime_api.h:729

hipDevResourceTypeWorkqueueConfig

@ hipDevResourceTypeWorkqueueConfig

Definition hip_runtime_api.h:731

hipArraySparseSubresourceTypeSparseLevel

@ hipArraySparseSubresourceTypeSparseLevel

Sparse level.

Definition hip_runtime_api.h:2027

hipArraySparseSubresourceTypeMiptail

@ hipArraySparseSubresourceTypeMiptail

Miptail.

Definition hip_runtime_api.h:2028

HIP_LAUNCH_CONFIG

Definition hip_runtime_api.h:2199

hipAccessPolicyWindow

Definition hip_runtime_api.h:1661

hipArrayMapInfo

Definition hip_runtime_api.h:2034

hipArrayMemoryRequirements

Definition hip_runtime_api.h:2215

hipBatchMemOpNodeParams

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

Definition hip_runtime_api.h:1185

hipChildGraphNodeParams

Definition hip_runtime_api.h:2084

hipDevResource

Definition hip_runtime_api.h:766

hipDevSmResource

Definition hip_runtime_api.h:749

hipDevSmResourceGroupParams

Definition hip_runtime_api.h:778

hipDevWorkqueueConfigResource

Definition hip_runtime_api.h:756

hipDevWorkqueueResource

Definition hip_runtime_api.h:762

hipDeviceArch_t

Definition hip_runtime_api.h:53

hipDeviceProp_t

Definition hip_runtime_api.h:260

hipEventRecordNodeParams

Definition hip_runtime_api.h:2099

hipEventWaitNodeParams

Definition hip_runtime_api.h:2092

hipExtDynDataPrefetchConfig

Configuration for dynamic data prefetch.

Definition hip_runtime_api.h:1744

hipExtDynDataPrefetchRegion

Describes one 2D memory region to prefetch into L2 cache.

Definition hip_runtime_api.h:1720

hipExternalMemoryBufferDesc

Definition hip_runtime_api.h:1471

hipExternalMemoryHandleDesc

Definition hip_runtime_api.h:1457

hipExternalMemoryMipmappedArrayDesc

Definition hip_runtime_api.h:1477

hipExternalSemaphoreHandleDesc

Definition hip_runtime_api.h:1497

hipExternalSemaphoreSignalNodeParams

Definition hip_runtime_api.h:1974

hipExternalSemaphoreSignalParams

Definition hip_runtime_api.h:1511

hipExternalSemaphoreWaitNodeParams

Definition hip_runtime_api.h:1986

hipExternalSemaphoreWaitParams

Definition hip_runtime_api.h:1531

hipFuncAttributes

Definition hip_runtime_api.h:821

hipFunctionLaunchParams

Definition hip_runtime_api.h:1435

hipGraphEdgeData

Definition hip_runtime_api.h:2156

hipGraphInstantiateParams

Definition hip_runtime_api.h:1944

hipGraphNodeParams

Definition hip_runtime_api.h:2113

hipHostNodeParams

Definition hip_runtime_api.h:1617

hipIpcEventHandle_t

Definition hip_runtime_api.h:805

hipIpcMemHandle_t

Definition hip_runtime_api.h:802

hipKernelNodeParams

Definition hip_runtime_api.h:1621

hipLaunchAttribute

Definition hip_runtime_api.h:2175

hipLaunchConfig_t

Definition hip_runtime_api.h:2187

hipLaunchMemSyncDomainMap

Definition hip_runtime_api.h:1672

hipLaunchParams

Definition hip_runtime_api.h:1424

hipMemAccessDesc

Definition hip_runtime_api.h:1324

hipMemAllocNodeParams

Definition hip_runtime_api.h:1638

hipMemAllocationProp

Definition hip_runtime_api.h:1956

hipMemFabricHandle_t

Definition hip_runtime_api.h:808

hipMemFreeNodeParams

Definition hip_runtime_api.h:2106

hipMemPoolProps

Definition hip_runtime_api.h:1356

hipMemPoolPtrExportData

Definition hip_runtime_api.h:1372

hipMemcpyNodeParams

Definition hip_runtime_api.h:2075

hipMemsetParams

Definition hip_runtime_api.h:1629

hipPointerAttribute_t

Definition hip_runtime_api.h:433

hipStreamBatchMemOpParams::hipStreamMemOpFlushRemoteWritesParams_t

Definition hip_runtime_api.h:1147

hipStreamBatchMemOpParams::hipStreamMemOpMemoryBarrierParams_t

Definition hip_runtime_api.h:1151

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t

Definition hip_runtime_api.h:1127

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t

Definition hip_runtime_api.h:1137

hipUUID

Definition hip_runtime_api.h:84

hipLaunchAttributeValue

Definition hip_runtime_api.h:1771

hipStreamBatchMemOpParams

Union representing batch memory operation parameters for HIP streams.

Definition hip_runtime_api.h:1125

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:108

hipJitOption

hipJitOption

Definition linker_types.h:31

hipJitInputType

hipJitInputType

Definition linker_types.h:76

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.

hipMipmappedArrayGetMemoryRequirements

hipError_t hipMipmappedArrayGetMemoryRequirements(hipArrayMemoryRequirements *memoryRequirements, hipMipmappedArray_t mipmap, hipDevice_t device)

Returns the memory requirements of a HIP mipmapped array.

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.

hipMemPrefetchBatchAsync

hipError_t hipMemPrefetchBatchAsync(void **dev_ptrs, size_t *sizes, size_t count, hipMemLocation *prefetch_locs, size_t *prefetch_loc_idxs, size_t num_prefetch_locs, unsigned long long flags, hipStream_t stream)

Prefetches a batch of memory ranges to the specified locations 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.

hipDrvMemDiscardBatchAsync

hipError_t hipDrvMemDiscardBatchAsync(hipDeviceptr_t *dptrs, size_t *sizes, size_t count, unsigned long long flags, hipStream_t stream)

Discards a batch of memory ranges asynchronously (driver API variant).

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.

hipMemDiscardAndPrefetchBatchAsync

hipError_t hipMemDiscardAndPrefetchBatchAsync(void **dptrs, size_t *sizes, size_t count, hipMemLocation *prefetchLocs, size_t *prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, hipStream_t stream)

Discards and prefetches a batch of memory ranges asynchronously.

hipDrvMemDiscardAndPrefetchBatchAsync

hipError_t hipDrvMemDiscardAndPrefetchBatchAsync(hipDeviceptr_t *dptrs, size_t *sizes, size_t count, hipMemLocation *prefetchLocs, size_t *prefetchLocIdxs, size_t numPrefetchLocs, unsigned long long flags, hipStream_t stream)

Discards and prefetches a batch of memory ranges asynchronously (driver API variant).

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.

hipMemDiscardBatchAsync

hipError_t hipMemDiscardBatchAsync(void **dev_ptrs, size_t *sizes, size_t count, unsigned long long flags, hipStream_t stream)

Discards a batch of memory ranges asynchronously.

hipMemAdvise_v2

hipError_t hipMemAdvise_v2(const void *dev_ptr, size_t count, hipMemoryAdvise advice, hipMemLocation location)

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

hipModuleEnumerateFunctions

hipError_t hipModuleEnumerateFunctions(hipFunction_t *functions, unsigned int numFunctions, hipModule_t mod)

Returns the function handles within a module.

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.

hipLibraryGetGlobal

hipError_t hipLibraryGetGlobal(void **dptr, size_t *bytes, hipLibrary_t library, const char *name)

Get device pointer to a __device__ global variable defined in a library.

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.

hipKernelGetParamInfo

hipError_t hipKernelGetParamInfo(hipKernel_t kernel, size_t paramIndex, size_t *paramOffset, size_t *paramSize)

Returns the offset and size of a kernel parameter.

hipKernelGetAttribute

hipError_t hipKernelGetAttribute(int *pi, hipFunction_attribute attrib, hipKernel_t kernel, hipDevice_t dev)

Returns information about a kernel.

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.

hipLibraryGetManaged

hipError_t hipLibraryGetManaged(void **dptr, size_t *bytes, hipLibrary_t library, const char *name)

Get host pointer to a __managed__ variable defined in a library.

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

hipOccupancyMaxActiveClusters

hipError_t hipOccupancyMaxActiveClusters(int *numClusters, const void *f, const hipLaunchConfig_t *config)

determines the amount of active kernel clusters can co-exist at the same time in a device

hipOccupancyMaxPotentialClusterSize

hipError_t hipOccupancyMaxPotentialClusterSize(int *clusterSize, const void *f, const hipLaunchConfig_t *config)

returns the maximum cluster size (in number of blocks) that can run on the device

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:3332

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.

hipMemGetDefaultMemPool

hipError_t hipMemGetDefaultMemPool(hipMemPool_t *memPool, hipMemLocation *location, hipMemAllocationType type)

Returns the default memory pool for a given location and allocation type.

hipMemSetMemPool

hipError_t hipMemSetMemPool(hipMemLocation *location, hipMemAllocationType type, hipMemPool_t pool)

Sets memory pool for memory location and allocation type.

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.

hipMemGetMemPool

hipError_t hipMemGetMemPool(hipMemPool_t *pool, hipMemLocation *location, hipMemAllocationType type)

Retrieves memory pool for memory location and allocation type.

hipDestroySurfaceObject

hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject)

Destroy a surface object.

hipExtEnableLogging

hipError_t hipExtEnableLogging()

Enable HIP runtime logging.

hipCreateSurfaceObject

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

Create a surface object.

hipExtDisableLogging

hipError_t hipExtDisableLogging()

Disable HIP runtime logging.

hipExtSetLoggingParams

hipError_t hipExtSetLoggingParams(size_t log_level, size_t log_size, size_t log_mask)

Set HIP runtime logging parameters.

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 handle for the allocation described by the properties and given 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

hip_deprecated.h

hipDeviceProp_tR0000

Definition hip_deprecated.h:13

hipErrorStreamDetached

hipErrorStreamDetached

The stream is detached.

Definition hip_runtime_api.h:222

hipErrorIllegalAddress

hipErrorIllegalAddress

Definition hip_runtime_api.h:172

hipErrorMemoryAllocation

hipErrorMemoryAllocation

Memory allocation error.

Definition hip_runtime_api.h:118

hipErrorNotFound

hipErrorNotFound

Not found.

Definition hip_runtime_api.h:167

hipErrorProfilerDisabled

hipErrorProfilerDisabled

Definition hip_runtime_api.h:123

hipErrorInvalidDevicePointer

hipErrorInvalidDevicePointer

Invalid Device Pointer.

Definition hip_runtime_api.h:130

HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

@ HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

Definition hip_runtime_api.h:41

HIP_ERROR_INVALID_VALUE

@ HIP_ERROR_INVALID_VALUE

Definition hip_runtime_api.h:39

HIP_SUCCESS

@ HIP_SUCCESS

Definition hip_runtime_api.h:38

HIP_ERROR_NOT_INITIALIZED

@ HIP_ERROR_NOT_INITIALIZED

Definition hip_runtime_api.h:40

hipErrorRuntimeMemory

hipErrorRuntimeMemory

Definition hip_runtime_api.h:225

hipErrorInvalidImage

hipErrorInvalidImage

Invalid image.

Definition hip_runtime_api.h:138

hipErrorPeerAccessUnsupported

hipErrorPeerAccessUnsupported

Definition hip_runtime_api.h:155

hipErrorArrayIsMapped

hipErrorArrayIsMapped

Definition hip_runtime_api.h:145

hipErrorStreamCaptureIsolation

hipErrorStreamCaptureIsolation

Definition hip_runtime_api.h:200

hipErrorInvalidKernelFile

hipErrorInvalidKernelFile

In CUDA DRV, it is CUDA_ERROR_INVALID_PTX.

Definition hip_runtime_api.h:156

hipErrorNotMapped

hipErrorNotMapped

Definition hip_runtime_api.h:149

hipErrorInvalidClusterSize

hipErrorInvalidClusterSize

calculations

Definition hip_runtime_api.h:229

hipErrorGraphExecUpdateFailure

hipErrorGraphExecUpdateFailure

Definition hip_runtime_api.h:213

hipErrorNotInitialized

hipErrorNotInitialized

Invalid not initialized.

Definition hip_runtime_api.h:119

hipErrorInvalidResourceHandle

hipErrorInvalidResourceHandle

Resource handle (hipEvent_t or hipStream_t) invalid.

Definition hip_runtime_api.h:165

hipErrorSharedObjectInitFailed

hipErrorSharedObjectInitFailed

Failed to initialize shared object.

Definition hip_runtime_api.h:161

hipErrorInvalidPitchValue

hipErrorInvalidPitchValue

Invalid pitch value.

Definition hip_runtime_api.h:128

hipErrorNoBinaryForGpu

hipErrorNoBinaryForGpu

Definition hip_runtime_api.h:147

hipErrorInvalidContext

hipErrorInvalidContext

Produced when input context is invalid.

Definition hip_runtime_api.h:139

hipErrorStreamCaptureUnsupported

hipErrorStreamCaptureUnsupported

Definition hip_runtime_api.h:191

hipErrorPeerAccessNotEnabled

hipErrorPeerAccessNotEnabled

Peer access was never enabled from the current device.

Definition hip_runtime_api.h:177

hipErrorOperatingSystem

hipErrorOperatingSystem

Not the correct operating system.

Definition hip_runtime_api.h:162

hipErrorStreamCaptureUnjoined

hipErrorStreamCaptureUnjoined

Definition hip_runtime_api.h:198

hipErrorInitializationError

hipErrorInitializationError

Definition hip_runtime_api.h:121

hipErrorNotMappedAsPointer

hipErrorNotMappedAsPointer

Definition hip_runtime_api.h:151

hipErrorPriorLaunchFailure

hipErrorPriorLaunchFailure

Definition hip_runtime_api.h:134

hipErrorContextIsDestroyed

hipErrorContextIsDestroyed

The context is already destroyed.

Definition hip_runtime_api.h:179

hipErrorInvalidValue

hipErrorInvalidValue

Definition hip_runtime_api.h:114

hipErrorLaunchTimeOut

hipErrorLaunchTimeOut

Timeout for the launch.

Definition hip_runtime_api.h:174

hipErrorUnmapFailed

hipErrorUnmapFailed

Definition hip_runtime_api.h:144

hipErrorSetOnActiveProcess

hipErrorSetOnActiveProcess

The process is active.

Definition hip_runtime_api.h:178

hipErrorFileNotFound

hipErrorFileNotFound

the file is not found.

Definition hip_runtime_api.h:159

hipErrorLaunchFailure

hipErrorLaunchFailure

An exception occurred on the device while executing a kernel.

Definition hip_runtime_api.h:185

hipErrorInvalidDevice

hipErrorInvalidDevice

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

Definition hip_runtime_api.h:137

hipErrorUnsupportedLimit

hipErrorUnsupportedLimit

Unsupported limit.

Definition hip_runtime_api.h:153

hipErrorMapBufferObjectFailed

hipErrorMapBufferObjectFailed

Produced when the IPC memory attach failed from ROCr.

Definition hip_runtime_api.h:143

hipErrorHostMemoryAlreadyRegistered

hipErrorHostMemoryAlreadyRegistered

Definition hip_runtime_api.h:181

hipErrorMissingConfiguration

hipErrorMissingConfiguration

Definition hip_runtime_api.h:133

hipErrorSharedObjectSymbolNotFound

hipErrorSharedObjectSymbolNotFound

Definition hip_runtime_api.h:160

hipErrorECCNotCorrectable

hipErrorECCNotCorrectable

Definition hip_runtime_api.h:152

hipErrorStreamCaptureWrongThread

hipErrorStreamCaptureWrongThread

Definition hip_runtime_api.h:209

hipErrorAssert

hipErrorAssert

Produced when the kernel calls assert.

Definition hip_runtime_api.h:180

hipErrorContextAlreadyInUse

hipErrorContextAlreadyInUse

The context is already in use.

Definition hip_runtime_api.h:154

hipErrorNotReady

hipErrorNotReady

Definition hip_runtime_api.h:168

hipErrorInvalidSource

hipErrorInvalidSource

Invalid source.

Definition hip_runtime_api.h:158

hipErrorLaunchOutOfResources

hipErrorLaunchOutOfResources

Out of resources error.

Definition hip_runtime_api.h:173

hipErrorInvalidDeviceFunction

hipErrorInvalidDeviceFunction

Invalid device function.

Definition hip_runtime_api.h:135

hipErrorCooperativeLaunchTooLarge

hipErrorCooperativeLaunchTooLarge

Definition hip_runtime_api.h:186

hipErrorAlreadyMapped

hipErrorAlreadyMapped

Definition hip_runtime_api.h:146

hipErrorInvalidResourceType

hipErrorInvalidResourceType

Resource type is not valid for the operation.

Definition hip_runtime_api.h:219

hipErrorProfilerNotInitialized

hipErrorProfilerNotInitialized

Definition hip_runtime_api.h:124

hipErrorProfilerAlreadyStarted

hipErrorProfilerAlreadyStarted

Definition hip_runtime_api.h:125

hipErrorInvalidChannelDescriptor

hipErrorInvalidChannelDescriptor

Invalid channel descriptor.

Definition hip_runtime_api.h:217

hipErrorNoDevice

hipErrorNoDevice

Call to hipGetDeviceCount returned 0 devices.

Definition hip_runtime_api.h:136

hipErrorMapFailed

hipErrorMapFailed

Definition hip_runtime_api.h:141

hipErrorStreamCaptureInvalidated

hipErrorStreamCaptureInvalidated

Definition hip_runtime_api.h:193

hipErrorProfilerAlreadyStopped

hipErrorProfilerAlreadyStopped

Definition hip_runtime_api.h:126

hipErrorDeinitialized

hipErrorDeinitialized

Deinitialized.

Definition hip_runtime_api.h:122

hipErrorPeerAccessAlreadyEnabled

hipErrorPeerAccessAlreadyEnabled

Definition hip_runtime_api.h:175

hipErrorNotMappedAsArray

hipErrorNotMappedAsArray

Definition hip_runtime_api.h:150

hipErrorNotSupported

hipErrorNotSupported

Produced when the hip API is not supported/implemented.

Definition hip_runtime_api.h:190

hipErrorInvalidConfiguration

hipErrorInvalidConfiguration

Invalide configuration.

Definition hip_runtime_api.h:127

hipErrorStreamCaptureImplicit

hipErrorStreamCaptureImplicit

Definition hip_runtime_api.h:204

hipErrorStreamCaptureMerge

hipErrorStreamCaptureMerge

Definition hip_runtime_api.h:195

hipErrorInvalidGraphicsContext

hipErrorInvalidGraphicsContext

Definition hip_runtime_api.h:157

hipErrorIllegalState

hipErrorIllegalState

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

Definition hip_runtime_api.h:166

hipErrorOutOfMemory

hipErrorOutOfMemory

out of memory range.

Definition hip_runtime_api.h:116

hipErrorInvalidSymbol

hipErrorInvalidSymbol

Invalid symbol.

Definition hip_runtime_api.h:129

hipSuccess

hipSuccess

Successful completion.

Definition hip_runtime_api.h:113

hipErrorUnknown

hipErrorUnknown

Unknown error.

Definition hip_runtime_api.h:223

hipErrorInvalidHandle

hipErrorInvalidHandle

Invalide handle.

Definition hip_runtime_api.h:163

hipErrorStreamCaptureUnmatched

hipErrorStreamCaptureUnmatched

The capture was not initiated in this stream.

Definition hip_runtime_api.h:197

hipErrorCapturedEvent

hipErrorCapturedEvent

Definition hip_runtime_api.h:207

hipErrorAlreadyAcquired

hipErrorAlreadyAcquired

Definition hip_runtime_api.h:148

hipErrorInsufficientDriver

hipErrorInsufficientDriver

Definition hip_runtime_api.h:132

hipErrorHostMemoryNotRegistered

hipErrorHostMemoryNotRegistered

Definition hip_runtime_api.h:183

hipErrorInvalidTexture

hipErrorInvalidTexture

Invalid texture.

Definition hip_runtime_api.h:218

hipErrorRuntimeOther

hipErrorRuntimeOther

Definition hip_runtime_api.h:227

hipErrorContextAlreadyCurrent

hipErrorContextAlreadyCurrent

Definition hip_runtime_api.h:140

hipErrorInvalidMemcpyDirection

hipErrorInvalidMemcpyDirection

Invalid memory copy direction.

Definition hip_runtime_api.h:131

hipErrorInvalidResourceConfiguration

hipErrorInvalidResourceConfiguration

Definition hip_runtime_api.h:220

linker_types.h

hip_impl

Definition hip_runtime_api.h:715

hip_impl::hip_init

hipError_t hip_init()

dim3

Definition hip_runtime_api.h:1412

dim3::y

uint32_t y

y

Definition hip_runtime_api.h:1414

dim3::z

uint32_t z

z

Definition hip_runtime_api.h:1415

dim3::x

uint32_t x

x

Definition hip_runtime_api.h:1413

dim3::dim3

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

Definition hip_runtime_api.h:1417

texture

Definition texture_types.h:131

textureReference

Definition texture_types.h:79

surface_types.h

Defines surface types for HIP runtime.

hipSurfaceObject_t

struct __hip_surface * hipSurfaceObject_t

Definition surface_types.h:28

texture_types.h

hipTextureObject_t

struct __hip_texture * hipTextureObject_t

Definition texture_types.h:54

hipTextureAddressMode

hipTextureAddressMode

Definition texture_types.h:59

hipTextureFilterMode

hipTextureFilterMode

Definition texture_types.h:69

hipTextureDesc

Definition texture_types.h:100