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 hipDeviceAttributeGPUDirectRDMASupported,

589 hipDeviceAttributeGPUDirectRDMAFlushWritesOptions,

593 hipDeviceAttributeGPUDirectRDMAWritesOrdering,

597

598 hipDeviceAttributeCudaCompatibleEnd = 9999,

599 hipDeviceAttributeAmdSpecificBegin = 10000,

600

601 hipDeviceAttributeClockInstructionRate =

602 hipDeviceAttributeAmdSpecificBegin,

604 hipDeviceAttributeUnused3,

605 hipDeviceAttributeMaxSharedMemoryPerMultiprocessor,

606 hipDeviceAttributeUnused4,

607 hipDeviceAttributeUnused5,

608 hipDeviceAttributeHdpMemFlushCntl,

609 hipDeviceAttributeHdpRegFlushCntl,

610 hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc,

613 hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim,

616 hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim,

619 hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem,

622 hipDeviceAttributeIsLargeBar,

623 hipDeviceAttributeAsicRevision,

624 hipDeviceAttributeCanUseStreamWaitValue,

626 hipDeviceAttributeImageSupport,

627 hipDeviceAttributePhysicalMultiProcessorCount,

629 hipDeviceAttributeFineGrainSupport,

630 hipDeviceAttributeWallClockRate,

631 hipDeviceAttributeNumberOfXccs,

638 hipDeviceAttributeMaxAvailableVgprsPerThread,

641 hipDeviceAttributePciChipId,

642 hipDeviceAttributeExpertSchedMode,

644 hipDeviceAttributeMaxDynDataPrefetchRegions,

646

647 hipDeviceAttributeAmdSpecificEnd = 19999,

648 hipDeviceAttributeVendorSpecificBegin = 20000,

649 // Extended attributes for vendors

650} hipDeviceAttribute_t;

651

652// Flags that can be used with hipGetProcAddress.

656#define HIP_GET_PROC_ADDRESS_DEFAULT 0x0

657

659#define HIP_GET_PROC_ADDRESS_LEGACY_STREAM 0x1

660

663#define HIP_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM 0x2

664

665typedef enum hipDriverProcAddressQueryResult {

666 HIP_GET_PROC_ADDRESS_SUCCESS = 0,

667 HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND = 1,

668 HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT = 2

669} hipDriverProcAddressQueryResult;

670

671enum hipComputeMode {

672 hipComputeModeDefault = 0,

673 hipComputeModeExclusive = 1,

674 hipComputeModeProhibited = 2,

675 hipComputeModeExclusiveProcess = 3

676};

677

678enum hipFlushGPUDirectRDMAWritesOptions {

679 hipFlushGPUDirectRDMAWritesOptionHost = 1 << 0,

680 hipFlushGPUDirectRDMAWritesOptionMemOps = 1 << 1

681};

682

683enum hipGPUDirectRDMAWritesOrdering {

684 hipGPUDirectRDMAWritesOrderingNone = 0,

685 hipGPUDirectRDMAWritesOrderingOwner = 100,

686 hipGPUDirectRDMAWritesOrderingAllDevices = 200

687};

688

692enum hipFlushGPUDirectRDMAWritesTarget {

693 hipFlushGPUDirectRDMAWritesTargetCurrentDevice = 0

694};

695

703enum hipFlushGPUDirectRDMAWritesScope {

704 hipFlushGPUDirectRDMAWritesToOwner = 100,

705 hipFlushGPUDirectRDMAWritesToAllDevices = 200

706};

707

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

709

710#ifndef GENERIC_GRID_LAUNCH

711#define GENERIC_GRID_LAUNCH 1

712#endif

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

714#include <hip/driver_types.h>

715#include <hip/texture_types.h>

716#include <hip/surface_types.h>

717

718#if defined(HIP_ABI_IMPL)

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

720#define HIP_DEPRECATED(x)

721#elif defined(_MSC_VER)

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

723#else // !defined(_MSC_VER)

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

725#endif // !defined(_MSC_VER)

726

727#define HIP_DEPRECATED_MSG \

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

729 "details please refer " \

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

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

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

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

734#ifdef __cplusplus

735#define __dparm(x) = x

736#else

737#define __dparm(x)

738#endif

739#ifdef __GNUC__

740#pragma GCC visibility push(default)

741#endif

742#ifdef __cplusplus

743namespace hip_impl {

744hipError_t hip_init();

745} // namespace hip_impl

746#endif

747// Structure definitions:

748#ifdef __cplusplus

749extern "C" {

750#endif

751//---

752// API-visible structures

753typedef struct ihipCtx_t* hipCtx_t;

754typedef struct ihipExecutionCtx_t* hipExecutionCtx_t;

755typedef struct ihipDevResourceDesc_t* hipDevResourceDesc_t;

756typedef enum hipDevResourceType {

757 hipDevResourceTypeInvalid = 0,

758 hipDevResourceTypeSm = 1,

759 hipDevResourceTypeWorkqueueConfig = 1000,

760 hipDevResourceTypeWorkqueue = 10000,

761} hipDevResourceType;

762typedef enum hipDevSmResourceGroup_flags {

763 hipDevSmResourceGroupDefault = 0,

764 hipDevSmResourceGroupBackfill = 0x1,

765} hipDevSmResourceGroup_flags;

766typedef enum hipDevSmResourceSplitByCount_flags {

767 hipDevSmResourceSplitIgnoreSmCoscheduling = 0x1,

768 hipDevSmResourceSplitMaxPotentialClusterSize = 0x2,

769} hipDevSmResourceSplitByCount_flags;

770typedef enum hipDevWorkqueueConfigScope {

771 hipDevWorkqueueConfigScopeDeviceCtx = 0,

772 hipDevWorkqueueConfigScopeGreenCtxBalanced = 1,

773} hipDevWorkqueueConfigScope;

774

775#define HIP_RESOURCE_ABI_BYTES 40

776

777typedef struct hipDevSmResource {

778 unsigned int smCount;

779 unsigned int minSmPartitionSize;

780 unsigned int smCoscheduledAlignment;

781 unsigned int flags;

782} hipDevSmResource;

783

784typedef struct hipDevWorkqueueConfigResource {

785 int device;

786 unsigned int wqConcurrencyLimit;

787 hipDevWorkqueueConfigScope sharingScope;

788} hipDevWorkqueueConfigResource;

789

790typedef struct hipDevWorkqueueResource {

791 unsigned char reserved[HIP_RESOURCE_ABI_BYTES];

792} hipDevWorkqueueResource;

793

794typedef struct hipDevResource_st {

795 hipDevResourceType type;

796 unsigned char _internal_padding[92];

797 union {

798 hipDevSmResource sm;

799 hipDevWorkqueueConfigResource wqConfig;

800 hipDevWorkqueueResource wq;

801 unsigned char _oversize[HIP_RESOURCE_ABI_BYTES];

802 };

803 struct hipDevResource_st* nextResource;

804} hipDevResource;

805

806typedef struct hipDevSmResourceGroupParams_st {

807 unsigned int smCount;

808 unsigned int coscheduledSmCount;

809 unsigned int preferredCoscheduledSmCount;

810 unsigned int flags;

811 unsigned int reserved[12];

812} hipDevSmResourceGroupParams;

813

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

815typedef int hipDevice_t;

816typedef enum hipDeviceP2PAttr {

817 hipDevP2PAttrPerformanceRank = 0,

818 hipDevP2PAttrAccessSupported,

819 hipDevP2PAttrNativeAtomicSupported,

820 hipDevP2PAttrHipArrayAccessSupported

821} hipDeviceP2PAttr;

822typedef enum hipDriverEntryPointQueryResult {

823 hipDriverEntryPointSuccess = 0,

824 hipDriverEntryPointSymbolNotFound = 1,

825 hipDriverEntryPointVersionNotSufficent = 2

826} hipDriverEntryPointQueryResult;

827typedef struct ihipStream_t* hipStream_t;

828#define hipIpcMemLazyEnablePeerAccess 0x01

829#define HIP_IPC_HANDLE_SIZE 64

830typedef struct hipIpcMemHandle_st {

831 char reserved[HIP_IPC_HANDLE_SIZE];

832} hipIpcMemHandle_t;

833typedef struct hipIpcEventHandle_st {

834 char reserved[HIP_IPC_HANDLE_SIZE];

835} hipIpcEventHandle_t;

836typedef struct hipMemFabricHandle_st {

837 unsigned char data[HIP_IPC_HANDLE_SIZE];

838} hipMemFabricHandle_t;

839typedef struct ihipModule_t* hipModule_t;

840typedef struct ihipModuleSymbol_t* hipFunction_t;

841typedef struct ihipLinkState_t* hipLinkState_t;

842typedef struct ihipLibrary_t* hipLibrary_t;

843typedef struct ihipKernel_t* hipKernel_t;

847typedef struct ihipMemPoolHandle_t* hipMemPool_t;

848

849typedef struct hipFuncAttributes {

850 int binaryVersion;

851 int cacheModeCA;

852 size_t constSizeBytes;

853 size_t localSizeBytes;

854 int maxDynamicSharedSizeBytes;

855 int maxThreadsPerBlock;

856 int numRegs;

857 int preferredShmemCarveout;

858 int ptxVersion;

859 size_t sharedSizeBytes;

860} hipFuncAttributes;

861typedef struct ihipEvent_t* hipEvent_t;

862

869enum hipLimit_t {

870 hipLimitStackSize = 0x0,

873 hipLimitPrintfFifoSize = 0x01,

875 hipLimitMallocHeapSize = 0x02,

877 hipExtLimitScratchMin = 0x1000,

879 hipExtLimitScratchMax = 0x1001,

881 hipExtLimitScratchCurrent = 0x1002,

885 hipLimitRange

886};

887

891// Flags that can be used with hipStreamCreateWithFlags.

893#define hipStreamDefault 0x00

894

896#define hipStreamNonBlocking 0x01

897

898// Flags that can be used with hipEventCreateWithFlags.

900#define hipEventDefault 0x0

901

903#define hipEventBlockingSync 0x1

904

906#define hipEventDisableTiming 0x2

907

909#define hipEventInterprocess 0x4

910

911// Flags that can be used with hipEventRecordWithFlags.

913#define hipEventRecordDefault 0x00

914

916#define hipEventRecordExternal 0x01

917

918//Flags that can be used with hipStreamWaitEvent.

920#define hipEventWaitDefault 0x00

921

923#define hipEventWaitExternal 0x01

924

933#define hipEventDisableSystemFence 0x20000000

934

937#define hipEventReleaseToDevice 0x40000000

938

941#define hipEventReleaseToSystem 0x80000000

942

943// Flags that can be used with hipGetDriverEntryPoint.

947#define hipEnableDefault 0x0

948

950#define hipEnableLegacyStream 0x1

951

954#define hipEnablePerThreadDefaultStream 0x2

955

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

958#define hipHostAllocDefault 0x0

959

962#define hipHostMallocDefault 0x0

963

965#define hipHostAllocPortable 0x1

966

969#define hipHostMallocPortable 0x1

970

973#define hipHostAllocMapped 0x2

974

978#define hipHostMallocMapped 0x2

979

985#define hipHostAllocWriteCombined 0x4

986

993#define hipHostMallocWriteCombined 0x4

994

1000#define hipHostMallocUncached 0x10000000

1001#define hipHostAllocUncached hipHostMallocUncached

1002

1007#define hipHostMallocNumaUser 0x20000000

1008

1010#define hipHostMallocCoherent 0x40000000

1011

1013#define hipHostMallocNonCoherent 0x80000000

1014

1016#define hipMemAttachGlobal 0x01

1017

1019#define hipMemAttachHost 0x02

1020

1022#define hipMemAttachSingle 0x04

1023

1024#define hipDeviceMallocDefault 0x0

1025

1027#define hipDeviceMallocFinegrained 0x1

1028

1030#define hipMallocSignalMemory 0x2

1031

1033#define hipDeviceMallocUncached 0x3

1034

1036#define hipDeviceMallocContiguous 0x4

1037

1038// Flags that can be used with hipHostRegister.

1040#define hipHostRegisterDefault 0x0

1041

1043#define hipHostRegisterPortable 0x1

1044

1047#define hipHostRegisterMapped 0x2

1048

1053#define hipHostRegisterIoMemory 0x4

1054

1056#define hipHostRegisterReadOnly 0x08

1057

1059#define hipExtHostRegisterCoarseGrained 0x8

1060

1064#define hipExtHostRegisterUncached 0x80000000

1065

1067#define hipDeviceScheduleAuto 0x0

1068

1071#define hipDeviceScheduleSpin 0x1

1072

1075#define hipDeviceScheduleYield 0x2

1076#define hipDeviceScheduleBlockingSync 0x4

1077#define hipDeviceScheduleMask 0x7

1078#define hipDeviceMapHost 0x8

1079#define hipDeviceLmemResizeToMax 0x10

1081#define hipInitDeviceFlagsAreValid 0x1

1083#define hipArrayDefault 0x00

1084#define hipArrayLayered 0x01

1085#define hipArraySurfaceLoadStore 0x02

1086#define hipArrayCubemap 0x04

1087#define hipArrayTextureGather 0x08

1088#define hipOccupancyDefault 0x00

1089#define hipOccupancyDisableCachingOverride 0x01

1090#define hipCooperativeLaunchMultiDeviceNoPreSync 0x01

1091#define hipCooperativeLaunchMultiDeviceNoPostSync 0x02

1092#define hipCpuDeviceId ((int)-1)

1093#define hipInvalidDeviceId ((int)-2)

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

1096#define hipExtAnyOrderLaunch 0x01

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

1098#define hipStreamWaitValueGte 0x0

1099#define hipStreamWaitValueEq 0x1

1100#define hipStreamWaitValueAnd 0x2

1101#define hipStreamWaitValueNor 0x3

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

1103#define hipStreamWriteValueDefault 0x0

1104#define hipExtStreamWriteValueIncrement 0x1000

1105#define hipExtStreamWriteValueDecrement 0x1001

1106

1108typedef enum hipStreamBatchMemOpType {

1109 hipStreamMemOpWaitValue32 = 0x1,

1110 hipStreamMemOpWriteValue32 = 0x2,

1111 hipStreamMemOpWaitValue64 = 0x4,

1112 hipStreamMemOpWriteValue64 = 0x5,

1113 hipStreamMemOpBarrier = 0x6,

1114 hipStreamMemOpFlushRemoteWrites = 0x3

1115} hipStreamBatchMemOpType;

1116

1153typedef union hipStreamBatchMemOpParams_union {

1154 hipStreamBatchMemOpType operation;

1155 struct hipStreamMemOpWaitValueParams_t {

1156 hipStreamBatchMemOpType operation;

1157 hipDeviceptr_t address;

1158 union {

1159 uint32_t value;

1160 uint64_t value64;

1161 };

1162 unsigned int flags;

1163 hipDeviceptr_t alias;

1164 } waitValue;

1165 struct hipStreamMemOpWriteValueParams_t {

1166 hipStreamBatchMemOpType operation;

1167 hipDeviceptr_t address;

1168 union {

1169 uint32_t value;

1170 uint64_t value64;

1171 };

1172 unsigned int flags;

1173 hipDeviceptr_t alias;

1174 } writeValue;

1175 struct hipStreamMemOpFlushRemoteWritesParams_t {

1176 hipStreamBatchMemOpType operation;

1177 unsigned int flags;

1178 } flushRemoteWrites;

1179 struct hipStreamMemOpMemoryBarrierParams_t {

1180 hipStreamBatchMemOpType operation;

1181 unsigned int flags;

1182 } memoryBarrier;

1183 uint64_t pad[6];

1184} hipStreamBatchMemOpParams;

1185

1213typedef struct hipBatchMemOpNodeParams {

1214 hipCtx_t ctx;

1215 unsigned int count;

1216 hipStreamBatchMemOpParams* paramArray;

1217 unsigned int flags;

1218} hipBatchMemOpNodeParams;

1219

1220// Stream per thread

1222#define hipStreamPerThread ((hipStream_t)2)

1223

1224#define hipStreamLegacy ((hipStream_t)1)

1225

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

1227#define hipExternalMemoryDedicated 0x1

1233typedef enum hipMemoryAdvise {

1234 hipMemAdviseSetReadMostly = 1,

1236 hipMemAdviseUnsetReadMostly = 2,

1237 hipMemAdviseSetPreferredLocation = 3,

1239 hipMemAdviseUnsetPreferredLocation = 4,

1240 hipMemAdviseSetAccessedBy = 5,

1242 hipMemAdviseUnsetAccessedBy = 6,

1244 hipMemAdviseSetCoarseGrain = 100,

1249 hipMemAdviseUnsetCoarseGrain = 101

1250} hipMemoryAdvise;

1254typedef enum hipMemRangeCoherencyMode {

1255 hipMemRangeCoherencyModeFineGrain = 0,

1257 hipMemRangeCoherencyModeCoarseGrain = 1,

1259 hipMemRangeCoherencyModeIndeterminate = 2

1262} hipMemRangeCoherencyMode;

1266typedef enum hipMemRangeAttribute {

1267 hipMemRangeAttributeReadMostly = 1,

1269 hipMemRangeAttributePreferredLocation = 2,

1270 hipMemRangeAttributeAccessedBy = 3,

1272 hipMemRangeAttributeLastPrefetchLocation = 4,

1274 hipMemRangeAttributeCoherencyMode = 100,

1276} hipMemRangeAttribute;

1277

1281typedef enum hipMemPoolAttr {

1290 hipMemPoolReuseFollowEventDependencies = 0x1,

1296 hipMemPoolReuseAllowOpportunistic = 0x2,

1303 hipMemPoolReuseAllowInternalDependencies = 0x3,

1312 hipMemPoolAttrReleaseThreshold = 0x4,

1317 hipMemPoolAttrReservedMemCurrent = 0x5,

1323 hipMemPoolAttrReservedMemHigh = 0x6,

1328 hipMemPoolAttrUsedMemCurrent = 0x7,

1334 hipMemPoolAttrUsedMemHigh = 0x8

1335} hipMemPoolAttr;

1336

1341typedef enum hipMemAccessFlags {

1342 hipMemAccessFlagsProtNone = 0,

1343 hipMemAccessFlagsProtRead = 1,

1344 hipMemAccessFlagsProtReadWrite = 3

1345} hipMemAccessFlags;

1352typedef struct hipMemAccessDesc {

1353 hipMemLocation location;

1354 hipMemAccessFlags flags;

1355} hipMemAccessDesc;

1359typedef enum hipMemAllocationType {

1360 hipMemAllocationTypeInvalid = 0x0,

1364 hipMemAllocationTypePinned = 0x1,

1365 hipMemAllocationTypeManaged = 0x2,

1366 hipMemAllocationTypeUncached = 0x40000000,

1367 hipMemAllocationTypeMax = 0x7FFFFFFF

1368} hipMemAllocationType;

1373typedef enum hipMemAllocationHandleType {

1374 hipMemHandleTypeNone = 0x0,

1375 hipMemHandleTypePosixFileDescriptor =

1376 0x1,

1377 hipMemHandleTypeWin32 = 0x2,

1378 hipMemHandleTypeWin32Kmt = 0x4,

1379 hipMemHandleTypeFabric = 0x8

1380} hipMemAllocationHandleType;

1384typedef struct hipMemPoolProps {

1385 hipMemAllocationType

1386 allocType;

1387 hipMemAllocationHandleType

1388 handleTypes;

1389 hipMemLocation location;

1393 void* win32SecurityAttributes;

1394 size_t maxSize;

1395 unsigned char reserved[56];

1396} hipMemPoolProps;

1400typedef struct hipMemPoolPtrExportData {

1401 unsigned char reserved[64];

1402} hipMemPoolPtrExportData;

1403

1407typedef enum hipFuncAttribute {

1408 hipFuncAttributeMaxDynamicSharedMemorySize = 8,

1409 hipFuncAttributePreferredSharedMemoryCarveout = 9,

1410 hipFuncAttributeClusterDimMustBeSet = 10,

1411 hipFuncAttributeRequiredClusterWidth = 11,

1412 hipFuncAttributeRequiredClusterHeight = 12,

1413 hipFuncAttributeRequiredClusterDepth = 13,

1414 hipFuncAttributeNonPortableClusterSizeAllowed = 14,

1415 hipFuncAttributeClusterSchedulingPolicyPreference = 15,

1416 hipFuncAttributeMax

1417} hipFuncAttribute;

1421typedef enum hipFuncCache_t {

1422 hipFuncCachePreferNone,

1423 hipFuncCachePreferShared,

1424 hipFuncCachePreferL1,

1425 hipFuncCachePreferEqual,

1426} hipFuncCache_t;

1430typedef enum hipSharedMemConfig {

1431 hipSharedMemBankSizeDefault,

1432 hipSharedMemBankSizeFourByte,

1434 hipSharedMemBankSizeEightByte

1436} hipSharedMemConfig;

1440typedef struct dim3 {

1441 uint32_t x;

1442 uint32_t y;

1443 uint32_t z;

1444#ifdef __cplusplus

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

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

1447#endif

1448} dim3;

1452typedef struct hipLaunchParams_t {

1453 void* func;

1454 dim3 gridDim;

1455 dim3 blockDim;

1456 void** args;

1457 size_t sharedMem;

1458 hipStream_t stream;

1459} hipLaunchParams;

1463typedef struct hipFunctionLaunchParams_t {

1464 hipFunction_t function;

1465 unsigned int gridDimX;

1466 unsigned int gridDimY;

1467 unsigned int gridDimZ;

1468 unsigned int blockDimX;

1469 unsigned int blockDimY;

1470 unsigned int blockDimZ;

1471 unsigned int sharedMemBytes;

1472 hipStream_t hStream;

1473 void** kernelParams;

1474} hipFunctionLaunchParams;

1475typedef enum hipExternalMemoryHandleType_enum {

1476 hipExternalMemoryHandleTypeOpaqueFd = 1,

1477 hipExternalMemoryHandleTypeOpaqueWin32 = 2,

1478 hipExternalMemoryHandleTypeOpaqueWin32Kmt = 3,

1479 hipExternalMemoryHandleTypeD3D12Heap = 4,

1480 hipExternalMemoryHandleTypeD3D12Resource = 5,

1481 hipExternalMemoryHandleTypeD3D11Resource = 6,

1482 hipExternalMemoryHandleTypeD3D11ResourceKmt = 7,

1483 hipExternalMemoryHandleTypeNvSciBuf = 8

1484} hipExternalMemoryHandleType;

1485typedef struct hipExternalMemoryHandleDesc_st {

1486 hipExternalMemoryHandleType type;

1487 union {

1488 int fd;

1489 struct {

1490 void* handle;

1491 const void* name;

1492 } win32;

1493 const void* nvSciBufObject;

1494 } handle;

1495 unsigned long long size;

1496 unsigned int flags;

1497 unsigned int reserved[16];

1498} hipExternalMemoryHandleDesc;

1499typedef struct hipExternalMemoryBufferDesc_st {

1500 unsigned long long offset;

1501 unsigned long long size;

1502 unsigned int flags;

1503 unsigned int reserved[16];

1504} hipExternalMemoryBufferDesc;

1505typedef struct hipExternalMemoryMipmappedArrayDesc_st {

1506 unsigned long long offset;

1507 hipChannelFormatDesc formatDesc;

1508 hipExtent extent;

1509 unsigned int flags;

1510 unsigned int numLevels;

1511} hipExternalMemoryMipmappedArrayDesc;

1512typedef void* hipExternalMemory_t;

1513typedef enum hipExternalSemaphoreHandleType_enum {

1514 hipExternalSemaphoreHandleTypeOpaqueFd = 1,

1515 hipExternalSemaphoreHandleTypeOpaqueWin32 = 2,

1516 hipExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3,

1517 hipExternalSemaphoreHandleTypeD3D12Fence = 4,

1518 hipExternalSemaphoreHandleTypeD3D11Fence = 5,

1519 hipExternalSemaphoreHandleTypeNvSciSync = 6,

1520 hipExternalSemaphoreHandleTypeKeyedMutex = 7,

1521 hipExternalSemaphoreHandleTypeKeyedMutexKmt = 8,

1522 hipExternalSemaphoreHandleTypeTimelineSemaphoreFd = 9,

1523 hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = 10

1524} hipExternalSemaphoreHandleType;

1525typedef struct hipExternalSemaphoreHandleDesc_st {

1526 hipExternalSemaphoreHandleType type;

1527 union {

1528 int fd;

1529 struct {

1530 void* handle;

1531 const void* name;

1532 } win32;

1533 const void* NvSciSyncObj;

1534 } handle;

1535 unsigned int flags;

1536 unsigned int reserved[16];

1537} hipExternalSemaphoreHandleDesc;

1538typedef void* hipExternalSemaphore_t;

1539typedef struct hipExternalSemaphoreSignalParams_st {

1540 struct {

1541 struct {

1542 unsigned long long value;

1543 } fence;

1544 union {

1545 void* fence;

1546 unsigned long long reserved;

1547 } nvSciSync;

1548 struct {

1549 unsigned long long key;

1550 } keyedMutex;

1551 unsigned int reserved[12];

1552 } params;

1553 unsigned int flags;

1554 unsigned int reserved[16];

1555} hipExternalSemaphoreSignalParams;

1559typedef struct hipExternalSemaphoreWaitParams_st {

1560 struct {

1561 struct {

1562 unsigned long long value;

1563 } fence;

1564 union {

1565 void* fence;

1566 unsigned long long reserved;

1567 } nvSciSync;

1568 struct {

1569 unsigned long long key;

1570 unsigned int timeoutMs;

1571 } keyedMutex;

1572 unsigned int reserved[10];

1573 } params;

1574 unsigned int flags;

1575 unsigned int reserved[16];

1576} hipExternalSemaphoreWaitParams;

1577

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

1583

1587typedef enum hipGraphicsRegisterFlags {

1588 hipGraphicsRegisterFlagsNone = 0,

1589 hipGraphicsRegisterFlagsReadOnly = 1,

1590 hipGraphicsRegisterFlagsWriteDiscard =

1591 2,

1592 hipGraphicsRegisterFlagsSurfaceLoadStore = 4,

1593 hipGraphicsRegisterFlagsTextureGather =

1594 8

1595} hipGraphicsRegisterFlags;

1596

1597typedef struct _hipGraphicsResource hipGraphicsResource;

1598

1599typedef hipGraphicsResource* hipGraphicsResource_t;

1600

1604typedef struct ihipGraph* hipGraph_t;

1608typedef struct hipGraphNode* hipGraphNode_t;

1612typedef struct hipGraphExec* hipGraphExec_t;

1613

1617typedef struct hipUserObject* hipUserObject_t;

1618

1619

1623typedef enum hipGraphNodeType {

1624 hipGraphNodeTypeKernel = 0,

1625 hipGraphNodeTypeMemcpy = 1,

1626 hipGraphNodeTypeMemset = 2,

1627 hipGraphNodeTypeHost = 3,

1628 hipGraphNodeTypeGraph = 4,

1629 hipGraphNodeTypeEmpty = 5,

1630 hipGraphNodeTypeWaitEvent = 6,

1631 hipGraphNodeTypeEventRecord = 7,

1632 hipGraphNodeTypeExtSemaphoreSignal = 8,

1633 hipGraphNodeTypeExtSemaphoreWait = 9,

1634 hipGraphNodeTypeMemAlloc = 10,

1635 hipGraphNodeTypeMemFree = 11,

1636 hipGraphNodeTypeMemcpyFromSymbol = 12,

1637 hipGraphNodeTypeMemcpyToSymbol = 13,

1638 hipGraphNodeTypeBatchMemOp = 14,

1639 hipGraphNodeTypeCount

1640} hipGraphNodeType;

1641

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

1643typedef struct hipHostNodeParams {

1644 hipHostFn_t fn;

1645 void* userData;

1646} hipHostNodeParams;

1647typedef struct hipKernelNodeParams {

1648 dim3 blockDim;

1649 void** extra;

1650 void* func;

1651 dim3 gridDim;

1652 void** kernelParams;

1653 unsigned int sharedMemBytes;

1654} hipKernelNodeParams;

1655typedef struct hipMemsetParams {

1656 void* dst;

1657 unsigned int elementSize;

1658 size_t height;

1659 size_t pitch;

1660 unsigned int value;

1661 size_t width;

1662} hipMemsetParams;

1663

1664typedef struct hipMemAllocNodeParams {

1665 hipMemPoolProps poolProps;

1667 const hipMemAccessDesc* accessDescs;

1668 size_t accessDescCount;

1670 size_t bytesize;

1671 void* dptr;

1672} hipMemAllocNodeParams;

1673

1677typedef enum hipAccessProperty {

1678 hipAccessPropertyNormal = 0,

1679 hipAccessPropertyStreaming = 1,

1680 hipAccessPropertyPersisting = 2,

1681} hipAccessProperty;

1682

1683/***

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

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

1686 */

1687typedef struct hipAccessPolicyWindow {

1688 void* base_ptr;

1689 hipAccessProperty hitProp;

1690 float hitRatio;

1691 hipAccessProperty missProp;

1692 size_t num_bytes;

1693} hipAccessPolicyWindow;

1694

1698typedef struct hipLaunchMemSyncDomainMap {

1699 unsigned char default_;

1700 unsigned char remote;

1701} hipLaunchMemSyncDomainMap;

1702

1706typedef enum hipLaunchMemSyncDomain {

1707 hipLaunchMemSyncDomainDefault = 0,

1708 hipLaunchMemSyncDomainRemote = 1

1709} hipLaunchMemSyncDomain;

1710

1715typedef enum hipSynchronizationPolicy {

1716 hipSyncPolicyAuto = 1,

1717 hipSyncPolicySpin = 2,

1718 hipSyncPolicyYield = 3,

1719 hipSyncPolicyBlockingSync = 4

1720} hipSynchronizationPolicy;

1721/* Cluster scheduling policies passed to hipFuncSetAttribute

1722*/

1723typedef enum hipClusterSchedulingPolicy {

1724 hipClusterSchedulingPolicyDefault = 0,

1725 hipClusterSchedulingPolicySpread = 1,

1726 hipClusterSchedulingPolicyLoadBalancing =

1727 2,

1728} hipClusterSchedulingPolicy;

1729

1733typedef enum hipExtDynDataPrefetchTemporal {

1734 hipExtDynDataPrefetchTemporalRegular = 0,

1735 hipExtDynDataPrefetchTemporalHigh = 1,

1736} hipExtDynDataPrefetchTemporal;

1737

1746typedef struct hipExtDynDataPrefetchRegion {

1747 void* address;

1748 size_t stride;

1749 size_t width;

1750 size_t height;

1751} hipExtDynDataPrefetchRegion;

1752

1758#define HIP_EXT_DYN_DATA_PREFETCH_MAX_REGIONS 2

1759

1770typedef struct hipExtDynDataPrefetchConfig {

1771 unsigned int numRegions;

1772 hipExtDynDataPrefetchTemporal temporal;

1773 hipExtDynDataPrefetchRegion regions[HIP_EXT_DYN_DATA_PREFETCH_MAX_REGIONS];

1774} hipExtDynDataPrefetchConfig;

1775

1779typedef enum hipLaunchAttributeID {

1780 hipLaunchAttributeIgnore = 0,

1781 hipLaunchAttributeAccessPolicyWindow = 1,

1782 hipLaunchAttributeCooperative = 2,

1783 hipLaunchAttributeSynchronizationPolicy = 3,

1784 hipLaunchAttributeClusterDimension = 4,

1785 hipLaunchAttributeClusterSchedulingPolicyPreference = 5,

1786 hipLaunchAttributePriority = 8,

1787 hipLaunchAttributeMemSyncDomainMap = 9,

1788 hipLaunchAttributeMemSyncDomain = 10,

1789 hipLaunchAttributeExtDynDataPrefetch = 1024,

1790 hipLaunchAttributeMax

1791} hipLaunchAttributeID;

1792

1793

1797typedef union hipLaunchAttributeValue {

1798 char pad[64];

1799 hipAccessPolicyWindow

1800 accessPolicyWindow;

1801 int cooperative;

1803 int priority;

1805 hipSynchronizationPolicy

1806 syncPolicy;

1808 hipLaunchMemSyncDomainMap

1809 memSyncDomainMap;

1810 hipLaunchMemSyncDomain

1811 memSyncDomain;

1824 struct {

1825 unsigned int x;

1826 unsigned int y;

1827 unsigned int z;

1828 } clusterDim;

1829

1830 hipClusterSchedulingPolicy clusterSchedulingPolicyPreference;

1832 const hipExtDynDataPrefetchConfig* dynDataPrefetch;

1833} hipLaunchAttributeValue;

1834

1838#define hipStreamAttrID hipLaunchAttributeID

1839#define hipStreamAttributeAccessPolicyWindow hipLaunchAttributeAccessPolicyWindow

1840#define hipStreamAttributeSynchronizationPolicy hipLaunchAttributeSynchronizationPolicy

1841#define hipStreamAttributeMemSyncDomainMap hipLaunchAttributeMemSyncDomainMap

1842#define hipStreamAttributeMemSyncDomain hipLaunchAttributeMemSyncDomain

1843#define hipStreamAttributePriority hipLaunchAttributePriority

1844

1845#define hipStreamAttrValue hipLaunchAttributeValue

1846

1850#define hipKernelNodeAttrID hipLaunchAttributeID

1851#define hipKernelNodeAttributeAccessPolicyWindow hipLaunchAttributeAccessPolicyWindow

1852#define hipKernelNodeAttributeCooperative hipLaunchAttributeCooperative

1853#define hipKernelNodeAttributePriority hipLaunchAttributePriority

1854

1858#define hipKernelNodeAttrValue hipLaunchAttributeValue

1859

1863#define hipDrvLaunchAttributeCooperative hipLaunchAttributeCooperative

1864

1865#define hipDrvLaunchAttributeID hipLaunchAttributeID

1866#define hipDrvLaunchAttributeValue hipLaunchAttributeValue

1867#define hipDrvLaunchAttribute hipLaunchAttribute

1868

1872typedef enum hipGraphExecUpdateResult {

1873 hipGraphExecUpdateSuccess = 0x0,

1874 hipGraphExecUpdateError = 0x1,

1876 hipGraphExecUpdateErrorTopologyChanged = 0x2,

1877 hipGraphExecUpdateErrorNodeTypeChanged = 0x3,

1878 hipGraphExecUpdateErrorFunctionChanged =

1879 0x4,

1880 hipGraphExecUpdateErrorParametersChanged =

1881 0x5,

1882 hipGraphExecUpdateErrorNotSupported =

1883 0x6,

1884 hipGraphExecUpdateErrorUnsupportedFunctionChange = 0x7

1885} hipGraphExecUpdateResult;

1886

1887typedef enum hipStreamCaptureMode {

1888 hipStreamCaptureModeGlobal = 0,

1889 hipStreamCaptureModeThreadLocal,

1890 hipStreamCaptureModeRelaxed

1891} hipStreamCaptureMode;

1892typedef enum hipStreamCaptureStatus {

1893 hipStreamCaptureStatusNone = 0,

1894 hipStreamCaptureStatusActive,

1895 hipStreamCaptureStatusInvalidated

1897} hipStreamCaptureStatus;

1898

1899typedef enum hipStreamUpdateCaptureDependenciesFlags {

1900 hipStreamAddCaptureDependencies = 0,

1901 hipStreamSetCaptureDependencies,

1902} hipStreamUpdateCaptureDependenciesFlags;

1903

1904typedef enum hipGraphMemAttributeType {

1905 hipGraphMemAttrUsedMemCurrent =

1906 0,

1907 hipGraphMemAttrUsedMemHigh,

1909 hipGraphMemAttrReservedMemCurrent,

1911 hipGraphMemAttrReservedMemHigh,

1913} hipGraphMemAttributeType;

1914typedef enum hipUserObjectFlags {

1915 hipUserObjectNoDestructorSync = 0x1,

1916} hipUserObjectFlags;

1917

1918typedef enum hipUserObjectRetainFlags {

1919 hipGraphUserObjectMove = 0x1,

1920} hipUserObjectRetainFlags;

1921

1922typedef enum hipGraphInstantiateFlags {

1923 hipGraphInstantiateFlagAutoFreeOnLaunch =

1924 1,

1925 hipGraphInstantiateFlagUpload = 2,

1926 hipGraphInstantiateFlagDeviceLaunch =

1927 4,

1928 hipGraphInstantiateFlagUseNodePriority =

1929 8,

1931} hipGraphInstantiateFlags;

1932

1933enum hipGraphDebugDotFlags {

1934 hipGraphDebugDotFlagsVerbose =

1935 1 << 0,

1936 hipGraphDebugDotFlagsKernelNodeParams = 1 << 2,

1937 hipGraphDebugDotFlagsMemcpyNodeParams = 1 << 3,

1938 hipGraphDebugDotFlagsMemsetNodeParams = 1 << 4,

1939 hipGraphDebugDotFlagsHostNodeParams = 1 << 5,

1940 hipGraphDebugDotFlagsEventNodeParams =

1941 1 << 6,

1942 hipGraphDebugDotFlagsExtSemasSignalNodeParams =

1943 1 << 7,

1944 hipGraphDebugDotFlagsExtSemasWaitNodeParams =

1945 1 << 8,

1946 hipGraphDebugDotFlagsKernelNodeAttributes =

1947 1 << 9,

1948 hipGraphDebugDotFlagsHandles =

1949 1 << 10

1950};

1951

1955typedef enum hipGraphInstantiateResult {

1956 hipGraphInstantiateSuccess = 0,

1957 hipGraphInstantiateError = 1,

1959 hipGraphInstantiateInvalidStructure = 2,

1961 hipGraphInstantiateNodeOperationNotSupported = 3,

1963 hipGraphInstantiateMultipleDevicesNotSupported = 4,

1965} hipGraphInstantiateResult;

1966

1970typedef struct hipGraphInstantiateParams {

1971 hipGraphNode_t errNode_out;

1972 unsigned long long flags;

1973 hipGraphInstantiateResult result_out;

1975 hipStream_t uploadStream;

1976} hipGraphInstantiateParams;

1977

1978

1982typedef struct hipMemAllocationProp {

1983 hipMemAllocationType type;

1984 union {

1985 hipMemAllocationHandleType requestedHandleType;

1986 hipMemAllocationHandleType requestedHandleTypes;

1987 };

1988 hipMemLocation location;

1989 void* win32HandleMetaData;

1990 struct {

1991 unsigned char compressionType;

1992 unsigned char gpuDirectRDMACapable;

1993 unsigned short usage;

1994 } allocFlags;

1995} hipMemAllocationProp;

1996

2000typedef struct hipExternalSemaphoreSignalNodeParams {

2002 hipExternalSemaphore_t* extSemArray;

2004 const hipExternalSemaphoreSignalParams* paramsArray;

2006 unsigned int numExtSems;

2007} hipExternalSemaphoreSignalNodeParams;

2008

2012typedef struct hipExternalSemaphoreWaitNodeParams {

2014 hipExternalSemaphore_t* extSemArray;

2016 const hipExternalSemaphoreWaitParams* paramsArray;

2018 unsigned int numExtSems;

2019} hipExternalSemaphoreWaitNodeParams;

2020

2024typedef struct ihipMemGenericAllocationHandle* hipMemGenericAllocationHandle_t;

2025

2029typedef enum hipMemAllocationGranularity_flags {

2030 hipMemAllocationGranularityMinimum = 0x0,

2031 hipMemAllocationGranularityRecommended = 0x1

2032} hipMemAllocationGranularity_flags;

2033

2037typedef enum hipMemHandleType {

2038 hipMemHandleTypeGeneric = 0x0

2039} hipMemHandleType;

2040

2044typedef enum hipMemOperationType {

2045 hipMemOperationTypeMap = 0x1,

2046 hipMemOperationTypeUnmap = 0x2

2047} hipMemOperationType;

2048

2052typedef enum hipArraySparseSubresourceType {

2053 hipArraySparseSubresourceTypeSparseLevel = 0x0,

2054 hipArraySparseSubresourceTypeMiptail = 0x1

2055} hipArraySparseSubresourceType;

2056

2060typedef struct hipArrayMapInfo {

2061 hipResourceType resourceType;

2062 union {

2063 hipMipmappedArray mipmap;

2064 hipArray_t array;

2065 } resource;

2066 hipArraySparseSubresourceType subresourceType;

2067 union {

2068 struct {

2069 unsigned int

2070 level;

2071 unsigned int

2072 layer;

2073 unsigned int offsetX;

2074 unsigned int offsetY;

2075 unsigned int offsetZ;

2076 unsigned int extentWidth;

2077 unsigned int extentHeight;

2078 unsigned int extentDepth;

2079 } sparseLevel;

2080 struct {

2081 unsigned int

2082 layer;

2083 unsigned long long offset;

2084 unsigned long long size;

2085 } miptail;

2086 } subresource;

2087 hipMemOperationType memOperationType;

2088 hipMemHandleType memHandleType;

2089 union {

2090 hipMemGenericAllocationHandle_t memHandle;

2091 } memHandle;

2092 unsigned long long offset;

2093 unsigned int deviceBitMask;

2094 unsigned int flags;

2095 unsigned int reserved[2];

2096} hipArrayMapInfo;

2097

2101typedef struct hipMemcpyNodeParams {

2102 int flags;

2103 int reserved[3];

2104 hipMemcpy3DParms copyParams;

2105} hipMemcpyNodeParams;

2106

2110typedef struct hipChildGraphNodeParams {

2111 hipGraph_t graph;

2113} hipChildGraphNodeParams;

2114

2118typedef struct hipEventWaitNodeParams {

2119 hipEvent_t event;

2120} hipEventWaitNodeParams;

2121

2125typedef struct hipEventRecordNodeParams {

2126 hipEvent_t event;

2127} hipEventRecordNodeParams;

2128

2132typedef struct hipMemFreeNodeParams {

2133 void* dptr;

2134} hipMemFreeNodeParams;

2135

2139typedef struct hipGraphNodeParams {

2140 hipGraphNodeType type;

2141 int reserved0[3];

2142 union {

2143 long long reserved1[29];

2144 hipKernelNodeParams kernel;

2145 hipMemcpyNodeParams memcpy;

2146 hipMemsetParams memset;

2147 hipHostNodeParams host;

2148 hipChildGraphNodeParams graph;

2149 hipEventWaitNodeParams eventWait;

2150 hipEventRecordNodeParams eventRecord;

2151 hipExternalSemaphoreSignalNodeParams extSemSignal;

2152 hipExternalSemaphoreWaitNodeParams extSemWait;

2153 hipMemAllocNodeParams alloc;

2154 hipMemFreeNodeParams free;

2155 };

2156

2157 long long reserved2;

2158} hipGraphNodeParams;

2159

2163#define hipGraphKernelNodePortDefault 0

2164

2168#define hipGraphKernelNodePortLaunchCompletion 2

2169

2175#define hipGraphKernelNodePortProgrammatic 1

2176

2177typedef enum hipGraphDependencyType {

2178 hipGraphDependencyTypeDefault = 0,

2179 hipGraphDependencyTypeProgrammatic = 1

2180} hipGraphDependencyType;

2181

2182typedef struct hipGraphEdgeData {

2183 unsigned char

2184 from_port;

2191 unsigned char reserved[5];

2192 unsigned char

2193 to_port;

2194 unsigned char type;

2195} hipGraphEdgeData;

2196

2197

2201typedef struct hipLaunchAttribute_st {

2202 hipLaunchAttributeID id;

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

2204 union {

2205 hipLaunchAttributeValue val;

2206 hipLaunchAttributeValue value;

2207 };

2208} hipLaunchAttribute;

2209

2213typedef struct hipLaunchConfig_st {

2214 dim3 gridDim;

2215 dim3 blockDim;

2216 size_t dynamicSmemBytes;

2217 hipStream_t stream;

2218 hipLaunchAttribute* attrs;

2219 unsigned int numAttrs;

2220} hipLaunchConfig_t;

2221

2225typedef struct HIP_LAUNCH_CONFIG_st {

2226 unsigned int gridDimX;

2227 unsigned int gridDimY;

2228 unsigned int gridDimZ;

2229 unsigned int blockDimX;

2230 unsigned int blockDimY;

2231 unsigned int blockDimZ;

2232 unsigned int sharedMemBytes;

2233 hipStream_t hStream;

2234 hipLaunchAttribute* attrs;

2235 unsigned int numAttrs;

2236} HIP_LAUNCH_CONFIG;

2237

2241typedef struct hipArrayMemoryRequirements {

2242 size_t alignment;

2243 size_t size;

2244} hipArrayMemoryRequirements;

2245

2249typedef enum hipMemRangeHandleType {

2250 hipMemRangeHandleTypeDmaBufFd = 0x1,

2251 hipMemRangeHandleTypeMax = 0x7fffffff

2252} hipMemRangeHandleType;

2253

2257typedef enum hipMemRangeFlags {

2258 hipMemRangeFlagDmaBufMappingTypePcie = 0x1,

2259 hipMemRangeFlagsMax = 0x7fffffff

2260} hipMemRangeFlags;

2261

2262

2263// Doxygen end group GlobalDefs

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

2296hipError_t hipInit(unsigned int flags);

2297

2315hipError_t hipDriverGetVersion(int* driverVersion);

2330hipError_t hipRuntimeGetVersion(int* runtimeVersion);

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

2339

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

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

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

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

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

2394 int dstDevice);

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

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

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

2420// doxygen end initialization

2439hipError_t hipDeviceSynchronize(void);

2451hipError_t hipDeviceReset(void);

2483hipError_t hipSetDevice(int deviceId);

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

2510hipError_t hipGetDevice(int* deviceId);

2523hipError_t hipGetDeviceCount(int* count);

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

2555hipError_t hipDeviceFlushGPUDirectRDMAWrites(enum hipFlushGPUDirectRDMAWritesTarget target,

2556 enum hipFlushGPUDirectRDMAWritesScope scope);

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

2593hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool);

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

2614

2615// hipDeviceProp_t and hipGetDeviceProperties/hipChooseDevice are versioned.

2616// See HIP_FORCE_API_VERSION in hip_common.h.

2617

2618#if HIP_FORCE_API_VERSION >= 600

2619

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

2621

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

2636 return hipGetDevicePropertiesR0600(prop, deviceId);

2637}

2638

2639#endif

2640

2641

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

2659 int device);

2671hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig);

2682hipError_t hipDeviceGetCacheConfig(hipFuncCache_t* cacheConfig);

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

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

2728hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig* pConfig);

2736hipError_t hipGetDeviceFlags(unsigned int* flags);

2748hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config);

2780hipError_t hipSetDeviceFlags(unsigned flags);

2781

2782#if HIP_FORCE_API_VERSION >= 600

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

2784

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

2794 return hipChooseDeviceR0600(device, prop);

2795}

2796

2797#endif

2798

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

2824

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

2839 uint32_t* hopcount);

2840// TODO: implement IPC apis

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

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

2918hipError_t hipIpcCloseMemHandle(void* devPtr);

2919

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

2937

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

2957

2958// end doxygen Device

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

2983

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

3000

3027hipError_t hipKernelSetAttributeForDevice(hipKernel_t kernel, hipFuncAttribute attr, int value,

3028 int device);

3029

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

3039

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

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

3066// doxygen end execution

3088hipError_t hipGetLastError(void);

3089

3101hipError_t hipExtGetLastError(void);

3102

3113hipError_t hipPeekAtLastError(void);

3122const char* hipGetErrorName(hipError_t hip_error);

3131const char* hipGetErrorString(hipError_t hipError);

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

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

3152// end doxygen Error

3185hipError_t hipStreamCreate(hipStream_t* stream);

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

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

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

3265hipError_t hipStreamDestroy(hipStream_t stream);

3281hipError_t hipStreamQuery(hipStream_t stream);

3303hipError_t hipStreamSynchronize(hipStream_t stream);

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

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

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

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

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

3393hipError_t hipExtStreamCreateWithCUMask(hipStream_t* stream, uint32_t cuMaskSize,

3394 const uint32_t* cuMask);

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

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

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

3428 unsigned int flags);

3429

3437hipError_t hipStreamSetAttribute(hipStream_t stream, hipStreamAttrID attr,

3438 const hipStreamAttrValue* value);

3439

3447hipError_t hipStreamGetAttribute(hipStream_t stream, hipStreamAttrID attr,

3448 hipStreamAttrValue* value_out);

3449

3456hipError_t hipStreamCopyAttributes(hipStream_t dst, hipStream_t src);

3457

3458// end doxygen Stream

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

3507 uint32_t mask __dparm(0xFFFFFFFF));

3508

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

3546 uint64_t mask __dparm(0xFFFFFFFFFFFFFFFF));

3547

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

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

3590

3610hipError_t hipStreamBatchMemOp(hipStream_t stream, unsigned int count,

3611 hipStreamBatchMemOpParams* paramArray, unsigned int flags);

3612

3630hipError_t hipGraphAddBatchMemOpNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

3631 const hipGraphNode_t* dependencies, size_t numDependencies,

3632 const hipBatchMemOpNodeParams* nodeParams);

3633

3654hipError_t hipGraphBatchMemOpNodeGetParams(hipGraphNode_t hNode,

3655 hipBatchMemOpNodeParams* nodeParams_out);

3656

3674hipError_t hipGraphBatchMemOpNodeSetParams(hipGraphNode_t hNode,

3675 hipBatchMemOpNodeParams* nodeParams);

3676

3696hipError_t hipGraphExecBatchMemOpNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

3697 const hipBatchMemOpNodeParams* nodeParams);

3698

3699// end doxygen Stream Memory Operations

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

3747hipError_t hipEventCreate(hipEvent_t* event);

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

3785 unsigned int flags __dparm(0));

3816#ifdef __cplusplus

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

3818#else

3819hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream);

3820#endif

3837hipError_t hipEventDestroy(hipEvent_t event);

3856hipError_t hipEventSynchronize(hipEvent_t event);

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

3902hipError_t hipEventQuery(hipEvent_t event);

3903// end doxygen Events

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

3935 hipDeviceptr_t ptr);

3936

3937

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

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

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

3990 void** data, hipDeviceptr_t ptr);

4014hipError_t hipImportExternalSemaphore(hipExternalSemaphore_t* extSem_out,

4015 const hipExternalSemaphoreHandleDesc* semHandleDesc);

4031hipError_t hipSignalExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

4032 const hipExternalSemaphoreSignalParams* paramsArray,

4033 unsigned int numExtSems, hipStream_t stream);

4049hipError_t hipWaitExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

4050 const hipExternalSemaphoreWaitParams* paramsArray,

4051 unsigned int numExtSems, hipStream_t stream);

4065hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem);

4066

4078hipError_t hipImportExternalMemory(hipExternalMemory_t* extMem_out,

4079 const hipExternalMemoryHandleDesc* memHandleDesc);

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

4092 const hipExternalMemoryBufferDesc* bufferDesc);

4102hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem);

4117hipError_t hipExternalMemoryGetMappedMipmappedArray(

4118 hipMipmappedArray_t* mipmap, hipExternalMemory_t extMem,

4119 const hipExternalMemoryMipmappedArrayDesc* mipmapDesc);

4120// end of external resource

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

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

4158

4159

4182HIP_DEPRECATED("use hipHostMalloc instead")

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

4196HIP_DEPRECATED("use hipHostMalloc instead")

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

4198// end doxygen deprecated management memory

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

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

4271 unsigned int flags __dparm(hipMemAttachGlobal));

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

4285 hipStream_t stream __dparm(0));

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

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

4301

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

4319 hipMemLocation* prefetch_locs, size_t* prefetch_loc_idxs,

4320 size_t num_prefetch_locs, unsigned long long flags,

4321 hipStream_t stream);

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

4347 unsigned long long flags, hipStream_t stream);

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

4369 unsigned long long flags, hipStream_t stream);

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

4400 hipMemLocation* prefetchLocs,

4401 size_t* prefetchLocIdxs,

4402 size_t numPrefetchLocs,

4403 unsigned long long flags, hipStream_t stream);

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

4423 hipMemLocation* prefetchLocs,

4424 size_t* prefetchLocIdxs,

4425 size_t numPrefetchLocs,

4426 unsigned long long flags, hipStream_t stream);

4427

4428// Deprecated since 800. Introduced in 700.

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

4430

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

4451 hipMemLocation location);

4452

4453#endif

4454

4455// Deprecated since 800.

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

4457

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

4478

4479#endif

4480

4481// Latest

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

4483

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

4485 hipMemLocation location);

4486

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

4508 hipMemLocation location) {

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

4510}

4511

4512#endif

4513

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

4529 const void* dev_ptr, size_t count);

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

4547 hipMemRangeAttribute* attributes, size_t num_attributes,

4548 const void* dev_ptr, size_t count);

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

4565 unsigned int flags __dparm(hipMemAttachSingle));

4566// end doxygen Managed Memory

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

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

4679hipError_t hipMemPoolTrimTo(hipMemPool_t mem_pool, size_t min_bytes_to_hold);

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

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

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

4778 size_t count);

4798hipError_t hipMemPoolGetAccess(hipMemAccessFlags* flags, hipMemPool_t mem_pool,

4799 hipMemLocation* location);

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

4852hipError_t hipMemPoolDestroy(hipMemPool_t mem_pool);

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

4889 hipStream_t stream);

4916hipError_t hipMemPoolExportToShareableHandle(void* shared_handle, hipMemPool_t mem_pool,

4917 hipMemAllocationHandleType handle_type,

4918 unsigned int flags);

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

4943 hipMemAllocationHandleType handle_type,

4944 unsigned int flags);

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

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

4994 hipMemPoolPtrExportData* export_data);

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

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

5007 hipMemAllocationType type);

5008

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

5021 hipMemAllocationType type);

5022

5023// Doxygen end of Stream Ordered Memory Allocator

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

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

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

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

5128hipError_t hipHostUnregister(void* hostPtr);

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

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

5171 unsigned int elementSizeBytes);

5185hipError_t hipFree(void* ptr);

5197hipError_t hipFreeHost(void* ptr);

5214hipError_t hipHostFree(void* ptr);

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

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

5263 hipStream_t stream);

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

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

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

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

5337 size_t ByteCount);

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

5357 size_t ByteCount);

5358

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

5379 size_t srcOffset, size_t ByteCount);

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

5399 hipStream_t stream);

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

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

5438 hipStream_t stream);

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

5459 size_t ByteCount, hipStream_t stream);

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

5480 size_t ByteCount, hipStream_t stream);

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

5500 const char* name);

5501

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

5512

5513

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

5524

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

5545 hipDriverProcAddressQueryResult* symbolStatus);

5546

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

5569 size_t offset __dparm(0),

5570 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice));

5571

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

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

5587

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

5601 size_t offset __dparm(0),

5602 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost));

5603

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

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

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

5648 hipStream_t stream __dparm(0));

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

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

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

5685 hipStream_t stream __dparm(0));

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

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

5712 hipStream_t stream __dparm(0));

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

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

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

5755 hipStream_t stream __dparm(0));

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

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

5779 hipStream_t stream __dparm(0));

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

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

5799 hipStream_t stream __dparm(0));

5800

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

5813 size_t height);

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

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

5828

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

5841 size_t height);

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

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

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

5868 size_t height);

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

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

5883

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

5901

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

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

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

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

5948hipError_t hipArrayDestroy(hipArray_t array);

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

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

5979hipError_t hipFreeArray(hipArray_t array);

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

5992 struct hipExtent extent, unsigned int flags);

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

6006 hipArray_t array);

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

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

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

6078 size_t height, hipMemcpyKind kind);

6088hipError_t hipMemcpyParam2D(const hip_Memcpy2D* pCopy);

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

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

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

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

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

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

6180 size_t spitch, size_t width, size_t height, hipMemcpyKind kind,

6181 hipStream_t stream __dparm(0));

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

6201 hipArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc,

6202 size_t width, size_t height, hipMemcpyKind kind);

6221HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6223 size_t count, hipMemcpyKind kind);

6242HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6244 size_t count, hipMemcpyKind kind);

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

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

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

6283 size_t hOffset, size_t width, size_t height,

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

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

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

6323hipError_t hipMemcpy3D(const struct hipMemcpy3DParms* p);

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

6346hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D* pCopy);

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

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

6372

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

6389 hipMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs,

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

6391

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

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

6406

6415hipError_t hipMemcpy3DPeer(hipMemcpy3DPeerParms* p);

6416

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

6426

6442hipError_t hipMipmappedArrayGetMemoryRequirements(hipArrayMemoryRequirements* memoryRequirements,

6443 hipMipmappedArray_t mipmap, hipDevice_t device);

6444// doxygen end Memory

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

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

6505hipError_t hipDeviceDisablePeerAccess(int peerDeviceId);

6506

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

6519 size_t sizeBytes);

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

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

6534

6535// doxygen end PeerToPeer

6556hipError_t hipDeviceGetDevResource(hipDevice_t device, hipDevResource* resource,

6557 hipDevResourceType type);

6558

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

6575 const hipDevResource* input, hipDevResource* remainder,

6576 unsigned int flags, unsigned int minCount);

6577

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

6595 const hipDevResource* input, hipDevResource* remainder,

6596 unsigned int flags,

6597 hipDevSmResourceGroupParams* groupParams);

6598

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

6610 unsigned int nbResources);

6611

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

6624 unsigned int flags);

6625

6633hipError_t hipExecutionCtxDestroy(hipExecutionCtx_t ctx);

6634

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

6644

6655hipError_t hipExecutionCtxStreamCreate(hipStream_t* stream, hipExecutionCtx_t greenctx,

6656 unsigned int flags, int priority);

6657

6667hipError_t hipExecutionCtxGetDevResource(hipExecutionCtx_t ctx, hipDevResource* resource,

6668 hipDevResourceType type);

6669

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

6679

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

6689

6699hipError_t hipStreamGetDevResource(hipStream_t hStream, hipDevResource* resource,

6700 hipDevResourceType type);

6701

6710hipError_t hipExecutionCtxRecordEvent(hipExecutionCtx_t ctx, hipEvent_t event);

6711

6719hipError_t hipExecutionCtxSynchronize(hipExecutionCtx_t ctx);

6720

6729hipError_t hipExecutionCtxWaitEvent(hipExecutionCtx_t ctx, hipEvent_t event);

6771HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6786HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6787hipError_t hipCtxDestroy(hipCtx_t ctx);

6801HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6802hipError_t hipCtxPopCurrent(hipCtx_t* ctx);

6816HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6817hipError_t hipCtxPushCurrent(hipCtx_t ctx);

6831HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6832hipError_t hipCtxSetCurrent(hipCtx_t ctx);

6846HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6847hipError_t hipCtxGetCurrent(hipCtx_t* ctx);

6861HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6862hipError_t hipCtxGetDevice(hipDevice_t* device);

6883HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6901HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6902hipError_t hipCtxGetCacheConfig(hipFuncCache_t* cacheConfig);

6919HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6920hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig);

6937HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6938hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config);

6955HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6956hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig* pConfig);

6971HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6972hipError_t hipCtxSynchronize(void);

6986HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6987hipError_t hipCtxGetFlags(unsigned int* flags);

7010HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7031HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7032hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx);

7033

7049HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7066HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7067hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev);

7082HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7097HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7098hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev);

7113HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7115// doxygen end Context Management

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

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

7163hipError_t hipModuleUnload(hipModule_t module);

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

7175

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

7186

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

7198 hipModule_t mod);

7199

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

7228 hipDevice_t dev);

7229

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

7244 void** jitOptionsValues, unsigned int numJitOptions,

7245 hipLibraryOption* libraryOptions, void** libraryOptionValues,

7246 unsigned int numLibraryOptions);

7247

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

7262 hipJitOption* jitOptions, void** jitOptionsValues,

7263 unsigned int numJitOptions, hipLibraryOption* libraryOptions,

7264 void** libraryOptionValues, unsigned int numLibraryOptions);

7265

7272hipError_t hipLibraryUnload(hipLibrary_t library);

7273

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

7283

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

7292

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

7308 const char* name);

7309

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

7327 const char* name);

7328

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

7338 hipLibrary_t library);

7339

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

7348

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

7357

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

7369 size_t* paramSize);

7370

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

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

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

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

7412 hipDriverEntryPointQueryResult* driverStatus);

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

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

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

7460 hipJitOption* options, void** optionValues);

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

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

7481 void** optionValues);

7482

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

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

7501

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

7517

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

7530 hipLinkState_t* stateOut);

7539hipError_t hipLinkDestroy(hipLinkState_t state);

7540

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

7570 unsigned int gridDimZ, unsigned int blockDimX,

7571 unsigned int blockDimY, unsigned int blockDimZ,

7572 unsigned int sharedMemBytes, hipStream_t stream,

7573 void** kernelParams, void** extra);

7602hipError_t hipModuleLaunchCooperativeKernel(hipFunction_t f, unsigned int gridDimX,

7603 unsigned int gridDimY, unsigned int gridDimZ,

7604 unsigned int blockDimX, unsigned int blockDimY,

7605 unsigned int blockDimZ, unsigned int sharedMemBytes,

7606 hipStream_t stream, void** kernelParams);

7621hipError_t hipModuleLaunchCooperativeKernelMultiDevice(hipFunctionLaunchParams* launchParamsList,

7622 unsigned int numDevices, unsigned int flags);

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

7644 void** kernelParams, unsigned int sharedMemBytes,

7645 hipStream_t stream);

7657hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList, int numDevices,

7658 unsigned int flags);

7659

7660// Doxygen end group ModuleCooperativeG

7674hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList, int numDevices,

7675 unsigned int flags);

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

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

7706 void** extra);

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

7722 hipMemRangeHandleType handleType,

7723 unsigned long long flags);

7724// doxygen end Module

7752// TODO - Match CUoccupancyB2DSize

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

7754 size_t dynSharedMemPerBlk, int blockSizeLimit);

7770// TODO - Match CUoccupancyB2DSize

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

7772 hipFunction_t f,

7773 size_t dynSharedMemPerBlk,

7774 int blockSizeLimit, unsigned int flags);

7784hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, hipFunction_t f,

7785 int blockSize,

7786 size_t dynSharedMemPerBlk);

7797hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

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

7809 int blockSize, size_t dynSharedMemPerBlk);

7820hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

7822 unsigned int flags __dparm(hipOccupancyDefault));

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

7838 size_t dynSharedMemPerBlk, int blockSizeLimit);

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

7855 int numBlocks, int blockSize);

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

7867 const hipLaunchConfig_t* config);

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

7879 const hipLaunchConfig_t* config);

7880

7881// doxygen end Occupancy

7895// TODO - expand descriptions:

7902HIP_DEPRECATED("use roctracer/rocTX instead")

7903hipError_t hipProfilerStart();

7910HIP_DEPRECATED("use roctracer/rocTX instead")

7911hipError_t hipProfilerStop();

7912// doxygen end profiler

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

7940 hipStream_t stream __dparm(0));

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

7960hipError_t hipLaunchByPtr(const void* func);

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

7978 hipStream_t stream __dparm(0));

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

7999 hipStream_t* stream);

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

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

8018 hipStream_t stream __dparm(0));

8019

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

8047

8055hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D* pCopy);

8056// TODO: Move this to hip_ext.h

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

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

8080 hipEvent_t startEvent, hipEvent_t stopEvent, int flags);

8081// doxygen end Clang launch

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

8108 const hipTextureDesc* pTexDesc,

8109 const struct hipResourceViewDesc* pResViewDesc);

8110

8119hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject);

8120

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

8131

8141hipError_t hipGetTextureObjectResourceDesc(hipResourceDesc* pResDesc,

8142 hipTextureObject_t textureObject);

8143

8153hipError_t hipGetTextureObjectResourceViewDesc(struct hipResourceViewDesc* pResViewDesc,

8154 hipTextureObject_t textureObject);

8155

8165hipError_t hipGetTextureObjectTextureDesc(hipTextureDesc* pTexDesc,

8166 hipTextureObject_t textureObject);

8167

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

8180 const HIP_TEXTURE_DESC* pTexDesc,

8181 const HIP_RESOURCE_VIEW_DESC* pResViewDesc);

8182

8191hipError_t hipTexObjectDestroy(hipTextureObject_t texObject);

8192

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

8203

8213hipError_t hipTexObjectGetResourceViewDesc(HIP_RESOURCE_VIEW_DESC* pResViewDesc,

8214 hipTextureObject_t texObject);

8215

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

8226

8241hipError_t hipMallocMipmappedArray(hipMipmappedArray_t* mipmappedArray,

8242 const struct hipChannelFormatDesc* desc, struct hipExtent extent,

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

8244

8255hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray);

8256

8269hipError_t hipGetMipmappedArrayLevel(hipArray_t* levelArray,

8270 hipMipmappedArray_const_t mipmappedArray, unsigned int level);

8271

8283hipError_t hipMipmappedArrayCreate(hipMipmappedArray_t* pHandle,

8284 HIP_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc,

8285 unsigned int numMipmapLevels);

8286

8297hipError_t hipMipmappedArrayDestroy(hipMipmappedArray_t hMipmappedArray);

8298

8311hipError_t hipMipmappedArrayGetLevel(hipArray_t* pLevelArray, hipMipmappedArray_t hMipMappedArray,

8312 unsigned int level);

8313

8332HIP_DEPRECATED(HIP_DEPRECATED_MSG)

8333hipError_t hipBindTextureToMipmappedArray(const textureReference* tex,

8334 hipMipmappedArray_const_t mipmappedArray,

8335 const hipChannelFormatDesc* desc);

8336

8347HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8349

8360HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8362

8374HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8376

8388HIP_DEPRECATED(HIP_DEPRECATED_MSG)

8389hipError_t hipTexRefSetAddressMode(textureReference* texRef, int dim,

8390 enum hipTextureAddressMode am);

8403HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8416HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8429HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8443HIP_DEPRECATED(HIP_DEPRECATED_MSG)

8444hipError_t hipTexRefSetFormat(textureReference* texRef, hipArray_Format fmt,

8445 int NumPackedComponents);

8460HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

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

8479HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

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

8482 size_t pitch);

8495HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8497 const hipChannelFormatDesc* desc);

8509HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8521HIP_DEPRECATED(HIP_DEPRECATED_MSG)

8522hipError_t hipUnbindTexture(const textureReference* tex);

8534HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8548HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8550 int dim);

8562HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8575HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8589HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8591 const textureReference* texRef);

8603HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8616HIP_DEPRECATED(HIP_DEPRECATED_MSG)

8617hipError_t hipTexRefGetMipmapFilterMode(enum hipTextureFilterMode* pfm,

8618 const textureReference* texRef);

8630HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8644HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8646 const textureReference* texRef);

8658HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8673HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8675 size_t bytes);

8689HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8691 hipDeviceptr_t dptr, size_t Pitch);

8703HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8716HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8729HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8742HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8756HIP_DEPRECATED(HIP_DEPRECATED_MSG)

8757hipError_t hipTexRefSetMipmapLevelClamp(textureReference* texRef, float minMipMapLevelClamp,

8758 float maxMipMapLevelClamp);

8771HIP_DEPRECATED(HIP_DEPRECATED_MSG)

8772hipError_t hipTexRefSetMipmappedArray(textureReference* texRef,

8773 struct hipMipmappedArray* mipmappedArray, unsigned int Flags);

8774

8775// doxygen end deprecated texture management

8780// doxygen end Texture management

8792// This group is for HIPrtc

8793

8794// doxygen end Runtime

8813const char* hipApiName(uint32_t id);

8822const char* hipKernelNameRef(const hipFunction_t f);

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

8841int hipGetStreamDeviceId(hipStream_t stream);

8842

8843// doxygen end Callback

8865hipError_t hipStreamBeginCapture(hipStream_t stream, hipStreamCaptureMode mode);

8866

8886hipError_t hipStreamBeginCaptureToGraph(hipStream_t stream, hipGraph_t graph,

8887 const hipGraphNode_t* dependencies,

8888 const hipGraphEdgeData* dependencyData,

8889 size_t numDependencies, hipStreamCaptureMode mode);

8890

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

8902

8913hipError_t hipStreamGetCaptureInfo(hipStream_t stream, hipStreamCaptureStatus* pCaptureStatus,

8914 unsigned long long* pId);

8915

8930hipError_t hipStreamGetCaptureInfo_v2(hipStream_t stream, hipStreamCaptureStatus* captureStatus_out,

8931 unsigned long long* id_out __dparm(0),

8932 hipGraph_t* graph_out __dparm(0),

8933 const hipGraphNode_t** dependencies_out __dparm(0),

8934 size_t* numDependencies_out __dparm(0));

8935

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

8946

8959hipError_t hipStreamUpdateCaptureDependencies(hipStream_t stream, hipGraphNode_t* dependencies,

8960 size_t numDependencies,

8961 unsigned int flags __dparm(0));

8962

8970hipError_t hipThreadExchangeStreamCaptureMode(hipStreamCaptureMode* mode);

8971

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

8982

8991hipError_t hipGraphDestroy(hipGraph_t graph);

8992

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

9004 const hipGraphNode_t* to, size_t numDependencies);

9005

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

9017 const hipGraphNode_t* to, size_t numDependencies);

9018

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

9035 size_t* numEdges);

9036

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

9052

9067hipError_t hipGraphGetRootNodes(hipGraph_t graph, hipGraphNode_t* pRootNodes,

9068 size_t* pNumRootNodes);

9069

9084hipError_t hipGraphNodeGetDependencies(hipGraphNode_t node, hipGraphNode_t* pDependencies,

9085 size_t* pNumDependencies);

9086

9102hipError_t hipGraphNodeGetDependentNodes(hipGraphNode_t node, hipGraphNode_t* pDependentNodes,

9103 size_t* pNumDependentNodes);

9104

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

9114

9122hipError_t hipGraphDestroyNode(hipGraphNode_t node);

9123

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

9133

9143hipError_t hipGraphNodeFindInClone(hipGraphNode_t* pNode, hipGraphNode_t originalNode,

9144 hipGraph_t clonedGraph);

9145

9159hipError_t hipGraphInstantiate(hipGraphExec_t* pGraphExec, hipGraph_t graph,

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

9161

9172hipError_t hipGraphInstantiateWithFlags(hipGraphExec_t* pGraphExec, hipGraph_t graph,

9173 unsigned long long flags);

9174

9184hipError_t hipGraphInstantiateWithParams(hipGraphExec_t* pGraphExec, hipGraph_t graph,

9185 hipGraphInstantiateParams* instantiateParams);

9194hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream);

9195

9204hipError_t hipGraphUpload(hipGraphExec_t graphExec, hipStream_t stream);

9205

9217hipError_t hipGraphAddNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9218 const hipGraphNode_t* pDependencies, size_t numDependencies,

9219 hipGraphNodeParams* nodeParams);

9220

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

9230

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

9241

9252hipError_t hipGraphExecNodeSetParams(hipGraphExec_t graphExec, hipGraphNode_t node,

9253 hipGraphNodeParams* nodeParams);

9254

9263hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec);

9264

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

9277hipError_t hipGraphExecUpdate(hipGraphExec_t hGraphExec, hipGraph_t hGraph,

9278 hipGraphNode_t* hErrorNode_out,

9279 hipGraphExecUpdateResult* updateResult_out);

9280

9292hipError_t hipGraphAddKernelNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9293 const hipGraphNode_t* pDependencies, size_t numDependencies,

9294 const hipKernelNodeParams* pNodeParams);

9295

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

9305

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

9315

9325hipError_t hipGraphExecKernelNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

9326 const hipKernelNodeParams* pNodeParams);

9327

9340hipError_t hipDrvGraphAddMemcpyNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

9341 const hipGraphNode_t* dependencies, size_t numDependencies,

9342 const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);

9354hipError_t hipGraphAddMemcpyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9355 const hipGraphNode_t* pDependencies, size_t numDependencies,

9356 const hipMemcpy3DParms* pCopyParams);

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

9366

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

9376

9386hipError_t hipGraphKernelNodeSetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

9387 const hipKernelNodeAttrValue* value);

9397hipError_t hipGraphKernelNodeGetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

9398 hipKernelNodeAttrValue* value);

9408hipError_t hipGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

9409 hipMemcpy3DParms* pNodeParams);

9410

9425hipError_t hipGraphAddMemcpyNode1D(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9426 const hipGraphNode_t* pDependencies, size_t numDependencies,

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

9428

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

9441 size_t count, hipMemcpyKind kind);

9442

9456hipError_t hipGraphExecMemcpyNodeSetParams1D(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

9458 hipMemcpyKind kind);

9459

9475hipError_t hipGraphAddMemcpyNodeFromSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9476 const hipGraphNode_t* pDependencies,

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

9478 size_t count, size_t offset, hipMemcpyKind kind);

9479

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

9493 size_t count, size_t offset, hipMemcpyKind kind);

9494

9509hipError_t hipGraphExecMemcpyNodeSetParamsFromSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

9511 size_t offset, hipMemcpyKind kind);

9512

9528hipError_t hipGraphAddMemcpyNodeToSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9529 const hipGraphNode_t* pDependencies,

9530 size_t numDependencies, const void* symbol,

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

9532 hipMemcpyKind kind);

9533

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

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

9548 hipMemcpyKind kind);

9549

9550

9564hipError_t hipGraphExecMemcpyNodeSetParamsToSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

9565 const void* symbol, const void* src,

9566 size_t count, size_t offset, hipMemcpyKind kind);

9567

9579hipError_t hipGraphAddMemsetNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9580 const hipGraphNode_t* pDependencies, size_t numDependencies,

9581 const hipMemsetParams* pMemsetParams);

9582

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

9592

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

9602

9612hipError_t hipGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

9613 const hipMemsetParams* pNodeParams);

9614

9626hipError_t hipGraphAddHostNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9627 const hipGraphNode_t* pDependencies, size_t numDependencies,

9628 const hipHostNodeParams* pNodeParams);

9629

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

9639

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

9649

9659hipError_t hipGraphExecHostNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

9660 const hipHostNodeParams* pNodeParams);

9661

9673hipError_t hipGraphAddChildGraphNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9674 const hipGraphNode_t* pDependencies, size_t numDependencies,

9675 hipGraph_t childGraph);

9676

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

9686

9696hipError_t hipGraphExecChildGraphNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

9697 hipGraph_t childGraph);

9698

9709hipError_t hipGraphAddEmptyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9710 const hipGraphNode_t* pDependencies, size_t numDependencies);

9711

9712

9724hipError_t hipGraphAddEventRecordNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9725 const hipGraphNode_t* pDependencies, size_t numDependencies,

9726 hipEvent_t event);

9727

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

9737

9746hipError_t hipGraphEventRecordNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

9747

9757hipError_t hipGraphExecEventRecordNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9758 hipEvent_t event);

9759

9771hipError_t hipGraphAddEventWaitNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9772 const hipGraphNode_t* pDependencies, size_t numDependencies,

9773 hipEvent_t event);

9774

9775

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

9785

9794hipError_t hipGraphEventWaitNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

9795

9805hipError_t hipGraphExecEventWaitNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9806 hipEvent_t event);

9807

9820hipError_t hipGraphAddMemAllocNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9821 const hipGraphNode_t* pDependencies, size_t numDependencies,

9822 hipMemAllocNodeParams* pNodeParams);

9823

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

9833

9845hipError_t hipGraphAddMemFreeNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9846 const hipGraphNode_t* pDependencies, size_t numDependencies,

9847 void* dev_ptr);

9848

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

9858

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

9869

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

9880

9888hipError_t hipDeviceGraphMemTrim(int device);

9889

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

9902 unsigned int initialRefcount, unsigned int flags);

9903

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

9913

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

9923

9934hipError_t hipGraphRetainUserObject(hipGraph_t graph, hipUserObject_t object,

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

9936

9946hipError_t hipGraphReleaseUserObject(hipGraph_t graph, hipUserObject_t object,

9947 unsigned int count __dparm(1));

9948

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

9959

9973hipError_t hipGraphKernelNodeCopyAttributes(hipGraphNode_t hSrc, hipGraphNode_t hDst);

9974

9996hipError_t hipGraphNodeSetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9997 unsigned int isEnabled);

10017hipError_t hipGraphNodeGetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

10018 unsigned int* isEnabled);

10019

10031hipError_t hipGraphAddExternalSemaphoresWaitNode(

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

10033 size_t numDependencies, const hipExternalSemaphoreWaitNodeParams* nodeParams);

10034

10046hipError_t hipGraphAddExternalSemaphoresSignalNode(

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

10048 size_t numDependencies, const hipExternalSemaphoreSignalNodeParams* nodeParams);

10057hipError_t hipGraphExternalSemaphoresSignalNodeSetParams(

10058 hipGraphNode_t hNode, const hipExternalSemaphoreSignalNodeParams* nodeParams);

10067hipError_t hipGraphExternalSemaphoresWaitNodeSetParams(

10068 hipGraphNode_t hNode, const hipExternalSemaphoreWaitNodeParams* nodeParams);

10077hipError_t hipGraphExternalSemaphoresSignalNodeGetParams(

10078 hipGraphNode_t hNode, hipExternalSemaphoreSignalNodeParams* params_out);

10087hipError_t hipGraphExternalSemaphoresWaitNodeGetParams(

10088 hipGraphNode_t hNode, hipExternalSemaphoreWaitNodeParams* params_out);

10098hipError_t hipGraphExecExternalSemaphoresSignalNodeSetParams(

10099 hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

10100 const hipExternalSemaphoreSignalNodeParams* nodeParams);

10110hipError_t hipGraphExecExternalSemaphoresWaitNodeSetParams(

10111 hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

10112 const hipExternalSemaphoreWaitNodeParams* nodeParams);

10113

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

10123

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

10133

10146hipError_t hipDrvGraphAddMemsetNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

10147 const hipGraphNode_t* dependencies, size_t numDependencies,

10148 const hipMemsetParams* memsetParams, hipCtx_t ctx);

10149

10161hipError_t hipDrvGraphAddMemFreeNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

10162 const hipGraphNode_t* dependencies, size_t numDependencies,

10163 hipDeviceptr_t dptr);

10164

10175hipError_t hipDrvGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

10176 const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);

10177

10188hipError_t hipDrvGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

10189 const hipMemsetParams* memsetParams, hipCtx_t ctx);

10190

10191// doxygen end graph API

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

10221

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

10235 unsigned long long flags);

10236

10254hipError_t hipMemCreate(hipMemGenericAllocationHandle_t* handle, size_t size,

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

10256

10268hipError_t hipMemExportToShareableHandle(void* shareableHandle,

10269 hipMemGenericAllocationHandle_t handle,

10270 hipMemAllocationHandleType handleType,

10271 unsigned long long flags);

10272

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

10284

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

10297 hipMemAllocationGranularity_flags option);

10298

10308hipError_t hipMemGetAllocationPropertiesFromHandle(hipMemAllocationProp* prop,

10309 hipMemGenericAllocationHandle_t handle);

10310

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

10322 hipMemAllocationHandleType shHandleType);

10323

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

10337 unsigned long long flags);

10338

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

10348 hipStream_t stream);

10349

10359hipError_t hipMemRelease(hipMemGenericAllocationHandle_t handle);

10360

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

10371

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

10385

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

10396

10397// doxygen end virtual memory management API

10419hipError_t hipGraphicsMapResources(int count, hipGraphicsResource_t* resources,

10420 hipStream_t stream __dparm(0));

10434hipError_t hipGraphicsSubResourceGetMappedArray(hipArray_t* array, hipGraphicsResource_t resource,

10435 unsigned int arrayIndex, unsigned int mipLevel);

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

10447 hipGraphicsResource_t resource);

10458hipError_t hipGraphicsUnmapResources(int count, hipGraphicsResource_t* resources,

10459 hipStream_t stream __dparm(0));

10468hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource);

10469// doxygen end GraphicsInterop

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

10503hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject);

10504// end of surface

10505

10506

10517hipError_t hipExtEnableLogging();

10528hipError_t hipExtDisableLogging();

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

10544

10548#ifdef __cplusplus

10549} /* extern "c" */

10550#endif

10551#ifdef __cplusplus

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

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

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

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

10556 dynSharedMemPerBlk, blockSizeLimit);

10557}

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

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

10560 unsigned int flags = 0) {

10561 (void)flags;

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

10563 dynSharedMemPerBlk, blockSizeLimit);

10564}

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

10566

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

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

10578}

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

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

10591}

10592

10601template <typename T>

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

10603 size_t offset __dparm(0),

10604 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice)) {

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

10606}

10615template <typename T>

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

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

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

10619}

10627template <typename T>

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

10629 size_t offset __dparm(0),

10630 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost)) {

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

10632}

10640template <typename T>

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

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

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

10644}

10645

10657template <class T>

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

10659 size_t dynSharedMemPerBlk) {

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

10661 blockSize, dynSharedMemPerBlk);

10662}

10676template <class T> inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

10678 return hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

10680}

10703template <typename UnaryFunction, class T>

10704static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(

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

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

10707 if (min_grid_size == nullptr || block_size == nullptr ||

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

10709 return hipErrorInvalidValue;

10710 }

10711

10712 int dev;

10713 hipError_t status;

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

10715 return status;

10716 }

10717

10718 int max_threads_per_cu;

10719 if ((status = hipDeviceGetAttribute(&max_threads_per_cu,

10720 hipDeviceAttributeMaxThreadsPerMultiProcessor, dev)) !=

10721 hipSuccess) {

10722 return status;

10723 }

10724

10725 int warp_size;

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

10727 return status;

10728 }

10729

10730 int max_cu_count;

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

10732 hipSuccess) {

10733 return status;

10734 }

10735

10736 struct hipFuncAttributes attr;

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

10738 return status;

10739 }

10740

10741 // Initial limits for the execution

10742 const int func_max_threads_per_block = attr.maxThreadsPerBlock;

10743 if (block_size_limit == 0) {

10744 block_size_limit = func_max_threads_per_block;

10745 }

10746

10747 if (func_max_threads_per_block < block_size_limit) {

10748 block_size_limit = func_max_threads_per_block;

10749 }

10750

10751 const int block_size_limit_aligned =

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

10753

10754 // For maximum search

10755 int max_threads = 0;

10756 int max_block_size{};

10757 int max_num_blocks{};

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

10759 block_size_check_aligned -= warp_size) {

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

10761 int block_size_check =

10762 (block_size_limit < block_size_check_aligned) ? block_size_limit : block_size_check_aligned;

10763

10764 size_t dyn_smem_size = block_size_to_dynamic_smem_size(block_size_check);

10765 int optimal_blocks;

10766 if ((status = hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

10768 return status;

10769 }

10770

10771 int total_threads = block_size_check * optimal_blocks;

10772 if (total_threads > max_threads) {

10773 max_block_size = block_size_check;

10774 max_num_blocks = optimal_blocks;

10775 max_threads = total_threads;

10776 }

10777

10778 // Break if the logic reached possible maximum

10779 if (max_threads_per_cu == max_threads) {

10780 break;

10781 }

10782 }

10783

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

10785 *min_grid_size = max_num_blocks * max_cu_count;

10786 *block_size = max_block_size;

10787

10788 return status;

10789}

10790

10812template <typename UnaryFunction, class T>

10813static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMem(

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

10815 int block_size_limit = 0) {

10816 return hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(

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

10818}

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

10835 int* blockSize, F kernel,

10836 size_t dynSharedMemPerBlk,

10837 uint32_t blockSizeLimit) {

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

10839 dynSharedMemPerBlk, blockSizeLimit);

10840}

10841

10857template <typename F>

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

10859 int numBlocks, int blockSize) {

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

10861 numBlocks, blockSize);

10862}

10884template <class T>

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

10886 unsigned int sharedMemBytes, hipStream_t stream) {

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

10888 kernelParams, sharedMemBytes, stream);

10889}

10905template <class T>

10906inline hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

10907 unsigned int numDevices,

10908 unsigned int flags = 0) {

10909 return hipLaunchCooperativeKernelMultiDevice(launchParamsList, numDevices, flags);

10910}

10923template <class T>

10924inline hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

10925 unsigned int numDevices,

10926 unsigned int flags = 0) {

10927 return hipExtLaunchMultiKernelMultiDevice(launchParamsList, numDevices, flags);

10928}

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

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

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

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

10946}

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

10962static inline hipError_t

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

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

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

10966}

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

10983static inline hipError_t

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

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

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

10987}

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

11005static inline hipError_t

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

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

11008 size_t height, size_t pitch) {

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

11010}

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

11023static inline hipError_t

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

11025 struct hipChannelFormatDesc desc;

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

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

11028}

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

11042static inline hipError_t

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

11044 const struct hipChannelFormatDesc& desc) {

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

11046}

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

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

11060 hipMipmappedArray_const_t mipmappedArray) {

11061 struct hipChannelFormatDesc desc;

11062 hipArray_t levelArray;

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

11064 if (err != hipSuccess) {

11065 return err;

11066 }

11067 err = hipGetChannelDesc(&desc, levelArray);

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

11069}

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

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

11084 hipMipmappedArray_const_t mipmappedArray,

11085 const struct hipChannelFormatDesc& desc) {

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

11087}

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

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

11100 return hipUnbindTexture(&tex);

11101}

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

11126 hipStream_t stream) {

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

11128}

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

11140 hipMemPool_t mem_pool,

11141 hipStream_t stream) {

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

11143}

11154template <class T>

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

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

11157}

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

11169 hipMemPool_t mem_pool,

11170 hipStream_t stream) {

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

11172}

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

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

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

11189 Params&&... args) {

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

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

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

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

11194}

11200#endif // __cplusplus

11201

11202#ifdef __GNUC__

11203#pragma GCC visibility pop

11204#endif

11205

11206

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

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

11209#else

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

11211#endif

11212

11213

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

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

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

11228}

11240template <class T>

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

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

11243}

11256template <class T>

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

11258 unsigned int flags = hipHostMallocDefault) {

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

11260}

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

11274 unsigned int flags = hipHostAllocDefault) {

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

11276}

11291template <class T>

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

11293 unsigned int flags = hipMemAttachGlobal) {

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

11295}

11296

11297#endif

11298#endif

11299// doxygen end HIP API

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

11304

11305#if USE_PROF_API

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

11307#endif

driver_types.h

err

hipError_t err

Definition hip_runtime_api.h:11026

tex

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

Definition hip_runtime_api.h:10943

size

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

Definition hip_runtime_api.h:10944

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

levelArray

hipArray_t levelArray

Definition hip_runtime_api.h:11062

dim

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

Definition hip_runtime_api.h:10961

mipmappedArray

readMode hipMipmappedArray_const_t mipmappedArray

Definition hip_runtime_api.h:11060

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

devPtr

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

Definition hip_runtime_api.h:10944

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

array

readMode hipArray_const_t array

Definition hip_runtime_api.h:11024

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

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.

hipDeviceFlushGPUDirectRDMAWrites

hipError_t hipDeviceFlushGPUDirectRDMAWrites(enum hipFlushGPUDirectRDMAWritesTarget target, enum hipFlushGPUDirectRDMAWritesScope scope)

Blocks until remote writes are visible to the specified scope.

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.

hipKernelSetAttributeForDevice

hipError_t hipKernelSetAttributeForDevice(hipKernel_t kernel, hipFuncAttribute attr, int value, int device)

Set a device-wide attribute for a kernel on a specific device.

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

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

hipDeviceProp_t::ipcEventSupported

int ipcEventSupported

Device supports IPC events.

Definition hip_runtime_api.h:374

hipGraphNodeParams::type

hipGraphNodeType type

Definition hip_runtime_api.h:2140

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

hipExternalSemaphoreHandleDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1535

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

hipLaunchAttributeValue::priority

int priority

Definition hip_runtime_api.h:1803

hipFunctionLaunchParams::gridDimX

unsigned int gridDimX

Width(X) of grid in blocks.

Definition hip_runtime_api.h:1465

hipFunctionLaunchParams::blockDimX

unsigned int blockDimX

X dimension of each thread block.

Definition hip_runtime_api.h:1468

hipMemAllocationProp::win32HandleMetaData

void * win32HandleMetaData

Metadata for Win32 handles.

Definition hip_runtime_api.h:1989

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

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

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

hipPointerAttribute_t::hostPointer

void * hostPointer

Definition hip_runtime_api.h:437

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::address

hipDeviceptr_t address

Definition hip_runtime_api.h:1157

hipAccessPolicyWindow::missProp

hipAccessProperty missProp

hipAccessProperty set for miss

Definition hip_runtime_api.h:1691

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

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

hipMemPoolProps::maxSize

size_t maxSize

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

Definition hip_runtime_api.h:1394

hipLaunchAttributeValue::pad

char pad[64]

64 byte padding

Definition hip_runtime_api.h:1798

hipDevSmResource::flags

unsigned int flags

Definition hip_runtime_api.h:781

hipDevSmResourceGroupParams::flags

unsigned int flags

Definition hip_runtime_api.h:810

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

hipDeviceProp_t::asyncEngineCount

int asyncEngineCount

Number of async engines.

Definition hip_runtime_api.h:325

hipMemsetParams::dst

void * dst

Definition hip_runtime_api.h:1656

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

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

hipKernelNodeParams::gridDim

dim3 gridDim

Definition hip_runtime_api.h:1651

hipExternalSemaphoreSignalNodeParams::paramsArray

const hipExternalSemaphoreSignalParams * paramsArray

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

Definition hip_runtime_api.h:2004

hipExtDynDataPrefetchRegion::address

void * address

Base address (must be cache-line aligned)

Definition hip_runtime_api.h:1747

hipDevResource::nextResource

struct hipDevResource_st * nextResource

Definition hip_runtime_api.h:803

hipHostNodeParams::fn

hipHostFn_t fn

Definition hip_runtime_api.h:1644

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

hipFuncAttributes::cacheModeCA

int cacheModeCA

Definition hip_runtime_api.h:851

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

hipMemAccessDesc::flags

hipMemAccessFlags flags

Accessibility flags to set.

Definition hip_runtime_api.h:1354

hipExtDynDataPrefetchConfig::numRegions

unsigned int numRegions

Number of valid regions (1-max)

Definition hip_runtime_api.h:1771

hipChildGraphNodeParams::graph

hipGraph_t graph

Definition hip_runtime_api.h:2111

hipDeviceProp_t::gpuDirectRDMAWritesOrdering

int gpuDirectRDMAWritesOrdering

value of hipGPUDirectRDMAWritesOrdering

Definition hip_runtime_api.h:369

hipMemsetParams::value

unsigned int value

Definition hip_runtime_api.h:1660

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

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

hipKernelNodeParams::sharedMemBytes

unsigned int sharedMemBytes

Definition hip_runtime_api.h:1653

hipArrayMapInfo::subresource

union hipArrayMapInfo::@38 subresource

HIP_LAUNCH_CONFIG::gridDimZ

unsigned int gridDimZ

Grid depth in blocks.

Definition hip_runtime_api.h:2228

hipLaunchMemSyncDomainMap::remote

unsigned char remote

Definition hip_runtime_api.h:1700

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

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

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

hipArrayMapInfo::subresourceType

hipArraySparseSubresourceType subresourceType

Sparse subresource type.

Definition hip_runtime_api.h:2066

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

hipExternalSemaphoreWaitNodeParams::numExtSems

unsigned int numExtSems

Definition hip_runtime_api.h:2018

hipGraphInstantiateParams::result_out

hipGraphInstantiateResult result_out

Definition hip_runtime_api.h:1973

hipDevWorkqueueConfigResource::wqConcurrencyLimit

unsigned int wqConcurrencyLimit

Definition hip_runtime_api.h:786

hipFunctionLaunchParams::function

hipFunction_t function

Kernel to launch.

Definition hip_runtime_api.h:1464

HIP_LAUNCH_CONFIG::sharedMemBytes

unsigned int sharedMemBytes

Dynamic shared-memory size in bytes per block.

Definition hip_runtime_api.h:2232

hipLaunchAttributeValue::dynDataPrefetch

const hipExtDynDataPrefetchConfig * dynDataPrefetch

Value of launch attribute hipLaunchAttributeExtDynDataPrefetch.

Definition hip_runtime_api.h:1832

hipKernelNodeParams::blockDim

dim3 blockDim

Definition hip_runtime_api.h:1648

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

hipLaunchConfig_t::gridDim

dim3 gridDim

Grid dimensions.

Definition hip_runtime_api.h:2214

hipLaunchConfig_t::numAttrs

unsigned int numAttrs

Number of attributes.

Definition hip_runtime_api.h:2219

hipDevSmResource::smCoscheduledAlignment

unsigned int smCoscheduledAlignment

Definition hip_runtime_api.h:780

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::alias

hipDeviceptr_t alias

Not valid for AMD backend. Initial value is unimportant.

Definition hip_runtime_api.h:1163

hipFuncAttributes::binaryVersion

int binaryVersion

Definition hip_runtime_api.h:850

hipExternalSemaphoreSignalParams::flags

unsigned int flags

Definition hip_runtime_api.h:1553

hipHostNodeParams::userData

void * userData

Definition hip_runtime_api.h:1645

hipLaunchAttributeValue::memSyncDomain

hipLaunchMemSyncDomain memSyncDomain

Value of launch attribute hipLaunchAttributeMemSyncDomain.

Definition hip_runtime_api.h:1811

hipArrayMemoryRequirements::alignment

size_t alignment

Definition hip_runtime_api.h:2242

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

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

hipStreamBatchMemOpParams::hipStreamMemOpMemoryBarrierParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:1181

hipExternalSemaphoreHandleDesc::type

hipExternalSemaphoreHandleType type

Definition hip_runtime_api.h:1526

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

hipMemAllocNodeParams::accessDescs

const hipMemAccessDesc * accessDescs

The number of memory access descriptors.

Definition hip_runtime_api.h:1667

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

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

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

HIP_LAUNCH_CONFIG::blockDimY

unsigned int blockDimY

Thread block dimension in Y.

Definition hip_runtime_api.h:2230

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

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

hipDevSmResource::minSmPartitionSize

unsigned int minSmPartitionSize

Definition hip_runtime_api.h:779

hipMemAccessDesc::location

hipMemLocation location

Location on which the accessibility has to change.

Definition hip_runtime_api.h:1353

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

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

hipMemAllocNodeParams::bytesize

size_t bytesize

The size of the requested allocation in bytes.

Definition hip_runtime_api.h:1670

hipMemcpyNodeParams::reserved

int reserved[3]

Must be zero.

Definition hip_runtime_api.h:2103

hipDevSmResourceGroupParams::preferredCoscheduledSmCount

unsigned int preferredCoscheduledSmCount

Definition hip_runtime_api.h:809

hipExternalSemaphoreWaitNodeParams::paramsArray

const hipExternalSemaphoreWaitParams * paramsArray

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

Definition hip_runtime_api.h:2016

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

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

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

hipBatchMemOpNodeParams::paramArray

hipStreamBatchMemOpParams * paramArray

Definition hip_runtime_api.h:1216

HIP_LAUNCH_CONFIG::attrs

hipLaunchAttribute * attrs

Attribute list.

Definition hip_runtime_api.h:2234

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

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

hipExternalSemaphoreWaitNodeParams::extSemArray

hipExternalSemaphore_t * extSemArray

< Array containing external semaphore handles.

Definition hip_runtime_api.h:2014

hipKernelNodeParams::kernelParams

void ** kernelParams

Definition hip_runtime_api.h:1652

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

hipLaunchConfig_t::dynamicSmemBytes

size_t dynamicSmemBytes

Dynamic shared-memory size per thread block.

Definition hip_runtime_api.h:2216

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

hipArrayMapInfo::memHandleType

hipMemHandleType memHandleType

Memory handle type.

Definition hip_runtime_api.h:2088

hipGraphEdgeData::reserved

unsigned char reserved[5]

These bytes are unused and must be zeroed.

Definition hip_runtime_api.h:2191

hipExternalMemoryMipmappedArrayDesc::offset

unsigned long long offset

Definition hip_runtime_api.h:1506

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

hipEventRecordNodeParams::event

hipEvent_t event

The event to be recorded when node executes.

Definition hip_runtime_api.h:2126

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

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

hipDevSmResourceGroupParams::smCount

unsigned int smCount

Definition hip_runtime_api.h:807

hipFuncAttributes::sharedSizeBytes

size_t sharedSizeBytes

Definition hip_runtime_api.h:859

hipMemAllocNodeParams::accessDescCount

size_t accessDescCount

Definition hip_runtime_api.h:1668

hipFuncAttributes::maxDynamicSharedSizeBytes

int maxDynamicSharedSizeBytes

Definition hip_runtime_api.h:854

hipFunctionLaunchParams::blockDimY

unsigned int blockDimY

Y dimension of each thread block.

Definition hip_runtime_api.h:1469

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

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

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

hipDevSmResourceGroupParams::coscheduledSmCount

unsigned int coscheduledSmCount

Definition hip_runtime_api.h:808

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

hipMemAllocationProp::location

hipMemLocation location

Memory location.

Definition hip_runtime_api.h:1988

hipExtDynDataPrefetchConfig::temporal

hipExtDynDataPrefetchTemporal temporal

Cache retention policy for prefetched data.

Definition hip_runtime_api.h:1772

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

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

hipExternalMemoryHandleDesc::type

hipExternalMemoryHandleType type

Definition hip_runtime_api.h:1486

hipFuncAttributes::ptxVersion

int ptxVersion

Definition hip_runtime_api.h:858

hipKernelNodeParams::extra

void ** extra

Definition hip_runtime_api.h:1649

hipGraphInstantiateParams::flags

unsigned long long flags

Definition hip_runtime_api.h:1972

hipBatchMemOpNodeParams::count

unsigned int count

Definition hip_runtime_api.h:1215

HIP_LAUNCH_CONFIG::numAttrs

unsigned int numAttrs

Number of attributes.

Definition hip_runtime_api.h:2235

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

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::alias

hipDeviceptr_t alias

Not valid for AMD backend. Initial value is unimportant.

Definition hip_runtime_api.h:1173

hipMemsetParams::elementSize

unsigned int elementSize

Definition hip_runtime_api.h:1657

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedGridDim

int cooperativeMultiDeviceUnmatchedGridDim

Definition hip_runtime_api.h:392

hipExternalSemaphoreWaitParams::flags

unsigned int flags

Definition hip_runtime_api.h:1574

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

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

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

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

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

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

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

hipLaunchParams::blockDim

dim3 blockDim

Block dimensions.

Definition hip_runtime_api.h:1455

hipLaunchAttribute::id

hipLaunchAttributeID id

Identifier of the launch attribute.

Definition hip_runtime_api.h:2202

hipArrayMapInfo::deviceBitMask

unsigned int deviceBitMask

Device ordinal bit mask.

Definition hip_runtime_api.h:2093

hipFunctionLaunchParams::gridDimY

unsigned int gridDimY

Height(Y) of grid in blocks.

Definition hip_runtime_api.h:1466

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

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

hipPointerAttribute_t::allocationFlags

unsigned allocationFlags

Definition hip_runtime_api.h:439

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:1166

hipFunctionLaunchParams::sharedMemBytes

unsigned int sharedMemBytes

Shared memory.

Definition hip_runtime_api.h:1471

hipBatchMemOpNodeParams::flags

unsigned int flags

Definition hip_runtime_api.h:1217

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

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

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

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

hipDevWorkqueueResource::reserved

unsigned char reserved[HIP_RESOURCE_ABI_BYTES]

Definition hip_runtime_api.h:791

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

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

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

hipDeviceProp_t::computeMode

int computeMode

Compute mode.

Definition hip_runtime_api.h:296

hipLaunchAttributeValue::syncPolicy

hipSynchronizationPolicy syncPolicy

Definition hip_runtime_api.h:1806

hipMemPoolProps::win32SecurityAttributes

void * win32SecurityAttributes

Definition hip_runtime_api.h:1393

hipFunctionLaunchParams::blockDimZ

unsigned int blockDimZ

Z dimension of each thread block.

Definition hip_runtime_api.h:1470

hipExtDynDataPrefetchRegion::height

size_t height

Number of rows to prefetch.

Definition hip_runtime_api.h:1750

hipLaunchAttributeValue::clusterSchedulingPolicyPreference

hipClusterSchedulingPolicy clusterSchedulingPolicyPreference

Definition hip_runtime_api.h:1830

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

hipBatchMemOpNodeParams::ctx

hipCtx_t ctx

Definition hip_runtime_api.h:1214

hipLaunchParams::gridDim

dim3 gridDim

Grid dimensions.

Definition hip_runtime_api.h:1454

hipLaunchParams::func

void * func

Device function symbol.

Definition hip_runtime_api.h:1453

hipMemcpyNodeParams::copyParams

hipMemcpy3DParms copyParams

Params set for the memory copy.

Definition hip_runtime_api.h:2104

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:1162

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

hipExternalMemoryBufferDesc::offset

unsigned long long offset

Definition hip_runtime_api.h:1500

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

hipExternalMemoryMipmappedArrayDesc::formatDesc

hipChannelFormatDesc formatDesc

Definition hip_runtime_api.h:1507

hipMemsetParams::height

size_t height

Definition hip_runtime_api.h:1658

hipFunctionLaunchParams::kernelParams

void ** kernelParams

Kernel parameters.

Definition hip_runtime_api.h:1473

hipDeviceProp_t::hostRegisterReadOnlySupported

int hostRegisterReadOnlySupported

Definition hip_runtime_api.h:362

hipFuncAttributes::localSizeBytes

size_t localSizeBytes

Definition hip_runtime_api.h:853

hipExternalMemoryBufferDesc::size

unsigned long long size

Definition hip_runtime_api.h:1501

HIP_LAUNCH_CONFIG::blockDimX

unsigned int blockDimX

Thread block dimension in X.

Definition hip_runtime_api.h:2229

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

hipLaunchParams::stream

hipStream_t stream

Stream identifier.

Definition hip_runtime_api.h:1458

hipFuncAttributes::maxThreadsPerBlock

int maxThreadsPerBlock

Definition hip_runtime_api.h:855

hipExtDynDataPrefetchRegion::stride

size_t stride

Stride between row starts in bytes.

Definition hip_runtime_api.h:1748

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

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

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

hipMemRangeHandleType

hipMemRangeHandleType

Definition hip_runtime_api.h:2249

hipExecutionCtx_t

struct ihipExecutionCtx_t * hipExecutionCtx_t

Definition hip_runtime_api.h:754

hipMemAllocationHandleType

hipMemAllocationHandleType

Definition hip_runtime_api.h:1373

hipGraphicsResource_t

hipGraphicsResource * hipGraphicsResource_t

Definition hip_runtime_api.h:1599

hipError_t

enum __HIP_NODISCARD hipError_t UINT32_BASE hipError_t

hipCtx_t

struct ihipCtx_t * hipCtx_t

Definition hip_runtime_api.h:753

__dparm

#define __dparm(x)

Definition hip_runtime_api.h:735

hipStream_t

struct ihipStream_t * hipStream_t

Definition hip_runtime_api.h:827

hipGraphInstantiateResult

hipGraphInstantiateResult

Definition hip_runtime_api.h:1955

hipDevice_t

int hipDevice_t

Definition hip_runtime_api.h:815

hipAccessProperty

hipAccessProperty

Definition hip_runtime_api.h:1677

hipFlushGPUDirectRDMAWritesScope

hipFlushGPUDirectRDMAWritesScope

Definition hip_runtime_api.h:703

hipLinkState_t

struct ihipLinkState_t * hipLinkState_t

Definition hip_runtime_api.h:841

hipGraphDependencyType

hipGraphDependencyType

Definition hip_runtime_api.h:2177

hipMemRangeAttribute

hipMemRangeAttribute

Definition hip_runtime_api.h:1266

hipMemAttachSingle

#define hipMemAttachSingle

Definition hip_runtime_api.h:1022

hipMemoryAdvise

hipMemoryAdvise

Definition hip_runtime_api.h:1233

hipArrayDefault

#define hipArrayDefault

Definition hip_runtime_api.h:1083

hipSharedMemConfig

hipSharedMemConfig

Definition hip_runtime_api.h:1430

hipKernelNodeAttrValue

#define hipKernelNodeAttrValue

Definition hip_runtime_api.h:1858

hipComputeMode

hipComputeMode

Definition hip_runtime_api.h:671

hipEvent_t

struct ihipEvent_t * hipEvent_t

Definition hip_runtime_api.h:861

hipStreamCaptureMode

hipStreamCaptureMode

Definition hip_runtime_api.h:1887

hipStreamBatchMemOpType

hipStreamBatchMemOpType

Definition hip_runtime_api.h:1108

hipDriverProcAddressQueryResult

hipDriverProcAddressQueryResult

Definition hip_runtime_api.h:665

HIP_DEPRECATED_MSG

#define HIP_DEPRECATED_MSG

Definition hip_runtime_api.h:727

hipLaunchAttributeID

hipLaunchAttributeID

Definition hip_runtime_api.h:1779

hipKernel_t

struct ihipKernel_t * hipKernel_t

Definition hip_runtime_api.h:843

hipSynchronizationPolicy

hipSynchronizationPolicy

Definition hip_runtime_api.h:1715

hipGraphNodeType

hipGraphNodeType

Definition hip_runtime_api.h:1623

hipExternalMemoryHandleType

hipExternalMemoryHandleType

Definition hip_runtime_api.h:1475

hipMemAttachGlobal

#define hipMemAttachGlobal

Definition hip_runtime_api.h:1016

hipLibrary_t

struct ihipLibrary_t * hipLibrary_t

Definition hip_runtime_api.h:842

hipFuncAttribute

hipFuncAttribute

Definition hip_runtime_api.h:1407

hipExternalSemaphoreHandleType

hipExternalSemaphoreHandleType

Definition hip_runtime_api.h:1513

hipLaunchMemSyncDomain

hipLaunchMemSyncDomain

Definition hip_runtime_api.h:1706

hipDevResourceDesc_t

struct ihipDevResourceDesc_t * hipDevResourceDesc_t

Definition hip_runtime_api.h:755

hipDeviceP2PAttr

hipDeviceP2PAttr

Definition hip_runtime_api.h:816

hipGraphDebugDotFlags

hipGraphDebugDotFlags

Definition hip_runtime_api.h:1933

hipDevSmResourceGroup_flags

hipDevSmResourceGroup_flags

Definition hip_runtime_api.h:762

hipUserObjectRetainFlags

hipUserObjectRetainFlags

Definition hip_runtime_api.h:1918

hipStreamAttrID

#define hipStreamAttrID

Definition hip_runtime_api.h:1838

hipHostAllocDefault

#define hipHostAllocDefault

Definition hip_runtime_api.h:958

hipHostFn_t

void(* hipHostFn_t)(void *userData)

Definition hip_runtime_api.h:1642

hipOccupancyDefault

#define hipOccupancyDefault

Definition hip_runtime_api.h:1088

hipStreamUpdateCaptureDependenciesFlags

hipStreamUpdateCaptureDependenciesFlags

Definition hip_runtime_api.h:1899

hipGraph_t

struct ihipGraph * hipGraph_t

Definition hip_runtime_api.h:1604

hipMemHandleType

hipMemHandleType

Definition hip_runtime_api.h:2037

hipFlushGPUDirectRDMAWritesOptions

hipFlushGPUDirectRDMAWritesOptions

Definition hip_runtime_api.h:678

hipFuncCache_t

hipFuncCache_t

Definition hip_runtime_api.h:1421

hipUserObjectFlags

hipUserObjectFlags

Definition hip_runtime_api.h:1914

__HIP_NODISCARD

#define __HIP_NODISCARD

Definition hip_runtime_api.h:96

hipDevWorkqueueConfigScope

hipDevWorkqueueConfigScope

Definition hip_runtime_api.h:770

hipGraphMemAttributeType

hipGraphMemAttributeType

Definition hip_runtime_api.h:1904

hipMemPoolAttr

hipMemPoolAttr

Definition hip_runtime_api.h:1281

hipDriverEntryPointQueryResult

hipDriverEntryPointQueryResult

Definition hip_runtime_api.h:822

hipMemRangeFlags

hipMemRangeFlags

Definition hip_runtime_api.h:2257

hipDevSmResourceSplitByCount_flags

hipDevSmResourceSplitByCount_flags

Definition hip_runtime_api.h:766

__hipGetPCH

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

HIP_RESOURCE_ABI_BYTES

#define HIP_RESOURCE_ABI_BYTES

Definition hip_runtime_api.h:775

UINT32_BASE

#define UINT32_BASE

Definition hip_runtime_api.h:102

hipModule_t

struct ihipModule_t * hipModule_t

Definition hip_runtime_api.h:839

hipUserObject_t

struct hipUserObject * hipUserObject_t

Definition hip_runtime_api.h:1617

hipMemOperationType

hipMemOperationType

Definition hip_runtime_api.h:2044

hipExternalSemaphore_t

void * hipExternalSemaphore_t

Definition hip_runtime_api.h:1538

hipGraphicsRegisterFlags

hipGraphicsRegisterFlags

Definition hip_runtime_api.h:1587

HIP_EXT_DYN_DATA_PREFETCH_MAX_REGIONS

#define HIP_EXT_DYN_DATA_PREFETCH_MAX_REGIONS

Definition hip_runtime_api.h:1758

hipStreamAttrValue

#define hipStreamAttrValue

Definition hip_runtime_api.h:1845

hipMemRangeCoherencyMode

hipMemRangeCoherencyMode

Definition hip_runtime_api.h:1254

hipMemAccessFlags

hipMemAccessFlags

Definition hip_runtime_api.h:1341

hipMemAllocationGranularity_flags

hipMemAllocationGranularity_flags

Definition hip_runtime_api.h:2029

hipExtDynDataPrefetchTemporal

hipExtDynDataPrefetchTemporal

Temporal locality hint for dynamic data prefetch.

Definition hip_runtime_api.h:1733

hipGraphExec_t

struct hipGraphExec * hipGraphExec_t

Definition hip_runtime_api.h:1612

hipGraphExecUpdateResult

hipGraphExecUpdateResult

Definition hip_runtime_api.h:1872

hipFunction_t

struct ihipModuleSymbol_t * hipFunction_t

Definition hip_runtime_api.h:840

hipKernelNodeAttrID

#define hipKernelNodeAttrID

Definition hip_runtime_api.h:1850

hipExternalMemory_t

void * hipExternalMemory_t

Definition hip_runtime_api.h:1512

hipStreamCaptureStatus

hipStreamCaptureStatus

Definition hip_runtime_api.h:1892

hipDeviceAttribute_t

hipDeviceAttribute_t

Definition hip_runtime_api.h:447

hipGPUDirectRDMAWritesOrdering

hipGPUDirectRDMAWritesOrdering

Definition hip_runtime_api.h:683

hipDeviceProp_tR0600

hipDeviceProp_t hipDeviceProp_tR0600

Definition hip_runtime_api.h:406

hipHostMallocDefault

#define hipHostMallocDefault

Definition hip_runtime_api.h:962

HIP_DEPRECATED

#define HIP_DEPRECATED(msg)

Definition hip_runtime_api.h:724

hipGraphicsResource

struct _hipGraphicsResource hipGraphicsResource

Definition hip_runtime_api.h:1597

hipMemAllocationType

hipMemAllocationType

Definition hip_runtime_api.h:1359

hipGraphNode_t

struct hipGraphNode * hipGraphNode_t

Definition hip_runtime_api.h:1608

hipMemGenericAllocationHandle_t

struct ihipMemGenericAllocationHandle * hipMemGenericAllocationHandle_t

Definition hip_runtime_api.h:2024

hipClusterSchedulingPolicy

hipClusterSchedulingPolicy

Definition hip_runtime_api.h:1723

hipMemoryType

hipMemoryType

Definition hip_runtime_api.h:416

hipGraphInstantiateFlags

hipGraphInstantiateFlags

Definition hip_runtime_api.h:1922

HIP_IPC_HANDLE_SIZE

#define HIP_IPC_HANDLE_SIZE

Definition hip_runtime_api.h:829

hipMemPool_t

struct ihipMemPoolHandle_t * hipMemPool_t

Definition hip_runtime_api.h:847

hipDevResourceType

hipDevResourceType

Definition hip_runtime_api.h:756

hipArraySparseSubresourceType

hipArraySparseSubresourceType

Definition hip_runtime_api.h:2052

hipFlushGPUDirectRDMAWritesTarget

hipFlushGPUDirectRDMAWritesTarget

Definition hip_runtime_api.h:692

hipExtLimitScratchMin

@ hipExtLimitScratchMin

Definition hip_runtime_api.h:877

hipLimitMallocHeapSize

@ hipLimitMallocHeapSize

Definition hip_runtime_api.h:875

hipLimitStackSize

@ hipLimitStackSize

Definition hip_runtime_api.h:870

hipLimitRange

@ hipLimitRange

Supported limit range.

Definition hip_runtime_api.h:885

hipLimitPrintfFifoSize

@ hipLimitPrintfFifoSize

Definition hip_runtime_api.h:873

hipExtLimitScratchMax

@ hipExtLimitScratchMax

Definition hip_runtime_api.h:879

hipExtLimitScratchCurrent

@ hipExtLimitScratchCurrent

Definition hip_runtime_api.h:881

hipMemRangeHandleTypeMax

@ hipMemRangeHandleTypeMax

Definition hip_runtime_api.h:2251

hipMemRangeHandleTypeDmaBufFd

@ hipMemRangeHandleTypeDmaBufFd

Definition hip_runtime_api.h:2250

hipMemHandleTypeWin32

@ hipMemHandleTypeWin32

Allows a Win32 NT handle for exporting. (HANDLE)

Definition hip_runtime_api.h:1377

hipMemHandleTypeWin32Kmt

@ hipMemHandleTypeWin32Kmt

Allows a Win32 KMT handle for exporting. (D3DKMT_HANDLE)

Definition hip_runtime_api.h:1378

hipMemHandleTypeNone

@ hipMemHandleTypeNone

Does not allow any export mechanism.

Definition hip_runtime_api.h:1374

hipMemHandleTypePosixFileDescriptor

@ hipMemHandleTypePosixFileDescriptor

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

Definition hip_runtime_api.h:1375

hipMemHandleTypeFabric

@ hipMemHandleTypeFabric

Allows a fabric handle to be used for exporting.

Definition hip_runtime_api.h:1379

hipGraphInstantiateNodeOperationNotSupported

@ hipGraphInstantiateNodeOperationNotSupported

Definition hip_runtime_api.h:1961

hipGraphInstantiateMultipleDevicesNotSupported

@ hipGraphInstantiateMultipleDevicesNotSupported

Definition hip_runtime_api.h:1963

hipGraphInstantiateError

@ hipGraphInstantiateError

Definition hip_runtime_api.h:1957

hipGraphInstantiateInvalidStructure

@ hipGraphInstantiateInvalidStructure

Definition hip_runtime_api.h:1959

hipGraphInstantiateSuccess

@ hipGraphInstantiateSuccess

Definition hip_runtime_api.h:1956

hipAccessPropertyNormal

@ hipAccessPropertyNormal

Normal cache persistence.

Definition hip_runtime_api.h:1678

hipAccessPropertyPersisting

@ hipAccessPropertyPersisting

Persisting access is more likely to persist in cache.

Definition hip_runtime_api.h:1680

hipAccessPropertyStreaming

@ hipAccessPropertyStreaming

Streaming access is less likely to persist from cache.

Definition hip_runtime_api.h:1679

hipFlushGPUDirectRDMAWritesToAllDevices

@ hipFlushGPUDirectRDMAWritesToAllDevices

Visible to all HIP devices.

Definition hip_runtime_api.h:705

hipFlushGPUDirectRDMAWritesToOwner

@ hipFlushGPUDirectRDMAWritesToOwner

Visible to the device owning the memory.

Definition hip_runtime_api.h:704

hipGraphDependencyTypeDefault

@ hipGraphDependencyTypeDefault

Definition hip_runtime_api.h:2178

hipGraphDependencyTypeProgrammatic

@ hipGraphDependencyTypeProgrammatic

Definition hip_runtime_api.h:2179

hipMemRangeAttributeLastPrefetchLocation

@ hipMemRangeAttributeLastPrefetchLocation

Definition hip_runtime_api.h:1272

hipMemRangeAttributePreferredLocation

@ hipMemRangeAttributePreferredLocation

The preferred location of the range.

Definition hip_runtime_api.h:1269

hipMemRangeAttributeAccessedBy

@ hipMemRangeAttributeAccessedBy

Definition hip_runtime_api.h:1270

hipMemRangeAttributeReadMostly

@ hipMemRangeAttributeReadMostly

Definition hip_runtime_api.h:1267

hipMemRangeAttributeCoherencyMode

@ hipMemRangeAttributeCoherencyMode

Definition hip_runtime_api.h:1274

hipMemAdviseUnsetAccessedBy

@ hipMemAdviseUnsetAccessedBy

Definition hip_runtime_api.h:1242

hipMemAdviseUnsetCoarseGrain

@ hipMemAdviseUnsetCoarseGrain

Restores cache coherency policy back to fine-grain.

Definition hip_runtime_api.h:1249

hipMemAdviseSetCoarseGrain

@ hipMemAdviseSetCoarseGrain

Definition hip_runtime_api.h:1244

hipMemAdviseUnsetPreferredLocation

@ hipMemAdviseUnsetPreferredLocation

Clear the preferred location for the data.

Definition hip_runtime_api.h:1239

hipMemAdviseSetAccessedBy

@ hipMemAdviseSetAccessedBy

Definition hip_runtime_api.h:1240

hipMemAdviseSetPreferredLocation

@ hipMemAdviseSetPreferredLocation

Definition hip_runtime_api.h:1237

hipMemAdviseSetReadMostly

@ hipMemAdviseSetReadMostly

Definition hip_runtime_api.h:1234

hipMemAdviseUnsetReadMostly

@ hipMemAdviseUnsetReadMostly

Undo the effect of hipMemAdviseSetReadMostly.

Definition hip_runtime_api.h:1236

hipSharedMemBankSizeFourByte

@ hipSharedMemBankSizeFourByte

Definition hip_runtime_api.h:1432

hipSharedMemBankSizeEightByte

@ hipSharedMemBankSizeEightByte

Definition hip_runtime_api.h:1434

hipSharedMemBankSizeDefault

@ hipSharedMemBankSizeDefault

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

Definition hip_runtime_api.h:1431

hipComputeModeProhibited

@ hipComputeModeProhibited

Definition hip_runtime_api.h:674

hipComputeModeExclusive

@ hipComputeModeExclusive

Definition hip_runtime_api.h:673

hipComputeModeDefault

@ hipComputeModeDefault

Definition hip_runtime_api.h:672

hipComputeModeExclusiveProcess

@ hipComputeModeExclusiveProcess

Definition hip_runtime_api.h:675

hipStreamCaptureModeRelaxed

@ hipStreamCaptureModeRelaxed

Definition hip_runtime_api.h:1890

hipStreamCaptureModeThreadLocal

@ hipStreamCaptureModeThreadLocal

Definition hip_runtime_api.h:1889

hipStreamCaptureModeGlobal

@ hipStreamCaptureModeGlobal

Definition hip_runtime_api.h:1888

hipStreamMemOpWriteValue64

@ hipStreamMemOpWriteValue64

Definition hip_runtime_api.h:1112

hipStreamMemOpBarrier

@ hipStreamMemOpBarrier

Currently not supported.

Definition hip_runtime_api.h:1113

hipStreamMemOpWriteValue32

@ hipStreamMemOpWriteValue32

Definition hip_runtime_api.h:1110

hipStreamMemOpWaitValue32

@ hipStreamMemOpWaitValue32

Definition hip_runtime_api.h:1109

hipStreamMemOpWaitValue64

@ hipStreamMemOpWaitValue64

Definition hip_runtime_api.h:1111

hipStreamMemOpFlushRemoteWrites

@ hipStreamMemOpFlushRemoteWrites

Currently not supported.

Definition hip_runtime_api.h:1114

HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND

@ HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND

Definition hip_runtime_api.h:667

HIP_GET_PROC_ADDRESS_SUCCESS

@ HIP_GET_PROC_ADDRESS_SUCCESS

Definition hip_runtime_api.h:666

HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT

@ HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT

Definition hip_runtime_api.h:668

hipLaunchAttributePriority

@ hipLaunchAttributePriority

Valid for graph node, streams, launches.

Definition hip_runtime_api.h:1786

hipLaunchAttributeMax

@ hipLaunchAttributeMax

Definition hip_runtime_api.h:1790

hipLaunchAttributeClusterDimension

@ hipLaunchAttributeClusterDimension

Valid for graph nodes, launches.

Definition hip_runtime_api.h:1784

hipLaunchAttributeMemSyncDomain

@ hipLaunchAttributeMemSyncDomain

Valid for streams, graph nodes, launches.

Definition hip_runtime_api.h:1788

hipLaunchAttributeMemSyncDomainMap

@ hipLaunchAttributeMemSyncDomainMap

Valid for streams, graph nodes, launches.

Definition hip_runtime_api.h:1787

hipLaunchAttributeIgnore

@ hipLaunchAttributeIgnore

Ignored entry.

Definition hip_runtime_api.h:1780

hipLaunchAttributeSynchronizationPolicy

@ hipLaunchAttributeSynchronizationPolicy

Valid for streams.

Definition hip_runtime_api.h:1783

hipLaunchAttributeExtDynDataPrefetch

@ hipLaunchAttributeExtDynDataPrefetch

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

Definition hip_runtime_api.h:1789

hipLaunchAttributeClusterSchedulingPolicyPreference

@ hipLaunchAttributeClusterSchedulingPolicyPreference

Valid for graph nodes, launches.

Definition hip_runtime_api.h:1785

hipLaunchAttributeAccessPolicyWindow

@ hipLaunchAttributeAccessPolicyWindow

Valid for Streams, graph nodes, launches.

Definition hip_runtime_api.h:1781

hipLaunchAttributeCooperative

@ hipLaunchAttributeCooperative

Valid for graph nodes, launches.

Definition hip_runtime_api.h:1782

hipSyncPolicyYield

@ hipSyncPolicyYield

Definition hip_runtime_api.h:1718

hipSyncPolicyBlockingSync

@ hipSyncPolicyBlockingSync

Definition hip_runtime_api.h:1719

hipSyncPolicyAuto

@ hipSyncPolicyAuto

Definition hip_runtime_api.h:1716

hipSyncPolicySpin

@ hipSyncPolicySpin

Definition hip_runtime_api.h:1717

hipGraphNodeTypeBatchMemOp

@ hipGraphNodeTypeBatchMemOp

BatchMemOp node.

Definition hip_runtime_api.h:1638

hipGraphNodeTypeGraph

@ hipGraphNodeTypeGraph

Node which executes an embedded graph.

Definition hip_runtime_api.h:1628

hipGraphNodeTypeMemset

@ hipGraphNodeTypeMemset

Memset node.

Definition hip_runtime_api.h:1626

hipGraphNodeTypeEventRecord

@ hipGraphNodeTypeEventRecord

External event record node.

Definition hip_runtime_api.h:1631

hipGraphNodeTypeExtSemaphoreSignal

@ hipGraphNodeTypeExtSemaphoreSignal

External Semaphore signal node.

Definition hip_runtime_api.h:1632

hipGraphNodeTypeMemcpy

@ hipGraphNodeTypeMemcpy

Memcpy node.

Definition hip_runtime_api.h:1625

hipGraphNodeTypeWaitEvent

@ hipGraphNodeTypeWaitEvent

External event wait node.

Definition hip_runtime_api.h:1630

hipGraphNodeTypeCount

@ hipGraphNodeTypeCount

Definition hip_runtime_api.h:1639

hipGraphNodeTypeKernel

@ hipGraphNodeTypeKernel

GPU kernel node.

Definition hip_runtime_api.h:1624

hipGraphNodeTypeHost

@ hipGraphNodeTypeHost

Host (executable) node.

Definition hip_runtime_api.h:1627

hipGraphNodeTypeMemAlloc

@ hipGraphNodeTypeMemAlloc

Memory alloc node.

Definition hip_runtime_api.h:1634

hipGraphNodeTypeMemFree

@ hipGraphNodeTypeMemFree

Memory free node.

Definition hip_runtime_api.h:1635

hipGraphNodeTypeMemcpyFromSymbol

@ hipGraphNodeTypeMemcpyFromSymbol

MemcpyFromSymbol node.

Definition hip_runtime_api.h:1636

hipGraphNodeTypeMemcpyToSymbol

@ hipGraphNodeTypeMemcpyToSymbol

MemcpyToSymbol node.

Definition hip_runtime_api.h:1637

hipGraphNodeTypeEmpty

@ hipGraphNodeTypeEmpty

Empty (no-op) node.

Definition hip_runtime_api.h:1629

hipGraphNodeTypeExtSemaphoreWait

@ hipGraphNodeTypeExtSemaphoreWait

External Semaphore wait node.

Definition hip_runtime_api.h:1633

hipExternalMemoryHandleTypeD3D11Resource

@ hipExternalMemoryHandleTypeD3D11Resource

Definition hip_runtime_api.h:1481

hipExternalMemoryHandleTypeD3D12Resource

@ hipExternalMemoryHandleTypeD3D12Resource

Definition hip_runtime_api.h:1480

hipExternalMemoryHandleTypeNvSciBuf

@ hipExternalMemoryHandleTypeNvSciBuf

Definition hip_runtime_api.h:1483

hipExternalMemoryHandleTypeOpaqueFd

@ hipExternalMemoryHandleTypeOpaqueFd

Definition hip_runtime_api.h:1476

hipExternalMemoryHandleTypeD3D12Heap

@ hipExternalMemoryHandleTypeD3D12Heap

Definition hip_runtime_api.h:1479

hipExternalMemoryHandleTypeOpaqueWin32Kmt

@ hipExternalMemoryHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:1478

hipExternalMemoryHandleTypeOpaqueWin32

@ hipExternalMemoryHandleTypeOpaqueWin32

Definition hip_runtime_api.h:1477

hipExternalMemoryHandleTypeD3D11ResourceKmt

@ hipExternalMemoryHandleTypeD3D11ResourceKmt

Definition hip_runtime_api.h:1482

hipFuncAttributeClusterSchedulingPolicyPreference

@ hipFuncAttributeClusterSchedulingPolicyPreference

The block scheduling policy of a function.

Definition hip_runtime_api.h:1415

hipFuncAttributePreferredSharedMemoryCarveout

@ hipFuncAttributePreferredSharedMemoryCarveout

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

Definition hip_runtime_api.h:1409

hipFuncAttributeRequiredClusterWidth

@ hipFuncAttributeRequiredClusterWidth

The required cluster width in blocks.

Definition hip_runtime_api.h:1411

hipFuncAttributeMaxDynamicSharedMemorySize

@ hipFuncAttributeMaxDynamicSharedMemorySize

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

Definition hip_runtime_api.h:1408

hipFuncAttributeMax

@ hipFuncAttributeMax

Definition hip_runtime_api.h:1416

hipFuncAttributeRequiredClusterDepth

@ hipFuncAttributeRequiredClusterDepth

The required cluster depth in blocks.

Definition hip_runtime_api.h:1413

hipFuncAttributeRequiredClusterHeight

@ hipFuncAttributeRequiredClusterHeight

The required cluster height in blocks.

Definition hip_runtime_api.h:1412

hipFuncAttributeClusterDimMustBeSet

@ hipFuncAttributeClusterDimMustBeSet

The kernel must launch with a valid cluster size specified.

Definition hip_runtime_api.h:1410

hipFuncAttributeNonPortableClusterSizeAllowed

@ hipFuncAttributeNonPortableClusterSizeAllowed

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

Definition hip_runtime_api.h:1414

hipExternalSemaphoreHandleTypeNvSciSync

@ hipExternalSemaphoreHandleTypeNvSciSync

Definition hip_runtime_api.h:1519

hipExternalSemaphoreHandleTypeKeyedMutexKmt

@ hipExternalSemaphoreHandleTypeKeyedMutexKmt

Definition hip_runtime_api.h:1521

hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

@ hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:1516

hipExternalSemaphoreHandleTypeKeyedMutex

@ hipExternalSemaphoreHandleTypeKeyedMutex

Definition hip_runtime_api.h:1520

hipExternalSemaphoreHandleTypeD3D11Fence

@ hipExternalSemaphoreHandleTypeD3D11Fence

Definition hip_runtime_api.h:1518

hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

@ hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

Definition hip_runtime_api.h:1523

hipExternalSemaphoreHandleTypeOpaqueFd

@ hipExternalSemaphoreHandleTypeOpaqueFd

Definition hip_runtime_api.h:1514

hipExternalSemaphoreHandleTypeOpaqueWin32

@ hipExternalSemaphoreHandleTypeOpaqueWin32

Definition hip_runtime_api.h:1515

hipExternalSemaphoreHandleTypeTimelineSemaphoreFd

@ hipExternalSemaphoreHandleTypeTimelineSemaphoreFd

Definition hip_runtime_api.h:1522

hipExternalSemaphoreHandleTypeD3D12Fence

@ hipExternalSemaphoreHandleTypeD3D12Fence

Definition hip_runtime_api.h:1517

hipLaunchMemSyncDomainRemote

@ hipLaunchMemSyncDomainRemote

Definition hip_runtime_api.h:1708

hipLaunchMemSyncDomainDefault

@ hipLaunchMemSyncDomainDefault

Definition hip_runtime_api.h:1707

hipDevP2PAttrAccessSupported

@ hipDevP2PAttrAccessSupported

Definition hip_runtime_api.h:818

hipDevP2PAttrHipArrayAccessSupported

@ hipDevP2PAttrHipArrayAccessSupported

Definition hip_runtime_api.h:820

hipDevP2PAttrNativeAtomicSupported

@ hipDevP2PAttrNativeAtomicSupported

Definition hip_runtime_api.h:819

hipDevP2PAttrPerformanceRank

@ hipDevP2PAttrPerformanceRank

Definition hip_runtime_api.h:817

hipGraphDebugDotFlagsKernelNodeAttributes

@ hipGraphDebugDotFlagsKernelNodeAttributes

Definition hip_runtime_api.h:1946

hipGraphDebugDotFlagsMemsetNodeParams

@ hipGraphDebugDotFlagsMemsetNodeParams

Definition hip_runtime_api.h:1938

hipGraphDebugDotFlagsKernelNodeParams

@ hipGraphDebugDotFlagsKernelNodeParams

Definition hip_runtime_api.h:1936

hipGraphDebugDotFlagsExtSemasWaitNodeParams

@ hipGraphDebugDotFlagsExtSemasWaitNodeParams

Definition hip_runtime_api.h:1944

hipGraphDebugDotFlagsHandles

@ hipGraphDebugDotFlagsHandles

Definition hip_runtime_api.h:1948

hipGraphDebugDotFlagsExtSemasSignalNodeParams

@ hipGraphDebugDotFlagsExtSemasSignalNodeParams

Definition hip_runtime_api.h:1942

hipGraphDebugDotFlagsHostNodeParams

@ hipGraphDebugDotFlagsHostNodeParams

Definition hip_runtime_api.h:1939

hipGraphDebugDotFlagsEventNodeParams

@ hipGraphDebugDotFlagsEventNodeParams

Definition hip_runtime_api.h:1940

hipGraphDebugDotFlagsVerbose

@ hipGraphDebugDotFlagsVerbose

Definition hip_runtime_api.h:1934

hipGraphDebugDotFlagsMemcpyNodeParams

@ hipGraphDebugDotFlagsMemcpyNodeParams

Definition hip_runtime_api.h:1937

hipDevSmResourceGroupBackfill

@ hipDevSmResourceGroupBackfill

Definition hip_runtime_api.h:764

hipDevSmResourceGroupDefault

@ hipDevSmResourceGroupDefault

Definition hip_runtime_api.h:763

hipGraphUserObjectMove

@ hipGraphUserObjectMove

Add new reference or retain.

Definition hip_runtime_api.h:1919

hipStreamAddCaptureDependencies

@ hipStreamAddCaptureDependencies

Add new nodes to the dependency set.

Definition hip_runtime_api.h:1900

hipStreamSetCaptureDependencies

@ hipStreamSetCaptureDependencies

Replace the dependency set with the new nodes.

Definition hip_runtime_api.h:1901

hipMemHandleTypeGeneric

@ hipMemHandleTypeGeneric

Generic handle type.

Definition hip_runtime_api.h:2038

hipFlushGPUDirectRDMAWritesOptionHost

@ hipFlushGPUDirectRDMAWritesOptionHost

Definition hip_runtime_api.h:679

hipFlushGPUDirectRDMAWritesOptionMemOps

@ hipFlushGPUDirectRDMAWritesOptionMemOps

Definition hip_runtime_api.h:680

hipFuncCachePreferNone

@ hipFuncCachePreferNone

no preference for shared memory or L1 (default)

Definition hip_runtime_api.h:1422

hipFuncCachePreferEqual

@ hipFuncCachePreferEqual

prefer equal size L1 cache and shared memory

Definition hip_runtime_api.h:1425

hipFuncCachePreferL1

@ hipFuncCachePreferL1

prefer larger L1 cache and smaller shared memory

Definition hip_runtime_api.h:1424

hipFuncCachePreferShared

@ hipFuncCachePreferShared

prefer larger shared memory and smaller L1 cache

Definition hip_runtime_api.h:1423

hipUserObjectNoDestructorSync

@ hipUserObjectNoDestructorSync

Destructor execution is not synchronized.

Definition hip_runtime_api.h:1915

hipDevWorkqueueConfigScopeDeviceCtx

@ hipDevWorkqueueConfigScopeDeviceCtx

Definition hip_runtime_api.h:771

hipDevWorkqueueConfigScopeGreenCtxBalanced

@ hipDevWorkqueueConfigScopeGreenCtxBalanced

Definition hip_runtime_api.h:772

hipGraphMemAttrReservedMemHigh

@ hipGraphMemAttrReservedMemHigh

Definition hip_runtime_api.h:1911

hipGraphMemAttrUsedMemCurrent

@ hipGraphMemAttrUsedMemCurrent

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

Definition hip_runtime_api.h:1905

hipGraphMemAttrUsedMemHigh

@ hipGraphMemAttrUsedMemHigh

Definition hip_runtime_api.h:1907

hipGraphMemAttrReservedMemCurrent

@ hipGraphMemAttrReservedMemCurrent

Definition hip_runtime_api.h:1909

hipMemPoolAttrUsedMemCurrent

@ hipMemPoolAttrUsedMemCurrent

Definition hip_runtime_api.h:1328

hipMemPoolAttrReservedMemHigh

@ hipMemPoolAttrReservedMemHigh

Definition hip_runtime_api.h:1323

hipMemPoolAttrReservedMemCurrent

@ hipMemPoolAttrReservedMemCurrent

Definition hip_runtime_api.h:1317

hipMemPoolAttrReleaseThreshold

@ hipMemPoolAttrReleaseThreshold

Definition hip_runtime_api.h:1312

hipMemPoolAttrUsedMemHigh

@ hipMemPoolAttrUsedMemHigh

Definition hip_runtime_api.h:1334

hipMemPoolReuseAllowInternalDependencies

@ hipMemPoolReuseAllowInternalDependencies

Definition hip_runtime_api.h:1303

hipMemPoolReuseFollowEventDependencies

@ hipMemPoolReuseFollowEventDependencies

Definition hip_runtime_api.h:1290

hipMemPoolReuseAllowOpportunistic

@ hipMemPoolReuseAllowOpportunistic

Definition hip_runtime_api.h:1296

hipDriverEntryPointSuccess

@ hipDriverEntryPointSuccess

Definition hip_runtime_api.h:823

hipDriverEntryPointSymbolNotFound

@ hipDriverEntryPointSymbolNotFound

Definition hip_runtime_api.h:824

hipDriverEntryPointVersionNotSufficent

@ hipDriverEntryPointVersionNotSufficent

Definition hip_runtime_api.h:825

hipMemRangeFlagsMax

@ hipMemRangeFlagsMax

Definition hip_runtime_api.h:2259

hipMemRangeFlagDmaBufMappingTypePcie

@ hipMemRangeFlagDmaBufMappingTypePcie

Definition hip_runtime_api.h:2258

hipDevSmResourceSplitMaxPotentialClusterSize

@ hipDevSmResourceSplitMaxPotentialClusterSize

Definition hip_runtime_api.h:768

hipDevSmResourceSplitIgnoreSmCoscheduling

@ hipDevSmResourceSplitIgnoreSmCoscheduling

Definition hip_runtime_api.h:767

hipMemOperationTypeMap

@ hipMemOperationTypeMap

Map operation.

Definition hip_runtime_api.h:2045

hipMemOperationTypeUnmap

@ hipMemOperationTypeUnmap

Unmap operation.

Definition hip_runtime_api.h:2046

hipGraphicsRegisterFlagsReadOnly

@ hipGraphicsRegisterFlagsReadOnly

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

Definition hip_runtime_api.h:1589

hipGraphicsRegisterFlagsTextureGather

@ hipGraphicsRegisterFlagsTextureGather

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

Definition hip_runtime_api.h:1593

hipGraphicsRegisterFlagsWriteDiscard

@ hipGraphicsRegisterFlagsWriteDiscard

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

Definition hip_runtime_api.h:1590

hipGraphicsRegisterFlagsNone

@ hipGraphicsRegisterFlagsNone

Definition hip_runtime_api.h:1588

hipGraphicsRegisterFlagsSurfaceLoadStore

@ hipGraphicsRegisterFlagsSurfaceLoadStore

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

Definition hip_runtime_api.h:1592

hipMemRangeCoherencyModeFineGrain

@ hipMemRangeCoherencyModeFineGrain

Definition hip_runtime_api.h:1255

hipMemRangeCoherencyModeIndeterminate

@ hipMemRangeCoherencyModeIndeterminate

Definition hip_runtime_api.h:1259

hipMemRangeCoherencyModeCoarseGrain

@ hipMemRangeCoherencyModeCoarseGrain

Definition hip_runtime_api.h:1257

hipMemAccessFlagsProtRead

@ hipMemAccessFlagsProtRead

Set the address range read accessible.

Definition hip_runtime_api.h:1343

hipMemAccessFlagsProtNone

@ hipMemAccessFlagsProtNone

Default, make the address range not accessible.

Definition hip_runtime_api.h:1342

hipMemAccessFlagsProtReadWrite

@ hipMemAccessFlagsProtReadWrite

Set the address range read-write accessible.

Definition hip_runtime_api.h:1344

hipMemAllocationGranularityMinimum

@ hipMemAllocationGranularityMinimum

Minimum granularity.

Definition hip_runtime_api.h:2030

hipMemAllocationGranularityRecommended

@ hipMemAllocationGranularityRecommended

Recommended granularity for performance.

Definition hip_runtime_api.h:2031

hipExtDynDataPrefetchTemporalRegular

@ hipExtDynDataPrefetchTemporalRegular

Regular temporal locality.

Definition hip_runtime_api.h:1734

hipExtDynDataPrefetchTemporalHigh

@ hipExtDynDataPrefetchTemporalHigh

High temporal locality (prefer caching)

Definition hip_runtime_api.h:1735

hipGraphExecUpdateErrorNotSupported

@ hipGraphExecUpdateErrorNotSupported

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

Definition hip_runtime_api.h:1882

hipGraphExecUpdateErrorNodeTypeChanged

@ hipGraphExecUpdateErrorNodeTypeChanged

The update failed because a node type changed.

Definition hip_runtime_api.h:1877

hipGraphExecUpdateErrorTopologyChanged

@ hipGraphExecUpdateErrorTopologyChanged

The update failed because the topology changed.

Definition hip_runtime_api.h:1876

hipGraphExecUpdateErrorUnsupportedFunctionChange

@ hipGraphExecUpdateErrorUnsupportedFunctionChange

Definition hip_runtime_api.h:1884

hipGraphExecUpdateError

@ hipGraphExecUpdateError

Definition hip_runtime_api.h:1874

hipGraphExecUpdateErrorFunctionChanged

@ hipGraphExecUpdateErrorFunctionChanged

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

Definition hip_runtime_api.h:1878

hipGraphExecUpdateSuccess

@ hipGraphExecUpdateSuccess

The update succeeded.

Definition hip_runtime_api.h:1873

hipGraphExecUpdateErrorParametersChanged

@ hipGraphExecUpdateErrorParametersChanged

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

Definition hip_runtime_api.h:1880

hipStreamCaptureStatusInvalidated

@ hipStreamCaptureStatusInvalidated

Definition hip_runtime_api.h:1895

hipStreamCaptureStatusNone

@ hipStreamCaptureStatusNone

Stream is not capturing.

Definition hip_runtime_api.h:1893

hipStreamCaptureStatusActive

@ hipStreamCaptureStatusActive

Stream is actively capturing.

Definition hip_runtime_api.h:1894

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

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

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

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

hipDeviceAttributeMaxTextureCubemap

@ hipDeviceAttributeMaxTextureCubemap

Maximum dimensions of Cubemap texture.

Definition hip_runtime_api.h:522

hipDeviceAttributeGPUDirectRDMASupported

@ hipDeviceAttributeGPUDirectRDMASupported

Device supports GPUDirect RDMA APIs.

Definition hip_runtime_api.h:588

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

hipDeviceAttributeGPUDirectRDMAFlushWritesOptions

@ hipDeviceAttributeGPUDirectRDMAFlushWritesOptions

Definition hip_runtime_api.h:589

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

hipDeviceAttributeMaxAvailableVgprsPerThread

@ hipDeviceAttributeMaxAvailableVgprsPerThread

Definition hip_runtime_api.h:638

hipDeviceAttributeComputeMode

@ hipDeviceAttributeComputeMode

Compute mode that device is currently in.

Definition hip_runtime_api.h:461

hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

Definition hip_runtime_api.h:610

hipDeviceAttributeAsicRevision

@ hipDeviceAttributeAsicRevision

Revision of the GPU in this device.

Definition hip_runtime_api.h:623

hipDeviceAttributeUnused4

@ hipDeviceAttributeUnused4

Previously hipDeviceAttributeGcnArch.

Definition hip_runtime_api.h:606

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

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

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

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

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

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

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

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

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

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

hipDeviceAttributeImageSupport

@ hipDeviceAttributeImageSupport

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

Definition hip_runtime_api.h:626

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

hipDeviceAttributeGPUDirectRDMAWritesOrdering

@ hipDeviceAttributeGPUDirectRDMAWritesOrdering

Definition hip_runtime_api.h:593

hipDeviceAttributeIsLargeBar

@ hipDeviceAttributeIsLargeBar

Whether it is LargeBar.

Definition hip_runtime_api.h:622

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

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

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

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

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

hipDeviceAttributeMaxTexture2DMipmap

@ hipDeviceAttributeMaxTexture2DMipmap

Maximum dimensions of 2D mipmapped texture.

Definition hip_runtime_api.h:517

hipDeviceAttributeMaxDynDataPrefetchRegions

@ hipDeviceAttributeMaxDynDataPrefetchRegions

Definition hip_runtime_api.h:644

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

hipGPUDirectRDMAWritesOrderingNone

@ hipGPUDirectRDMAWritesOrderingNone

Definition hip_runtime_api.h:684

hipGPUDirectRDMAWritesOrderingAllDevices

@ hipGPUDirectRDMAWritesOrderingAllDevices

Definition hip_runtime_api.h:686

hipMemAllocationTypeManaged

@ hipMemAllocationTypeManaged

Definition hip_runtime_api.h:1365

hipMemAllocationTypeMax

@ hipMemAllocationTypeMax

Definition hip_runtime_api.h:1367

hipMemAllocationTypePinned

@ hipMemAllocationTypePinned

Definition hip_runtime_api.h:1364

hipMemAllocationTypeUncached

@ hipMemAllocationTypeUncached

Definition hip_runtime_api.h:1366

hipMemAllocationTypeInvalid

@ hipMemAllocationTypeInvalid

Definition hip_runtime_api.h:1360

hipClusterSchedulingPolicyDefault

@ hipClusterSchedulingPolicyDefault

the default scheduling policy

Definition hip_runtime_api.h:1724

hipClusterSchedulingPolicyLoadBalancing

@ hipClusterSchedulingPolicyLoadBalancing

Dynamically balance block assignment to optimize resource usage.

Definition hip_runtime_api.h:1726

hipClusterSchedulingPolicySpread

@ hipClusterSchedulingPolicySpread

distribute blocks evenly across cluster's CUs

Definition hip_runtime_api.h:1725

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

hipGraphInstantiateFlagUseNodePriority

@ hipGraphInstantiateFlagUseNodePriority

Definition hip_runtime_api.h:1928

hipGraphInstantiateFlagUpload

@ hipGraphInstantiateFlagUpload

Automatically upload the graph after instantiation.

Definition hip_runtime_api.h:1925

hipGraphInstantiateFlagDeviceLaunch

@ hipGraphInstantiateFlagDeviceLaunch

Instantiate the graph to be launched from the device.

Definition hip_runtime_api.h:1926

hipDevResourceTypeWorkqueue

@ hipDevResourceTypeWorkqueue

Definition hip_runtime_api.h:760

hipDevResourceTypeSm

@ hipDevResourceTypeSm

Definition hip_runtime_api.h:758

hipDevResourceTypeInvalid

@ hipDevResourceTypeInvalid

Definition hip_runtime_api.h:757

hipDevResourceTypeWorkqueueConfig

@ hipDevResourceTypeWorkqueueConfig

Definition hip_runtime_api.h:759

hipArraySparseSubresourceTypeSparseLevel

@ hipArraySparseSubresourceTypeSparseLevel

Sparse level.

Definition hip_runtime_api.h:2053

hipArraySparseSubresourceTypeMiptail

@ hipArraySparseSubresourceTypeMiptail

Miptail.

Definition hip_runtime_api.h:2054

hipFlushGPUDirectRDMAWritesTargetCurrentDevice

@ hipFlushGPUDirectRDMAWritesTargetCurrentDevice

Memory of the current HIP device.

Definition hip_runtime_api.h:693

HIP_LAUNCH_CONFIG

Definition hip_runtime_api.h:2225

hipAccessPolicyWindow

Definition hip_runtime_api.h:1687

hipArrayMapInfo

Definition hip_runtime_api.h:2060

hipArrayMemoryRequirements

Definition hip_runtime_api.h:2241

hipBatchMemOpNodeParams

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

Definition hip_runtime_api.h:1213

hipChildGraphNodeParams

Definition hip_runtime_api.h:2110

hipDevResource

Definition hip_runtime_api.h:794

hipDevSmResource

Definition hip_runtime_api.h:777

hipDevSmResourceGroupParams

Definition hip_runtime_api.h:806

hipDevWorkqueueConfigResource

Definition hip_runtime_api.h:784

hipDevWorkqueueResource

Definition hip_runtime_api.h:790

hipDeviceArch_t

Definition hip_runtime_api.h:53

hipDeviceProp_t

Definition hip_runtime_api.h:260

hipEventRecordNodeParams

Definition hip_runtime_api.h:2125

hipEventWaitNodeParams

Definition hip_runtime_api.h:2118

hipExtDynDataPrefetchConfig

Configuration for dynamic data prefetch.

Definition hip_runtime_api.h:1770

hipExtDynDataPrefetchRegion

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

Definition hip_runtime_api.h:1746

hipExternalMemoryBufferDesc

Definition hip_runtime_api.h:1499

hipExternalMemoryHandleDesc

Definition hip_runtime_api.h:1485

hipExternalMemoryMipmappedArrayDesc

Definition hip_runtime_api.h:1505

hipExternalSemaphoreHandleDesc

Definition hip_runtime_api.h:1525

hipExternalSemaphoreSignalNodeParams

Definition hip_runtime_api.h:2000

hipExternalSemaphoreSignalParams

Definition hip_runtime_api.h:1539

hipExternalSemaphoreWaitNodeParams

Definition hip_runtime_api.h:2012

hipExternalSemaphoreWaitParams

Definition hip_runtime_api.h:1559

hipFuncAttributes

Definition hip_runtime_api.h:849

hipFunctionLaunchParams

Definition hip_runtime_api.h:1463

hipGraphEdgeData

Definition hip_runtime_api.h:2182

hipGraphInstantiateParams

Definition hip_runtime_api.h:1970

hipGraphNodeParams

Definition hip_runtime_api.h:2139

hipHostNodeParams

Definition hip_runtime_api.h:1643

hipIpcEventHandle_t

Definition hip_runtime_api.h:833

hipIpcMemHandle_t

Definition hip_runtime_api.h:830

hipKernelNodeParams

Definition hip_runtime_api.h:1647

hipLaunchAttribute

Definition hip_runtime_api.h:2201

hipLaunchConfig_t

Definition hip_runtime_api.h:2213

hipLaunchMemSyncDomainMap

Definition hip_runtime_api.h:1698

hipLaunchParams

Definition hip_runtime_api.h:1452

hipMemAccessDesc

Definition hip_runtime_api.h:1352

hipMemAllocNodeParams

Definition hip_runtime_api.h:1664

hipMemAllocationProp

Definition hip_runtime_api.h:1982

hipMemFabricHandle_t

Definition hip_runtime_api.h:836

hipMemFreeNodeParams

Definition hip_runtime_api.h:2132

hipMemPoolProps

Definition hip_runtime_api.h:1384

hipMemPoolPtrExportData

Definition hip_runtime_api.h:1400

hipMemcpyNodeParams

Definition hip_runtime_api.h:2101

hipMemsetParams

Definition hip_runtime_api.h:1655

hipPointerAttribute_t

Definition hip_runtime_api.h:433

hipStreamBatchMemOpParams::hipStreamMemOpFlushRemoteWritesParams_t

Definition hip_runtime_api.h:1175

hipStreamBatchMemOpParams::hipStreamMemOpMemoryBarrierParams_t

Definition hip_runtime_api.h:1179

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t

Definition hip_runtime_api.h:1155

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t

Definition hip_runtime_api.h:1165

hipUUID

Definition hip_runtime_api.h:84

hipLaunchAttributeValue

Definition hip_runtime_api.h:1797

hipStreamBatchMemOpParams

Union representing batch memory operation parameters for HIP streams.

Definition hip_runtime_api.h:1153

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

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

hip_impl::hip_init

hipError_t hip_init()

dim3

Definition hip_runtime_api.h:1440

dim3::y

uint32_t y

y

Definition hip_runtime_api.h:1442

dim3::z

uint32_t z

z

Definition hip_runtime_api.h:1443

dim3::x

uint32_t x

x

Definition hip_runtime_api.h:1441

dim3::dim3

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

Definition hip_runtime_api.h:1445

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