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

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

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

105

106typedef enum __HIP_NODISCARD hipError_t {

107 hipSuccess = 0,

108 hipErrorInvalidValue = 1,

110 hipErrorOutOfMemory = 2,

111 // Deprecated

112 hipErrorMemoryAllocation = 2,

113 hipErrorNotInitialized = 3,

114 // Deprecated

115 hipErrorInitializationError = 3,

116 hipErrorDeinitialized = 4,

117 hipErrorProfilerDisabled = 5,

118 hipErrorProfilerNotInitialized = 6,

119 hipErrorProfilerAlreadyStarted = 7,

120 hipErrorProfilerAlreadyStopped = 8,

121 hipErrorInvalidConfiguration = 9,

122 hipErrorInvalidPitchValue = 12,

123 hipErrorInvalidSymbol = 13,

124 hipErrorInvalidDevicePointer = 17,

125 hipErrorInvalidMemcpyDirection = 21,

126 hipErrorInsufficientDriver = 35,

127 hipErrorMissingConfiguration = 52,

128 hipErrorPriorLaunchFailure = 53,

129 hipErrorInvalidDeviceFunction = 98,

130 hipErrorNoDevice = 100,

131 hipErrorInvalidDevice = 101,

132 hipErrorInvalidImage = 200,

133 hipErrorInvalidContext = 201,

134 hipErrorContextAlreadyCurrent = 202,

135 hipErrorMapFailed = 205,

136 // Deprecated

137 hipErrorMapBufferObjectFailed = 205,

138 hipErrorUnmapFailed = 206,

139 hipErrorArrayIsMapped = 207,

140 hipErrorAlreadyMapped = 208,

141 hipErrorNoBinaryForGpu = 209,

142 hipErrorAlreadyAcquired = 210,

143 hipErrorNotMapped = 211,

144 hipErrorNotMappedAsArray = 212,

145 hipErrorNotMappedAsPointer = 213,

146 hipErrorECCNotCorrectable = 214,

147 hipErrorUnsupportedLimit = 215,

148 hipErrorContextAlreadyInUse = 216,

149 hipErrorPeerAccessUnsupported = 217,

150 hipErrorInvalidKernelFile = 218,

151 hipErrorInvalidGraphicsContext = 219,

152 hipErrorInvalidSource = 300,

153 hipErrorFileNotFound = 301,

154 hipErrorSharedObjectSymbolNotFound = 302,

155 hipErrorSharedObjectInitFailed = 303,

156 hipErrorOperatingSystem = 304,

157 hipErrorInvalidHandle = 400,

158 // Deprecated

159 hipErrorInvalidResourceHandle = 400,

160 hipErrorIllegalState = 401,

161 hipErrorNotFound = 500,

162 hipErrorNotReady = 600,

166 hipErrorIllegalAddress = 700,

167 hipErrorLaunchOutOfResources = 701,

168 hipErrorLaunchTimeOut = 702,

169 hipErrorPeerAccessAlreadyEnabled = 704,

171 hipErrorPeerAccessNotEnabled = 705,

172 hipErrorSetOnActiveProcess = 708,

173 hipErrorContextIsDestroyed = 709,

174 hipErrorAssert = 710,

175 hipErrorHostMemoryAlreadyRegistered = 712,

177 hipErrorHostMemoryNotRegistered = 713,

179 hipErrorLaunchFailure = 719,

180 hipErrorCooperativeLaunchTooLarge = 720,

184 hipErrorNotSupported = 801,

185 hipErrorStreamCaptureUnsupported = 900,

187 hipErrorStreamCaptureInvalidated = 901,

189 hipErrorStreamCaptureMerge = 902,

191 hipErrorStreamCaptureUnmatched = 903,

192 hipErrorStreamCaptureUnjoined = 904,

194 hipErrorStreamCaptureIsolation = 905,

198 hipErrorStreamCaptureImplicit = 906,

201 hipErrorCapturedEvent = 907,

203 hipErrorStreamCaptureWrongThread = 908,

207 hipErrorGraphExecUpdateFailure = 910,

211 hipErrorInvalidChannelDescriptor = 911,

212 hipErrorInvalidTexture = 912,

213 hipErrorInvalidResourceType = 914,

214 hipErrorInvalidResourceConfiguration = 915,

216 hipErrorStreamDetached = 916,

217 hipErrorUnknown = 999,

218 // HSA Runtime Error Codes start here.

219 hipErrorRuntimeMemory = 1052,

221 hipErrorRuntimeOther = 1053,

223 hipErrorInvalidClusterSize = 1054,

226 hipErrorTbd

227} hipError_t;

228

229#undef __HIP_NODISCARD

230

231/*

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

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

234*/

235

236#if HIP_FORCE_API_VERSION < 600

237

238#include <hip/hip_deprecated.h>

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

240typedef hipDeviceProp_tR0000 hipDeviceProp_t;

241// Dummy struct for hip_prof_str.h

242typedef struct hipDeviceProp_tR0600 {} hipDeviceProp_tR0600;

243

244#endif

245

246#if HIP_FORCE_API_VERSION >= 600

247// Latest version.

248

253typedef struct hipDeviceProp_t {

254 char name[256];

255 hipUUID uuid;

256 char luid[8];

257 unsigned int luidDeviceNodeMask;

258 size_t totalGlobalMem;

259 size_t sharedMemPerBlock;

260 int regsPerBlock;

261 int warpSize;

262 size_t memPitch;

264 int maxThreadsPerBlock;

265 int maxThreadsDim[3];

266 int maxGridSize[3];

267 int clockRate;

268 size_t totalConstMem;

270 int major;

274 int minor;

279 size_t textureAlignment;

280 size_t texturePitchAlignment;

281 int deviceOverlap;

282 int multiProcessorCount;

286 int kernelExecTimeoutEnabled;

287 int integrated;

288 int canMapHostMemory;

289 int computeMode;

290 int maxTexture1D;

291 int maxTexture1DMipmap;

292 int maxTexture1DLinear;

293 int maxTexture2D[2];

294 int maxTexture2DMipmap[2];

295 int maxTexture2DLinear[3];

296 int maxTexture2DGather[2];

297 int maxTexture3D[3];

299 int maxTexture3DAlt[3];

300 int maxTextureCubemap;

301 int maxTexture1DLayered[2];

302 int maxTexture2DLayered[3];

303 int maxTextureCubemapLayered[2];

304 int maxSurface1D;

305 int maxSurface2D[2];

306 int maxSurface3D[3];

307 int maxSurface1DLayered[2];

308 int maxSurface2DLayered[3];

309 int maxSurfaceCubemap;

310 int maxSurfaceCubemapLayered[2];

311 size_t surfaceAlignment;

312 int concurrentKernels;

313 int ECCEnabled;

314 int pciBusID;

315 int pciDeviceID;

316 int pciDomainID;

317 int tccDriver;

318 int asyncEngineCount;

319 int unifiedAddressing;

320 int memoryClockRate;

321 int memoryBusWidth;

322 int l2CacheSize;

323 int persistingL2CacheMaxSize;

324 int maxThreadsPerMultiProcessor;

325 int streamPrioritiesSupported;

326 int globalL1CacheSupported;

327 int localL1CacheSupported;

328 size_t sharedMemPerMultiprocessor;

329 int regsPerMultiprocessor;

330 int managedMemory;

331 int isMultiGpuBoard;

332 int multiGpuBoardGroupID;

333 int hostNativeAtomicSupported;

334 int singleToDoublePrecisionPerfRatio;

335 int pageableMemoryAccess;

337 int concurrentManagedAccess;

339 int computePreemptionSupported;

340 int canUseHostPointerForRegisteredMem;

342 int cooperativeLaunch;

343 int cooperativeMultiDeviceLaunch;

345 size_t sharedMemPerBlockOptin;

346 int pageableMemoryAccessUsesHostPageTables;

348 int directManagedMemAccessFromHost;

350 int maxBlocksPerMultiProcessor;

351 int accessPolicyMaxWindowSize;

352 size_t reservedSharedMemPerBlock;

353 int hostRegisterSupported;

354 int sparseHipArraySupported;

355 int hostRegisterReadOnlySupported;

357 int timelineSemaphoreInteropSupported;

358 int memoryPoolsSupported;

359 int gpuDirectRDMASupported;

360 unsigned int gpuDirectRDMAFlushWritesOptions;

362 int gpuDirectRDMAWritesOrdering;

363 unsigned int

364 memoryPoolSupportedHandleTypes;

365 int deferredMappingHipArraySupported;

367 int ipcEventSupported;

368 int clusterLaunch;

369 int unifiedFunctionPointers;

370 int reserved[63];

371

372 int hipReserved[32];

373

374 /* HIP Only struct members */

375 char gcnArchName[256];

376 size_t maxSharedMemoryPerMultiProcessor;

377 int clockInstructionRate;

379 hipDeviceArch_t arch;

380 unsigned int* hdpMemFlushCntl;

381 unsigned int* hdpRegFlushCntl;

382 int cooperativeMultiDeviceUnmatchedFunc;

385 int cooperativeMultiDeviceUnmatchedGridDim;

388 int cooperativeMultiDeviceUnmatchedBlockDim;

391 int cooperativeMultiDeviceUnmatchedSharedMem;

394 int isLargeBar;

395 int asicRevision;

396} hipDeviceProp_t;

397

398// Latest version, HIP_ABI_IMPL should see this.

399typedef hipDeviceProp_t hipDeviceProp_tR0600;

400#endif

401

409typedef enum hipMemoryType {

410 hipMemoryTypeUnregistered = 0,

411 hipMemoryTypeHost = 1,

412 hipMemoryTypeDevice = 2,

414 hipMemoryTypeManaged = 3,

417 hipMemoryTypeArray = 10,

419 hipMemoryTypeUnified = 11

420

421} hipMemoryType;

422

426typedef struct hipPointerAttribute_t {

427 enum hipMemoryType type;

428 int device;

429 void* devicePointer;

430 void* hostPointer;

431 int isManaged;

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

433 /* peers? */

434} hipPointerAttribute_t;

435

440typedef enum hipDeviceAttribute_t {

441 hipDeviceAttributeCudaCompatibleBegin = 0,

442

443 hipDeviceAttributeEccEnabled =

444 hipDeviceAttributeCudaCompatibleBegin,

445 hipDeviceAttributeAccessPolicyMaxWindowSize,

447 hipDeviceAttributeAsyncEngineCount,

448 hipDeviceAttributeCanMapHostMemory,

450 hipDeviceAttributeCanUseHostPointerForRegisteredMem,

453 hipDeviceAttributeClockRate,

454 hipDeviceAttributeComputeMode,

455 hipDeviceAttributeComputePreemptionSupported,

456 hipDeviceAttributeConcurrentKernels,

458 hipDeviceAttributeConcurrentManagedAccess,

460 hipDeviceAttributeCooperativeLaunch,

461 hipDeviceAttributeCooperativeMultiDeviceLaunch,

463 hipDeviceAttributeDeviceOverlap,

465 hipDeviceAttributeDirectManagedMemAccessFromHost,

467 hipDeviceAttributeGlobalL1CacheSupported,

468 hipDeviceAttributeHostNativeAtomicSupported,

470 hipDeviceAttributeIntegrated,

471 hipDeviceAttributeIsMultiGpuBoard,

472 hipDeviceAttributeKernelExecTimeout,

473 hipDeviceAttributeL2CacheSize,

475 hipDeviceAttributeLocalL1CacheSupported,

476 hipDeviceAttributeLuid,

478 hipDeviceAttributeLuidDeviceNodeMask,

480 hipDeviceAttributeComputeCapabilityMajor,

481 hipDeviceAttributeManagedMemory,

482 hipDeviceAttributeMaxBlocksPerMultiProcessor,

483 hipDeviceAttributeMaxBlockDimX,

484 hipDeviceAttributeMaxBlockDimY,

485 hipDeviceAttributeMaxBlockDimZ,

486 hipDeviceAttributeMaxGridDimX,

487 hipDeviceAttributeMaxGridDimY,

488 hipDeviceAttributeMaxGridDimZ,

489 hipDeviceAttributeMaxSurface1D,

490 hipDeviceAttributeMaxSurface1DLayered,

491 hipDeviceAttributeMaxSurface2D,

492 hipDeviceAttributeMaxSurface2DLayered,

493 hipDeviceAttributeMaxSurface3D,

494 hipDeviceAttributeMaxSurfaceCubemap,

495 hipDeviceAttributeMaxSurfaceCubemapLayered,

497 hipDeviceAttributeMaxTexture1DWidth,

498 hipDeviceAttributeMaxTexture1DLayered,

499 hipDeviceAttributeMaxTexture1DLinear,

502 hipDeviceAttributeMaxTexture1DMipmap,

503 hipDeviceAttributeMaxTexture2DWidth,

504 hipDeviceAttributeMaxTexture2DHeight,

505 hipDeviceAttributeMaxTexture2DGather,

507 hipDeviceAttributeMaxTexture2DLayered,

508 hipDeviceAttributeMaxTexture2DLinear,

510 hipDeviceAttributeMaxTexture2DMipmap,

511 hipDeviceAttributeMaxTexture3DWidth,

512 hipDeviceAttributeMaxTexture3DHeight,

513 hipDeviceAttributeMaxTexture3DDepth,

514 hipDeviceAttributeMaxTexture3DAlt,

515 hipDeviceAttributeMaxTextureCubemap,

516 hipDeviceAttributeMaxTextureCubemapLayered,

517 hipDeviceAttributeMaxThreadsDim,

518 hipDeviceAttributeMaxThreadsPerBlock,

519 hipDeviceAttributeMaxThreadsPerMultiProcessor,

520 hipDeviceAttributeMaxPitch,

521 hipDeviceAttributeMemoryBusWidth,

522 hipDeviceAttributeMemoryClockRate,

523 hipDeviceAttributeComputeCapabilityMinor,

524 hipDeviceAttributeMultiGpuBoardGroupID,

526 hipDeviceAttributeMultiprocessorCount,

530 hipDeviceAttributeUnused1,

531 hipDeviceAttributePageableMemoryAccess,

533 hipDeviceAttributePageableMemoryAccessUsesHostPageTables,

535 hipDeviceAttributePciBusId,

536 hipDeviceAttributePciDeviceId,

537 hipDeviceAttributePciDomainId,

538 hipDeviceAttributePciDomainID =

539 hipDeviceAttributePciDomainId,

540 hipDeviceAttributePersistingL2CacheMaxSize,

541 hipDeviceAttributeMaxRegistersPerBlock,

544 hipDeviceAttributeMaxRegistersPerMultiprocessor,

545 hipDeviceAttributeReservedSharedMemPerBlock,

547 hipDeviceAttributeMaxSharedMemoryPerBlock,

549 hipDeviceAttributeSharedMemPerBlockOptin,

551 hipDeviceAttributeSharedMemPerMultiprocessor,

552 hipDeviceAttributeSingleToDoublePrecisionPerfRatio,

554 hipDeviceAttributeStreamPrioritiesSupported,

555 hipDeviceAttributeSurfaceAlignment,

556 hipDeviceAttributeTccDriver,

557 hipDeviceAttributeTextureAlignment,

558 hipDeviceAttributeTexturePitchAlignment,

560 hipDeviceAttributeTotalConstantMemory,

561 hipDeviceAttributeTotalGlobalMem,

562 hipDeviceAttributeUnifiedAddressing,

564 hipDeviceAttributeUnused2,

565 hipDeviceAttributeWarpSize,

566 hipDeviceAttributeMemoryPoolsSupported,

567 hipDeviceAttributeVirtualMemoryManagementSupported,

569 hipDeviceAttributeHostRegisterSupported,

571 hipDeviceAttributeMemoryPoolSupportedHandleTypes,

573 hipDeviceAttributeHostNumaId,

575 hipDeviceAttributeDmaBufSupported,

576 hipDeviceAttributeGPUDirectRDMAWithHipVMMSupported,

579 hipDeviceAttributeHandleTypeFabricSupported,

580 hipDeviceAttributeHostAllocDmaBufSupported,

581

582 hipDeviceAttributeCudaCompatibleEnd = 9999,

583 hipDeviceAttributeAmdSpecificBegin = 10000,

584

585 hipDeviceAttributeClockInstructionRate =

586 hipDeviceAttributeAmdSpecificBegin,

588 hipDeviceAttributeUnused3,

589 hipDeviceAttributeMaxSharedMemoryPerMultiprocessor,

590 hipDeviceAttributeUnused4,

591 hipDeviceAttributeUnused5,

592 hipDeviceAttributeHdpMemFlushCntl,

593 hipDeviceAttributeHdpRegFlushCntl,

594 hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc,

597 hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim,

600 hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim,

603 hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem,

606 hipDeviceAttributeIsLargeBar,

607 hipDeviceAttributeAsicRevision,

608 hipDeviceAttributeCanUseStreamWaitValue,

610 hipDeviceAttributeImageSupport,

611 hipDeviceAttributePhysicalMultiProcessorCount,

613 hipDeviceAttributeFineGrainSupport,

614 hipDeviceAttributeWallClockRate,

615 hipDeviceAttributeNumberOfXccs,

622 hipDeviceAttributeMaxAvailableVgprsPerThread,

625 hipDeviceAttributePciChipId,

626 hipDeviceAttributeExpertSchedMode,

628 hipDeviceAttributeMaxDynDataPrefetchRegions,

630

631 hipDeviceAttributeAmdSpecificEnd = 19999,

632 hipDeviceAttributeVendorSpecificBegin = 20000,

633 // Extended attributes for vendors

634} hipDeviceAttribute_t;

635

636// Flags that can be used with hipGetProcAddress.

640#define HIP_GET_PROC_ADDRESS_DEFAULT 0x0

641

643#define HIP_GET_PROC_ADDRESS_LEGACY_STREAM 0x1

644

647#define HIP_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM 0x2

648

649typedef enum hipDriverProcAddressQueryResult {

650 HIP_GET_PROC_ADDRESS_SUCCESS = 0,

651 HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND = 1,

652 HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT = 2

653} hipDriverProcAddressQueryResult;

654

655enum hipComputeMode {

656 hipComputeModeDefault = 0,

657 hipComputeModeExclusive = 1,

658 hipComputeModeProhibited = 2,

659 hipComputeModeExclusiveProcess = 3

660};

661

662enum hipFlushGPUDirectRDMAWritesOptions {

663 hipFlushGPUDirectRDMAWritesOptionHost = 1 << 0,

664 hipFlushGPUDirectRDMAWritesOptionMemOps = 1 << 1

665};

666

667enum hipGPUDirectRDMAWritesOrdering {

668 hipGPUDirectRDMAWritesOrderingNone = 0,

669 hipGPUDirectRDMAWritesOrderingOwner = 100,

670 hipGPUDirectRDMAWritesOrderingAllDevices = 200

671};

672

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

674

675#ifndef GENERIC_GRID_LAUNCH

676#define GENERIC_GRID_LAUNCH 1

677#endif

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

679#include <hip/driver_types.h>

680#include <hip/texture_types.h>

681#include <hip/surface_types.h>

682

683#if defined(HIP_ABI_IMPL)

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

685#define HIP_DEPRECATED(x)

686#elif defined(_MSC_VER)

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

688#else // !defined(_MSC_VER)

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

690#endif // !defined(_MSC_VER)

691

692#define HIP_DEPRECATED_MSG \

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

694 "details please refer " \

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

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

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

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

699#ifdef __cplusplus

700#define __dparm(x) = x

701#else

702#define __dparm(x)

703#endif

704#ifdef __GNUC__

705#pragma GCC visibility push(default)

706#endif

707#ifdef __cplusplus

708namespace hip_impl {

709hipError_t hip_init();

710} // namespace hip_impl

711#endif

712// Structure definitions:

713#ifdef __cplusplus

714extern "C" {

715#endif

716//---

717// API-visible structures

718typedef struct ihipCtx_t* hipCtx_t;

719typedef struct ihipExecutionCtx_t* hipExecutionCtx_t;

720typedef struct ihipDevResourceDesc_t* hipDevResourceDesc_t;

721typedef enum hipDevResourceType {

722 hipDevResourceTypeInvalid = 0,

723 hipDevResourceTypeSm = 1,

724 hipDevResourceTypeWorkqueueConfig = 1000,

725 hipDevResourceTypeWorkqueue = 10000,

726} hipDevResourceType;

727typedef enum hipDevSmResourceGroup_flags {

728 hipDevSmResourceGroupDefault = 0,

729 hipDevSmResourceGroupBackfill = 0x1,

730} hipDevSmResourceGroup_flags;

731typedef enum hipDevSmResourceSplitByCount_flags {

732 hipDevSmResourceSplitIgnoreSmCoscheduling = 0x1,

733 hipDevSmResourceSplitMaxPotentialClusterSize = 0x2,

734} hipDevSmResourceSplitByCount_flags;

735typedef enum hipDevWorkqueueConfigScope {

736 hipDevWorkqueueConfigScopeDeviceCtx = 0,

737 hipDevWorkqueueConfigScopeGreenCtxBalanced = 1,

738} hipDevWorkqueueConfigScope;

739

740#define HIP_RESOURCE_ABI_BYTES 40

741

742typedef struct hipDevSmResource {

743 unsigned int smCount;

744 unsigned int minSmPartitionSize;

745 unsigned int smCoscheduledAlignment;

746 unsigned int flags;

747} hipDevSmResource;

748

749typedef struct hipDevWorkqueueConfigResource {

750 int device;

751 unsigned int wqConcurrencyLimit;

752 hipDevWorkqueueConfigScope sharingScope;

753} hipDevWorkqueueConfigResource;

754

755typedef struct hipDevWorkqueueResource {

756 unsigned char reserved[HIP_RESOURCE_ABI_BYTES];

757} hipDevWorkqueueResource;

758

759typedef struct hipDevResource_st {

760 hipDevResourceType type;

761 unsigned char _internal_padding[92];

762 union {

763 hipDevSmResource sm;

764 hipDevWorkqueueConfigResource wqConfig;

765 hipDevWorkqueueResource wq;

766 unsigned char _oversize[HIP_RESOURCE_ABI_BYTES];

767 };

768 struct hipDevResource_st* nextResource;

769} hipDevResource;

770

771typedef struct hipDevSmResourceGroupParams_st {

772 unsigned int smCount;

773 unsigned int coscheduledSmCount;

774 unsigned int preferredCoscheduledSmCount;

775 unsigned int flags;

776 unsigned int reserved[12];

777} hipDevSmResourceGroupParams;

778

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

780typedef int hipDevice_t;

781typedef enum hipDeviceP2PAttr {

782 hipDevP2PAttrPerformanceRank = 0,

783 hipDevP2PAttrAccessSupported,

784 hipDevP2PAttrNativeAtomicSupported,

785 hipDevP2PAttrHipArrayAccessSupported

786} hipDeviceP2PAttr;

787typedef enum hipDriverEntryPointQueryResult {

788 hipDriverEntryPointSuccess = 0,

789 hipDriverEntryPointSymbolNotFound = 1,

790 hipDriverEntryPointVersionNotSufficent = 2

791} hipDriverEntryPointQueryResult;

792typedef struct ihipStream_t* hipStream_t;

793#define hipIpcMemLazyEnablePeerAccess 0x01

794#define HIP_IPC_HANDLE_SIZE 64

795typedef struct hipIpcMemHandle_st {

796 char reserved[HIP_IPC_HANDLE_SIZE];

797} hipIpcMemHandle_t;

798typedef struct hipIpcEventHandle_st {

799 char reserved[HIP_IPC_HANDLE_SIZE];

800} hipIpcEventHandle_t;

801typedef struct hipMemFabricHandle_st {

802 unsigned char data[HIP_IPC_HANDLE_SIZE];

803} hipMemFabricHandle_t;

804typedef struct ihipModule_t* hipModule_t;

805typedef struct ihipModuleSymbol_t* hipFunction_t;

806typedef struct ihipLinkState_t* hipLinkState_t;

807typedef struct ihipLibrary_t* hipLibrary_t;

808typedef struct ihipKernel_t* hipKernel_t;

812typedef struct ihipMemPoolHandle_t* hipMemPool_t;

813

814typedef struct hipFuncAttributes {

815 int binaryVersion;

816 int cacheModeCA;

817 size_t constSizeBytes;

818 size_t localSizeBytes;

819 int maxDynamicSharedSizeBytes;

820 int maxThreadsPerBlock;

821 int numRegs;

822 int preferredShmemCarveout;

823 int ptxVersion;

824 size_t sharedSizeBytes;

825} hipFuncAttributes;

826typedef struct ihipEvent_t* hipEvent_t;

827

834enum hipLimit_t {

835 hipLimitStackSize = 0x0,

838 hipLimitPrintfFifoSize = 0x01,

840 hipLimitMallocHeapSize = 0x02,

842 hipExtLimitScratchMin = 0x1000,

844 hipExtLimitScratchMax = 0x1001,

846 hipExtLimitScratchCurrent = 0x1002,

850 hipLimitRange

851};

852

856// Flags that can be used with hipStreamCreateWithFlags.

858#define hipStreamDefault 0x00

859

861#define hipStreamNonBlocking 0x01

862

863// Flags that can be used with hipEventCreateWithFlags.

865#define hipEventDefault 0x0

866

868#define hipEventBlockingSync 0x1

869

871#define hipEventDisableTiming 0x2

872

874#define hipEventInterprocess 0x4

875

876// Flags that can be used with hipEventRecordWithFlags.

878#define hipEventRecordDefault 0x00

879

881#define hipEventRecordExternal 0x01

882

883//Flags that can be used with hipStreamWaitEvent.

885#define hipEventWaitDefault 0x00

886

888#define hipEventWaitExternal 0x01

889

898#define hipEventDisableSystemFence 0x20000000

899

902#define hipEventReleaseToDevice 0x40000000

903

906#define hipEventReleaseToSystem 0x80000000

907

908// Flags that can be used with hipGetDriverEntryPoint.

912#define hipEnableDefault 0x0

913

915#define hipEnableLegacyStream 0x1

916

919#define hipEnablePerThreadDefaultStream 0x2

920

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

923#define hipHostAllocDefault 0x0

924

927#define hipHostMallocDefault 0x0

928

930#define hipHostAllocPortable 0x1

931

934#define hipHostMallocPortable 0x1

935

938#define hipHostAllocMapped 0x2

939

943#define hipHostMallocMapped 0x2

944

950#define hipHostAllocWriteCombined 0x4

951

958#define hipHostMallocWriteCombined 0x4

959

965#define hipHostMallocUncached 0x10000000

966#define hipHostAllocUncached hipHostMallocUncached

967

972#define hipHostMallocNumaUser 0x20000000

973

975#define hipHostMallocCoherent 0x40000000

976

978#define hipHostMallocNonCoherent 0x80000000

979

981#define hipMemAttachGlobal 0x01

982

984#define hipMemAttachHost 0x02

985

987#define hipMemAttachSingle 0x04

988

989#define hipDeviceMallocDefault 0x0

990

992#define hipDeviceMallocFinegrained 0x1

993

995#define hipMallocSignalMemory 0x2

996

998#define hipDeviceMallocUncached 0x3

999

1001#define hipDeviceMallocContiguous 0x4

1002

1003// Flags that can be used with hipHostRegister.

1005#define hipHostRegisterDefault 0x0

1006

1008#define hipHostRegisterPortable 0x1

1009

1012#define hipHostRegisterMapped 0x2

1013

1018#define hipHostRegisterIoMemory 0x4

1019

1021#define hipHostRegisterReadOnly 0x08

1022

1024#define hipExtHostRegisterCoarseGrained 0x8

1025

1029#define hipExtHostRegisterUncached 0x80000000

1030

1032#define hipDeviceScheduleAuto 0x0

1033

1036#define hipDeviceScheduleSpin 0x1

1037

1040#define hipDeviceScheduleYield 0x2

1041#define hipDeviceScheduleBlockingSync 0x4

1042#define hipDeviceScheduleMask 0x7

1043#define hipDeviceMapHost 0x8

1044#define hipDeviceLmemResizeToMax 0x10

1046#define hipInitDeviceFlagsAreValid 0x1

1048#define hipArrayDefault 0x00

1049#define hipArrayLayered 0x01

1050#define hipArraySurfaceLoadStore 0x02

1051#define hipArrayCubemap 0x04

1052#define hipArrayTextureGather 0x08

1053#define hipOccupancyDefault 0x00

1054#define hipOccupancyDisableCachingOverride 0x01

1055#define hipCooperativeLaunchMultiDeviceNoPreSync 0x01

1056#define hipCooperativeLaunchMultiDeviceNoPostSync 0x02

1057#define hipCpuDeviceId ((int)-1)

1058#define hipInvalidDeviceId ((int)-2)

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

1061#define hipExtAnyOrderLaunch 0x01

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

1063#define hipStreamWaitValueGte 0x0

1064#define hipStreamWaitValueEq 0x1

1065#define hipStreamWaitValueAnd 0x2

1066#define hipStreamWaitValueNor 0x3

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

1068#define hipStreamWriteValueDefault 0x0

1069#define hipExtStreamWriteValueIncrement 0x1000

1070#define hipExtStreamWriteValueDecrement 0x1001

1071

1073typedef enum hipStreamBatchMemOpType {

1074 hipStreamMemOpWaitValue32 = 0x1,

1075 hipStreamMemOpWriteValue32 = 0x2,

1076 hipStreamMemOpWaitValue64 = 0x4,

1077 hipStreamMemOpWriteValue64 = 0x5,

1078 hipStreamMemOpBarrier = 0x6,

1079 hipStreamMemOpFlushRemoteWrites = 0x3

1080} hipStreamBatchMemOpType;

1081

1118typedef union hipStreamBatchMemOpParams_union {

1119 hipStreamBatchMemOpType operation;

1120 struct hipStreamMemOpWaitValueParams_t {

1121 hipStreamBatchMemOpType operation;

1122 hipDeviceptr_t address;

1123 union {

1124 uint32_t value;

1125 uint64_t value64;

1126 };

1127 unsigned int flags;

1128 hipDeviceptr_t alias;

1129 } waitValue;

1130 struct hipStreamMemOpWriteValueParams_t {

1131 hipStreamBatchMemOpType operation;

1132 hipDeviceptr_t address;

1133 union {

1134 uint32_t value;

1135 uint64_t value64;

1136 };

1137 unsigned int flags;

1138 hipDeviceptr_t alias;

1139 } writeValue;

1140 struct hipStreamMemOpFlushRemoteWritesParams_t {

1141 hipStreamBatchMemOpType operation;

1142 unsigned int flags;

1143 } flushRemoteWrites;

1144 struct hipStreamMemOpMemoryBarrierParams_t {

1145 hipStreamBatchMemOpType operation;

1146 unsigned int flags;

1147 } memoryBarrier;

1148 uint64_t pad[6];

1149} hipStreamBatchMemOpParams;

1150

1178typedef struct hipBatchMemOpNodeParams {

1179 hipCtx_t ctx;

1180 unsigned int count;

1181 hipStreamBatchMemOpParams* paramArray;

1182 unsigned int flags;

1183} hipBatchMemOpNodeParams;

1184

1185// Stream per thread

1187#define hipStreamPerThread ((hipStream_t)2)

1188

1189#define hipStreamLegacy ((hipStream_t)1)

1190

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

1192#define hipExternalMemoryDedicated 0x1

1198typedef enum hipMemoryAdvise {

1199 hipMemAdviseSetReadMostly = 1,

1201 hipMemAdviseUnsetReadMostly = 2,

1202 hipMemAdviseSetPreferredLocation = 3,

1204 hipMemAdviseUnsetPreferredLocation = 4,

1205 hipMemAdviseSetAccessedBy = 5,

1207 hipMemAdviseUnsetAccessedBy = 6,

1209 hipMemAdviseSetCoarseGrain = 100,

1214 hipMemAdviseUnsetCoarseGrain = 101

1215} hipMemoryAdvise;

1219typedef enum hipMemRangeCoherencyMode {

1220 hipMemRangeCoherencyModeFineGrain = 0,

1222 hipMemRangeCoherencyModeCoarseGrain = 1,

1224 hipMemRangeCoherencyModeIndeterminate = 2

1227} hipMemRangeCoherencyMode;

1231typedef enum hipMemRangeAttribute {

1232 hipMemRangeAttributeReadMostly = 1,

1234 hipMemRangeAttributePreferredLocation = 2,

1235 hipMemRangeAttributeAccessedBy = 3,

1237 hipMemRangeAttributeLastPrefetchLocation = 4,

1239 hipMemRangeAttributeCoherencyMode = 100,

1241} hipMemRangeAttribute;

1242

1246typedef enum hipMemPoolAttr {

1255 hipMemPoolReuseFollowEventDependencies = 0x1,

1261 hipMemPoolReuseAllowOpportunistic = 0x2,

1268 hipMemPoolReuseAllowInternalDependencies = 0x3,

1277 hipMemPoolAttrReleaseThreshold = 0x4,

1282 hipMemPoolAttrReservedMemCurrent = 0x5,

1288 hipMemPoolAttrReservedMemHigh = 0x6,

1293 hipMemPoolAttrUsedMemCurrent = 0x7,

1299 hipMemPoolAttrUsedMemHigh = 0x8

1300} hipMemPoolAttr;

1301

1306typedef enum hipMemAccessFlags {

1307 hipMemAccessFlagsProtNone = 0,

1308 hipMemAccessFlagsProtRead = 1,

1309 hipMemAccessFlagsProtReadWrite = 3

1310} hipMemAccessFlags;

1317typedef struct hipMemAccessDesc {

1318 hipMemLocation location;

1319 hipMemAccessFlags flags;

1320} hipMemAccessDesc;

1324typedef enum hipMemAllocationType {

1325 hipMemAllocationTypeInvalid = 0x0,

1329 hipMemAllocationTypePinned = 0x1,

1330 hipMemAllocationTypeManaged = 0x2,

1331 hipMemAllocationTypeUncached = 0x40000000,

1332 hipMemAllocationTypeMax = 0x7FFFFFFF

1333} hipMemAllocationType;

1338typedef enum hipMemAllocationHandleType {

1339 hipMemHandleTypeNone = 0x0,

1340 hipMemHandleTypePosixFileDescriptor =

1341 0x1,

1342 hipMemHandleTypeWin32 = 0x2,

1343 hipMemHandleTypeWin32Kmt = 0x4,

1344 hipMemHandleTypeFabric = 0x8

1345} hipMemAllocationHandleType;

1349typedef struct hipMemPoolProps {

1350 hipMemAllocationType

1351 allocType;

1352 hipMemAllocationHandleType

1353 handleTypes;

1354 hipMemLocation location;

1358 void* win32SecurityAttributes;

1359 size_t maxSize;

1360 unsigned char reserved[56];

1361} hipMemPoolProps;

1365typedef struct hipMemPoolPtrExportData {

1366 unsigned char reserved[64];

1367} hipMemPoolPtrExportData;

1368

1372typedef enum hipFuncAttribute {

1373 hipFuncAttributeMaxDynamicSharedMemorySize = 8,

1374 hipFuncAttributePreferredSharedMemoryCarveout = 9,

1375 hipFuncAttributeClusterDimMustBeSet = 10,

1376 hipFuncAttributeRequiredClusterWidth = 11,

1377 hipFuncAttributeRequiredClusterHeight = 12,

1378 hipFuncAttributeRequiredClusterDepth = 13,

1379 hipFuncAttributeNonPortableClusterSizeAllowed = 14,

1380 hipFuncAttributeClusterSchedulingPolicyPreference = 15,

1381 hipFuncAttributeMax

1382} hipFuncAttribute;

1386typedef enum hipFuncCache_t {

1387 hipFuncCachePreferNone,

1388 hipFuncCachePreferShared,

1389 hipFuncCachePreferL1,

1390 hipFuncCachePreferEqual,

1391} hipFuncCache_t;

1395typedef enum hipSharedMemConfig {

1396 hipSharedMemBankSizeDefault,

1397 hipSharedMemBankSizeFourByte,

1399 hipSharedMemBankSizeEightByte

1401} hipSharedMemConfig;

1405typedef struct dim3 {

1406 uint32_t x;

1407 uint32_t y;

1408 uint32_t z;

1409#ifdef __cplusplus

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

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

1412#endif

1413} dim3;

1417typedef struct hipLaunchParams_t {

1418 void* func;

1419 dim3 gridDim;

1420 dim3 blockDim;

1421 void** args;

1422 size_t sharedMem;

1423 hipStream_t stream;

1424} hipLaunchParams;

1428typedef struct hipFunctionLaunchParams_t {

1429 hipFunction_t function;

1430 unsigned int gridDimX;

1431 unsigned int gridDimY;

1432 unsigned int gridDimZ;

1433 unsigned int blockDimX;

1434 unsigned int blockDimY;

1435 unsigned int blockDimZ;

1436 unsigned int sharedMemBytes;

1437 hipStream_t hStream;

1438 void** kernelParams;

1439} hipFunctionLaunchParams;

1440typedef enum hipExternalMemoryHandleType_enum {

1441 hipExternalMemoryHandleTypeOpaqueFd = 1,

1442 hipExternalMemoryHandleTypeOpaqueWin32 = 2,

1443 hipExternalMemoryHandleTypeOpaqueWin32Kmt = 3,

1444 hipExternalMemoryHandleTypeD3D12Heap = 4,

1445 hipExternalMemoryHandleTypeD3D12Resource = 5,

1446 hipExternalMemoryHandleTypeD3D11Resource = 6,

1447 hipExternalMemoryHandleTypeD3D11ResourceKmt = 7,

1448 hipExternalMemoryHandleTypeNvSciBuf = 8

1449} hipExternalMemoryHandleType;

1450typedef struct hipExternalMemoryHandleDesc_st {

1451 hipExternalMemoryHandleType type;

1452 union {

1453 int fd;

1454 struct {

1455 void* handle;

1456 const void* name;

1457 } win32;

1458 const void* nvSciBufObject;

1459 } handle;

1460 unsigned long long size;

1461 unsigned int flags;

1462 unsigned int reserved[16];

1463} hipExternalMemoryHandleDesc;

1464typedef struct hipExternalMemoryBufferDesc_st {

1465 unsigned long long offset;

1466 unsigned long long size;

1467 unsigned int flags;

1468 unsigned int reserved[16];

1469} hipExternalMemoryBufferDesc;

1470typedef struct hipExternalMemoryMipmappedArrayDesc_st {

1471 unsigned long long offset;

1472 hipChannelFormatDesc formatDesc;

1473 hipExtent extent;

1474 unsigned int flags;

1475 unsigned int numLevels;

1476} hipExternalMemoryMipmappedArrayDesc;

1477typedef void* hipExternalMemory_t;

1478typedef enum hipExternalSemaphoreHandleType_enum {

1479 hipExternalSemaphoreHandleTypeOpaqueFd = 1,

1480 hipExternalSemaphoreHandleTypeOpaqueWin32 = 2,

1481 hipExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3,

1482 hipExternalSemaphoreHandleTypeD3D12Fence = 4,

1483 hipExternalSemaphoreHandleTypeD3D11Fence = 5,

1484 hipExternalSemaphoreHandleTypeNvSciSync = 6,

1485 hipExternalSemaphoreHandleTypeKeyedMutex = 7,

1486 hipExternalSemaphoreHandleTypeKeyedMutexKmt = 8,

1487 hipExternalSemaphoreHandleTypeTimelineSemaphoreFd = 9,

1488 hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = 10

1489} hipExternalSemaphoreHandleType;

1490typedef struct hipExternalSemaphoreHandleDesc_st {

1491 hipExternalSemaphoreHandleType type;

1492 union {

1493 int fd;

1494 struct {

1495 void* handle;

1496 const void* name;

1497 } win32;

1498 const void* NvSciSyncObj;

1499 } handle;

1500 unsigned int flags;

1501 unsigned int reserved[16];

1502} hipExternalSemaphoreHandleDesc;

1503typedef void* hipExternalSemaphore_t;

1504typedef struct hipExternalSemaphoreSignalParams_st {

1505 struct {

1506 struct {

1507 unsigned long long value;

1508 } fence;

1509 union {

1510 void* fence;

1511 unsigned long long reserved;

1512 } nvSciSync;

1513 struct {

1514 unsigned long long key;

1515 } keyedMutex;

1516 unsigned int reserved[12];

1517 } params;

1518 unsigned int flags;

1519 unsigned int reserved[16];

1520} hipExternalSemaphoreSignalParams;

1524typedef struct hipExternalSemaphoreWaitParams_st {

1525 struct {

1526 struct {

1527 unsigned long long value;

1528 } fence;

1529 union {

1530 void* fence;

1531 unsigned long long reserved;

1532 } nvSciSync;

1533 struct {

1534 unsigned long long key;

1535 unsigned int timeoutMs;

1536 } keyedMutex;

1537 unsigned int reserved[10];

1538 } params;

1539 unsigned int flags;

1540 unsigned int reserved[16];

1541} hipExternalSemaphoreWaitParams;

1542

1543#if __HIP_HAS_GET_PCH

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

1549#endif

1550

1554typedef enum hipGraphicsRegisterFlags {

1555 hipGraphicsRegisterFlagsNone = 0,

1556 hipGraphicsRegisterFlagsReadOnly = 1,

1557 hipGraphicsRegisterFlagsWriteDiscard =

1558 2,

1559 hipGraphicsRegisterFlagsSurfaceLoadStore = 4,

1560 hipGraphicsRegisterFlagsTextureGather =

1561 8

1562} hipGraphicsRegisterFlags;

1563

1564typedef struct _hipGraphicsResource hipGraphicsResource;

1565

1566typedef hipGraphicsResource* hipGraphicsResource_t;

1567

1571typedef struct ihipGraph* hipGraph_t;

1575typedef struct hipGraphNode* hipGraphNode_t;

1579typedef struct hipGraphExec* hipGraphExec_t;

1580

1584typedef struct hipUserObject* hipUserObject_t;

1585

1586

1590typedef enum hipGraphNodeType {

1591 hipGraphNodeTypeKernel = 0,

1592 hipGraphNodeTypeMemcpy = 1,

1593 hipGraphNodeTypeMemset = 2,

1594 hipGraphNodeTypeHost = 3,

1595 hipGraphNodeTypeGraph = 4,

1596 hipGraphNodeTypeEmpty = 5,

1597 hipGraphNodeTypeWaitEvent = 6,

1598 hipGraphNodeTypeEventRecord = 7,

1599 hipGraphNodeTypeExtSemaphoreSignal = 8,

1600 hipGraphNodeTypeExtSemaphoreWait = 9,

1601 hipGraphNodeTypeMemAlloc = 10,

1602 hipGraphNodeTypeMemFree = 11,

1603 hipGraphNodeTypeMemcpyFromSymbol = 12,

1604 hipGraphNodeTypeMemcpyToSymbol = 13,

1605 hipGraphNodeTypeBatchMemOp = 14,

1606 hipGraphNodeTypeCount

1607} hipGraphNodeType;

1608

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

1610typedef struct hipHostNodeParams {

1611 hipHostFn_t fn;

1612 void* userData;

1613} hipHostNodeParams;

1614typedef struct hipKernelNodeParams {

1615 dim3 blockDim;

1616 void** extra;

1617 void* func;

1618 dim3 gridDim;

1619 void** kernelParams;

1620 unsigned int sharedMemBytes;

1621} hipKernelNodeParams;

1622typedef struct hipMemsetParams {

1623 void* dst;

1624 unsigned int elementSize;

1625 size_t height;

1626 size_t pitch;

1627 unsigned int value;

1628 size_t width;

1629} hipMemsetParams;

1630

1631typedef struct hipMemAllocNodeParams {

1632 hipMemPoolProps poolProps;

1634 const hipMemAccessDesc* accessDescs;

1635 size_t accessDescCount;

1637 size_t bytesize;

1638 void* dptr;

1639} hipMemAllocNodeParams;

1640

1644typedef enum hipAccessProperty {

1645 hipAccessPropertyNormal = 0,

1646 hipAccessPropertyStreaming = 1,

1647 hipAccessPropertyPersisting = 2,

1648} hipAccessProperty;

1649

1650/***

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

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

1653 */

1654typedef struct hipAccessPolicyWindow {

1655 void* base_ptr;

1656 hipAccessProperty hitProp;

1657 float hitRatio;

1658 hipAccessProperty missProp;

1659 size_t num_bytes;

1660} hipAccessPolicyWindow;

1661

1665typedef struct hipLaunchMemSyncDomainMap {

1666 unsigned char default_;

1667 unsigned char remote;

1668} hipLaunchMemSyncDomainMap;

1669

1673typedef enum hipLaunchMemSyncDomain {

1674 hipLaunchMemSyncDomainDefault = 0,

1675 hipLaunchMemSyncDomainRemote = 1

1676} hipLaunchMemSyncDomain;

1677

1682typedef enum hipSynchronizationPolicy {

1683 hipSyncPolicyAuto = 1,

1684 hipSyncPolicySpin = 2,

1685 hipSyncPolicyYield = 3,

1686 hipSyncPolicyBlockingSync = 4

1687} hipSynchronizationPolicy;

1688/* Cluster scheduling policies passed to hipFuncSetAttribute

1689*/

1690typedef enum hipClusterSchedulingPolicy {

1691 hipClusterSchedulingPolicyDefault = 0,

1692 hipClusterSchedulingPolicySpread = 1,

1693 hipClusterSchedulingPolicyLoadBalancing =

1694 2,

1695} hipClusterSchedulingPolicy;

1696

1700typedef enum hipExtDynDataPrefetchTemporal {

1701 hipExtDynDataPrefetchTemporalRegular = 0,

1702 hipExtDynDataPrefetchTemporalHigh = 1,

1703} hipExtDynDataPrefetchTemporal;

1704

1713typedef struct hipExtDynDataPrefetchRegion {

1714 void* address;

1715 size_t stride;

1716 size_t width;

1717 size_t height;

1718} hipExtDynDataPrefetchRegion;

1719

1725#define HIP_EXT_DYN_DATA_PREFETCH_MAX_REGIONS 2

1726

1737typedef struct hipExtDynDataPrefetchConfig {

1738 unsigned int numRegions;

1739 hipExtDynDataPrefetchTemporal temporal;

1740 hipExtDynDataPrefetchRegion regions[HIP_EXT_DYN_DATA_PREFETCH_MAX_REGIONS];

1741} hipExtDynDataPrefetchConfig;

1742

1746typedef enum hipLaunchAttributeID {

1747 hipLaunchAttributeIgnore = 0,

1748 hipLaunchAttributeAccessPolicyWindow = 1,

1749 hipLaunchAttributeCooperative = 2,

1750 hipLaunchAttributeSynchronizationPolicy = 3,

1751 hipLaunchAttributeClusterDimension = 4,

1752 hipLaunchAttributeClusterSchedulingPolicyPreference = 5,

1753 hipLaunchAttributePriority = 8,

1754 hipLaunchAttributeMemSyncDomainMap = 9,

1755 hipLaunchAttributeMemSyncDomain = 10,

1756 hipLaunchAttributeExtDynDataPrefetch = 1024,

1757 hipLaunchAttributeMax

1758} hipLaunchAttributeID;

1759

1760

1764typedef union hipLaunchAttributeValue {

1765 char pad[64];

1766 hipAccessPolicyWindow

1767 accessPolicyWindow;

1768 int cooperative;

1770 int priority;

1772 hipSynchronizationPolicy

1773 syncPolicy;

1775 hipLaunchMemSyncDomainMap

1776 memSyncDomainMap;

1777 hipLaunchMemSyncDomain

1778 memSyncDomain;

1791 struct {

1792 unsigned int x;

1793 unsigned int y;

1794 unsigned int z;

1795 } clusterDim;

1796

1797 hipClusterSchedulingPolicy clusterSchedulingPolicyPreference;

1799 const hipExtDynDataPrefetchConfig* dynDataPrefetch;

1800} hipLaunchAttributeValue;

1801

1805#define hipStreamAttrID hipLaunchAttributeID

1806#define hipStreamAttributeAccessPolicyWindow hipLaunchAttributeAccessPolicyWindow

1807#define hipStreamAttributeSynchronizationPolicy hipLaunchAttributeSynchronizationPolicy

1808#define hipStreamAttributeMemSyncDomainMap hipLaunchAttributeMemSyncDomainMap

1809#define hipStreamAttributeMemSyncDomain hipLaunchAttributeMemSyncDomain

1810#define hipStreamAttributePriority hipLaunchAttributePriority

1811

1812#define hipStreamAttrValue hipLaunchAttributeValue

1813

1817#define hipKernelNodeAttrID hipLaunchAttributeID

1818#define hipKernelNodeAttributeAccessPolicyWindow hipLaunchAttributeAccessPolicyWindow

1819#define hipKernelNodeAttributeCooperative hipLaunchAttributeCooperative

1820#define hipKernelNodeAttributePriority hipLaunchAttributePriority

1821

1825#define hipKernelNodeAttrValue hipLaunchAttributeValue

1826

1830#define hipDrvLaunchAttributeCooperative hipLaunchAttributeCooperative

1831

1832#define hipDrvLaunchAttributeID hipLaunchAttributeID

1833#define hipDrvLaunchAttributeValue hipLaunchAttributeValue

1834#define hipDrvLaunchAttribute hipLaunchAttribute

1835

1839typedef enum hipGraphExecUpdateResult {

1840 hipGraphExecUpdateSuccess = 0x0,

1841 hipGraphExecUpdateError = 0x1,

1843 hipGraphExecUpdateErrorTopologyChanged = 0x2,

1844 hipGraphExecUpdateErrorNodeTypeChanged = 0x3,

1845 hipGraphExecUpdateErrorFunctionChanged =

1846 0x4,

1847 hipGraphExecUpdateErrorParametersChanged =

1848 0x5,

1849 hipGraphExecUpdateErrorNotSupported =

1850 0x6,

1851 hipGraphExecUpdateErrorUnsupportedFunctionChange = 0x7

1852} hipGraphExecUpdateResult;

1853

1854typedef enum hipStreamCaptureMode {

1855 hipStreamCaptureModeGlobal = 0,

1856 hipStreamCaptureModeThreadLocal,

1857 hipStreamCaptureModeRelaxed

1858} hipStreamCaptureMode;

1859typedef enum hipStreamCaptureStatus {

1860 hipStreamCaptureStatusNone = 0,

1861 hipStreamCaptureStatusActive,

1862 hipStreamCaptureStatusInvalidated

1864} hipStreamCaptureStatus;

1865

1866typedef enum hipStreamUpdateCaptureDependenciesFlags {

1867 hipStreamAddCaptureDependencies = 0,

1868 hipStreamSetCaptureDependencies,

1869} hipStreamUpdateCaptureDependenciesFlags;

1870

1871typedef enum hipGraphMemAttributeType {

1872 hipGraphMemAttrUsedMemCurrent =

1873 0,

1874 hipGraphMemAttrUsedMemHigh,

1876 hipGraphMemAttrReservedMemCurrent,

1878 hipGraphMemAttrReservedMemHigh,

1880} hipGraphMemAttributeType;

1881typedef enum hipUserObjectFlags {

1882 hipUserObjectNoDestructorSync = 0x1,

1883} hipUserObjectFlags;

1884

1885typedef enum hipUserObjectRetainFlags {

1886 hipGraphUserObjectMove = 0x1,

1887} hipUserObjectRetainFlags;

1888

1889typedef enum hipGraphInstantiateFlags {

1890 hipGraphInstantiateFlagAutoFreeOnLaunch =

1891 1,

1892 hipGraphInstantiateFlagUpload = 2,

1893 hipGraphInstantiateFlagDeviceLaunch =

1894 4,

1895 hipGraphInstantiateFlagUseNodePriority =

1896 8,

1898} hipGraphInstantiateFlags;

1899

1900enum hipGraphDebugDotFlags {

1901 hipGraphDebugDotFlagsVerbose =

1902 1 << 0,

1903 hipGraphDebugDotFlagsKernelNodeParams = 1 << 2,

1904 hipGraphDebugDotFlagsMemcpyNodeParams = 1 << 3,

1905 hipGraphDebugDotFlagsMemsetNodeParams = 1 << 4,

1906 hipGraphDebugDotFlagsHostNodeParams = 1 << 5,

1907 hipGraphDebugDotFlagsEventNodeParams =

1908 1 << 6,

1909 hipGraphDebugDotFlagsExtSemasSignalNodeParams =

1910 1 << 7,

1911 hipGraphDebugDotFlagsExtSemasWaitNodeParams =

1912 1 << 8,

1913 hipGraphDebugDotFlagsKernelNodeAttributes =

1914 1 << 9,

1915 hipGraphDebugDotFlagsHandles =

1916 1 << 10

1917};

1918

1922typedef enum hipGraphInstantiateResult {

1923 hipGraphInstantiateSuccess = 0,

1924 hipGraphInstantiateError = 1,

1926 hipGraphInstantiateInvalidStructure = 2,

1928 hipGraphInstantiateNodeOperationNotSupported = 3,

1930 hipGraphInstantiateMultipleDevicesNotSupported = 4,

1932} hipGraphInstantiateResult;

1933

1937typedef struct hipGraphInstantiateParams {

1938 hipGraphNode_t errNode_out;

1939 unsigned long long flags;

1940 hipGraphInstantiateResult result_out;

1942 hipStream_t uploadStream;

1943} hipGraphInstantiateParams;

1944

1945

1949typedef struct hipMemAllocationProp {

1950 hipMemAllocationType type;

1951 union {

1952 hipMemAllocationHandleType requestedHandleType;

1953 hipMemAllocationHandleType requestedHandleTypes;

1954 };

1955 hipMemLocation location;

1956 void* win32HandleMetaData;

1957 struct {

1958 unsigned char compressionType;

1959 unsigned char gpuDirectRDMACapable;

1960 unsigned short usage;

1961 } allocFlags;

1962} hipMemAllocationProp;

1963

1967typedef struct hipExternalSemaphoreSignalNodeParams {

1969 hipExternalSemaphore_t* extSemArray;

1971 const hipExternalSemaphoreSignalParams* paramsArray;

1973 unsigned int numExtSems;

1974} hipExternalSemaphoreSignalNodeParams;

1975

1979typedef struct hipExternalSemaphoreWaitNodeParams {

1981 hipExternalSemaphore_t* extSemArray;

1983 const hipExternalSemaphoreWaitParams* paramsArray;

1985 unsigned int numExtSems;

1986} hipExternalSemaphoreWaitNodeParams;

1987

1991typedef struct ihipMemGenericAllocationHandle* hipMemGenericAllocationHandle_t;

1992

1996typedef enum hipMemAllocationGranularity_flags {

1997 hipMemAllocationGranularityMinimum = 0x0,

1998 hipMemAllocationGranularityRecommended = 0x1

1999} hipMemAllocationGranularity_flags;

2000

2004typedef enum hipMemHandleType {

2005 hipMemHandleTypeGeneric = 0x0

2006} hipMemHandleType;

2007

2011typedef enum hipMemOperationType {

2012 hipMemOperationTypeMap = 0x1,

2013 hipMemOperationTypeUnmap = 0x2

2014} hipMemOperationType;

2015

2019typedef enum hipArraySparseSubresourceType {

2020 hipArraySparseSubresourceTypeSparseLevel = 0x0,

2021 hipArraySparseSubresourceTypeMiptail = 0x1

2022} hipArraySparseSubresourceType;

2023

2027typedef struct hipArrayMapInfo {

2028 hipResourceType resourceType;

2029 union {

2030 hipMipmappedArray mipmap;

2031 hipArray_t array;

2032 } resource;

2033 hipArraySparseSubresourceType subresourceType;

2034 union {

2035 struct {

2036 unsigned int

2037 level;

2038 unsigned int

2039 layer;

2040 unsigned int offsetX;

2041 unsigned int offsetY;

2042 unsigned int offsetZ;

2043 unsigned int extentWidth;

2044 unsigned int extentHeight;

2045 unsigned int extentDepth;

2046 } sparseLevel;

2047 struct {

2048 unsigned int

2049 layer;

2050 unsigned long long offset;

2051 unsigned long long size;

2052 } miptail;

2053 } subresource;

2054 hipMemOperationType memOperationType;

2055 hipMemHandleType memHandleType;

2056 union {

2057 hipMemGenericAllocationHandle_t memHandle;

2058 } memHandle;

2059 unsigned long long offset;

2060 unsigned int deviceBitMask;

2061 unsigned int flags;

2062 unsigned int reserved[2];

2063} hipArrayMapInfo;

2064

2068typedef struct hipMemcpyNodeParams {

2069 int flags;

2070 int reserved[3];

2071 hipMemcpy3DParms copyParams;

2072} hipMemcpyNodeParams;

2073

2077typedef struct hipChildGraphNodeParams {

2078 hipGraph_t graph;

2080} hipChildGraphNodeParams;

2081

2085typedef struct hipEventWaitNodeParams {

2086 hipEvent_t event;

2087} hipEventWaitNodeParams;

2088

2092typedef struct hipEventRecordNodeParams {

2093 hipEvent_t event;

2094} hipEventRecordNodeParams;

2095

2099typedef struct hipMemFreeNodeParams {

2100 void* dptr;

2101} hipMemFreeNodeParams;

2102

2106typedef struct hipGraphNodeParams {

2107 hipGraphNodeType type;

2108 int reserved0[3];

2109 union {

2110 long long reserved1[29];

2111 hipKernelNodeParams kernel;

2112 hipMemcpyNodeParams memcpy;

2113 hipMemsetParams memset;

2114 hipHostNodeParams host;

2115 hipChildGraphNodeParams graph;

2116 hipEventWaitNodeParams eventWait;

2117 hipEventRecordNodeParams eventRecord;

2118 hipExternalSemaphoreSignalNodeParams extSemSignal;

2119 hipExternalSemaphoreWaitNodeParams extSemWait;

2120 hipMemAllocNodeParams alloc;

2121 hipMemFreeNodeParams free;

2122 };

2123

2124 long long reserved2;

2125} hipGraphNodeParams;

2126

2130#define hipGraphKernelNodePortDefault 0

2131

2135#define hipGraphKernelNodePortLaunchCompletion 2

2136

2142#define hipGraphKernelNodePortProgrammatic 1

2143

2144typedef enum hipGraphDependencyType {

2145 hipGraphDependencyTypeDefault = 0,

2146 hipGraphDependencyTypeProgrammatic = 1

2147} hipGraphDependencyType;

2148

2149typedef struct hipGraphEdgeData {

2150 unsigned char

2151 from_port;

2158 unsigned char reserved[5];

2159 unsigned char

2160 to_port;

2161 unsigned char type;

2162} hipGraphEdgeData;

2163

2164

2168typedef struct hipLaunchAttribute_st {

2169 hipLaunchAttributeID id;

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

2171 union {

2172 hipLaunchAttributeValue val;

2173 hipLaunchAttributeValue value;

2174 };

2175} hipLaunchAttribute;

2176

2180typedef struct hipLaunchConfig_st {

2181 dim3 gridDim;

2182 dim3 blockDim;

2183 size_t dynamicSmemBytes;

2184 hipStream_t stream;

2185 hipLaunchAttribute* attrs;

2186 unsigned int numAttrs;

2187} hipLaunchConfig_t;

2188

2192typedef struct HIP_LAUNCH_CONFIG_st {

2193 unsigned int gridDimX;

2194 unsigned int gridDimY;

2195 unsigned int gridDimZ;

2196 unsigned int blockDimX;

2197 unsigned int blockDimY;

2198 unsigned int blockDimZ;

2199 unsigned int sharedMemBytes;

2200 hipStream_t hStream;

2201 hipLaunchAttribute* attrs;

2202 unsigned int numAttrs;

2203} HIP_LAUNCH_CONFIG;

2204

2208typedef struct hipArrayMemoryRequirements {

2209 size_t alignment;

2210 size_t size;

2211} hipArrayMemoryRequirements;

2212

2216typedef enum hipMemRangeHandleType {

2217 hipMemRangeHandleTypeDmaBufFd = 0x1,

2218 hipMemRangeHandleTypeMax = 0x7fffffff

2219} hipMemRangeHandleType;

2220

2224typedef enum hipMemRangeFlags {

2225 hipMemRangeFlagDmaBufMappingTypePcie = 0x1,

2226 hipMemRangeFlagsMax = 0x7fffffff

2227} hipMemRangeFlags;

2228

2229

2230// Doxygen end group GlobalDefs

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

2263hipError_t hipInit(unsigned int flags);

2264

2282hipError_t hipDriverGetVersion(int* driverVersion);

2297hipError_t hipRuntimeGetVersion(int* runtimeVersion);

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

2306

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

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

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

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

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

2361 int dstDevice);

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

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

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

2387// doxygen end initialization

2406hipError_t hipDeviceSynchronize(void);

2418hipError_t hipDeviceReset(void);

2450hipError_t hipSetDevice(int deviceId);

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

2477hipError_t hipGetDevice(int* deviceId);

2490hipError_t hipGetDeviceCount(int* count);

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

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

2537hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool);

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

2558

2559// hipDeviceProp_t and hipGetDeviceProperties/hipChooseDevice are versioned.

2560// See HIP_FORCE_API_VERSION in hip_common.h.

2561

2562#if HIP_FORCE_API_VERSION >= 600

2563

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

2565

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

2580 return hipGetDevicePropertiesR0600(prop, deviceId);

2581}

2582

2583#endif

2584

2585

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

2603 int device);

2615hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig);

2626hipError_t hipDeviceGetCacheConfig(hipFuncCache_t* cacheConfig);

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

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

2672hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig* pConfig);

2680hipError_t hipGetDeviceFlags(unsigned int* flags);

2692hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config);

2724hipError_t hipSetDeviceFlags(unsigned flags);

2725

2726#if HIP_FORCE_API_VERSION >= 600

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

2728

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

2738 return hipChooseDeviceR0600(device, prop);

2739}

2740

2741#endif

2742

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

2768

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

2783 uint32_t* hopcount);

2784// TODO: implement IPC apis

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

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

2862hipError_t hipIpcCloseMemHandle(void* devPtr);

2863

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

2881

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

2901

2902// end doxygen Device

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

2927

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

2944

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

2954

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

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

2981// doxygen end execution

3003hipError_t hipGetLastError(void);

3004

3016hipError_t hipExtGetLastError(void);

3017

3028hipError_t hipPeekAtLastError(void);

3037const char* hipGetErrorName(hipError_t hip_error);

3046const char* hipGetErrorString(hipError_t hipError);

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

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

3067// end doxygen Error

3100hipError_t hipStreamCreate(hipStream_t* stream);

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

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

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

3180hipError_t hipStreamDestroy(hipStream_t stream);

3196hipError_t hipStreamQuery(hipStream_t stream);

3218hipError_t hipStreamSynchronize(hipStream_t stream);

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

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

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

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

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

3307hipError_t hipExtStreamCreateWithCUMask(hipStream_t* stream, uint32_t cuMaskSize,

3308 const uint32_t* cuMask);

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

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

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

3342 unsigned int flags);

3343

3351hipError_t hipStreamSetAttribute(hipStream_t stream, hipStreamAttrID attr,

3352 const hipStreamAttrValue* value);

3353

3361hipError_t hipStreamGetAttribute(hipStream_t stream, hipStreamAttrID attr,

3362 hipStreamAttrValue* value_out);

3363

3370hipError_t hipStreamCopyAttributes(hipStream_t dst, hipStream_t src);

3371

3372// end doxygen Stream

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

3421 uint32_t mask __dparm(0xFFFFFFFF));

3422

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

3460 uint64_t mask __dparm(0xFFFFFFFFFFFFFFFF));

3461

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

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

3504

3524hipError_t hipStreamBatchMemOp(hipStream_t stream, unsigned int count,

3525 hipStreamBatchMemOpParams* paramArray, unsigned int flags);

3526

3544hipError_t hipGraphAddBatchMemOpNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

3545 const hipGraphNode_t* dependencies, size_t numDependencies,

3546 const hipBatchMemOpNodeParams* nodeParams);

3547

3568hipError_t hipGraphBatchMemOpNodeGetParams(hipGraphNode_t hNode,

3569 hipBatchMemOpNodeParams* nodeParams_out);

3570

3588hipError_t hipGraphBatchMemOpNodeSetParams(hipGraphNode_t hNode,

3589 hipBatchMemOpNodeParams* nodeParams);

3590

3610hipError_t hipGraphExecBatchMemOpNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

3611 const hipBatchMemOpNodeParams* nodeParams);

3612

3613// end doxygen Stream Memory Operations

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

3661hipError_t hipEventCreate(hipEvent_t* event);

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

3699 unsigned int flags __dparm(0));

3730#ifdef __cplusplus

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

3732#else

3733hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream);

3734#endif

3751hipError_t hipEventDestroy(hipEvent_t event);

3770hipError_t hipEventSynchronize(hipEvent_t event);

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

3816hipError_t hipEventQuery(hipEvent_t event);

3817// end doxygen Events

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

3849 hipDeviceptr_t ptr);

3850

3851

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

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

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

3904 void** data, hipDeviceptr_t ptr);

3928hipError_t hipImportExternalSemaphore(hipExternalSemaphore_t* extSem_out,

3929 const hipExternalSemaphoreHandleDesc* semHandleDesc);

3945hipError_t hipSignalExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

3946 const hipExternalSemaphoreSignalParams* paramsArray,

3947 unsigned int numExtSems, hipStream_t stream);

3963hipError_t hipWaitExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

3964 const hipExternalSemaphoreWaitParams* paramsArray,

3965 unsigned int numExtSems, hipStream_t stream);

3979hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem);

3980

3992hipError_t hipImportExternalMemory(hipExternalMemory_t* extMem_out,

3993 const hipExternalMemoryHandleDesc* memHandleDesc);

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

4006 const hipExternalMemoryBufferDesc* bufferDesc);

4016hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem);

4031hipError_t hipExternalMemoryGetMappedMipmappedArray(

4032 hipMipmappedArray_t* mipmap, hipExternalMemory_t extMem,

4033 const hipExternalMemoryMipmappedArrayDesc* mipmapDesc);

4034// end of external resource

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

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

4072

4073

4096HIP_DEPRECATED("use hipHostMalloc instead")

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

4110HIP_DEPRECATED("use hipHostMalloc instead")

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

4112// end doxygen deprecated management memory

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

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

4185 unsigned int flags __dparm(hipMemAttachGlobal));

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

4199 hipStream_t stream __dparm(0));

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

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

4215

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

4233 hipMemLocation* prefetch_locs, size_t* prefetch_loc_idxs,

4234 size_t num_prefetch_locs, unsigned long long flags,

4235 hipStream_t stream);

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

4261 unsigned long long flags, hipStream_t stream);

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

4283 unsigned long long flags, hipStream_t stream);

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

4314 hipMemLocation* prefetchLocs,

4315 size_t* prefetchLocIdxs,

4316 size_t numPrefetchLocs,

4317 unsigned long long flags, hipStream_t stream);

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

4337 hipMemLocation* prefetchLocs,

4338 size_t* prefetchLocIdxs,

4339 size_t numPrefetchLocs,

4340 unsigned long long flags, hipStream_t stream);

4341

4342// Deprecated since 800. Introduced in 700.

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

4344

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

4365 hipMemLocation location);

4366

4367#endif

4368

4369// Deprecated since 800.

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

4371

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

4392

4393#endif

4394

4395// Latest

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

4397

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

4399 hipMemLocation location);

4400

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

4422 hipMemLocation location) {

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

4424}

4425

4426#endif

4427

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

4443 const void* dev_ptr, size_t count);

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

4461 hipMemRangeAttribute* attributes, size_t num_attributes,

4462 const void* dev_ptr, size_t count);

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

4479 unsigned int flags __dparm(hipMemAttachSingle));

4480// end doxygen Managed Memory

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

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

4593hipError_t hipMemPoolTrimTo(hipMemPool_t mem_pool, size_t min_bytes_to_hold);

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

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

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

4692 size_t count);

4712hipError_t hipMemPoolGetAccess(hipMemAccessFlags* flags, hipMemPool_t mem_pool,

4713 hipMemLocation* location);

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

4766hipError_t hipMemPoolDestroy(hipMemPool_t mem_pool);

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

4803 hipStream_t stream);

4830hipError_t hipMemPoolExportToShareableHandle(void* shared_handle, hipMemPool_t mem_pool,

4831 hipMemAllocationHandleType handle_type,

4832 unsigned int flags);

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

4857 hipMemAllocationHandleType handle_type,

4858 unsigned int flags);

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

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

4908 hipMemPoolPtrExportData* export_data);

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

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

4921 hipMemAllocationType type);

4922

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

4935 hipMemAllocationType type);

4936

4937// Doxygen end of Stream Ordered Memory Allocator

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

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

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

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

5030hipError_t hipHostUnregister(void* hostPtr);

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

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

5073 unsigned int elementSizeBytes);

5087hipError_t hipFree(void* ptr);

5099hipError_t hipFreeHost(void* ptr);

5116hipError_t hipHostFree(void* ptr);

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

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

5165 hipStream_t stream);

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

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

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

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

5239 size_t ByteCount);

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

5259 size_t ByteCount);

5260

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

5281 size_t srcOffset, size_t ByteCount);

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

5301 hipStream_t stream);

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

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

5340 hipStream_t stream);

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

5361 size_t ByteCount, hipStream_t stream);

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

5382 size_t ByteCount, hipStream_t stream);

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

5400 const char* name);

5401

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

5412

5413

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

5424

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

5445 hipDriverProcAddressQueryResult* symbolStatus);

5446

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

5469 size_t offset __dparm(0),

5470 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice));

5471

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

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

5487

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

5501 size_t offset __dparm(0),

5502 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost));

5503

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

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

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

5548 hipStream_t stream __dparm(0));

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

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

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

5585 hipStream_t stream __dparm(0));

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

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

5612 hipStream_t stream __dparm(0));

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

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

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

5655 hipStream_t stream __dparm(0));

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

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

5679 hipStream_t stream __dparm(0));

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

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

5699 hipStream_t stream __dparm(0));

5700

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

5713 size_t height);

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

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

5728

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

5741 size_t height);

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

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

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

5768 size_t height);

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

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

5783

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

5801

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

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

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

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

5848hipError_t hipArrayDestroy(hipArray_t array);

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

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

5879hipError_t hipFreeArray(hipArray_t array);

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

5892 struct hipExtent extent, unsigned int flags);

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

5906 hipArray_t array);

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

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

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

5978 size_t height, hipMemcpyKind kind);

5988hipError_t hipMemcpyParam2D(const hip_Memcpy2D* pCopy);

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

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

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

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

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

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

6080 size_t spitch, size_t width, size_t height, hipMemcpyKind kind,

6081 hipStream_t stream __dparm(0));

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

6101 hipArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc,

6102 size_t width, size_t height, hipMemcpyKind kind);

6121HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6123 size_t count, hipMemcpyKind kind);

6142HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6144 size_t count, hipMemcpyKind kind);

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

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

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

6183 size_t hOffset, size_t width, size_t height,

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

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

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

6223hipError_t hipMemcpy3D(const struct hipMemcpy3DParms* p);

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

6246hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D* pCopy);

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

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

6272

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

6289 hipMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs,

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

6291

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

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

6306

6315hipError_t hipMemcpy3DPeer(hipMemcpy3DPeerParms* p);

6316

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

6326

6342hipError_t hipMipmappedArrayGetMemoryRequirements(hipArrayMemoryRequirements* memoryRequirements,

6343 hipMipmappedArray_t mipmap, hipDevice_t device);

6344// doxygen end Memory

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

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

6405hipError_t hipDeviceDisablePeerAccess(int peerDeviceId);

6406

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

6419 size_t sizeBytes);

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

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

6434

6435// doxygen end PeerToPeer

6456hipError_t hipDeviceGetDevResource(hipDevice_t device, hipDevResource* resource,

6457 hipDevResourceType type);

6458

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

6475 const hipDevResource* input, hipDevResource* remainder,

6476 unsigned int flags, unsigned int minCount);

6477

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

6495 const hipDevResource* input, hipDevResource* remainder,

6496 unsigned int flags,

6497 hipDevSmResourceGroupParams* groupParams);

6498

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

6510 unsigned int nbResources);

6511

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

6524 unsigned int flags);

6525

6533hipError_t hipExecutionCtxDestroy(hipExecutionCtx_t ctx);

6534

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

6544

6555hipError_t hipExecutionCtxStreamCreate(hipStream_t* stream, hipExecutionCtx_t greenctx,

6556 unsigned int flags, int priority);

6557

6567hipError_t hipExecutionCtxGetDevResource(hipExecutionCtx_t ctx, hipDevResource* resource,

6568 hipDevResourceType type);

6569

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

6579

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

6589

6599hipError_t hipStreamGetDevResource(hipStream_t hStream, hipDevResource* resource,

6600 hipDevResourceType type);

6601

6610hipError_t hipExecutionCtxRecordEvent(hipExecutionCtx_t ctx, hipEvent_t event);

6611

6619hipError_t hipExecutionCtxSynchronize(hipExecutionCtx_t ctx);

6620

6629hipError_t hipExecutionCtxWaitEvent(hipExecutionCtx_t ctx, hipEvent_t event);

6671HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6686HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6687hipError_t hipCtxDestroy(hipCtx_t ctx);

6701HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6702hipError_t hipCtxPopCurrent(hipCtx_t* ctx);

6716HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6717hipError_t hipCtxPushCurrent(hipCtx_t ctx);

6731HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6732hipError_t hipCtxSetCurrent(hipCtx_t ctx);

6746HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6747hipError_t hipCtxGetCurrent(hipCtx_t* ctx);

6761HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6762hipError_t hipCtxGetDevice(hipDevice_t* device);

6783HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6801HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6802hipError_t hipCtxGetCacheConfig(hipFuncCache_t* cacheConfig);

6819HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6820hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig);

6837HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6838hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config);

6855HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6856hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig* pConfig);

6871HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6872hipError_t hipCtxSynchronize(void);

6886HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6887hipError_t hipCtxGetFlags(unsigned int* flags);

6910HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6931HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6932hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx);

6933

6949HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6966HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6967hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev);

6982HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6997HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6998hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev);

7013HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7015// doxygen end Context Management

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

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

7063hipError_t hipModuleUnload(hipModule_t module);

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

7075

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

7086

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

7115 hipDevice_t dev);

7116

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

7131 void** jitOptionsValues, unsigned int numJitOptions,

7132 hipLibraryOption* libraryOptions, void** libraryOptionValues,

7133 unsigned int numLibraryOptions);

7134

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

7149 hipJitOption* jitOptions, void** jitOptionsValues,

7150 unsigned int numJitOptions, hipLibraryOption* libraryOptions,

7151 void** libraryOptionValues, unsigned int numLibraryOptions);

7152

7159hipError_t hipLibraryUnload(hipLibrary_t library);

7160

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

7170

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

7179

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

7195 const char* name);

7196

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

7214 const char* name);

7215

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

7225 hipLibrary_t library);

7226

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

7235

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

7244

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

7256 size_t* paramSize);

7257

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

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

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

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

7299 hipDriverEntryPointQueryResult* driverStatus);

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

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

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

7347 hipJitOption* options, void** optionValues);

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

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

7368 void** optionValues);

7369

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

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

7388

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

7404

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

7417 hipLinkState_t* stateOut);

7426hipError_t hipLinkDestroy(hipLinkState_t state);

7427

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

7457 unsigned int gridDimZ, unsigned int blockDimX,

7458 unsigned int blockDimY, unsigned int blockDimZ,

7459 unsigned int sharedMemBytes, hipStream_t stream,

7460 void** kernelParams, void** extra);

7489hipError_t hipModuleLaunchCooperativeKernel(hipFunction_t f, unsigned int gridDimX,

7490 unsigned int gridDimY, unsigned int gridDimZ,

7491 unsigned int blockDimX, unsigned int blockDimY,

7492 unsigned int blockDimZ, unsigned int sharedMemBytes,

7493 hipStream_t stream, void** kernelParams);

7508hipError_t hipModuleLaunchCooperativeKernelMultiDevice(hipFunctionLaunchParams* launchParamsList,

7509 unsigned int numDevices, unsigned int flags);

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

7531 void** kernelParams, unsigned int sharedMemBytes,

7532 hipStream_t stream);

7544hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList, int numDevices,

7545 unsigned int flags);

7546

7547// Doxygen end group ModuleCooperativeG

7561hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList, int numDevices,

7562 unsigned int flags);

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

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

7593 void** extra);

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

7609 hipMemRangeHandleType handleType,

7610 unsigned long long flags);

7611// doxygen end Module

7639// TODO - Match CUoccupancyB2DSize

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

7641 size_t dynSharedMemPerBlk, int blockSizeLimit);

7657// TODO - Match CUoccupancyB2DSize

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

7659 hipFunction_t f,

7660 size_t dynSharedMemPerBlk,

7661 int blockSizeLimit, unsigned int flags);

7671hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, hipFunction_t f,

7672 int blockSize,

7673 size_t dynSharedMemPerBlk);

7684hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

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

7696 int blockSize, size_t dynSharedMemPerBlk);

7707hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

7709 unsigned int flags __dparm(hipOccupancyDefault));

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

7725 size_t dynSharedMemPerBlk, int blockSizeLimit);

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

7742 int numBlocks, int blockSize);

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

7754 const hipLaunchConfig_t* config);

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

7766 const hipLaunchConfig_t* config);

7767

7768// doxygen end Occupancy

7782// TODO - expand descriptions:

7789HIP_DEPRECATED("use roctracer/rocTX instead")

7790hipError_t hipProfilerStart();

7797HIP_DEPRECATED("use roctracer/rocTX instead")

7798hipError_t hipProfilerStop();

7799// doxygen end profiler

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

7827 hipStream_t stream __dparm(0));

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

7847hipError_t hipLaunchByPtr(const void* func);

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

7865 hipStream_t stream __dparm(0));

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

7886 hipStream_t* stream);

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

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

7905 hipStream_t stream __dparm(0));

7906

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

7934

7942hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D* pCopy);

7943// TODO: Move this to hip_ext.h

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

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

7967 hipEvent_t startEvent, hipEvent_t stopEvent, int flags);

7968// doxygen end Clang launch

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

7995 const hipTextureDesc* pTexDesc,

7996 const struct hipResourceViewDesc* pResViewDesc);

7997

8006hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject);

8007

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

8018

8028hipError_t hipGetTextureObjectResourceDesc(hipResourceDesc* pResDesc,

8029 hipTextureObject_t textureObject);

8030

8040hipError_t hipGetTextureObjectResourceViewDesc(struct hipResourceViewDesc* pResViewDesc,

8041 hipTextureObject_t textureObject);

8042

8052hipError_t hipGetTextureObjectTextureDesc(hipTextureDesc* pTexDesc,

8053 hipTextureObject_t textureObject);

8054

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

8067 const HIP_TEXTURE_DESC* pTexDesc,

8068 const HIP_RESOURCE_VIEW_DESC* pResViewDesc);

8069

8078hipError_t hipTexObjectDestroy(hipTextureObject_t texObject);

8079

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

8090

8100hipError_t hipTexObjectGetResourceViewDesc(HIP_RESOURCE_VIEW_DESC* pResViewDesc,

8101 hipTextureObject_t texObject);

8102

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

8113

8128hipError_t hipMallocMipmappedArray(hipMipmappedArray_t* mipmappedArray,

8129 const struct hipChannelFormatDesc* desc, struct hipExtent extent,

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

8131

8142hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray);

8143

8156hipError_t hipGetMipmappedArrayLevel(hipArray_t* levelArray,

8157 hipMipmappedArray_const_t mipmappedArray, unsigned int level);

8158

8170hipError_t hipMipmappedArrayCreate(hipMipmappedArray_t* pHandle,

8171 HIP_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc,

8172 unsigned int numMipmapLevels);

8173

8184hipError_t hipMipmappedArrayDestroy(hipMipmappedArray_t hMipmappedArray);

8185

8198hipError_t hipMipmappedArrayGetLevel(hipArray_t* pLevelArray, hipMipmappedArray_t hMipMappedArray,

8199 unsigned int level);

8200

8219HIP_DEPRECATED(HIP_DEPRECATED_MSG)

8220hipError_t hipBindTextureToMipmappedArray(const textureReference* tex,

8221 hipMipmappedArray_const_t mipmappedArray,

8222 const hipChannelFormatDesc* desc);

8223

8234HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8236

8247HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8249

8261HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8263

8275HIP_DEPRECATED(HIP_DEPRECATED_MSG)

8276hipError_t hipTexRefSetAddressMode(textureReference* texRef, int dim,

8277 enum hipTextureAddressMode am);

8290HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8303HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8316HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8330HIP_DEPRECATED(HIP_DEPRECATED_MSG)

8331hipError_t hipTexRefSetFormat(textureReference* texRef, hipArray_Format fmt,

8332 int NumPackedComponents);

8347HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

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

8366HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

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

8369 size_t pitch);

8382HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8384 const hipChannelFormatDesc* desc);

8396HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8408HIP_DEPRECATED(HIP_DEPRECATED_MSG)

8409hipError_t hipUnbindTexture(const textureReference* tex);

8421HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8435HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8437 int dim);

8449HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8462HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8476HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8478 const textureReference* texRef);

8490HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8503HIP_DEPRECATED(HIP_DEPRECATED_MSG)

8504hipError_t hipTexRefGetMipmapFilterMode(enum hipTextureFilterMode* pfm,

8505 const textureReference* texRef);

8517HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8531HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8533 const textureReference* texRef);

8545HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8560HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8562 size_t bytes);

8576HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8578 hipDeviceptr_t dptr, size_t Pitch);

8590HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8603HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8616HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8629HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8643HIP_DEPRECATED(HIP_DEPRECATED_MSG)

8644hipError_t hipTexRefSetMipmapLevelClamp(textureReference* texRef, float minMipMapLevelClamp,

8645 float maxMipMapLevelClamp);

8658HIP_DEPRECATED(HIP_DEPRECATED_MSG)

8659hipError_t hipTexRefSetMipmappedArray(textureReference* texRef,

8660 struct hipMipmappedArray* mipmappedArray, unsigned int Flags);

8661

8662// doxygen end deprecated texture management

8667// doxygen end Texture management

8679// This group is for HIPrtc

8680

8681// doxygen end Runtime

8700const char* hipApiName(uint32_t id);

8709const char* hipKernelNameRef(const hipFunction_t f);

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

8728int hipGetStreamDeviceId(hipStream_t stream);

8729

8730// doxygen end Callback

8752hipError_t hipStreamBeginCapture(hipStream_t stream, hipStreamCaptureMode mode);

8753

8773hipError_t hipStreamBeginCaptureToGraph(hipStream_t stream, hipGraph_t graph,

8774 const hipGraphNode_t* dependencies,

8775 const hipGraphEdgeData* dependencyData,

8776 size_t numDependencies, hipStreamCaptureMode mode);

8777

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

8788

8799hipError_t hipStreamGetCaptureInfo(hipStream_t stream, hipStreamCaptureStatus* pCaptureStatus,

8800 unsigned long long* pId);

8801

8816hipError_t hipStreamGetCaptureInfo_v2(hipStream_t stream, hipStreamCaptureStatus* captureStatus_out,

8817 unsigned long long* id_out __dparm(0),

8818 hipGraph_t* graph_out __dparm(0),

8819 const hipGraphNode_t** dependencies_out __dparm(0),

8820 size_t* numDependencies_out __dparm(0));

8821

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

8832

8844hipError_t hipStreamUpdateCaptureDependencies(hipStream_t stream, hipGraphNode_t* dependencies,

8845 size_t numDependencies,

8846 unsigned int flags __dparm(0));

8847

8855hipError_t hipThreadExchangeStreamCaptureMode(hipStreamCaptureMode* mode);

8856

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

8867

8876hipError_t hipGraphDestroy(hipGraph_t graph);

8877

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

8889 const hipGraphNode_t* to, size_t numDependencies);

8890

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

8902 const hipGraphNode_t* to, size_t numDependencies);

8903

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

8920 size_t* numEdges);

8921

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

8937

8952hipError_t hipGraphGetRootNodes(hipGraph_t graph, hipGraphNode_t* pRootNodes,

8953 size_t* pNumRootNodes);

8954

8969hipError_t hipGraphNodeGetDependencies(hipGraphNode_t node, hipGraphNode_t* pDependencies,

8970 size_t* pNumDependencies);

8971

8987hipError_t hipGraphNodeGetDependentNodes(hipGraphNode_t node, hipGraphNode_t* pDependentNodes,

8988 size_t* pNumDependentNodes);

8989

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

8999

9007hipError_t hipGraphDestroyNode(hipGraphNode_t node);

9008

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

9018

9028hipError_t hipGraphNodeFindInClone(hipGraphNode_t* pNode, hipGraphNode_t originalNode,

9029 hipGraph_t clonedGraph);

9030

9044hipError_t hipGraphInstantiate(hipGraphExec_t* pGraphExec, hipGraph_t graph,

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

9046

9057hipError_t hipGraphInstantiateWithFlags(hipGraphExec_t* pGraphExec, hipGraph_t graph,

9058 unsigned long long flags);

9059

9069hipError_t hipGraphInstantiateWithParams(hipGraphExec_t* pGraphExec, hipGraph_t graph,

9070 hipGraphInstantiateParams* instantiateParams);

9079hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream);

9080

9089hipError_t hipGraphUpload(hipGraphExec_t graphExec, hipStream_t stream);

9090

9102hipError_t hipGraphAddNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9103 const hipGraphNode_t* pDependencies, size_t numDependencies,

9104 hipGraphNodeParams* nodeParams);

9105

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

9115

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

9126

9137hipError_t hipGraphExecNodeSetParams(hipGraphExec_t graphExec, hipGraphNode_t node,

9138 hipGraphNodeParams* nodeParams);

9139

9148hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec);

9149

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

9162hipError_t hipGraphExecUpdate(hipGraphExec_t hGraphExec, hipGraph_t hGraph,

9163 hipGraphNode_t* hErrorNode_out,

9164 hipGraphExecUpdateResult* updateResult_out);

9165

9177hipError_t hipGraphAddKernelNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9178 const hipGraphNode_t* pDependencies, size_t numDependencies,

9179 const hipKernelNodeParams* pNodeParams);

9180

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

9190

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

9200

9210hipError_t hipGraphExecKernelNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

9211 const hipKernelNodeParams* pNodeParams);

9212

9225hipError_t hipDrvGraphAddMemcpyNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

9226 const hipGraphNode_t* dependencies, size_t numDependencies,

9227 const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);

9239hipError_t hipGraphAddMemcpyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9240 const hipGraphNode_t* pDependencies, size_t numDependencies,

9241 const hipMemcpy3DParms* pCopyParams);

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

9251

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

9261

9271hipError_t hipGraphKernelNodeSetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

9272 const hipKernelNodeAttrValue* value);

9282hipError_t hipGraphKernelNodeGetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

9283 hipKernelNodeAttrValue* value);

9293hipError_t hipGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

9294 hipMemcpy3DParms* pNodeParams);

9295

9310hipError_t hipGraphAddMemcpyNode1D(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9311 const hipGraphNode_t* pDependencies, size_t numDependencies,

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

9313

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

9326 size_t count, hipMemcpyKind kind);

9327

9341hipError_t hipGraphExecMemcpyNodeSetParams1D(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

9343 hipMemcpyKind kind);

9344

9360hipError_t hipGraphAddMemcpyNodeFromSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9361 const hipGraphNode_t* pDependencies,

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

9363 size_t count, size_t offset, hipMemcpyKind kind);

9364

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

9378 size_t count, size_t offset, hipMemcpyKind kind);

9379

9394hipError_t hipGraphExecMemcpyNodeSetParamsFromSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

9396 size_t offset, hipMemcpyKind kind);

9397

9413hipError_t hipGraphAddMemcpyNodeToSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9414 const hipGraphNode_t* pDependencies,

9415 size_t numDependencies, const void* symbol,

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

9417 hipMemcpyKind kind);

9418

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

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

9433 hipMemcpyKind kind);

9434

9435

9449hipError_t hipGraphExecMemcpyNodeSetParamsToSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

9450 const void* symbol, const void* src,

9451 size_t count, size_t offset, hipMemcpyKind kind);

9452

9464hipError_t hipGraphAddMemsetNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9465 const hipGraphNode_t* pDependencies, size_t numDependencies,

9466 const hipMemsetParams* pMemsetParams);

9467

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

9477

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

9487

9497hipError_t hipGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

9498 const hipMemsetParams* pNodeParams);

9499

9511hipError_t hipGraphAddHostNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9512 const hipGraphNode_t* pDependencies, size_t numDependencies,

9513 const hipHostNodeParams* pNodeParams);

9514

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

9524

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

9534

9544hipError_t hipGraphExecHostNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

9545 const hipHostNodeParams* pNodeParams);

9546

9558hipError_t hipGraphAddChildGraphNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9559 const hipGraphNode_t* pDependencies, size_t numDependencies,

9560 hipGraph_t childGraph);

9561

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

9571

9581hipError_t hipGraphExecChildGraphNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

9582 hipGraph_t childGraph);

9583

9594hipError_t hipGraphAddEmptyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9595 const hipGraphNode_t* pDependencies, size_t numDependencies);

9596

9597

9609hipError_t hipGraphAddEventRecordNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9610 const hipGraphNode_t* pDependencies, size_t numDependencies,

9611 hipEvent_t event);

9612

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

9622

9631hipError_t hipGraphEventRecordNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

9632

9642hipError_t hipGraphExecEventRecordNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9643 hipEvent_t event);

9644

9656hipError_t hipGraphAddEventWaitNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9657 const hipGraphNode_t* pDependencies, size_t numDependencies,

9658 hipEvent_t event);

9659

9660

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

9670

9679hipError_t hipGraphEventWaitNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

9680

9690hipError_t hipGraphExecEventWaitNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9691 hipEvent_t event);

9692

9705hipError_t hipGraphAddMemAllocNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9706 const hipGraphNode_t* pDependencies, size_t numDependencies,

9707 hipMemAllocNodeParams* pNodeParams);

9708

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

9718

9730hipError_t hipGraphAddMemFreeNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9731 const hipGraphNode_t* pDependencies, size_t numDependencies,

9732 void* dev_ptr);

9733

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

9743

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

9754

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

9765

9773hipError_t hipDeviceGraphMemTrim(int device);

9774

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

9787 unsigned int initialRefcount, unsigned int flags);

9788

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

9798

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

9808

9819hipError_t hipGraphRetainUserObject(hipGraph_t graph, hipUserObject_t object,

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

9821

9831hipError_t hipGraphReleaseUserObject(hipGraph_t graph, hipUserObject_t object,

9832 unsigned int count __dparm(1));

9833

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

9844

9858hipError_t hipGraphKernelNodeCopyAttributes(hipGraphNode_t hSrc, hipGraphNode_t hDst);

9859

9881hipError_t hipGraphNodeSetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9882 unsigned int isEnabled);

9902hipError_t hipGraphNodeGetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9903 unsigned int* isEnabled);

9904

9916hipError_t hipGraphAddExternalSemaphoresWaitNode(

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

9918 size_t numDependencies, const hipExternalSemaphoreWaitNodeParams* nodeParams);

9919

9931hipError_t hipGraphAddExternalSemaphoresSignalNode(

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

9933 size_t numDependencies, const hipExternalSemaphoreSignalNodeParams* nodeParams);

9942hipError_t hipGraphExternalSemaphoresSignalNodeSetParams(

9943 hipGraphNode_t hNode, const hipExternalSemaphoreSignalNodeParams* nodeParams);

9952hipError_t hipGraphExternalSemaphoresWaitNodeSetParams(

9953 hipGraphNode_t hNode, const hipExternalSemaphoreWaitNodeParams* nodeParams);

9962hipError_t hipGraphExternalSemaphoresSignalNodeGetParams(

9963 hipGraphNode_t hNode, hipExternalSemaphoreSignalNodeParams* params_out);

9972hipError_t hipGraphExternalSemaphoresWaitNodeGetParams(

9973 hipGraphNode_t hNode, hipExternalSemaphoreWaitNodeParams* params_out);

9983hipError_t hipGraphExecExternalSemaphoresSignalNodeSetParams(

9984 hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9985 const hipExternalSemaphoreSignalNodeParams* nodeParams);

9995hipError_t hipGraphExecExternalSemaphoresWaitNodeSetParams(

9996 hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9997 const hipExternalSemaphoreWaitNodeParams* nodeParams);

9998

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

10008

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

10018

10031hipError_t hipDrvGraphAddMemsetNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

10032 const hipGraphNode_t* dependencies, size_t numDependencies,

10033 const hipMemsetParams* memsetParams, hipCtx_t ctx);

10034

10046hipError_t hipDrvGraphAddMemFreeNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

10047 const hipGraphNode_t* dependencies, size_t numDependencies,

10048 hipDeviceptr_t dptr);

10049

10060hipError_t hipDrvGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

10061 const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);

10062

10073hipError_t hipDrvGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

10074 const hipMemsetParams* memsetParams, hipCtx_t ctx);

10075

10076// doxygen end graph API

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

10106

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

10120 unsigned long long flags);

10121

10139hipError_t hipMemCreate(hipMemGenericAllocationHandle_t* handle, size_t size,

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

10141

10153hipError_t hipMemExportToShareableHandle(void* shareableHandle,

10154 hipMemGenericAllocationHandle_t handle,

10155 hipMemAllocationHandleType handleType,

10156 unsigned long long flags);

10157

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

10169

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

10182 hipMemAllocationGranularity_flags option);

10183

10193hipError_t hipMemGetAllocationPropertiesFromHandle(hipMemAllocationProp* prop,

10194 hipMemGenericAllocationHandle_t handle);

10195

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

10207 hipMemAllocationHandleType shHandleType);

10208

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

10222 unsigned long long flags);

10223

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

10233 hipStream_t stream);

10234

10244hipError_t hipMemRelease(hipMemGenericAllocationHandle_t handle);

10245

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

10256

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

10270

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

10281

10282// doxygen end virtual memory management API

10304hipError_t hipGraphicsMapResources(int count, hipGraphicsResource_t* resources,

10305 hipStream_t stream __dparm(0));

10319hipError_t hipGraphicsSubResourceGetMappedArray(hipArray_t* array, hipGraphicsResource_t resource,

10320 unsigned int arrayIndex, unsigned int mipLevel);

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

10332 hipGraphicsResource_t resource);

10343hipError_t hipGraphicsUnmapResources(int count, hipGraphicsResource_t* resources,

10344 hipStream_t stream __dparm(0));

10353hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource);

10354// doxygen end GraphicsInterop

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

10388hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject);

10389// end of surface

10390

10391

10402hipError_t hipExtEnableLogging();

10413hipError_t hipExtDisableLogging();

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

10429

10433#ifdef __cplusplus

10434} /* extern "c" */

10435#endif

10436#ifdef __cplusplus

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

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

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

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

10441 dynSharedMemPerBlk, blockSizeLimit);

10442}

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

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

10445 unsigned int flags = 0) {

10446 (void)flags;

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

10448 dynSharedMemPerBlk, blockSizeLimit);

10449}

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

10451

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

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

10463}

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

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

10476}

10477

10486template <typename T>

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

10488 size_t offset __dparm(0),

10489 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice)) {

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

10491}

10500template <typename T>

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

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

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

10504}

10512template <typename T>

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

10514 size_t offset __dparm(0),

10515 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost)) {

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

10517}

10525template <typename T>

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

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

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

10529}

10530

10542template <class T>

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

10544 size_t dynSharedMemPerBlk) {

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

10546 blockSize, dynSharedMemPerBlk);

10547}

10561template <class T> inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

10563 return hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

10565}

10588template <typename UnaryFunction, class T>

10589static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(

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

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

10592 if (min_grid_size == nullptr || block_size == nullptr ||

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

10594 return hipErrorInvalidValue;

10595 }

10596

10597 int dev;

10598 hipError_t status;

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

10600 return status;

10601 }

10602

10603 int max_threads_per_cu;

10604 if ((status = hipDeviceGetAttribute(&max_threads_per_cu,

10605 hipDeviceAttributeMaxThreadsPerMultiProcessor, dev)) !=

10606 hipSuccess) {

10607 return status;

10608 }

10609

10610 int warp_size;

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

10612 return status;

10613 }

10614

10615 int max_cu_count;

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

10617 hipSuccess) {

10618 return status;

10619 }

10620

10621 struct hipFuncAttributes attr;

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

10623 return status;

10624 }

10625

10626 // Initial limits for the execution

10627 const int func_max_threads_per_block = attr.maxThreadsPerBlock;

10628 if (block_size_limit == 0) {

10629 block_size_limit = func_max_threads_per_block;

10630 }

10631

10632 if (func_max_threads_per_block < block_size_limit) {

10633 block_size_limit = func_max_threads_per_block;

10634 }

10635

10636 const int block_size_limit_aligned =

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

10638

10639 // For maximum search

10640 int max_threads = 0;

10641 int max_block_size{};

10642 int max_num_blocks{};

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

10644 block_size_check_aligned -= warp_size) {

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

10646 int block_size_check =

10647 (block_size_limit < block_size_check_aligned) ? block_size_limit : block_size_check_aligned;

10648

10649 size_t dyn_smem_size = block_size_to_dynamic_smem_size(block_size_check);

10650 int optimal_blocks;

10651 if ((status = hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

10653 return status;

10654 }

10655

10656 int total_threads = block_size_check * optimal_blocks;

10657 if (total_threads > max_threads) {

10658 max_block_size = block_size_check;

10659 max_num_blocks = optimal_blocks;

10660 max_threads = total_threads;

10661 }

10662

10663 // Break if the logic reached possible maximum

10664 if (max_threads_per_cu == max_threads) {

10665 break;

10666 }

10667 }

10668

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

10670 *min_grid_size = max_num_blocks * max_cu_count;

10671 *block_size = max_block_size;

10672

10673 return status;

10674}

10675

10697template <typename UnaryFunction, class T>

10698static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMem(

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

10700 int block_size_limit = 0) {

10701 return hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(

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

10703}

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

10720 int* blockSize, F kernel,

10721 size_t dynSharedMemPerBlk,

10722 uint32_t blockSizeLimit) {

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

10724 dynSharedMemPerBlk, blockSizeLimit);

10725}

10726

10742template <typename F>

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

10744 int numBlocks, int blockSize) {

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

10746 numBlocks, blockSize);

10747}

10769template <class T>

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

10771 unsigned int sharedMemBytes, hipStream_t stream) {

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

10773 kernelParams, sharedMemBytes, stream);

10774}

10790template <class T>

10791inline hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

10792 unsigned int numDevices,

10793 unsigned int flags = 0) {

10794 return hipLaunchCooperativeKernelMultiDevice(launchParamsList, numDevices, flags);

10795}

10808template <class T>

10809inline hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

10810 unsigned int numDevices,

10811 unsigned int flags = 0) {

10812 return hipExtLaunchMultiKernelMultiDevice(launchParamsList, numDevices, flags);

10813}

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

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

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

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

10831}

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

10847static inline hipError_t

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

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

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

10851}

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

10868static inline hipError_t

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

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

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

10872}

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

10890static inline hipError_t

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

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

10893 size_t height, size_t pitch) {

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

10895}

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

10908static inline hipError_t

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

10910 struct hipChannelFormatDesc desc;

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

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

10913}

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

10927static inline hipError_t

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

10929 const struct hipChannelFormatDesc& desc) {

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

10931}

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

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

10945 hipMipmappedArray_const_t mipmappedArray) {

10946 struct hipChannelFormatDesc desc;

10947 hipArray_t levelArray;

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

10949 if (err != hipSuccess) {

10950 return err;

10951 }

10952 err = hipGetChannelDesc(&desc, levelArray);

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

10954}

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

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

10969 hipMipmappedArray_const_t mipmappedArray,

10970 const struct hipChannelFormatDesc& desc) {

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

10972}

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

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

10985 return hipUnbindTexture(&tex);

10986}

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

11011 hipStream_t stream) {

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

11013}

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

11025 hipMemPool_t mem_pool,

11026 hipStream_t stream) {

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

11028}

11039template <class T>

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

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

11042}

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

11054 hipMemPool_t mem_pool,

11055 hipStream_t stream) {

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

11057}

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

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

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

11074 Params&&... args) {

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

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

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

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

11079}

11085#endif // __cplusplus

11086

11087#ifdef __GNUC__

11088#pragma GCC visibility pop

11089#endif

11090

11091

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

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

11094#else

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

11096#endif

11097

11098

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

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

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

11113}

11125template <class T>

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

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

11128}

11141template <class T>

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

11143 unsigned int flags = hipHostMallocDefault) {

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

11145}

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

11159 unsigned int flags = hipHostAllocDefault) {

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

11161}

11176template <class T>

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

11178 unsigned int flags = hipMemAttachGlobal) {

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

11180}

11181

11182#endif

11183#endif

11184// doxygen end HIP API

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

11189

11190#if USE_PROF_API

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

11192#endif

driver_types.h

err

hipError_t err

Definition hip_runtime_api.h:10911

tex

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

Definition hip_runtime_api.h:10828

size

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

Definition hip_runtime_api.h:10829

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

levelArray

hipArray_t levelArray

Definition hip_runtime_api.h:10947

dim

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

Definition hip_runtime_api.h:10846

mipmappedArray

readMode hipMipmappedArray_const_t mipmappedArray

Definition hip_runtime_api.h:10945

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

devPtr

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

Definition hip_runtime_api.h:10829

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

array

readMode hipArray_const_t array

Definition hip_runtime_api.h:10909

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

hipApiName

const char * hipApiName(uint32_t id)

Returns HIP API name by ID.

hipKernelNameRef

const char * hipKernelNameRef(const hipFunction_t f)

Returns kernel name reference by function name.

hipKernelNameRefByPtr

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

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

hipGetStreamDeviceId

int hipGetStreamDeviceId(hipStream_t stream)

Returns device ID on the stream.

hipSetupArgument

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

Set a kernel argument.

__hipPopCallConfiguration

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

Pop configuration of a kernel launch.

hipLaunchHostFunc

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

Enqueues a host function call in a stream.

hipLaunchKernel

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

C compliant kernel launch API.

hipExtLaunchKernel

hipError_t hipExtLaunchKernel(const void *function_address, dim3 numBlocks, dim3 dimBlocks, void **args, size_t sharedMemBytes, hipStream_t stream, hipEvent_t startEvent, hipEvent_t stopEvent, int flags)

Launches kernel from the pointer address, with arguments and shared memory on stream.

__hipPushCallConfiguration

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

Push configuration of a kernel launch.

hipLaunchByPtr

hipError_t hipLaunchByPtr(const void *func)

Launch a kernel.

hipDrvMemcpy2DUnaligned

hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D *pCopy)

hipConfigureCall

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

Configure a kernel launch.

hipCtxGetFlags

hipError_t hipCtxGetFlags(unsigned int *flags)

Return flags used for creating default context [Deprecated].

hipCtxGetApiVersion

hipError_t hipCtxGetApiVersion(hipCtx_t ctx, unsigned int *apiVersion)

Returns the approximate HIP api version.

hipCtxPopCurrent

hipError_t hipCtxPopCurrent(hipCtx_t *ctx)

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

hipCtxGetSharedMemConfig

hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig *pConfig)

Get Shared memory bank configuration [Deprecated].

hipDevicePrimaryCtxSetFlags

hipError_t hipDevicePrimaryCtxSetFlags(hipDevice_t dev, unsigned int flags)

Set flags for the primary context [Deprecated].

hipDevicePrimaryCtxGetState

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

Get the state of the primary context [Deprecated].

hipCtxGetCurrent

hipError_t hipCtxGetCurrent(hipCtx_t *ctx)

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

hipDevicePrimaryCtxRelease

hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev)

Release the primary context on the GPU.

hipCtxSetCacheConfig

hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig)

Set L1/Shared cache partition [Deprecated].

hipCtxSetCurrent

hipError_t hipCtxSetCurrent(hipCtx_t ctx)

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

hipCtxEnablePeerAccess

hipError_t hipCtxEnablePeerAccess(hipCtx_t peerCtx, unsigned int flags)

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

hipCtxGetDevice

hipError_t hipCtxGetDevice(hipDevice_t *device)

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

hipCtxDestroy

hipError_t hipCtxDestroy(hipCtx_t ctx)

Destroy a HIP context [Deprecated].

hipCtxPushCurrent

hipError_t hipCtxPushCurrent(hipCtx_t ctx)

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

hipCtxGetCacheConfig

hipError_t hipCtxGetCacheConfig(hipFuncCache_t *cacheConfig)

Get Cache configuration for a specific function [Deprecated].

hipCtxCreate

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

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

hipDevicePrimaryCtxRetain

hipError_t hipDevicePrimaryCtxRetain(hipCtx_t *pctx, hipDevice_t dev)

Retain the primary context on the GPU [Deprecated].

hipDevicePrimaryCtxReset

hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev)

Resets the primary context on the GPU [Deprecated].

hipCtxSynchronize

hipError_t hipCtxSynchronize(void)

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

hipCtxSetSharedMemConfig

hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config)

Set Shared memory bank configuration [Deprecated].

hipCtxDisablePeerAccess

hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx)

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

hipInitDevice

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

Initialize the specified device to be used for GPU executions.

hipGetDeviceFlags

hipError_t hipGetDeviceFlags(unsigned int *flags)

Gets the flags set for current device.

hipIpcGetEventHandle

hipError_t hipIpcGetEventHandle(hipIpcEventHandle_t *handle, hipEvent_t event)

Gets an opaque interprocess handle for an event.

hipDeviceGetDefaultMemPool

hipError_t hipDeviceGetDefaultMemPool(hipMemPool_t *mem_pool, int device)

Returns the default memory pool of the specified device.

hipDeviceGetSharedMemConfig

hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig *pConfig)

Returns bank width of shared memory for current device.

hipDeviceSetMemPool

hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool)

Sets the current memory pool of a device.

hipIpcOpenMemHandle

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

Opens an interprocess memory handle exported from another process and returns a device pointer usable...

hipDeviceGetCacheConfig

hipError_t hipDeviceGetCacheConfig(hipFuncCache_t *cacheConfig)

Get Cache configuration for a specific Device.

hipSetDevice

hipError_t hipSetDevice(int deviceId)

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

hipExtGetLinkTypeAndHopCount

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

Returns the link type and hop count between two devices.

hipDeviceGetTexture1DLinearMaxWidth

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

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

hipSetDeviceFlags

hipError_t hipSetDeviceFlags(unsigned flags)

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

hipDeviceGetAttribute

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

Query for a specific device attribute.

hipGetDevice

hipError_t hipGetDevice(int *deviceId)

Return the default device id for the calling host thread.

hipGetDeviceCount

hipError_t hipGetDeviceCount(int *count)

Return number of compute-capable devices.

hipDeviceGetMemPool

hipError_t hipDeviceGetMemPool(hipMemPool_t *mem_pool, int device)

Gets the current memory pool for the specified device.

hipDeviceReset

hipError_t hipDeviceReset(void)

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

hipDeviceGetLimit

hipError_t hipDeviceGetLimit(size_t *pValue, enum hipLimit_t limit)

Gets resource limits of current device.

hipDeviceSetSharedMemConfig

hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config)

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

hipDeviceSetLimit

hipError_t hipDeviceSetLimit(enum hipLimit_t limit, size_t value)

Sets resource limits of current device.

hipDeviceSetCacheConfig

hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig)

Set L1/Shared cache partition.

hipIpcCloseMemHandle

hipError_t hipIpcCloseMemHandle(void *devPtr)

Close memory mapped with hipIpcOpenMemHandle.

hipSetValidDevices

hipError_t hipSetValidDevices(int *device_arr, int len)

Set a list of devices that can be used.

hipGetDevicePropertiesR0600

hipError_t hipGetDevicePropertiesR0600(hipDeviceProp_tR0600 *prop, int deviceId)

hipIpcOpenEventHandle

hipError_t hipIpcOpenEventHandle(hipEvent_t *event, hipIpcEventHandle_t handle)

Opens an interprocess event handles.

hipDeviceSynchronize

hipError_t hipDeviceSynchronize(void)

Waits on all active streams on current device.

hipChooseDeviceR0600

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

hipIpcGetMemHandle

hipError_t hipIpcGetMemHandle(hipIpcMemHandle_t *handle, void *devPtr)

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

hipInit

hipError_t hipInit(unsigned int flags)

Explicitly initializes the HIP runtime.

hipDeviceComputeCapability

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

Returns the compute capability of the device.

hipDeviceGetName

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

Returns an identifer string for the device.

hipDeviceGetByPCIBusId

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

Returns a handle to a compute device.

hipDeviceGetUuid

hipError_t hipDeviceGetUuid(hipUUID *uuid, hipDevice_t device)

Returns an UUID for the device.[BETA].

hipDeviceTotalMem

hipError_t hipDeviceTotalMem(size_t *bytes, hipDevice_t device)

Returns the total amount of memory on the device.

hipDeviceGetPCIBusId

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

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

hipDeviceGet

hipError_t hipDeviceGet(hipDevice_t *device, int ordinal)

Returns a handle to a compute device.

hipDeviceGetLuid

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

Returns an LUID and device node mask for the device.

hipRuntimeGetVersion

hipError_t hipRuntimeGetVersion(int *runtimeVersion)

Returns the approximate HIP Runtime version.

hipDeviceGetP2PAttribute

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

Returns a value for attribute of link between two devices.

hipDriverGetVersion

hipError_t hipDriverGetVersion(int *driverVersion)

Returns the approximate HIP driver version.

hipMemcpyKind

hipMemcpyKind

Definition driver_types.h:357

hipPointer_attribute

hipPointer_attribute

Definition driver_types.h:631

hipArray_t

struct hipArray * hipArray_t

Definition driver_types.h:59

hipDeviceptr_t

void * hipDeviceptr_t

Definition driver_types.h:30

hipFunction_attribute

hipFunction_attribute

Definition driver_types.h:604

hipArray_const_t

const struct hipArray * hipArray_const_t

Definition driver_types.h:60

hipArray_Format

hipArray_Format

Definition driver_types.h:64

hipResourceType

hipResourceType

Definition driver_types.h:143

hipMemcpyDeviceToHost

@ hipMemcpyDeviceToHost

Device-to-Host Copy.

Definition driver_types.h:360

hipMemcpyHostToDevice

@ hipMemcpyHostToDevice

Host-to-Device Copy.

Definition driver_types.h:359

HIP_ARRAY3D_DESCRIPTOR

Definition driver_types.h:87

HIP_ARRAY_DESCRIPTOR

Definition driver_types.h:77

HIP_MEMCPY3D

Definition driver_types.h:408

HIP_RESOURCE_DESC

Definition driver_types.h:297

HIP_RESOURCE_VIEW_DESC

Definition driver_types.h:342

HIP_TEXTURE_DESC

Definition driver_types.h:175

hip_Memcpy2D

Definition driver_types.h:99

hipChannelFormatDesc

Definition driver_types.h:43

hipExtent

Definition driver_types.h:378

hipMemLocation

Definition driver_types.h:450

hipMemcpy3DBatchOp

Definition driver_types.h:533

hipMemcpy3DParms

Definition driver_types.h:395

hipMemcpy3DPeerParms

Definition driver_types.h:541

hipMemcpyAttributes

Definition driver_types.h:487

hipMipmappedArray

Definition driver_types.h:121

hipPitchedPtr

Definition driver_types.h:369

hipResourceDesc

Definition driver_types.h:270

hipResourceViewDesc

Definition driver_types.h:329

hipGetErrorString

const char * hipGetErrorString(hipError_t hipError)

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

hipPeekAtLastError

hipError_t hipPeekAtLastError(void)

Return last error returned by any HIP runtime API call.

hipDrvGetErrorString

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

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

hipGetLastError

hipError_t hipGetLastError(void)

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

hipExtGetLastError

hipError_t hipExtGetLastError(void)

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

hipDrvGetErrorName

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

Return hip error as text string form.

hipGetErrorName

const char * hipGetErrorName(hipError_t hip_error)

Return hip error as text string form.

hipEventSynchronize

hipError_t hipEventSynchronize(hipEvent_t event)

Wait for an event to complete.

hipEventQuery

hipError_t hipEventQuery(hipEvent_t event)

Query event status.

hipEventCreate

hipError_t hipEventCreate(hipEvent_t *event)

hipEventDestroy

hipError_t hipEventDestroy(hipEvent_t event)

Destroy the specified event.

hipEventRecordWithFlags

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

Record an event in the specified stream.

hipEventRecord

hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream=NULL)

Record an event in the specified stream.

hipEventElapsedTime

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

Return the elapsed time between two events.

hipEventCreateWithFlags

hipError_t hipEventCreateWithFlags(hipEvent_t *event, unsigned flags)

Create an event with the specified flags.

hipDeviceGetExecutionCtx

hipError_t hipDeviceGetExecutionCtx(hipExecutionCtx_t *ctx, int device)

Returns the default execution context for a device.

hipExecutionCtxStreamCreate

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

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

hipGreenCtxCreate

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

Creates a green context from a resource descriptor.

hipExecutionCtxGetDevice

hipError_t hipExecutionCtxGetDevice(int *device, hipExecutionCtx_t ctx)

Returns the device associated with an execution context.

hipExecutionCtxWaitEvent

hipError_t hipExecutionCtxWaitEvent(hipExecutionCtx_t ctx, hipEvent_t event)

Makes an execution context wait on an event.

hipExecutionCtxSynchronize

hipError_t hipExecutionCtxSynchronize(hipExecutionCtx_t ctx)

Blocks until all work on an execution context has completed.

hipDevResourceGenerateDesc

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

Generates a resource descriptor from one or more device resources.

hipExecutionCtxRecordEvent

hipError_t hipExecutionCtxRecordEvent(hipExecutionCtx_t ctx, hipEvent_t event)

Records an event on an execution context.

hipExecutionCtxDestroy

hipError_t hipExecutionCtxDestroy(hipExecutionCtx_t ctx)

Destroys an execution context.

hipDevSmResourceSplitByCount

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

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

hipDeviceGetDevResource

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

Gets device resource of a given type for a device.

hipExecutionCtxGetDevResource

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

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

hipStreamGetDevResource

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

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

hipDevSmResourceSplit

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

Splits SM resources into structured groups.

hipExecutionCtxGetId

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

Returns a unique identifier for an execution context.

hipFuncGetAttributes

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

Find out attributes for a given function.

hipLaunchKernelExC

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

Launches a HIP kernel using a generic function pointer and the specified configuration.

hipExtLaunchMultiKernelMultiDevice

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

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

hipKernelGetFunction

hipError_t hipKernelGetFunction(hipFunction_t *pFunc, hipKernel_t kernel)

Function will be extracted for specific kernel.

hipModuleLaunchKernel

hipError_t hipModuleLaunchKernel(hipFunction_t f, unsigned int gridDimX, unsigned int gridDimY, unsigned int gridDimZ, unsigned int blockDimX, unsigned int blockDimY, unsigned int blockDimZ, unsigned int sharedMemBytes, hipStream_t stream, void **kernelParams, void **extra)

launches kernel f with launch parameters and shared memory on stream with arguments passed to kernelp...

hipFuncSetSharedMemConfig

hipError_t hipFuncSetSharedMemConfig(const void *func, hipSharedMemConfig config)

Set shared memory configuation for a specific function.

hipFuncGetAttribute

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

Find out a specific attribute for a given function.

hipFuncSetAttribute

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

Set attribute for a specific function.

hipDrvLaunchKernelEx

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

Launches a HIP kernel using the driver API with the specified configuration.

hipKernelSetAttribute

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

Set attribute for a specific kernel.

hipFuncSetCacheConfig

hipError_t hipFuncSetCacheConfig(const void *func, hipFuncCache_t config)

Set Cache configuration for a specific function.

hipDestroyExternalMemory

hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem)

Destroys an external memory object.

hipImportExternalSemaphore

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

Imports an external semaphore.

hipImportExternalMemory

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

Imports an external memory object.

hipDestroyExternalSemaphore

hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem)

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

hipWaitExternalSemaphoresAsync

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

Waits on a set of external semaphore objects.

hipSignalExternalSemaphoresAsync

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

Signals a set of external semaphore objects.

hipExternalMemoryGetMappedMipmappedArray

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

Maps a mipmapped array onto an external memory object.

hipExternalMemoryGetMappedBuffer

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

Maps a buffer onto an imported memory object.

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:1121

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

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::address

hipDeviceptr_t address

Definition hip_runtime_api.h:1132

hipDeviceProp_t::ipcEventSupported

int ipcEventSupported

Device supports IPC events.

Definition hip_runtime_api.h:367

hipGraphNodeParams::type

hipGraphNodeType type

Definition hip_runtime_api.h:2107

hipDeviceProp_t::computePreemptionSupported

int computePreemptionSupported

Is compute preemption supported on the device.

Definition hip_runtime_api.h:339

hipExternalMemoryHandleDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1461

hipExternalSemaphoreHandleDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1500

hipDeviceProp_t::maxTexture1DLinear

int maxTexture1DLinear

Maximum size for 1D textures bound to linear memory.

Definition hip_runtime_api.h:292

hipGraphNodeParams::reserved0

int reserved0[3]

Definition hip_runtime_api.h:2108

hipLaunchAttributeValue::priority

int priority

Definition hip_runtime_api.h:1770

hipFunctionLaunchParams::gridDimX

unsigned int gridDimX

Width(X) of grid in blocks.

Definition hip_runtime_api.h:1430

hipFunctionLaunchParams::blockDimX

unsigned int blockDimX

X dimension of each thread block.

Definition hip_runtime_api.h:1433

hipMemAllocationProp::win32HandleMetaData

void * win32HandleMetaData

Metadata for Win32 handles.

Definition hip_runtime_api.h:1956

hipDeviceProp_t::timelineSemaphoreInteropSupported

int timelineSemaphoreInteropSupported

Indicates external timeline semaphore support.

Definition hip_runtime_api.h:357

hipPointerAttribute_t::device

int device

Definition hip_runtime_api.h:428

hipMemAllocationProp::type

hipMemAllocationType type

Memory allocation type.

Definition hip_runtime_api.h:1950

hipDeviceProp_t::pciBusID

int pciBusID

PCI Bus ID.

Definition hip_runtime_api.h:314

hipArrayMapInfo::flags

unsigned int flags

flags for future use, must be zero now.

Definition hip_runtime_api.h:2061

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

hipAccessPolicyWindow::hitProp

hipAccessProperty hitProp

hipAccessProperty set for hit

Definition hip_runtime_api.h:1656

hipPointerAttribute_t::hostPointer

void * hostPointer

Definition hip_runtime_api.h:430

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::address

hipDeviceptr_t address

Definition hip_runtime_api.h:1122

hipAccessPolicyWindow::missProp

hipAccessProperty missProp

hipAccessProperty set for miss

Definition hip_runtime_api.h:1658

hipDeviceProp_t::memoryBusWidth

int memoryBusWidth

Global memory bus width in bits.

Definition hip_runtime_api.h:321

hipDeviceProp_t::maxTexture2DMipmap

int maxTexture2DMipmap[2]

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

Definition hip_runtime_api.h:294

hipDevWorkqueueConfigResource::sharingScope

hipDevWorkqueueConfigScope sharingScope

Definition hip_runtime_api.h:752

hipDeviceProp_t::clockRate

int clockRate

Max clock frequency of the multiProcessors in khz.

Definition hip_runtime_api.h:267

hipExternalMemoryMipmappedArrayDesc::extent

hipExtent extent

Definition hip_runtime_api.h:1473

hipMemPoolProps::maxSize

size_t maxSize

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

Definition hip_runtime_api.h:1359

hipLaunchAttributeValue::pad

char pad[64]

64 byte padding

Definition hip_runtime_api.h:1765

hipDevSmResource::flags

unsigned int flags

Definition hip_runtime_api.h:746

hipDevSmResourceGroupParams::flags

unsigned int flags

Definition hip_runtime_api.h:775

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

hipDeviceProp_t::l2CacheSize

int l2CacheSize

L2 cache size.

Definition hip_runtime_api.h:322

hipDeviceProp_t::deferredMappingHipArraySupported

int deferredMappingHipArraySupported

Definition hip_runtime_api.h:365

hipArrayMemoryRequirements::size

size_t size

Definition hip_runtime_api.h:2210

hipDeviceProp_t::asyncEngineCount

int asyncEngineCount

Number of async engines.

Definition hip_runtime_api.h:318

hipMemsetParams::dst

void * dst

Definition hip_runtime_api.h:1623

hipDeviceProp_t::accessPolicyMaxWindowSize

int accessPolicyMaxWindowSize

Max value of access policy window.

Definition hip_runtime_api.h:351

hipPointerAttribute_t::type

enum hipMemoryType type

Definition hip_runtime_api.h:427

hipStreamBatchMemOpParams::hipStreamMemOpFlushRemoteWritesParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:1142

hipDeviceProp_t::totalConstMem

size_t totalConstMem

Definition hip_runtime_api.h:268

hipDeviceProp_t::memoryPoolsSupported

int memoryPoolsSupported

Indicates if device supports hipMallocAsync and hipMemPool APIs.

Definition hip_runtime_api.h:358

hipLaunchConfig_t::blockDim

dim3 blockDim

Block dimensions.

Definition hip_runtime_api.h:2182

hipKernelNodeParams::gridDim

dim3 gridDim

Definition hip_runtime_api.h:1618

hipExternalSemaphoreSignalNodeParams::paramsArray

const hipExternalSemaphoreSignalParams * paramsArray

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

Definition hip_runtime_api.h:1971

hipExtDynDataPrefetchRegion::address

void * address

Base address (must be cache-line aligned)

Definition hip_runtime_api.h:1714

hipDevResource::nextResource

struct hipDevResource_st * nextResource

Definition hip_runtime_api.h:768

hipHostNodeParams::fn

hipHostFn_t fn

Definition hip_runtime_api.h:1611

hipDeviceProp_t::unifiedFunctionPointers

int unifiedFunctionPointers

Indicates device supports unified function pointers.

Definition hip_runtime_api.h:369

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

hipStreamBatchMemOpParams::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:1119

hipFuncAttributes::cacheModeCA

int cacheModeCA

Definition hip_runtime_api.h:816

hipDeviceProp_t::memPitch

size_t memPitch

Definition hip_runtime_api.h:262

hipExtDynDataPrefetchConfig::regions

hipExtDynDataPrefetchRegion regions[HIP_EXT_DYN_DATA_PREFETCH_MAX_REGIONS]

Prefetch regions.

Definition hip_runtime_api.h:1740

hipMemAccessDesc::flags

hipMemAccessFlags flags

Accessibility flags to set.

Definition hip_runtime_api.h:1319

hipExtDynDataPrefetchConfig::numRegions

unsigned int numRegions

Number of valid regions (1-max)

Definition hip_runtime_api.h:1738

hipChildGraphNodeParams::graph

hipGraph_t graph

Definition hip_runtime_api.h:2078

hipDeviceProp_t::gpuDirectRDMAWritesOrdering

int gpuDirectRDMAWritesOrdering

value of hipGPUDirectRDMAWritesOrdering

Definition hip_runtime_api.h:362

hipMemsetParams::value

unsigned int value

Definition hip_runtime_api.h:1627

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

hipDeviceProp_t::uuid

hipUUID uuid

UUID of a device.

Definition hip_runtime_api.h:255

hipExternalMemoryMipmappedArrayDesc::numLevels

unsigned int numLevels

Definition hip_runtime_api.h:1475

hipKernelNodeParams::sharedMemBytes

unsigned int sharedMemBytes

Definition hip_runtime_api.h:1620

hipArrayMapInfo::subresource

union hipArrayMapInfo::@38 subresource

HIP_LAUNCH_CONFIG::gridDimZ

unsigned int gridDimZ

Grid depth in blocks.

Definition hip_runtime_api.h:2195

hipLaunchMemSyncDomainMap::remote

unsigned char remote

Definition hip_runtime_api.h:1667

hipDeviceProp_t::sharedMemPerBlock

size_t sharedMemPerBlock

Size of shared memory per block (in bytes).

Definition hip_runtime_api.h:259

hipAccessPolicyWindow::hitRatio

float hitRatio

hitRatio specifies percentage of lines assigned hitProp

Definition hip_runtime_api.h:1657

hipDeviceProp_t::gpuDirectRDMAFlushWritesOptions

unsigned int gpuDirectRDMAFlushWritesOptions

Definition hip_runtime_api.h:360

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

hipExtDynDataPrefetchRegion::width

size_t width

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

Definition hip_runtime_api.h:1716

hipDeviceProp_t::reserved

int reserved[63]

CUDA Reserved.

Definition hip_runtime_api.h:370

hipDeviceProp_t::maxTexture2DLayered

int maxTexture2DLayered[3]

Maximum number of elements in 2D array images.

Definition hip_runtime_api.h:302

hipMemPoolProps::reserved

unsigned char reserved[56]

Reserved for future use, must be 0.

Definition hip_runtime_api.h:1360

hipArrayMapInfo::subresourceType

hipArraySparseSubresourceType subresourceType

Sparse subresource type.

Definition hip_runtime_api.h:2033

hipDeviceProp_t::streamPrioritiesSupported

int streamPrioritiesSupported

Device supports stream priority.

Definition hip_runtime_api.h:325

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

hipExternalSemaphoreWaitNodeParams::numExtSems

unsigned int numExtSems

Definition hip_runtime_api.h:1985

hipGraphInstantiateParams::result_out

hipGraphInstantiateResult result_out

Definition hip_runtime_api.h:1940

hipDevWorkqueueConfigResource::wqConcurrencyLimit

unsigned int wqConcurrencyLimit

Definition hip_runtime_api.h:751

hipFunctionLaunchParams::function

hipFunction_t function

Kernel to launch.

Definition hip_runtime_api.h:1429

HIP_LAUNCH_CONFIG::sharedMemBytes

unsigned int sharedMemBytes

Dynamic shared-memory size in bytes per block.

Definition hip_runtime_api.h:2199

hipLaunchAttributeValue::dynDataPrefetch

const hipExtDynDataPrefetchConfig * dynDataPrefetch

Value of launch attribute hipLaunchAttributeExtDynDataPrefetch.

Definition hip_runtime_api.h:1799

hipKernelNodeParams::blockDim

dim3 blockDim

Definition hip_runtime_api.h:1615

hipDeviceProp_t::cooperativeMultiDeviceLaunch

int cooperativeMultiDeviceLaunch

Definition hip_runtime_api.h:343

hipDeviceProp_t::hostRegisterSupported

int hostRegisterSupported

Device supports hipHostRegister.

Definition hip_runtime_api.h:353

hipExternalMemoryMipmappedArrayDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1474

hipLaunchConfig_t::gridDim

dim3 gridDim

Grid dimensions.

Definition hip_runtime_api.h:2181

hipLaunchConfig_t::numAttrs

unsigned int numAttrs

Number of attributes.

Definition hip_runtime_api.h:2186

hipDevSmResource::smCoscheduledAlignment

unsigned int smCoscheduledAlignment

Definition hip_runtime_api.h:745

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::alias

hipDeviceptr_t alias

Not valid for AMD backend. Initial value is unimportant.

Definition hip_runtime_api.h:1128

hipFuncAttributes::binaryVersion

int binaryVersion

Definition hip_runtime_api.h:815

hipExternalSemaphoreSignalParams::flags

unsigned int flags

Definition hip_runtime_api.h:1518

hipHostNodeParams::userData

void * userData

Definition hip_runtime_api.h:1612

hipLaunchAttributeValue::memSyncDomain

hipLaunchMemSyncDomain memSyncDomain

Value of launch attribute hipLaunchAttributeMemSyncDomain.

Definition hip_runtime_api.h:1778

hipArrayMemoryRequirements::alignment

size_t alignment

Definition hip_runtime_api.h:2209

hipDeviceProp_t::pageableMemoryAccess

int pageableMemoryAccess

Definition hip_runtime_api.h:335

hipDeviceProp_t::name

char name[256]

Device name.

Definition hip_runtime_api.h:254

hipMemPoolPtrExportData::reserved

unsigned char reserved[64]

Definition hip_runtime_api.h:1366

hipDeviceProp_t::textureAlignment

size_t textureAlignment

Alignment requirement for textures.

Definition hip_runtime_api.h:279

hipStreamBatchMemOpParams::hipStreamMemOpFlushRemoteWritesParams_t::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:1141

hipStreamBatchMemOpParams::hipStreamMemOpMemoryBarrierParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:1146

hipExternalSemaphoreHandleDesc::type

hipExternalSemaphoreHandleType type

Definition hip_runtime_api.h:1491

hipDeviceProp_t::globalL1CacheSupported

int globalL1CacheSupported

Indicates globals are cached in L1.

Definition hip_runtime_api.h:326

hipFuncAttributes::constSizeBytes

size_t constSizeBytes

Definition hip_runtime_api.h:817

hipMemAllocNodeParams::accessDescs

const hipMemAccessDesc * accessDescs

The number of memory access descriptors.

Definition hip_runtime_api.h:1634

hipDeviceProp_t::hostNativeAtomicSupported

int hostNativeAtomicSupported

Link between host and device supports native atomics.

Definition hip_runtime_api.h:333

hipArrayMapInfo::resourceType

hipResourceType resourceType

Resource type.

Definition hip_runtime_api.h:2028

hipDeviceProp_t::maxSurfaceCubemapLayered

int maxSurfaceCubemapLayered[2]

Maximum cubemap layered surface size.

Definition hip_runtime_api.h:310

hipPointerAttribute_t::isManaged

int isManaged

Definition hip_runtime_api.h:431

hipExternalMemoryHandleDesc::size

unsigned long long size

Definition hip_runtime_api.h:1460

hipDeviceProp_t::maxTextureCubemapLayered

int maxTextureCubemapLayered[2]

Maximum cubemaps layered texture dims.

Definition hip_runtime_api.h:303

hipDeviceProp_t::sharedMemPerBlockOptin

size_t sharedMemPerBlockOptin

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

Definition hip_runtime_api.h:345

hipDeviceProp_t::sharedMemPerMultiprocessor

size_t sharedMemPerMultiprocessor

Amount of shared memory available per multiprocessor.

Definition hip_runtime_api.h:328

hipDeviceProp_t::singleToDoublePrecisionPerfRatio

int singleToDoublePrecisionPerfRatio

Deprecated. CUDA only.

Definition hip_runtime_api.h:334

hipArrayMapInfo::memOperationType

hipMemOperationType memOperationType

Memory operation type.

Definition hip_runtime_api.h:2054

HIP_LAUNCH_CONFIG::blockDimY

unsigned int blockDimY

Thread block dimension in Y.

Definition hip_runtime_api.h:2197

hipDeviceProp_t::maxSurface2D

int maxSurface2D[2]

Maximum 2D surface size.

Definition hip_runtime_api.h:305

hipDeviceProp_t::memoryClockRate

int memoryClockRate

Max global memory clock frequency in khz.

Definition hip_runtime_api.h:320

hipEventWaitNodeParams::event

hipEvent_t event

Event to wait on.

Definition hip_runtime_api.h:2086

hipDeviceProp_t::maxTexture2DLinear

int maxTexture2DLinear[3]

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

Definition hip_runtime_api.h:295

hipDeviceProp_t::sparseHipArraySupported

int sparseHipArraySupported

Indicates if device supports sparse hip arrays.

Definition hip_runtime_api.h:354

hipArrayMapInfo::reserved

unsigned int reserved[2]

Reserved for future use, must be zero now.

Definition hip_runtime_api.h:2062

hipDevSmResource::minSmPartitionSize

unsigned int minSmPartitionSize

Definition hip_runtime_api.h:744

hipMemAccessDesc::location

hipMemLocation location

Location on which the accessibility has to change.

Definition hip_runtime_api.h:1318

hipDeviceProp_t::clockInstructionRate

int clockInstructionRate

Definition hip_runtime_api.h:377

hipMemPoolProps::location

hipMemLocation location

Location where allocations should reside.

Definition hip_runtime_api.h:1354

hipDeviceProp_t::localL1CacheSupported

int localL1CacheSupported

Locals are cahced in L1.

Definition hip_runtime_api.h:327

hipDeviceProp_t::regsPerMultiprocessor

int regsPerMultiprocessor

registers available per multiprocessor

Definition hip_runtime_api.h:329

hipDeviceProp_t::regsPerBlock

int regsPerBlock

Registers per block.

Definition hip_runtime_api.h:260

hipLaunchConfig_t::stream

hipStream_t stream

Stream identifier.

Definition hip_runtime_api.h:2184

hipMemAllocNodeParams::bytesize

size_t bytesize

The size of the requested allocation in bytes.

Definition hip_runtime_api.h:1637

hipMemcpyNodeParams::reserved

int reserved[3]

Must be zero.

Definition hip_runtime_api.h:2070

hipDevSmResourceGroupParams::preferredCoscheduledSmCount

unsigned int preferredCoscheduledSmCount

Definition hip_runtime_api.h:774

hipExternalSemaphoreWaitNodeParams::paramsArray

const hipExternalSemaphoreWaitParams * paramsArray

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

Definition hip_runtime_api.h:1983

hipDeviceProp_t::maxTexture2D

int maxTexture2D[2]

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

Definition hip_runtime_api.h:293

hipFuncAttributes::preferredShmemCarveout

int preferredShmemCarveout

Definition hip_runtime_api.h:822

hipDeviceProp_t::cooperativeLaunch

int cooperativeLaunch

HIP device supports cooperative launch.

Definition hip_runtime_api.h:342

hipDeviceProp_t::maxTexture3D

int maxTexture3D[3]

Definition hip_runtime_api.h:297

hipMemPoolProps::handleTypes

hipMemAllocationHandleType handleTypes

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

Definition hip_runtime_api.h:1353

hipDeviceProp_t::directManagedMemAccessFromHost

int directManagedMemAccessFromHost

Definition hip_runtime_api.h:348

HIP_LAUNCH_CONFIG::hStream

hipStream_t hStream

HIP stream identifier.

Definition hip_runtime_api.h:2200

hipBatchMemOpNodeParams::paramArray

hipStreamBatchMemOpParams * paramArray

Definition hip_runtime_api.h:1181

HIP_LAUNCH_CONFIG::attrs

hipLaunchAttribute * attrs

Attribute list.

Definition hip_runtime_api.h:2201

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedFunc

int cooperativeMultiDeviceUnmatchedFunc

Definition hip_runtime_api.h:382

hipMemPoolProps::allocType

hipMemAllocationType allocType

Allocation type. Currently must be specified as hipMemAllocationTypePinned.

Definition hip_runtime_api.h:1351

hipDeviceProp_t::deviceOverlap

int deviceOverlap

Deprecated. Use asyncEngineCount instead.

Definition hip_runtime_api.h:281

hipDeviceProp_t::pageableMemoryAccessUsesHostPageTables

int pageableMemoryAccessUsesHostPageTables

Definition hip_runtime_api.h:346

hipLaunchAttributeValue::cooperative

int cooperative

Definition hip_runtime_api.h:1768

hipExternalSemaphoreWaitNodeParams::extSemArray

hipExternalSemaphore_t * extSemArray

< Array containing external semaphore handles.

Definition hip_runtime_api.h:1981

hipKernelNodeParams::kernelParams

void ** kernelParams

Definition hip_runtime_api.h:1619

hipDeviceProp_t::hdpRegFlushCntl

unsigned int * hdpRegFlushCntl

Addres of HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:381

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

hipLaunchConfig_t::dynamicSmemBytes

size_t dynamicSmemBytes

Dynamic shared-memory size per thread block.

Definition hip_runtime_api.h:2183

hipDeviceProp_t::maxThreadsDim

int maxThreadsDim[3]

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

Definition hip_runtime_api.h:265

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

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

hipArrayMapInfo::memHandleType

hipMemHandleType memHandleType

Memory handle type.

Definition hip_runtime_api.h:2055

hipGraphEdgeData::reserved

unsigned char reserved[5]

These bytes are unused and must be zeroed.

Definition hip_runtime_api.h:2158

hipExternalMemoryMipmappedArrayDesc::offset

unsigned long long offset

Definition hip_runtime_api.h:1471

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

hipEventRecordNodeParams::event

hipEvent_t event

The event to be recorded when node executes.

Definition hip_runtime_api.h:2093

hipDeviceProp_t::multiGpuBoardGroupID

int multiGpuBoardGroupID

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

Definition hip_runtime_api.h:332

hipGraphInstantiateParams::uploadStream

hipStream_t uploadStream

Definition hip_runtime_api.h:1942

hipDeviceProp_t::isMultiGpuBoard

int isMultiGpuBoard

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

Definition hip_runtime_api.h:331

hipMemAllocNodeParams::poolProps

hipMemPoolProps poolProps

Definition hip_runtime_api.h:1632

hipDevSmResourceGroupParams::smCount

unsigned int smCount

Definition hip_runtime_api.h:772

hipFuncAttributes::sharedSizeBytes

size_t sharedSizeBytes

Definition hip_runtime_api.h:824

hipMemAllocNodeParams::accessDescCount

size_t accessDescCount

Definition hip_runtime_api.h:1635

hipFuncAttributes::maxDynamicSharedSizeBytes

int maxDynamicSharedSizeBytes

Definition hip_runtime_api.h:819

hipFunctionLaunchParams::blockDimY

unsigned int blockDimY

Y dimension of each thread block.

Definition hip_runtime_api.h:1434

hipDeviceProp_t::canUseHostPointerForRegisteredMem

int canUseHostPointerForRegisteredMem

Definition hip_runtime_api.h:340

hipGraphEdgeData::type

unsigned char type

This should be populated with a value from hipGraphDependencyType.

Definition hip_runtime_api.h:2161

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

hipGraphInstantiateParams::errNode_out

hipGraphNode_t errNode_out

Definition hip_runtime_api.h:1938

hipDeviceProp_t::pciDomainID

int pciDomainID

PCI Domain ID.

Definition hip_runtime_api.h:316

hipExternalSemaphoreSignalNodeParams::extSemArray

hipExternalSemaphore_t * extSemArray

< Array containing external semaphore handles.

Definition hip_runtime_api.h:1969

hipDevSmResourceGroupParams::coscheduledSmCount

unsigned int coscheduledSmCount

Definition hip_runtime_api.h:773

hipDeviceProp_t::maxSharedMemoryPerMultiProcessor

size_t maxSharedMemoryPerMultiProcessor

Maximum Shared Memory Per CU. HIP Only.

Definition hip_runtime_api.h:376

hipDevWorkqueueConfigResource::device

int device

Definition hip_runtime_api.h:750

hipMemAllocationProp::location

hipMemLocation location

Memory location.

Definition hip_runtime_api.h:1955

hipExtDynDataPrefetchConfig::temporal

hipExtDynDataPrefetchTemporal temporal

Cache retention policy for prefetched data.

Definition hip_runtime_api.h:1739

hipDeviceProp_t::maxTextureCubemap

int maxTextureCubemap

Maximum cubemap texture dims.

Definition hip_runtime_api.h:300

HIP_LAUNCH_CONFIG::blockDimZ

unsigned int blockDimZ

Thread block dimension in Z.

Definition hip_runtime_api.h:2198

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

hipExternalMemoryHandleDesc::type

hipExternalMemoryHandleType type

Definition hip_runtime_api.h:1451

hipFuncAttributes::ptxVersion

int ptxVersion

Definition hip_runtime_api.h:823

hipKernelNodeParams::extra

void ** extra

Definition hip_runtime_api.h:1616

hipGraphInstantiateParams::flags

unsigned long long flags

Definition hip_runtime_api.h:1939

hipBatchMemOpNodeParams::count

unsigned int count

Definition hip_runtime_api.h:1180

HIP_LAUNCH_CONFIG::numAttrs

unsigned int numAttrs

Number of attributes.

Definition hip_runtime_api.h:2202

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

hipMemAllocNodeParams::dptr

void * dptr

Returned device address of the allocation.

Definition hip_runtime_api.h:1638

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::alias

hipDeviceptr_t alias

Not valid for AMD backend. Initial value is unimportant.

Definition hip_runtime_api.h:1138

hipMemsetParams::elementSize

unsigned int elementSize

Definition hip_runtime_api.h:1624

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedGridDim

int cooperativeMultiDeviceUnmatchedGridDim

Definition hip_runtime_api.h:385

hipExternalSemaphoreWaitParams::flags

unsigned int flags

Definition hip_runtime_api.h:1539

hipDeviceProp_t::gpuDirectRDMASupported

int gpuDirectRDMASupported

Indicates device support of RDMA APIs.

Definition hip_runtime_api.h:359

hipArrayMapInfo::resource

union hipArrayMapInfo::@37 resource

HIP_LAUNCH_CONFIG::gridDimX

unsigned int gridDimX

Grid width in blocks.

Definition hip_runtime_api.h:2193

hipDeviceProp_t::minor

int minor

Definition hip_runtime_api.h:274

hipDeviceProp_t::gcnArchName

char gcnArchName[256]

AMD GCN Arch Name. HIP Only.

Definition hip_runtime_api.h:375

hipPointerAttribute_t::devicePointer

void * devicePointer

Definition hip_runtime_api.h:429

hipDeviceProp_t::luid

char luid[8]

8-byte unique identifier. Only valid on windows

Definition hip_runtime_api.h:256

hipLaunchConfig_t::attrs

hipLaunchAttribute * attrs

Attributes list.

Definition hip_runtime_api.h:2185

hipDeviceProp_t::kernelExecTimeoutEnabled

int kernelExecTimeoutEnabled

Run time limit for kernels executed on the device.

Definition hip_runtime_api.h:286

hipKernelNodeParams::func

void * func

Definition hip_runtime_api.h:1617

hipDeviceProp_t::memoryPoolSupportedHandleTypes

unsigned int memoryPoolSupportedHandleTypes

Bitmask of handle types support with mempool based IPC.

Definition hip_runtime_api.h:364

hipDeviceProp_t::hdpMemFlushCntl

unsigned int * hdpMemFlushCntl

Addres of HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:380

hipDeviceProp_t::concurrentManagedAccess

int concurrentManagedAccess

Definition hip_runtime_api.h:337

hipDeviceProp_t::integrated

int integrated

APU vs dGPU.

Definition hip_runtime_api.h:287

hipDeviceProp_t::canMapHostMemory

int canMapHostMemory

Check whether HIP can map host memory.

Definition hip_runtime_api.h:288

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

hipDeviceProp_t::reservedSharedMemPerBlock

size_t reservedSharedMemPerBlock

Shared memory reserved by driver per block.

Definition hip_runtime_api.h:352

hipDevResource::type

hipDevResourceType type

Definition hip_runtime_api.h:760

hipDeviceProp_t::maxSurfaceCubemap

int maxSurfaceCubemap

Maximum cubemap surface size.

Definition hip_runtime_api.h:309

hipDeviceProp_t::maxSurface3D

int maxSurface3D[3]

Maximum 3D surface size.

Definition hip_runtime_api.h:306

hipLaunchParams::args

void ** args

Arguments.

Definition hip_runtime_api.h:1421

hipDeviceProp_t::asicRevision

int asicRevision

Revision of the GPU in this device.

Definition hip_runtime_api.h:395

hipGraphEdgeData::from_port

unsigned char from_port

Definition hip_runtime_api.h:2151

hipLaunchParams::blockDim

dim3 blockDim

Block dimensions.

Definition hip_runtime_api.h:1420

hipLaunchAttribute::id

hipLaunchAttributeID id

Identifier of the launch attribute.

Definition hip_runtime_api.h:2169

hipArrayMapInfo::deviceBitMask

unsigned int deviceBitMask

Device ordinal bit mask.

Definition hip_runtime_api.h:2060

hipFunctionLaunchParams::gridDimY

unsigned int gridDimY

Height(Y) of grid in blocks.

Definition hip_runtime_api.h:1431

hipDeviceProp_t::totalGlobalMem

size_t totalGlobalMem

Size of global memory region (in bytes).

Definition hip_runtime_api.h:258

hipMemsetParams::width

size_t width

Definition hip_runtime_api.h:1628

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedBlockDim

int cooperativeMultiDeviceUnmatchedBlockDim

Definition hip_runtime_api.h:388

hipFunctionLaunchParams::gridDimZ

unsigned int gridDimZ

Depth(Z) of grid in blocks.

Definition hip_runtime_api.h:1432

hipPointerAttribute_t::allocationFlags

unsigned allocationFlags

Definition hip_runtime_api.h:432

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:1131

hipFunctionLaunchParams::sharedMemBytes

unsigned int sharedMemBytes

Shared memory.

Definition hip_runtime_api.h:1436

hipBatchMemOpNodeParams::flags

unsigned int flags

Definition hip_runtime_api.h:1182

hipDeviceProp_t::maxSurface1DLayered

int maxSurface1DLayered[2]

Maximum 1D layered surface size.

Definition hip_runtime_api.h:307

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

hipDeviceProp_t::maxSurface1D

int maxSurface1D

Maximum 1D surface size.

Definition hip_runtime_api.h:304

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:1137

hipDeviceProp_t::concurrentKernels

int concurrentKernels

Device can possibly execute multiple kernels concurrently.

Definition hip_runtime_api.h:312

hipDeviceProp_t::isLargeBar

int isLargeBar

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

Definition hip_runtime_api.h:394

hipDeviceProp_t::clusterLaunch

int clusterLaunch

Device supports cluster launch.

Definition hip_runtime_api.h:368

hipFuncAttributes::numRegs

int numRegs

Definition hip_runtime_api.h:821

hipDeviceProp_t::maxTexture1DMipmap

int maxTexture1DMipmap

Maximum 1D mipmap texture size.

Definition hip_runtime_api.h:291

hipDeviceProp_t::multiProcessorCount

int multiProcessorCount

Definition hip_runtime_api.h:282

hipMemAllocationProp::allocFlags

struct hipMemAllocationProp::@36 allocFlags

hipGraphNodeParams::reserved2

long long reserved2

Definition hip_runtime_api.h:2124

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

hipDevWorkqueueResource::reserved

unsigned char reserved[HIP_RESOURCE_ABI_BYTES]

Definition hip_runtime_api.h:756

hipDeviceProp_t::maxTexture3DAlt

int maxTexture3DAlt[3]

Maximum alternate 3D texture dims.

Definition hip_runtime_api.h:299

hipMemFreeNodeParams::dptr

void * dptr

the pointer to be freed

Definition hip_runtime_api.h:2100

hipDeviceProp_t::maxGridSize

int maxGridSize[3]

Max grid dimensions (XYZ).

Definition hip_runtime_api.h:266

hipAccessPolicyWindow::base_ptr

void * base_ptr

Starting address of the access policy window.

Definition hip_runtime_api.h:1655

hipDeviceProp_t::pciDeviceID

int pciDeviceID

PCI Device ID.

Definition hip_runtime_api.h:315

hipDeviceProp_t::maxBlocksPerMultiProcessor

int maxBlocksPerMultiProcessor

Max number of blocks on CU.

Definition hip_runtime_api.h:350

hipStreamBatchMemOpParams::hipStreamMemOpMemoryBarrierParams_t::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:1145

hipDeviceProp_t::computeMode

int computeMode

Compute mode.

Definition hip_runtime_api.h:289

hipLaunchAttributeValue::syncPolicy

hipSynchronizationPolicy syncPolicy

Definition hip_runtime_api.h:1773

hipMemPoolProps::win32SecurityAttributes

void * win32SecurityAttributes

Definition hip_runtime_api.h:1358

hipFunctionLaunchParams::blockDimZ

unsigned int blockDimZ

Z dimension of each thread block.

Definition hip_runtime_api.h:1435

hipExtDynDataPrefetchRegion::height

size_t height

Number of rows to prefetch.

Definition hip_runtime_api.h:1717

hipLaunchAttributeValue::clusterSchedulingPolicyPreference

hipClusterSchedulingPolicy clusterSchedulingPolicyPreference

Definition hip_runtime_api.h:1797

hipDeviceProp_t::maxSurface2DLayered

int maxSurface2DLayered[3]

Maximum 2D layared surface size.

Definition hip_runtime_api.h:308

hipDeviceProp_t::major

int major

Definition hip_runtime_api.h:270

hipArrayMapInfo::memHandle

union hipArrayMapInfo::@39 memHandle

hipLaunchMemSyncDomainMap::default_

unsigned char default_

Definition hip_runtime_api.h:1666

hipBatchMemOpNodeParams::ctx

hipCtx_t ctx

Definition hip_runtime_api.h:1179

hipLaunchParams::gridDim

dim3 gridDim

Grid dimensions.

Definition hip_runtime_api.h:1419

hipLaunchParams::func

void * func

Device function symbol.

Definition hip_runtime_api.h:1418

hipMemcpyNodeParams::copyParams

hipMemcpy3DParms copyParams

Params set for the memory copy.

Definition hip_runtime_api.h:2071

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:1127

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

hipExternalMemoryBufferDesc::offset

unsigned long long offset

Definition hip_runtime_api.h:1465

hipDeviceProp_t::warpSize

int warpSize

Warp size.

Definition hip_runtime_api.h:261

hipDeviceProp_t::tccDriver

int tccDriver

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

Definition hip_runtime_api.h:317

hipDeviceProp_t::luidDeviceNodeMask

unsigned int luidDeviceNodeMask

LUID node mask.

Definition hip_runtime_api.h:257

hipMemsetParams::pitch

size_t pitch

Definition hip_runtime_api.h:1626

hipExternalMemoryMipmappedArrayDesc::formatDesc

hipChannelFormatDesc formatDesc

Definition hip_runtime_api.h:1472

hipMemsetParams::height

size_t height

Definition hip_runtime_api.h:1625

hipFunctionLaunchParams::kernelParams

void ** kernelParams

Kernel parameters.

Definition hip_runtime_api.h:1438

hipDeviceProp_t::hostRegisterReadOnlySupported

int hostRegisterReadOnlySupported

Definition hip_runtime_api.h:355

hipFuncAttributes::localSizeBytes

size_t localSizeBytes

Definition hip_runtime_api.h:818

hipExternalMemoryBufferDesc::size

unsigned long long size

Definition hip_runtime_api.h:1466

HIP_LAUNCH_CONFIG::blockDimX

unsigned int blockDimX

Thread block dimension in X.

Definition hip_runtime_api.h:2196

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedSharedMem

int cooperativeMultiDeviceUnmatchedSharedMem

Definition hip_runtime_api.h:391

hipArrayMapInfo::offset

unsigned long long offset

Offset within the memory.

Definition hip_runtime_api.h:2059

hipLaunchParams::stream

hipStream_t stream

Stream identifier.

Definition hip_runtime_api.h:1423

hipFuncAttributes::maxThreadsPerBlock

int maxThreadsPerBlock

Definition hip_runtime_api.h:820

hipExtDynDataPrefetchRegion::stride

size_t stride

Stride between row starts in bytes.

Definition hip_runtime_api.h:1715

hipDeviceProp_t::maxThreadsPerBlock

int maxThreadsPerBlock

Max work items per work group or workgroup max size.

Definition hip_runtime_api.h:264

hipAccessPolicyWindow::num_bytes

size_t num_bytes

Size in bytes of the window policy.

Definition hip_runtime_api.h:1659

hipDeviceProp_t::arch

hipDeviceArch_t arch

Architectural feature flags. New for HIP.

Definition hip_runtime_api.h:379

hipLaunchAttributeValue::memSyncDomainMap

hipLaunchMemSyncDomainMap memSyncDomainMap

Value of launch attribute hipLaunchAttributeMemSyncDomainMap.

Definition hip_runtime_api.h:1776

hipDeviceProp_t::managedMemory

int managedMemory

Device supports allocating managed memory on this system.

Definition hip_runtime_api.h:330

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

hipLimit_t

hipLimit_t

Definition hip_runtime_api.h:834

hipMemRangeHandleType

hipMemRangeHandleType

Definition hip_runtime_api.h:2216

hipExecutionCtx_t

struct ihipExecutionCtx_t * hipExecutionCtx_t

Definition hip_runtime_api.h:719

hipMemAllocationHandleType

hipMemAllocationHandleType

Definition hip_runtime_api.h:1338

hipGraphicsResource_t

hipGraphicsResource * hipGraphicsResource_t

Definition hip_runtime_api.h:1566

hipCtx_t

struct ihipCtx_t * hipCtx_t

Definition hip_runtime_api.h:718

__dparm

#define __dparm(x)

Definition hip_runtime_api.h:700

hipStream_t

struct ihipStream_t * hipStream_t

Definition hip_runtime_api.h:792

hipGraphInstantiateResult

hipGraphInstantiateResult

Definition hip_runtime_api.h:1922

hipDevice_t

int hipDevice_t

Definition hip_runtime_api.h:780

hipAccessProperty

hipAccessProperty

Definition hip_runtime_api.h:1644

hipLinkState_t

struct ihipLinkState_t * hipLinkState_t

Definition hip_runtime_api.h:806

hipGraphDependencyType

hipGraphDependencyType

Definition hip_runtime_api.h:2144

hipMemRangeAttribute

hipMemRangeAttribute

Definition hip_runtime_api.h:1231

hipMemAttachSingle

#define hipMemAttachSingle

Definition hip_runtime_api.h:987

hipMemoryAdvise

hipMemoryAdvise

Definition hip_runtime_api.h:1198

hipArrayDefault

#define hipArrayDefault

Definition hip_runtime_api.h:1048

hipSharedMemConfig

hipSharedMemConfig

Definition hip_runtime_api.h:1395

hipKernelNodeAttrValue

#define hipKernelNodeAttrValue

Definition hip_runtime_api.h:1825

hipComputeMode

hipComputeMode

Definition hip_runtime_api.h:655

hipEvent_t

struct ihipEvent_t * hipEvent_t

Definition hip_runtime_api.h:826

hipStreamCaptureMode

hipStreamCaptureMode

Definition hip_runtime_api.h:1854

hipStreamBatchMemOpType

hipStreamBatchMemOpType

Definition hip_runtime_api.h:1073

hipDriverProcAddressQueryResult

hipDriverProcAddressQueryResult

Definition hip_runtime_api.h:649

HIP_DEPRECATED_MSG

#define HIP_DEPRECATED_MSG

Definition hip_runtime_api.h:692

hipLaunchAttributeID

hipLaunchAttributeID

Definition hip_runtime_api.h:1746

hipKernel_t

struct ihipKernel_t * hipKernel_t

Definition hip_runtime_api.h:808

hipSynchronizationPolicy

hipSynchronizationPolicy

Definition hip_runtime_api.h:1682

hipGraphNodeType

hipGraphNodeType

Definition hip_runtime_api.h:1590

hipExternalMemoryHandleType

hipExternalMemoryHandleType

Definition hip_runtime_api.h:1440

hipMemAttachGlobal

#define hipMemAttachGlobal

Definition hip_runtime_api.h:981

hipLibrary_t

struct ihipLibrary_t * hipLibrary_t

Definition hip_runtime_api.h:807

hipFuncAttribute

hipFuncAttribute

Definition hip_runtime_api.h:1372

hipExternalSemaphoreHandleType

hipExternalSemaphoreHandleType

Definition hip_runtime_api.h:1478

hipLaunchMemSyncDomain

hipLaunchMemSyncDomain

Definition hip_runtime_api.h:1673

hipDevResourceDesc_t

struct ihipDevResourceDesc_t * hipDevResourceDesc_t

Definition hip_runtime_api.h:720

hipDeviceP2PAttr

hipDeviceP2PAttr

Definition hip_runtime_api.h:781

hipGraphDebugDotFlags

hipGraphDebugDotFlags

Definition hip_runtime_api.h:1900

hipDevSmResourceGroup_flags

hipDevSmResourceGroup_flags

Definition hip_runtime_api.h:727

hipUserObjectRetainFlags

hipUserObjectRetainFlags

Definition hip_runtime_api.h:1885

hipStreamAttrID

#define hipStreamAttrID

Definition hip_runtime_api.h:1805

hipError_t

enum __HIP_NODISCARD hipError_t hipError_t

Definition hip_runtime_api.h:106

hipHostAllocDefault

#define hipHostAllocDefault

Definition hip_runtime_api.h:923

hipHostFn_t

void(* hipHostFn_t)(void *userData)

Definition hip_runtime_api.h:1609

hipOccupancyDefault

#define hipOccupancyDefault

Definition hip_runtime_api.h:1053

hipStreamUpdateCaptureDependenciesFlags

hipStreamUpdateCaptureDependenciesFlags

Definition hip_runtime_api.h:1866

hipGraph_t

struct ihipGraph * hipGraph_t

Definition hip_runtime_api.h:1571

hipMemHandleType

hipMemHandleType

Definition hip_runtime_api.h:2004

hipFlushGPUDirectRDMAWritesOptions

hipFlushGPUDirectRDMAWritesOptions

Definition hip_runtime_api.h:662

hipFuncCache_t

hipFuncCache_t

Definition hip_runtime_api.h:1386

hipUserObjectFlags

hipUserObjectFlags

Definition hip_runtime_api.h:1881

__HIP_NODISCARD

#define __HIP_NODISCARD

Definition hip_runtime_api.h:96

hipDevWorkqueueConfigScope

hipDevWorkqueueConfigScope

Definition hip_runtime_api.h:735

hipGraphMemAttributeType

hipGraphMemAttributeType

Definition hip_runtime_api.h:1871

hipMemPoolAttr

hipMemPoolAttr

Definition hip_runtime_api.h:1246

hipDriverEntryPointQueryResult

hipDriverEntryPointQueryResult

Definition hip_runtime_api.h:787

hipMemRangeFlags

hipMemRangeFlags

Definition hip_runtime_api.h:2224

hipDevSmResourceSplitByCount_flags

hipDevSmResourceSplitByCount_flags

Definition hip_runtime_api.h:731

HIP_RESOURCE_ABI_BYTES

#define HIP_RESOURCE_ABI_BYTES

Definition hip_runtime_api.h:740

hipModule_t

struct ihipModule_t * hipModule_t

Definition hip_runtime_api.h:804

hipUserObject_t

struct hipUserObject * hipUserObject_t

Definition hip_runtime_api.h:1584

hipMemOperationType

hipMemOperationType

Definition hip_runtime_api.h:2011

hipExternalSemaphore_t

void * hipExternalSemaphore_t

Definition hip_runtime_api.h:1503

hipGraphicsRegisterFlags

hipGraphicsRegisterFlags

Definition hip_runtime_api.h:1554

HIP_EXT_DYN_DATA_PREFETCH_MAX_REGIONS

#define HIP_EXT_DYN_DATA_PREFETCH_MAX_REGIONS

Definition hip_runtime_api.h:1725

hipStreamAttrValue

#define hipStreamAttrValue

Definition hip_runtime_api.h:1812

hipMemRangeCoherencyMode

hipMemRangeCoherencyMode

Definition hip_runtime_api.h:1219

hipMemAccessFlags

hipMemAccessFlags

Definition hip_runtime_api.h:1306

hipMemAllocationGranularity_flags

hipMemAllocationGranularity_flags

Definition hip_runtime_api.h:1996

hipExtDynDataPrefetchTemporal

hipExtDynDataPrefetchTemporal

Temporal locality hint for dynamic data prefetch.

Definition hip_runtime_api.h:1700

hipGraphExec_t

struct hipGraphExec * hipGraphExec_t

Definition hip_runtime_api.h:1579

hipGraphExecUpdateResult

hipGraphExecUpdateResult

Definition hip_runtime_api.h:1839

hipFunction_t

struct ihipModuleSymbol_t * hipFunction_t

Definition hip_runtime_api.h:805

hipKernelNodeAttrID

#define hipKernelNodeAttrID

Definition hip_runtime_api.h:1817

hipExternalMemory_t

void * hipExternalMemory_t

Definition hip_runtime_api.h:1477

hipStreamCaptureStatus

hipStreamCaptureStatus

Definition hip_runtime_api.h:1859

hipDeviceAttribute_t

hipDeviceAttribute_t

Definition hip_runtime_api.h:440

hipGPUDirectRDMAWritesOrdering

hipGPUDirectRDMAWritesOrdering

Definition hip_runtime_api.h:667

hipDeviceProp_tR0600

hipDeviceProp_t hipDeviceProp_tR0600

Definition hip_runtime_api.h:399

hipHostMallocDefault

#define hipHostMallocDefault

Definition hip_runtime_api.h:927

HIP_DEPRECATED

#define HIP_DEPRECATED(msg)

Definition hip_runtime_api.h:689

hipGraphicsResource

struct _hipGraphicsResource hipGraphicsResource

Definition hip_runtime_api.h:1564

hipMemAllocationType

hipMemAllocationType

Definition hip_runtime_api.h:1324

hipGraphNode_t

struct hipGraphNode * hipGraphNode_t

Definition hip_runtime_api.h:1575

hipMemGenericAllocationHandle_t

struct ihipMemGenericAllocationHandle * hipMemGenericAllocationHandle_t

Definition hip_runtime_api.h:1991

hipClusterSchedulingPolicy

hipClusterSchedulingPolicy

Definition hip_runtime_api.h:1690

hipMemoryType

hipMemoryType

Definition hip_runtime_api.h:409

hipGraphInstantiateFlags

hipGraphInstantiateFlags

Definition hip_runtime_api.h:1889

HIP_IPC_HANDLE_SIZE

#define HIP_IPC_HANDLE_SIZE

Definition hip_runtime_api.h:794

hipMemPool_t

struct ihipMemPoolHandle_t * hipMemPool_t

Definition hip_runtime_api.h:812

hipDevResourceType

hipDevResourceType

Definition hip_runtime_api.h:721

hipArraySparseSubresourceType

hipArraySparseSubresourceType

Definition hip_runtime_api.h:2019

hipExtLimitScratchMin

@ hipExtLimitScratchMin

Definition hip_runtime_api.h:842

hipLimitMallocHeapSize

@ hipLimitMallocHeapSize

Definition hip_runtime_api.h:840

hipLimitStackSize

@ hipLimitStackSize

Definition hip_runtime_api.h:835

hipLimitRange

@ hipLimitRange

Supported limit range.

Definition hip_runtime_api.h:850

hipLimitPrintfFifoSize

@ hipLimitPrintfFifoSize

Definition hip_runtime_api.h:838

hipExtLimitScratchMax

@ hipExtLimitScratchMax

Definition hip_runtime_api.h:844

hipExtLimitScratchCurrent

@ hipExtLimitScratchCurrent

Definition hip_runtime_api.h:846

hipMemRangeHandleTypeMax

@ hipMemRangeHandleTypeMax

Definition hip_runtime_api.h:2218

hipMemRangeHandleTypeDmaBufFd

@ hipMemRangeHandleTypeDmaBufFd

Definition hip_runtime_api.h:2217

hipMemHandleTypeWin32

@ hipMemHandleTypeWin32

Allows a Win32 NT handle for exporting. (HANDLE)

Definition hip_runtime_api.h:1342

hipMemHandleTypeWin32Kmt

@ hipMemHandleTypeWin32Kmt

Allows a Win32 KMT handle for exporting. (D3DKMT_HANDLE)

Definition hip_runtime_api.h:1343

hipMemHandleTypeNone

@ hipMemHandleTypeNone

Does not allow any export mechanism.

Definition hip_runtime_api.h:1339

hipMemHandleTypePosixFileDescriptor

@ hipMemHandleTypePosixFileDescriptor

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

Definition hip_runtime_api.h:1340

hipMemHandleTypeFabric

@ hipMemHandleTypeFabric

Allows a fabric handle to be used for exporting.

Definition hip_runtime_api.h:1344

hipGraphInstantiateNodeOperationNotSupported

@ hipGraphInstantiateNodeOperationNotSupported

Definition hip_runtime_api.h:1928

hipGraphInstantiateMultipleDevicesNotSupported

@ hipGraphInstantiateMultipleDevicesNotSupported

Definition hip_runtime_api.h:1930

hipGraphInstantiateError

@ hipGraphInstantiateError

Definition hip_runtime_api.h:1924

hipGraphInstantiateInvalidStructure

@ hipGraphInstantiateInvalidStructure

Definition hip_runtime_api.h:1926

hipGraphInstantiateSuccess

@ hipGraphInstantiateSuccess

Definition hip_runtime_api.h:1923

hipAccessPropertyNormal

@ hipAccessPropertyNormal

Normal cache persistence.

Definition hip_runtime_api.h:1645

hipAccessPropertyPersisting

@ hipAccessPropertyPersisting

Persisting access is more likely to persist in cache.

Definition hip_runtime_api.h:1647

hipAccessPropertyStreaming

@ hipAccessPropertyStreaming

Streaming access is less likely to persist from cache.

Definition hip_runtime_api.h:1646

hipGraphDependencyTypeDefault

@ hipGraphDependencyTypeDefault

Definition hip_runtime_api.h:2145

hipGraphDependencyTypeProgrammatic

@ hipGraphDependencyTypeProgrammatic

Definition hip_runtime_api.h:2146

hipMemRangeAttributeLastPrefetchLocation

@ hipMemRangeAttributeLastPrefetchLocation

Definition hip_runtime_api.h:1237

hipMemRangeAttributePreferredLocation

@ hipMemRangeAttributePreferredLocation

The preferred location of the range.

Definition hip_runtime_api.h:1234

hipMemRangeAttributeAccessedBy

@ hipMemRangeAttributeAccessedBy

Definition hip_runtime_api.h:1235

hipMemRangeAttributeReadMostly

@ hipMemRangeAttributeReadMostly

Definition hip_runtime_api.h:1232

hipMemRangeAttributeCoherencyMode

@ hipMemRangeAttributeCoherencyMode

Definition hip_runtime_api.h:1239

hipMemAdviseUnsetAccessedBy

@ hipMemAdviseUnsetAccessedBy

Definition hip_runtime_api.h:1207

hipMemAdviseUnsetCoarseGrain

@ hipMemAdviseUnsetCoarseGrain

Restores cache coherency policy back to fine-grain.

Definition hip_runtime_api.h:1214

hipMemAdviseSetCoarseGrain

@ hipMemAdviseSetCoarseGrain

Definition hip_runtime_api.h:1209

hipMemAdviseUnsetPreferredLocation

@ hipMemAdviseUnsetPreferredLocation

Clear the preferred location for the data.

Definition hip_runtime_api.h:1204

hipMemAdviseSetAccessedBy

@ hipMemAdviseSetAccessedBy

Definition hip_runtime_api.h:1205

hipMemAdviseSetPreferredLocation

@ hipMemAdviseSetPreferredLocation

Definition hip_runtime_api.h:1202

hipMemAdviseSetReadMostly

@ hipMemAdviseSetReadMostly

Definition hip_runtime_api.h:1199

hipMemAdviseUnsetReadMostly

@ hipMemAdviseUnsetReadMostly

Undo the effect of hipMemAdviseSetReadMostly.

Definition hip_runtime_api.h:1201

hipSharedMemBankSizeFourByte

@ hipSharedMemBankSizeFourByte

Definition hip_runtime_api.h:1397

hipSharedMemBankSizeEightByte

@ hipSharedMemBankSizeEightByte

Definition hip_runtime_api.h:1399

hipSharedMemBankSizeDefault

@ hipSharedMemBankSizeDefault

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

Definition hip_runtime_api.h:1396

hipComputeModeProhibited

@ hipComputeModeProhibited

Definition hip_runtime_api.h:658

hipComputeModeExclusive

@ hipComputeModeExclusive

Definition hip_runtime_api.h:657

hipComputeModeDefault

@ hipComputeModeDefault

Definition hip_runtime_api.h:656

hipComputeModeExclusiveProcess

@ hipComputeModeExclusiveProcess

Definition hip_runtime_api.h:659

hipStreamCaptureModeRelaxed

@ hipStreamCaptureModeRelaxed

Definition hip_runtime_api.h:1857

hipStreamCaptureModeThreadLocal

@ hipStreamCaptureModeThreadLocal

Definition hip_runtime_api.h:1856

hipStreamCaptureModeGlobal

@ hipStreamCaptureModeGlobal

Definition hip_runtime_api.h:1855

hipStreamMemOpWriteValue64

@ hipStreamMemOpWriteValue64

Definition hip_runtime_api.h:1077

hipStreamMemOpBarrier

@ hipStreamMemOpBarrier

Currently not supported.

Definition hip_runtime_api.h:1078

hipStreamMemOpWriteValue32

@ hipStreamMemOpWriteValue32

Definition hip_runtime_api.h:1075

hipStreamMemOpWaitValue32

@ hipStreamMemOpWaitValue32

Definition hip_runtime_api.h:1074

hipStreamMemOpWaitValue64

@ hipStreamMemOpWaitValue64

Definition hip_runtime_api.h:1076

hipStreamMemOpFlushRemoteWrites

@ hipStreamMemOpFlushRemoteWrites

Currently not supported.

Definition hip_runtime_api.h:1079

HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND

@ HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND

Definition hip_runtime_api.h:651

HIP_GET_PROC_ADDRESS_SUCCESS

@ HIP_GET_PROC_ADDRESS_SUCCESS

Definition hip_runtime_api.h:650

HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT

@ HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT

Definition hip_runtime_api.h:652

hipLaunchAttributePriority

@ hipLaunchAttributePriority

Valid for graph node, streams, launches.

Definition hip_runtime_api.h:1753

hipLaunchAttributeMax

@ hipLaunchAttributeMax

Definition hip_runtime_api.h:1757

hipLaunchAttributeClusterDimension

@ hipLaunchAttributeClusterDimension

Valid for graph nodes, launches.

Definition hip_runtime_api.h:1751

hipLaunchAttributeMemSyncDomain

@ hipLaunchAttributeMemSyncDomain

Valid for streams, graph nodes, launches.

Definition hip_runtime_api.h:1755

hipLaunchAttributeMemSyncDomainMap

@ hipLaunchAttributeMemSyncDomainMap

Valid for streams, graph nodes, launches.

Definition hip_runtime_api.h:1754

hipLaunchAttributeIgnore

@ hipLaunchAttributeIgnore

Ignored entry.

Definition hip_runtime_api.h:1747

hipLaunchAttributeSynchronizationPolicy

@ hipLaunchAttributeSynchronizationPolicy

Valid for streams.

Definition hip_runtime_api.h:1750

hipLaunchAttributeExtDynDataPrefetch

@ hipLaunchAttributeExtDynDataPrefetch

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

Definition hip_runtime_api.h:1756

hipLaunchAttributeClusterSchedulingPolicyPreference

@ hipLaunchAttributeClusterSchedulingPolicyPreference

Valid for graph nodes, launches.

Definition hip_runtime_api.h:1752

hipLaunchAttributeAccessPolicyWindow

@ hipLaunchAttributeAccessPolicyWindow

Valid for Streams, graph nodes, launches.

Definition hip_runtime_api.h:1748

hipLaunchAttributeCooperative

@ hipLaunchAttributeCooperative

Valid for graph nodes, launches.

Definition hip_runtime_api.h:1749

hipSyncPolicyYield

@ hipSyncPolicyYield

Definition hip_runtime_api.h:1685

hipSyncPolicyBlockingSync

@ hipSyncPolicyBlockingSync

Definition hip_runtime_api.h:1686

hipSyncPolicyAuto

@ hipSyncPolicyAuto

Definition hip_runtime_api.h:1683

hipSyncPolicySpin

@ hipSyncPolicySpin

Definition hip_runtime_api.h:1684

hipGraphNodeTypeBatchMemOp

@ hipGraphNodeTypeBatchMemOp

BatchMemOp node.

Definition hip_runtime_api.h:1605

hipGraphNodeTypeGraph

@ hipGraphNodeTypeGraph

Node which executes an embedded graph.

Definition hip_runtime_api.h:1595

hipGraphNodeTypeMemset

@ hipGraphNodeTypeMemset

Memset node.

Definition hip_runtime_api.h:1593

hipGraphNodeTypeEventRecord

@ hipGraphNodeTypeEventRecord

External event record node.

Definition hip_runtime_api.h:1598

hipGraphNodeTypeExtSemaphoreSignal

@ hipGraphNodeTypeExtSemaphoreSignal

External Semaphore signal node.

Definition hip_runtime_api.h:1599

hipGraphNodeTypeMemcpy

@ hipGraphNodeTypeMemcpy

Memcpy node.

Definition hip_runtime_api.h:1592

hipGraphNodeTypeWaitEvent

@ hipGraphNodeTypeWaitEvent

External event wait node.

Definition hip_runtime_api.h:1597

hipGraphNodeTypeCount

@ hipGraphNodeTypeCount

Definition hip_runtime_api.h:1606

hipGraphNodeTypeKernel

@ hipGraphNodeTypeKernel

GPU kernel node.

Definition hip_runtime_api.h:1591

hipGraphNodeTypeHost

@ hipGraphNodeTypeHost

Host (executable) node.

Definition hip_runtime_api.h:1594

hipGraphNodeTypeMemAlloc

@ hipGraphNodeTypeMemAlloc

Memory alloc node.

Definition hip_runtime_api.h:1601

hipGraphNodeTypeMemFree

@ hipGraphNodeTypeMemFree

Memory free node.

Definition hip_runtime_api.h:1602

hipGraphNodeTypeMemcpyFromSymbol

@ hipGraphNodeTypeMemcpyFromSymbol

MemcpyFromSymbol node.

Definition hip_runtime_api.h:1603

hipGraphNodeTypeMemcpyToSymbol

@ hipGraphNodeTypeMemcpyToSymbol

MemcpyToSymbol node.

Definition hip_runtime_api.h:1604

hipGraphNodeTypeEmpty

@ hipGraphNodeTypeEmpty

Empty (no-op) node.

Definition hip_runtime_api.h:1596

hipGraphNodeTypeExtSemaphoreWait

@ hipGraphNodeTypeExtSemaphoreWait

External Semaphore wait node.

Definition hip_runtime_api.h:1600

hipExternalMemoryHandleTypeD3D11Resource

@ hipExternalMemoryHandleTypeD3D11Resource

Definition hip_runtime_api.h:1446

hipExternalMemoryHandleTypeD3D12Resource

@ hipExternalMemoryHandleTypeD3D12Resource

Definition hip_runtime_api.h:1445

hipExternalMemoryHandleTypeNvSciBuf

@ hipExternalMemoryHandleTypeNvSciBuf

Definition hip_runtime_api.h:1448

hipExternalMemoryHandleTypeOpaqueFd

@ hipExternalMemoryHandleTypeOpaqueFd

Definition hip_runtime_api.h:1441

hipExternalMemoryHandleTypeD3D12Heap

@ hipExternalMemoryHandleTypeD3D12Heap

Definition hip_runtime_api.h:1444

hipExternalMemoryHandleTypeOpaqueWin32Kmt

@ hipExternalMemoryHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:1443

hipExternalMemoryHandleTypeOpaqueWin32

@ hipExternalMemoryHandleTypeOpaqueWin32

Definition hip_runtime_api.h:1442

hipExternalMemoryHandleTypeD3D11ResourceKmt

@ hipExternalMemoryHandleTypeD3D11ResourceKmt

Definition hip_runtime_api.h:1447

hipFuncAttributeClusterSchedulingPolicyPreference

@ hipFuncAttributeClusterSchedulingPolicyPreference

The block scheduling policy of a function.

Definition hip_runtime_api.h:1380

hipFuncAttributePreferredSharedMemoryCarveout

@ hipFuncAttributePreferredSharedMemoryCarveout

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

Definition hip_runtime_api.h:1374

hipFuncAttributeRequiredClusterWidth

@ hipFuncAttributeRequiredClusterWidth

The required cluster width in blocks.

Definition hip_runtime_api.h:1376

hipFuncAttributeMaxDynamicSharedMemorySize

@ hipFuncAttributeMaxDynamicSharedMemorySize

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

Definition hip_runtime_api.h:1373

hipFuncAttributeMax

@ hipFuncAttributeMax

Definition hip_runtime_api.h:1381

hipFuncAttributeRequiredClusterDepth

@ hipFuncAttributeRequiredClusterDepth

The required cluster depth in blocks.

Definition hip_runtime_api.h:1378

hipFuncAttributeRequiredClusterHeight

@ hipFuncAttributeRequiredClusterHeight

The required cluster height in blocks.

Definition hip_runtime_api.h:1377

hipFuncAttributeClusterDimMustBeSet

@ hipFuncAttributeClusterDimMustBeSet

The kernel must launch with a valid cluster size specified.

Definition hip_runtime_api.h:1375

hipFuncAttributeNonPortableClusterSizeAllowed

@ hipFuncAttributeNonPortableClusterSizeAllowed

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

Definition hip_runtime_api.h:1379

hipExternalSemaphoreHandleTypeNvSciSync

@ hipExternalSemaphoreHandleTypeNvSciSync

Definition hip_runtime_api.h:1484

hipExternalSemaphoreHandleTypeKeyedMutexKmt

@ hipExternalSemaphoreHandleTypeKeyedMutexKmt

Definition hip_runtime_api.h:1486

hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

@ hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:1481

hipExternalSemaphoreHandleTypeKeyedMutex

@ hipExternalSemaphoreHandleTypeKeyedMutex

Definition hip_runtime_api.h:1485

hipExternalSemaphoreHandleTypeD3D11Fence

@ hipExternalSemaphoreHandleTypeD3D11Fence

Definition hip_runtime_api.h:1483

hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

@ hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

Definition hip_runtime_api.h:1488

hipExternalSemaphoreHandleTypeOpaqueFd

@ hipExternalSemaphoreHandleTypeOpaqueFd

Definition hip_runtime_api.h:1479

hipExternalSemaphoreHandleTypeOpaqueWin32

@ hipExternalSemaphoreHandleTypeOpaqueWin32

Definition hip_runtime_api.h:1480

hipExternalSemaphoreHandleTypeTimelineSemaphoreFd

@ hipExternalSemaphoreHandleTypeTimelineSemaphoreFd

Definition hip_runtime_api.h:1487

hipExternalSemaphoreHandleTypeD3D12Fence

@ hipExternalSemaphoreHandleTypeD3D12Fence

Definition hip_runtime_api.h:1482

hipLaunchMemSyncDomainRemote

@ hipLaunchMemSyncDomainRemote

Definition hip_runtime_api.h:1675

hipLaunchMemSyncDomainDefault

@ hipLaunchMemSyncDomainDefault

Definition hip_runtime_api.h:1674

hipDevP2PAttrAccessSupported

@ hipDevP2PAttrAccessSupported

Definition hip_runtime_api.h:783

hipDevP2PAttrHipArrayAccessSupported

@ hipDevP2PAttrHipArrayAccessSupported

Definition hip_runtime_api.h:785

hipDevP2PAttrNativeAtomicSupported

@ hipDevP2PAttrNativeAtomicSupported

Definition hip_runtime_api.h:784

hipDevP2PAttrPerformanceRank

@ hipDevP2PAttrPerformanceRank

Definition hip_runtime_api.h:782

hipGraphDebugDotFlagsKernelNodeAttributes

@ hipGraphDebugDotFlagsKernelNodeAttributes

Definition hip_runtime_api.h:1913

hipGraphDebugDotFlagsMemsetNodeParams

@ hipGraphDebugDotFlagsMemsetNodeParams

Definition hip_runtime_api.h:1905

hipGraphDebugDotFlagsKernelNodeParams

@ hipGraphDebugDotFlagsKernelNodeParams

Definition hip_runtime_api.h:1903

hipGraphDebugDotFlagsExtSemasWaitNodeParams

@ hipGraphDebugDotFlagsExtSemasWaitNodeParams

Definition hip_runtime_api.h:1911

hipGraphDebugDotFlagsHandles

@ hipGraphDebugDotFlagsHandles

Definition hip_runtime_api.h:1915

hipGraphDebugDotFlagsExtSemasSignalNodeParams

@ hipGraphDebugDotFlagsExtSemasSignalNodeParams

Definition hip_runtime_api.h:1909

hipGraphDebugDotFlagsHostNodeParams

@ hipGraphDebugDotFlagsHostNodeParams

Definition hip_runtime_api.h:1906

hipGraphDebugDotFlagsEventNodeParams

@ hipGraphDebugDotFlagsEventNodeParams

Definition hip_runtime_api.h:1907

hipGraphDebugDotFlagsVerbose

@ hipGraphDebugDotFlagsVerbose

Definition hip_runtime_api.h:1901

hipGraphDebugDotFlagsMemcpyNodeParams

@ hipGraphDebugDotFlagsMemcpyNodeParams

Definition hip_runtime_api.h:1904

hipDevSmResourceGroupBackfill

@ hipDevSmResourceGroupBackfill

Definition hip_runtime_api.h:729

hipDevSmResourceGroupDefault

@ hipDevSmResourceGroupDefault

Definition hip_runtime_api.h:728

hipGraphUserObjectMove

@ hipGraphUserObjectMove

Add new reference or retain.

Definition hip_runtime_api.h:1886

hipStreamAddCaptureDependencies

@ hipStreamAddCaptureDependencies

Add new nodes to the dependency set.

Definition hip_runtime_api.h:1867

hipStreamSetCaptureDependencies

@ hipStreamSetCaptureDependencies

Replace the dependency set with the new nodes.

Definition hip_runtime_api.h:1868

hipMemHandleTypeGeneric

@ hipMemHandleTypeGeneric

Generic handle type.

Definition hip_runtime_api.h:2005

hipFlushGPUDirectRDMAWritesOptionHost

@ hipFlushGPUDirectRDMAWritesOptionHost

Definition hip_runtime_api.h:663

hipFlushGPUDirectRDMAWritesOptionMemOps

@ hipFlushGPUDirectRDMAWritesOptionMemOps

Definition hip_runtime_api.h:664

hipFuncCachePreferNone

@ hipFuncCachePreferNone

no preference for shared memory or L1 (default)

Definition hip_runtime_api.h:1387

hipFuncCachePreferEqual

@ hipFuncCachePreferEqual

prefer equal size L1 cache and shared memory

Definition hip_runtime_api.h:1390

hipFuncCachePreferL1

@ hipFuncCachePreferL1

prefer larger L1 cache and smaller shared memory

Definition hip_runtime_api.h:1389

hipFuncCachePreferShared

@ hipFuncCachePreferShared

prefer larger shared memory and smaller L1 cache

Definition hip_runtime_api.h:1388

hipUserObjectNoDestructorSync

@ hipUserObjectNoDestructorSync

Destructor execution is not synchronized.

Definition hip_runtime_api.h:1882

hipDevWorkqueueConfigScopeDeviceCtx

@ hipDevWorkqueueConfigScopeDeviceCtx

Definition hip_runtime_api.h:736

hipDevWorkqueueConfigScopeGreenCtxBalanced

@ hipDevWorkqueueConfigScopeGreenCtxBalanced

Definition hip_runtime_api.h:737

hipGraphMemAttrReservedMemHigh

@ hipGraphMemAttrReservedMemHigh

Definition hip_runtime_api.h:1878

hipGraphMemAttrUsedMemCurrent

@ hipGraphMemAttrUsedMemCurrent

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

Definition hip_runtime_api.h:1872

hipGraphMemAttrUsedMemHigh

@ hipGraphMemAttrUsedMemHigh

Definition hip_runtime_api.h:1874

hipGraphMemAttrReservedMemCurrent

@ hipGraphMemAttrReservedMemCurrent

Definition hip_runtime_api.h:1876

hipMemPoolAttrUsedMemCurrent

@ hipMemPoolAttrUsedMemCurrent

Definition hip_runtime_api.h:1293

hipMemPoolAttrReservedMemHigh

@ hipMemPoolAttrReservedMemHigh

Definition hip_runtime_api.h:1288

hipMemPoolAttrReservedMemCurrent

@ hipMemPoolAttrReservedMemCurrent

Definition hip_runtime_api.h:1282

hipMemPoolAttrReleaseThreshold

@ hipMemPoolAttrReleaseThreshold

Definition hip_runtime_api.h:1277

hipMemPoolAttrUsedMemHigh

@ hipMemPoolAttrUsedMemHigh

Definition hip_runtime_api.h:1299

hipMemPoolReuseAllowInternalDependencies

@ hipMemPoolReuseAllowInternalDependencies

Definition hip_runtime_api.h:1268

hipMemPoolReuseFollowEventDependencies

@ hipMemPoolReuseFollowEventDependencies

Definition hip_runtime_api.h:1255

hipMemPoolReuseAllowOpportunistic

@ hipMemPoolReuseAllowOpportunistic

Definition hip_runtime_api.h:1261

hipDriverEntryPointSuccess

@ hipDriverEntryPointSuccess

Definition hip_runtime_api.h:788

hipDriverEntryPointSymbolNotFound

@ hipDriverEntryPointSymbolNotFound

Definition hip_runtime_api.h:789

hipDriverEntryPointVersionNotSufficent

@ hipDriverEntryPointVersionNotSufficent

Definition hip_runtime_api.h:790

hipMemRangeFlagsMax

@ hipMemRangeFlagsMax

Definition hip_runtime_api.h:2226

hipMemRangeFlagDmaBufMappingTypePcie

@ hipMemRangeFlagDmaBufMappingTypePcie

Definition hip_runtime_api.h:2225

hipDevSmResourceSplitMaxPotentialClusterSize

@ hipDevSmResourceSplitMaxPotentialClusterSize

Definition hip_runtime_api.h:733

hipDevSmResourceSplitIgnoreSmCoscheduling

@ hipDevSmResourceSplitIgnoreSmCoscheduling

Definition hip_runtime_api.h:732

hipMemOperationTypeMap

@ hipMemOperationTypeMap

Map operation.

Definition hip_runtime_api.h:2012

hipMemOperationTypeUnmap

@ hipMemOperationTypeUnmap

Unmap operation.

Definition hip_runtime_api.h:2013

hipGraphicsRegisterFlagsReadOnly

@ hipGraphicsRegisterFlagsReadOnly

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

Definition hip_runtime_api.h:1556

hipGraphicsRegisterFlagsTextureGather

@ hipGraphicsRegisterFlagsTextureGather

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

Definition hip_runtime_api.h:1560

hipGraphicsRegisterFlagsWriteDiscard

@ hipGraphicsRegisterFlagsWriteDiscard

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

Definition hip_runtime_api.h:1557

hipGraphicsRegisterFlagsNone

@ hipGraphicsRegisterFlagsNone

Definition hip_runtime_api.h:1555

hipGraphicsRegisterFlagsSurfaceLoadStore

@ hipGraphicsRegisterFlagsSurfaceLoadStore

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

Definition hip_runtime_api.h:1559

hipMemRangeCoherencyModeFineGrain

@ hipMemRangeCoherencyModeFineGrain

Definition hip_runtime_api.h:1220

hipMemRangeCoherencyModeIndeterminate

@ hipMemRangeCoherencyModeIndeterminate

Definition hip_runtime_api.h:1224

hipMemRangeCoherencyModeCoarseGrain

@ hipMemRangeCoherencyModeCoarseGrain

Definition hip_runtime_api.h:1222

hipMemAccessFlagsProtRead

@ hipMemAccessFlagsProtRead

Set the address range read accessible.

Definition hip_runtime_api.h:1308

hipMemAccessFlagsProtNone

@ hipMemAccessFlagsProtNone

Default, make the address range not accessible.

Definition hip_runtime_api.h:1307

hipMemAccessFlagsProtReadWrite

@ hipMemAccessFlagsProtReadWrite

Set the address range read-write accessible.

Definition hip_runtime_api.h:1309

hipMemAllocationGranularityMinimum

@ hipMemAllocationGranularityMinimum

Minimum granularity.

Definition hip_runtime_api.h:1997

hipMemAllocationGranularityRecommended

@ hipMemAllocationGranularityRecommended

Recommended granularity for performance.

Definition hip_runtime_api.h:1998

hipExtDynDataPrefetchTemporalRegular

@ hipExtDynDataPrefetchTemporalRegular

Regular temporal locality.

Definition hip_runtime_api.h:1701

hipExtDynDataPrefetchTemporalHigh

@ hipExtDynDataPrefetchTemporalHigh

High temporal locality (prefer caching)

Definition hip_runtime_api.h:1702

hipGraphExecUpdateErrorNotSupported

@ hipGraphExecUpdateErrorNotSupported

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

Definition hip_runtime_api.h:1849

hipGraphExecUpdateErrorNodeTypeChanged

@ hipGraphExecUpdateErrorNodeTypeChanged

The update failed because a node type changed.

Definition hip_runtime_api.h:1844

hipGraphExecUpdateErrorTopologyChanged

@ hipGraphExecUpdateErrorTopologyChanged

The update failed because the topology changed.

Definition hip_runtime_api.h:1843

hipGraphExecUpdateErrorUnsupportedFunctionChange

@ hipGraphExecUpdateErrorUnsupportedFunctionChange

Definition hip_runtime_api.h:1851

hipGraphExecUpdateError

@ hipGraphExecUpdateError

Definition hip_runtime_api.h:1841

hipGraphExecUpdateErrorFunctionChanged

@ hipGraphExecUpdateErrorFunctionChanged

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

Definition hip_runtime_api.h:1845

hipGraphExecUpdateSuccess

@ hipGraphExecUpdateSuccess

The update succeeded.

Definition hip_runtime_api.h:1840

hipGraphExecUpdateErrorParametersChanged

@ hipGraphExecUpdateErrorParametersChanged

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

Definition hip_runtime_api.h:1847

hipStreamCaptureStatusInvalidated

@ hipStreamCaptureStatusInvalidated

Definition hip_runtime_api.h:1862

hipStreamCaptureStatusNone

@ hipStreamCaptureStatusNone

Stream is not capturing.

Definition hip_runtime_api.h:1860

hipStreamCaptureStatusActive

@ hipStreamCaptureStatusActive

Stream is actively capturing.

Definition hip_runtime_api.h:1861

hipDeviceAttributeDirectManagedMemAccessFromHost

@ hipDeviceAttributeDirectManagedMemAccessFromHost

Definition hip_runtime_api.h:465

hipDeviceAttributeSurfaceAlignment

@ hipDeviceAttributeSurfaceAlignment

Alignment requirement for surfaces.

Definition hip_runtime_api.h:555

hipDeviceAttributeMaxGridDimX

@ hipDeviceAttributeMaxGridDimX

Max grid size in width.

Definition hip_runtime_api.h:486

hipDeviceAttributeMaxSurfaceCubemapLayered

@ hipDeviceAttributeMaxSurfaceCubemapLayered

Definition hip_runtime_api.h:495

hipDeviceAttributeMaxSurface3D

@ hipDeviceAttributeMaxSurface3D

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

Definition hip_runtime_api.h:493

hipDeviceAttributeMaxPitch

@ hipDeviceAttributeMaxPitch

Maximum pitch in bytes allowed by memory copies.

Definition hip_runtime_api.h:520

hipDeviceAttributeTccDriver

@ hipDeviceAttributeTccDriver

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

Definition hip_runtime_api.h:556

hipDeviceAttributeHostNativeAtomicSupported

@ hipDeviceAttributeHostNativeAtomicSupported

Definition hip_runtime_api.h:468

hipDeviceAttributePageableMemoryAccessUsesHostPageTables

@ hipDeviceAttributePageableMemoryAccessUsesHostPageTables

Definition hip_runtime_api.h:533

hipDeviceAttributeUnused5

@ hipDeviceAttributeUnused5

Previously hipDeviceAttributeGcnArchName.

Definition hip_runtime_api.h:591

hipDeviceAttributeMaxBlockDimY

@ hipDeviceAttributeMaxBlockDimY

Max block size in height.

Definition hip_runtime_api.h:484

hipDeviceAttributeMaxSurfaceCubemap

@ hipDeviceAttributeMaxSurfaceCubemap

Cuda only. Maximum dimensions of Cubemap surface.

Definition hip_runtime_api.h:494

hipDeviceAttributePageableMemoryAccess

@ hipDeviceAttributePageableMemoryAccess

Definition hip_runtime_api.h:531

hipDeviceAttributeClockRate

@ hipDeviceAttributeClockRate

Peak clock frequency in kilohertz.

Definition hip_runtime_api.h:453

hipDeviceAttributeCudaCompatibleEnd

@ hipDeviceAttributeCudaCompatibleEnd

Definition hip_runtime_api.h:582

hipDeviceAttributeMaxTexture1DMipmap

@ hipDeviceAttributeMaxTexture1DMipmap

Maximum size of 1D mipmapped texture.

Definition hip_runtime_api.h:502

hipDeviceAttributeComputeCapabilityMajor

@ hipDeviceAttributeComputeCapabilityMajor

Major compute capability version number.

Definition hip_runtime_api.h:480

hipDeviceAttributeGlobalL1CacheSupported

@ hipDeviceAttributeGlobalL1CacheSupported

Device supports caching globals in L1.

Definition hip_runtime_api.h:467

hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

Definition hip_runtime_api.h:603

hipDeviceAttributeAccessPolicyMaxWindowSize

@ hipDeviceAttributeAccessPolicyMaxWindowSize

Definition hip_runtime_api.h:445

hipDeviceAttributeMaxTexture3DHeight

@ hipDeviceAttributeMaxTexture3DHeight

Maximum dimension height of 3D texture.

Definition hip_runtime_api.h:512

hipDeviceAttributeComputeCapabilityMinor

@ hipDeviceAttributeComputeCapabilityMinor

Minor compute capability version number.

Definition hip_runtime_api.h:523

hipDeviceAttributeNumberOfXccs

@ hipDeviceAttributeNumberOfXccs

Definition hip_runtime_api.h:615

hipDeviceAttributeMaxTextureCubemap

@ hipDeviceAttributeMaxTextureCubemap

Maximum dimensions of Cubemap texture.

Definition hip_runtime_api.h:515

hipDeviceAttributeDeviceOverlap

@ hipDeviceAttributeDeviceOverlap

Definition hip_runtime_api.h:463

hipDeviceAttributeMaxTexture2DLinear

@ hipDeviceAttributeMaxTexture2DLinear

Definition hip_runtime_api.h:508

hipDeviceAttributeHostAllocDmaBufSupported

@ hipDeviceAttributeHostAllocDmaBufSupported

Device supports host-allocated DMABuf buffer sharing.

Definition hip_runtime_api.h:580

hipDeviceAttributeMaxSurface2D

@ hipDeviceAttributeMaxSurface2D

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

Definition hip_runtime_api.h:491

hipDeviceAttributeMaxSurface1DLayered

@ hipDeviceAttributeMaxSurface1DLayered

Cuda only. Maximum dimensions of 1D layered surface.

Definition hip_runtime_api.h:490

hipDeviceAttributeHdpRegFlushCntl

@ hipDeviceAttributeHdpRegFlushCntl

Address of the HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:593

hipDeviceAttributeMaxAvailableVgprsPerThread

@ hipDeviceAttributeMaxAvailableVgprsPerThread

Definition hip_runtime_api.h:622

hipDeviceAttributeComputeMode

@ hipDeviceAttributeComputeMode

Compute mode that device is currently in.

Definition hip_runtime_api.h:454

hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

Definition hip_runtime_api.h:594

hipDeviceAttributeAsicRevision

@ hipDeviceAttributeAsicRevision

Revision of the GPU in this device.

Definition hip_runtime_api.h:607

hipDeviceAttributeUnused4

@ hipDeviceAttributeUnused4

Previously hipDeviceAttributeGcnArch.

Definition hip_runtime_api.h:590

hipDeviceAttributeCooperativeMultiDeviceLaunch

@ hipDeviceAttributeCooperativeMultiDeviceLaunch

Definition hip_runtime_api.h:461

hipDeviceAttributeMaxTexture2DHeight

@ hipDeviceAttributeMaxTexture2DHeight

Maximum dimension hight of 2D texture.

Definition hip_runtime_api.h:504

hipDeviceAttributePersistingL2CacheMaxSize

@ hipDeviceAttributePersistingL2CacheMaxSize

Maximum l2 persisting lines capacity in bytes.

Definition hip_runtime_api.h:540

hipDeviceAttributeEccEnabled

@ hipDeviceAttributeEccEnabled

Whether ECC support is enabled.

Definition hip_runtime_api.h:443

hipDeviceAttributeDmaBufSupported

@ hipDeviceAttributeDmaBufSupported

Device supports DMABuf buffer sharing.

Definition hip_runtime_api.h:575

hipDeviceAttributeExpertSchedMode

@ hipDeviceAttributeExpertSchedMode

Definition hip_runtime_api.h:626

hipDeviceAttributeCanUseHostPointerForRegisteredMem

@ hipDeviceAttributeCanUseHostPointerForRegisteredMem

Definition hip_runtime_api.h:450

hipDeviceAttributePciBusId

@ hipDeviceAttributePciBusId

PCI Bus ID.

Definition hip_runtime_api.h:535

hipDeviceAttributeL2CacheSize

@ hipDeviceAttributeL2CacheSize

Definition hip_runtime_api.h:473

hipDeviceAttributeKernelExecTimeout

@ hipDeviceAttributeKernelExecTimeout

Run time limit for kernels executed on the device.

Definition hip_runtime_api.h:472

hipDeviceAttributeMaxThreadsDim

@ hipDeviceAttributeMaxThreadsDim

Maximum dimension of a block.

Definition hip_runtime_api.h:517

hipDeviceAttributeSingleToDoublePrecisionPerfRatio

@ hipDeviceAttributeSingleToDoublePrecisionPerfRatio

Definition hip_runtime_api.h:552

hipDeviceAttributeMaxGridDimY

@ hipDeviceAttributeMaxGridDimY

Max grid size in height.

Definition hip_runtime_api.h:487

hipDeviceAttributeMultiprocessorCount

@ hipDeviceAttributeMultiprocessorCount

Definition hip_runtime_api.h:526

hipDeviceAttributeAmdSpecificBegin

@ hipDeviceAttributeAmdSpecificBegin

Definition hip_runtime_api.h:583

hipDeviceAttributeMaxRegistersPerMultiprocessor

@ hipDeviceAttributeMaxRegistersPerMultiprocessor

32-bit registers available per block.

Definition hip_runtime_api.h:544

hipDeviceAttributeIsMultiGpuBoard

@ hipDeviceAttributeIsMultiGpuBoard

Multiple GPU devices.

Definition hip_runtime_api.h:471

hipDeviceAttributeSharedMemPerBlockOptin

@ hipDeviceAttributeSharedMemPerBlockOptin

Definition hip_runtime_api.h:549

hipDeviceAttributeMaxSurface2DLayered

@ hipDeviceAttributeMaxSurface2DLayered

Cuda only. Maximum dimensions of 2D layered surface.

Definition hip_runtime_api.h:492

hipDeviceAttributeAmdSpecificEnd

@ hipDeviceAttributeAmdSpecificEnd

Definition hip_runtime_api.h:631

hipDeviceAttributeMemoryClockRate

@ hipDeviceAttributeMemoryClockRate

Peak memory clock frequency in kilohertz.

Definition hip_runtime_api.h:522

hipDeviceAttributeMaxGridDimZ

@ hipDeviceAttributeMaxGridDimZ

Max grid size in depth.

Definition hip_runtime_api.h:488

hipDeviceAttributeHdpMemFlushCntl

@ hipDeviceAttributeHdpMemFlushCntl

Address of the HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:592

hipDeviceAttributeUnused2

@ hipDeviceAttributeUnused2

Previously hipDeviceAttributeUuid.

Definition hip_runtime_api.h:564

hipDeviceAttributeFineGrainSupport

@ hipDeviceAttributeFineGrainSupport

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

Definition hip_runtime_api.h:613

hipDeviceAttributeCooperativeLaunch

@ hipDeviceAttributeCooperativeLaunch

Support cooperative launch.

Definition hip_runtime_api.h:460

hipDeviceAttributeUnifiedAddressing

@ hipDeviceAttributeUnifiedAddressing

Definition hip_runtime_api.h:562

hipDeviceAttributeAsyncEngineCount

@ hipDeviceAttributeAsyncEngineCount

Asynchronous engines number.

Definition hip_runtime_api.h:447

hipDeviceAttributeMultiGpuBoardGroupID

@ hipDeviceAttributeMultiGpuBoardGroupID

Definition hip_runtime_api.h:524

hipDeviceAttributeStreamPrioritiesSupported

@ hipDeviceAttributeStreamPrioritiesSupported

Whether to support stream priorities.

Definition hip_runtime_api.h:554

hipDeviceAttributeMaxSharedMemoryPerBlock

@ hipDeviceAttributeMaxSharedMemoryPerBlock

Definition hip_runtime_api.h:547

hipDeviceAttributeLocalL1CacheSupported

@ hipDeviceAttributeLocalL1CacheSupported

caching locals in L1 is supported

Definition hip_runtime_api.h:475

hipDeviceAttributeCanUseStreamWaitValue

@ hipDeviceAttributeCanUseStreamWaitValue

Definition hip_runtime_api.h:608

hipDeviceAttributeMaxRegistersPerBlock

@ hipDeviceAttributeMaxRegistersPerBlock

Definition hip_runtime_api.h:541

hipDeviceAttributeMaxThreadsPerBlock

@ hipDeviceAttributeMaxThreadsPerBlock

Maximum number of threads per block.

Definition hip_runtime_api.h:518

hipDeviceAttributePciDomainId

@ hipDeviceAttributePciDomainId

PCI Domain Id.

Definition hip_runtime_api.h:537

hipDeviceAttributeMemoryBusWidth

@ hipDeviceAttributeMemoryBusWidth

Global memory bus width in bits.

Definition hip_runtime_api.h:521

hipDeviceAttributeMemoryPoolSupportedHandleTypes

@ hipDeviceAttributeMemoryPoolSupportedHandleTypes

Definition hip_runtime_api.h:571

hipDeviceAttributeComputePreemptionSupported

@ hipDeviceAttributeComputePreemptionSupported

Device supports Compute Preemption.

Definition hip_runtime_api.h:455

hipDeviceAttributeMaxSurface1D

@ hipDeviceAttributeMaxSurface1D

Maximum size of 1D surface.

Definition hip_runtime_api.h:489

hipDeviceAttributeUnused1

@ hipDeviceAttributeUnused1

Previously hipDeviceAttributeName.

Definition hip_runtime_api.h:530

hipDeviceAttributeMaxTexture3DAlt

@ hipDeviceAttributeMaxTexture3DAlt

Maximum dimensions of alternate 3D texture.

Definition hip_runtime_api.h:514

hipDeviceAttributeMaxTexture1DLinear

@ hipDeviceAttributeMaxTexture1DLinear

Definition hip_runtime_api.h:499

hipDeviceAttributeMaxTexture2DGather

@ hipDeviceAttributeMaxTexture2DGather

Definition hip_runtime_api.h:505

hipDeviceAttributeWallClockRate

@ hipDeviceAttributeWallClockRate

Constant frequency of wall clock in kilohertz.

Definition hip_runtime_api.h:614

hipDeviceAttributePciDeviceId

@ hipDeviceAttributePciDeviceId

PCI Device ID. Returns pcie slot id.

Definition hip_runtime_api.h:536

hipDeviceAttributeCanMapHostMemory

@ hipDeviceAttributeCanMapHostMemory

Definition hip_runtime_api.h:448

hipDeviceAttributeMaxTexture1DWidth

@ hipDeviceAttributeMaxTexture1DWidth

Maximum size of 1D texture.

Definition hip_runtime_api.h:497

hipDeviceAttributeConcurrentManagedAccess

@ hipDeviceAttributeConcurrentManagedAccess

Definition hip_runtime_api.h:458

hipDeviceAttributeVendorSpecificBegin

@ hipDeviceAttributeVendorSpecificBegin

Definition hip_runtime_api.h:632

hipDeviceAttributeManagedMemory

@ hipDeviceAttributeManagedMemory

Device supports allocating managed memory on this system.

Definition hip_runtime_api.h:481

hipDeviceAttributeHostNumaId

@ hipDeviceAttributeHostNumaId

Definition hip_runtime_api.h:573

hipDeviceAttributeIntegrated

@ hipDeviceAttributeIntegrated

Device is integrated GPU.

Definition hip_runtime_api.h:470

hipDeviceAttributeMaxTexture2DLayered

@ hipDeviceAttributeMaxTexture2DLayered

Maximum dimensions of 2D layered texture.

Definition hip_runtime_api.h:507

hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

Definition hip_runtime_api.h:597

hipDeviceAttributeMaxTexture3DDepth

@ hipDeviceAttributeMaxTexture3DDepth

Maximum dimension depth of 3D texture.

Definition hip_runtime_api.h:513

hipDeviceAttributePciChipId

@ hipDeviceAttributePciChipId

GPU Manufacturer device id.

Definition hip_runtime_api.h:625

hipDeviceAttributeImageSupport

@ hipDeviceAttributeImageSupport

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

Definition hip_runtime_api.h:610

hipDeviceAttributeTotalGlobalMem

@ hipDeviceAttributeTotalGlobalMem

Global memory available on devicice.

Definition hip_runtime_api.h:561

hipDeviceAttributeMaxBlocksPerMultiProcessor

@ hipDeviceAttributeMaxBlocksPerMultiProcessor

Max block size per multiprocessor.

Definition hip_runtime_api.h:482

hipDeviceAttributeHandleTypeFabricSupported

@ hipDeviceAttributeHandleTypeFabricSupported

Device supports exporting memory to a fabric handle.

Definition hip_runtime_api.h:579

hipDeviceAttributeIsLargeBar

@ hipDeviceAttributeIsLargeBar

Whether it is LargeBar.

Definition hip_runtime_api.h:606

hipDeviceAttributeMaxTexture2DWidth

@ hipDeviceAttributeMaxTexture2DWidth

Maximum dimension width of 2D texture.

Definition hip_runtime_api.h:503

hipDeviceAttributeMaxBlockDimX

@ hipDeviceAttributeMaxBlockDimX

Max block size in width.

Definition hip_runtime_api.h:483

hipDeviceAttributeMaxTexture3DWidth

@ hipDeviceAttributeMaxTexture3DWidth

Maximum dimension width of 3D texture.

Definition hip_runtime_api.h:511

hipDeviceAttributeUnused3

@ hipDeviceAttributeUnused3

Previously hipDeviceAttributeArch.

Definition hip_runtime_api.h:588

hipDeviceAttributeTotalConstantMemory

@ hipDeviceAttributeTotalConstantMemory

Constant memory size in bytes.

Definition hip_runtime_api.h:560

hipDeviceAttributeTextureAlignment

@ hipDeviceAttributeTextureAlignment

Alignment requirement for textures.

Definition hip_runtime_api.h:557

hipDeviceAttributeMaxTexture1DLayered

@ hipDeviceAttributeMaxTexture1DLayered

Maximum dimensions of 1D layered texture.

Definition hip_runtime_api.h:498

hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

@ hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

Maximum Shared Memory PerMultiprocessor.

Definition hip_runtime_api.h:589

hipDeviceAttributeGPUDirectRDMAWithHipVMMSupported

@ hipDeviceAttributeGPUDirectRDMAWithHipVMMSupported

Definition hip_runtime_api.h:576

hipDeviceAttributeReservedSharedMemPerBlock

@ hipDeviceAttributeReservedSharedMemPerBlock

Definition hip_runtime_api.h:545

hipDeviceAttributeCudaCompatibleBegin

@ hipDeviceAttributeCudaCompatibleBegin

Definition hip_runtime_api.h:441

hipDeviceAttributeConcurrentKernels

@ hipDeviceAttributeConcurrentKernels

Definition hip_runtime_api.h:456

hipDeviceAttributeLuid

@ hipDeviceAttributeLuid

Definition hip_runtime_api.h:476

hipDeviceAttributePciDomainID

@ hipDeviceAttributePciDomainID

PCI Domain ID, for backward compatibility.

Definition hip_runtime_api.h:538

hipDeviceAttributeMaxThreadsPerMultiProcessor

@ hipDeviceAttributeMaxThreadsPerMultiProcessor

Maximum resident threads per multiprocessor.

Definition hip_runtime_api.h:519

hipDeviceAttributeTexturePitchAlignment

@ hipDeviceAttributeTexturePitchAlignment

Definition hip_runtime_api.h:558

hipDeviceAttributePhysicalMultiProcessorCount

@ hipDeviceAttributePhysicalMultiProcessorCount

Definition hip_runtime_api.h:611

hipDeviceAttributeHostRegisterSupported

@ hipDeviceAttributeHostRegisterSupported

Definition hip_runtime_api.h:569

hipDeviceAttributeSharedMemPerMultiprocessor

@ hipDeviceAttributeSharedMemPerMultiprocessor

Shared memory available per multiprocessor.

Definition hip_runtime_api.h:551

hipDeviceAttributeLuidDeviceNodeMask

@ hipDeviceAttributeLuidDeviceNodeMask

Definition hip_runtime_api.h:478

hipDeviceAttributeMaxTextureCubemapLayered

@ hipDeviceAttributeMaxTextureCubemapLayered

Maximum dimensions of Cubemap layered texture.

Definition hip_runtime_api.h:516

hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

Definition hip_runtime_api.h:600

hipDeviceAttributeVirtualMemoryManagementSupported

@ hipDeviceAttributeVirtualMemoryManagementSupported

Definition hip_runtime_api.h:567

hipDeviceAttributeMemoryPoolsSupported

@ hipDeviceAttributeMemoryPoolsSupported

Device supports HIP Stream Ordered Memory Allocator.

Definition hip_runtime_api.h:566

hipDeviceAttributeClockInstructionRate

@ hipDeviceAttributeClockInstructionRate

Definition hip_runtime_api.h:585

hipDeviceAttributeMaxTexture2DMipmap

@ hipDeviceAttributeMaxTexture2DMipmap

Maximum dimensions of 2D mipmapped texture.

Definition hip_runtime_api.h:510

hipDeviceAttributeMaxDynDataPrefetchRegions

@ hipDeviceAttributeMaxDynDataPrefetchRegions

Definition hip_runtime_api.h:628

hipDeviceAttributeMaxBlockDimZ

@ hipDeviceAttributeMaxBlockDimZ

Max block size in depth.

Definition hip_runtime_api.h:485

hipDeviceAttributeWarpSize

@ hipDeviceAttributeWarpSize

Warp size in threads.

Definition hip_runtime_api.h:565

hipGPUDirectRDMAWritesOrderingOwner

@ hipGPUDirectRDMAWritesOrderingOwner

Definition hip_runtime_api.h:669

hipGPUDirectRDMAWritesOrderingNone

@ hipGPUDirectRDMAWritesOrderingNone

Definition hip_runtime_api.h:668

hipGPUDirectRDMAWritesOrderingAllDevices

@ hipGPUDirectRDMAWritesOrderingAllDevices

Definition hip_runtime_api.h:670

hipMemAllocationTypeManaged

@ hipMemAllocationTypeManaged

Definition hip_runtime_api.h:1330

hipMemAllocationTypeMax

@ hipMemAllocationTypeMax

Definition hip_runtime_api.h:1332

hipMemAllocationTypePinned

@ hipMemAllocationTypePinned

Definition hip_runtime_api.h:1329

hipMemAllocationTypeUncached

@ hipMemAllocationTypeUncached

Definition hip_runtime_api.h:1331

hipMemAllocationTypeInvalid

@ hipMemAllocationTypeInvalid

Definition hip_runtime_api.h:1325

hipClusterSchedulingPolicyDefault

@ hipClusterSchedulingPolicyDefault

the default scheduling policy

Definition hip_runtime_api.h:1691

hipClusterSchedulingPolicyLoadBalancing

@ hipClusterSchedulingPolicyLoadBalancing

Dynamically balance block assignment to optimize resource usage.

Definition hip_runtime_api.h:1693

hipClusterSchedulingPolicySpread

@ hipClusterSchedulingPolicySpread

distribute blocks evenly across cluster's CUs

Definition hip_runtime_api.h:1692

hipMemoryTypeDevice

@ hipMemoryTypeDevice

Definition hip_runtime_api.h:412

hipMemoryTypeHost

@ hipMemoryTypeHost

Memory is physically located on host.

Definition hip_runtime_api.h:411

hipMemoryTypeUnregistered

@ hipMemoryTypeUnregistered

Unregistered memory.

Definition hip_runtime_api.h:410

hipMemoryTypeArray

@ hipMemoryTypeArray

Definition hip_runtime_api.h:417

hipMemoryTypeManaged

@ hipMemoryTypeManaged

Definition hip_runtime_api.h:414

hipMemoryTypeUnified

@ hipMemoryTypeUnified

unified address space

Definition hip_runtime_api.h:419

hipGraphInstantiateFlagAutoFreeOnLaunch

@ hipGraphInstantiateFlagAutoFreeOnLaunch

Automatically free memory allocated in a graph before relaunching.

Definition hip_runtime_api.h:1890

hipGraphInstantiateFlagUseNodePriority

@ hipGraphInstantiateFlagUseNodePriority

Definition hip_runtime_api.h:1895

hipGraphInstantiateFlagUpload

@ hipGraphInstantiateFlagUpload

Automatically upload the graph after instantiation.

Definition hip_runtime_api.h:1892

hipGraphInstantiateFlagDeviceLaunch

@ hipGraphInstantiateFlagDeviceLaunch

Instantiate the graph to be launched from the device.

Definition hip_runtime_api.h:1893

hipDevResourceTypeWorkqueue

@ hipDevResourceTypeWorkqueue

Definition hip_runtime_api.h:725

hipDevResourceTypeSm

@ hipDevResourceTypeSm

Definition hip_runtime_api.h:723

hipDevResourceTypeInvalid

@ hipDevResourceTypeInvalid

Definition hip_runtime_api.h:722

hipDevResourceTypeWorkqueueConfig

@ hipDevResourceTypeWorkqueueConfig

Definition hip_runtime_api.h:724

hipArraySparseSubresourceTypeSparseLevel

@ hipArraySparseSubresourceTypeSparseLevel

Sparse level.

Definition hip_runtime_api.h:2020

hipArraySparseSubresourceTypeMiptail

@ hipArraySparseSubresourceTypeMiptail

Miptail.

Definition hip_runtime_api.h:2021

HIP_LAUNCH_CONFIG

Definition hip_runtime_api.h:2192

hipAccessPolicyWindow

Definition hip_runtime_api.h:1654

hipArrayMapInfo

Definition hip_runtime_api.h:2027

hipArrayMemoryRequirements

Definition hip_runtime_api.h:2208

hipBatchMemOpNodeParams

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

Definition hip_runtime_api.h:1178

hipChildGraphNodeParams

Definition hip_runtime_api.h:2077

hipDevResource

Definition hip_runtime_api.h:759

hipDevSmResource

Definition hip_runtime_api.h:742

hipDevSmResourceGroupParams

Definition hip_runtime_api.h:771

hipDevWorkqueueConfigResource

Definition hip_runtime_api.h:749

hipDevWorkqueueResource

Definition hip_runtime_api.h:755

hipDeviceArch_t

Definition hip_runtime_api.h:53

hipDeviceProp_t

Definition hip_runtime_api.h:253

hipEventRecordNodeParams

Definition hip_runtime_api.h:2092

hipEventWaitNodeParams

Definition hip_runtime_api.h:2085

hipExtDynDataPrefetchConfig

Configuration for dynamic data prefetch.

Definition hip_runtime_api.h:1737

hipExtDynDataPrefetchRegion

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

Definition hip_runtime_api.h:1713

hipExternalMemoryBufferDesc

Definition hip_runtime_api.h:1464

hipExternalMemoryHandleDesc

Definition hip_runtime_api.h:1450

hipExternalMemoryMipmappedArrayDesc

Definition hip_runtime_api.h:1470

hipExternalSemaphoreHandleDesc

Definition hip_runtime_api.h:1490

hipExternalSemaphoreSignalNodeParams

Definition hip_runtime_api.h:1967

hipExternalSemaphoreSignalParams

Definition hip_runtime_api.h:1504

hipExternalSemaphoreWaitNodeParams

Definition hip_runtime_api.h:1979

hipExternalSemaphoreWaitParams

Definition hip_runtime_api.h:1524

hipFuncAttributes

Definition hip_runtime_api.h:814

hipFunctionLaunchParams

Definition hip_runtime_api.h:1428

hipGraphEdgeData

Definition hip_runtime_api.h:2149

hipGraphInstantiateParams

Definition hip_runtime_api.h:1937

hipGraphNodeParams

Definition hip_runtime_api.h:2106

hipHostNodeParams

Definition hip_runtime_api.h:1610

hipIpcEventHandle_t

Definition hip_runtime_api.h:798

hipIpcMemHandle_t

Definition hip_runtime_api.h:795

hipKernelNodeParams

Definition hip_runtime_api.h:1614

hipLaunchAttribute

Definition hip_runtime_api.h:2168

hipLaunchConfig_t

Definition hip_runtime_api.h:2180

hipLaunchMemSyncDomainMap

Definition hip_runtime_api.h:1665

hipLaunchParams

Definition hip_runtime_api.h:1417

hipMemAccessDesc

Definition hip_runtime_api.h:1317

hipMemAllocNodeParams

Definition hip_runtime_api.h:1631

hipMemAllocationProp

Definition hip_runtime_api.h:1949

hipMemFabricHandle_t

Definition hip_runtime_api.h:801

hipMemFreeNodeParams

Definition hip_runtime_api.h:2099

hipMemPoolProps

Definition hip_runtime_api.h:1349

hipMemPoolPtrExportData

Definition hip_runtime_api.h:1365

hipMemcpyNodeParams

Definition hip_runtime_api.h:2068

hipMemsetParams

Definition hip_runtime_api.h:1622

hipPointerAttribute_t

Definition hip_runtime_api.h:426

hipStreamBatchMemOpParams::hipStreamMemOpFlushRemoteWritesParams_t

Definition hip_runtime_api.h:1140

hipStreamBatchMemOpParams::hipStreamMemOpMemoryBarrierParams_t

Definition hip_runtime_api.h:1144

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t

Definition hip_runtime_api.h:1120

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t

Definition hip_runtime_api.h:1130

hipUUID

Definition hip_runtime_api.h:84

hipLaunchAttributeValue

Definition hip_runtime_api.h:1764

hipStreamBatchMemOpParams

Union representing batch memory operation parameters for HIP streams.

Definition hip_runtime_api.h:1118

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

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

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

hipErrorIllegalAddress

hipErrorIllegalAddress

Definition hip_runtime_api.h:166

hipErrorMemoryAllocation

hipErrorMemoryAllocation

Memory allocation error.

Definition hip_runtime_api.h:112

hipErrorNotFound

hipErrorNotFound

Not found.

Definition hip_runtime_api.h:161

hipErrorProfilerDisabled

hipErrorProfilerDisabled

Definition hip_runtime_api.h:117

hipErrorInvalidDevicePointer

hipErrorInvalidDevicePointer

Invalid Device Pointer.

Definition hip_runtime_api.h:124

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

hipErrorInvalidImage

hipErrorInvalidImage

Invalid image.

Definition hip_runtime_api.h:132

hipErrorPeerAccessUnsupported

hipErrorPeerAccessUnsupported

Definition hip_runtime_api.h:149

hipErrorArrayIsMapped

hipErrorArrayIsMapped

Definition hip_runtime_api.h:139

hipErrorStreamCaptureIsolation

hipErrorStreamCaptureIsolation

Definition hip_runtime_api.h:194

hipErrorInvalidKernelFile

hipErrorInvalidKernelFile

In CUDA DRV, it is CUDA_ERROR_INVALID_PTX.

Definition hip_runtime_api.h:150

hipErrorNotMapped

hipErrorNotMapped

Definition hip_runtime_api.h:143

hipErrorInvalidClusterSize

hipErrorInvalidClusterSize

calculations

Definition hip_runtime_api.h:223

hipErrorGraphExecUpdateFailure

hipErrorGraphExecUpdateFailure

Definition hip_runtime_api.h:207

hipErrorNotInitialized

hipErrorNotInitialized

Invalid not initialized.

Definition hip_runtime_api.h:113

hipErrorInvalidResourceHandle

hipErrorInvalidResourceHandle

Resource handle (hipEvent_t or hipStream_t) invalid.

Definition hip_runtime_api.h:159

hipErrorSharedObjectInitFailed

hipErrorSharedObjectInitFailed

Failed to initialize shared object.

Definition hip_runtime_api.h:155

hipErrorInvalidPitchValue

hipErrorInvalidPitchValue

Invalid pitch value.

Definition hip_runtime_api.h:122

hipErrorNoBinaryForGpu

hipErrorNoBinaryForGpu

Definition hip_runtime_api.h:141

hipErrorInvalidContext

hipErrorInvalidContext

Produced when input context is invalid.

Definition hip_runtime_api.h:133

hipErrorStreamCaptureUnsupported

hipErrorStreamCaptureUnsupported

Definition hip_runtime_api.h:185

hipErrorPeerAccessNotEnabled

hipErrorPeerAccessNotEnabled

Peer access was never enabled from the current device.

Definition hip_runtime_api.h:171

hipErrorOperatingSystem

hipErrorOperatingSystem

Not the correct operating system.

Definition hip_runtime_api.h:156

hipErrorStreamCaptureUnjoined

hipErrorStreamCaptureUnjoined

Definition hip_runtime_api.h:192

hipErrorInitializationError

hipErrorInitializationError

Definition hip_runtime_api.h:115

hipErrorNotMappedAsPointer

hipErrorNotMappedAsPointer

Definition hip_runtime_api.h:145

hipErrorPriorLaunchFailure

hipErrorPriorLaunchFailure

Definition hip_runtime_api.h:128

hipErrorContextIsDestroyed

hipErrorContextIsDestroyed

The context is already destroyed.

Definition hip_runtime_api.h:173

hipErrorInvalidValue

hipErrorInvalidValue

Definition hip_runtime_api.h:108

hipErrorLaunchTimeOut

hipErrorLaunchTimeOut

Timeout for the launch.

Definition hip_runtime_api.h:168

hipErrorUnmapFailed

hipErrorUnmapFailed

Definition hip_runtime_api.h:138

hipErrorSetOnActiveProcess

hipErrorSetOnActiveProcess

The process is active.

Definition hip_runtime_api.h:172

hipErrorFileNotFound

hipErrorFileNotFound

the file is not found.

Definition hip_runtime_api.h:153

hipErrorLaunchFailure

hipErrorLaunchFailure

An exception occurred on the device while executing a kernel.

Definition hip_runtime_api.h:179

hipErrorInvalidDevice

hipErrorInvalidDevice

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

Definition hip_runtime_api.h:131

hipErrorUnsupportedLimit

hipErrorUnsupportedLimit

Unsupported limit.

Definition hip_runtime_api.h:147

hipErrorMapBufferObjectFailed

hipErrorMapBufferObjectFailed

Produced when the IPC memory attach failed from ROCr.

Definition hip_runtime_api.h:137

hipErrorHostMemoryAlreadyRegistered

hipErrorHostMemoryAlreadyRegistered

Definition hip_runtime_api.h:175

hipErrorMissingConfiguration

hipErrorMissingConfiguration

Definition hip_runtime_api.h:127

hipErrorSharedObjectSymbolNotFound

hipErrorSharedObjectSymbolNotFound

Definition hip_runtime_api.h:154

hipErrorECCNotCorrectable

hipErrorECCNotCorrectable

Definition hip_runtime_api.h:146

hipErrorStreamCaptureWrongThread

hipErrorStreamCaptureWrongThread

Definition hip_runtime_api.h:203

hipErrorAssert

hipErrorAssert

Produced when the kernel calls assert.

Definition hip_runtime_api.h:174

hipErrorContextAlreadyInUse

hipErrorContextAlreadyInUse

The context is already in use.

Definition hip_runtime_api.h:148

hipErrorNotReady

hipErrorNotReady

Definition hip_runtime_api.h:162

hipErrorInvalidSource

hipErrorInvalidSource

Invalid source.

Definition hip_runtime_api.h:152

hipErrorLaunchOutOfResources

hipErrorLaunchOutOfResources

Out of resources error.

Definition hip_runtime_api.h:167

hipErrorInvalidDeviceFunction

hipErrorInvalidDeviceFunction

Invalid device function.

Definition hip_runtime_api.h:129

hipErrorCooperativeLaunchTooLarge

hipErrorCooperativeLaunchTooLarge

Definition hip_runtime_api.h:180

hipErrorAlreadyMapped

hipErrorAlreadyMapped

Definition hip_runtime_api.h:140

hipErrorInvalidResourceType

hipErrorInvalidResourceType

Resource type is not valid for the operation.

Definition hip_runtime_api.h:213

hipErrorProfilerNotInitialized

hipErrorProfilerNotInitialized

Definition hip_runtime_api.h:118

hipErrorProfilerAlreadyStarted

hipErrorProfilerAlreadyStarted

Definition hip_runtime_api.h:119

hipErrorInvalidChannelDescriptor

hipErrorInvalidChannelDescriptor

Invalid channel descriptor.

Definition hip_runtime_api.h:211

hipErrorNoDevice

hipErrorNoDevice

Call to hipGetDeviceCount returned 0 devices.

Definition hip_runtime_api.h:130

hipErrorMapFailed

hipErrorMapFailed

Definition hip_runtime_api.h:135

hipErrorStreamCaptureInvalidated

hipErrorStreamCaptureInvalidated

Definition hip_runtime_api.h:187

hipErrorProfilerAlreadyStopped

hipErrorProfilerAlreadyStopped

Definition hip_runtime_api.h:120

hipErrorDeinitialized

hipErrorDeinitialized

Deinitialized.

Definition hip_runtime_api.h:116

hipErrorPeerAccessAlreadyEnabled

hipErrorPeerAccessAlreadyEnabled

Definition hip_runtime_api.h:169

hipErrorNotMappedAsArray

hipErrorNotMappedAsArray

Definition hip_runtime_api.h:144

hipErrorNotSupported

hipErrorNotSupported

Produced when the hip API is not supported/implemented.

Definition hip_runtime_api.h:184

hipErrorInvalidConfiguration

hipErrorInvalidConfiguration

Invalide configuration.

Definition hip_runtime_api.h:121

hipErrorStreamCaptureImplicit

hipErrorStreamCaptureImplicit

Definition hip_runtime_api.h:198

hipErrorStreamCaptureMerge

hipErrorStreamCaptureMerge

Definition hip_runtime_api.h:189

hipErrorInvalidGraphicsContext

hipErrorInvalidGraphicsContext

Definition hip_runtime_api.h:151

hipErrorIllegalState

hipErrorIllegalState

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

Definition hip_runtime_api.h:160

hipErrorOutOfMemory

hipErrorOutOfMemory

out of memory range.

Definition hip_runtime_api.h:110

hipErrorInvalidSymbol

hipErrorInvalidSymbol

Invalid symbol.

Definition hip_runtime_api.h:123

hipSuccess

hipSuccess

Successful completion.

Definition hip_runtime_api.h:107

hipErrorUnknown

hipErrorUnknown

Unknown error.

Definition hip_runtime_api.h:217

hipErrorInvalidHandle

hipErrorInvalidHandle

Invalide handle.

Definition hip_runtime_api.h:157

hipErrorStreamCaptureUnmatched

hipErrorStreamCaptureUnmatched

The capture was not initiated in this stream.

Definition hip_runtime_api.h:191

hipErrorCapturedEvent

hipErrorCapturedEvent

Definition hip_runtime_api.h:201

hipErrorAlreadyAcquired

hipErrorAlreadyAcquired

Definition hip_runtime_api.h:142

hipErrorInsufficientDriver

hipErrorInsufficientDriver

Definition hip_runtime_api.h:126

hipErrorHostMemoryNotRegistered

hipErrorHostMemoryNotRegistered

Definition hip_runtime_api.h:177

hipErrorInvalidTexture

hipErrorInvalidTexture

Invalid texture.

Definition hip_runtime_api.h:212

hipErrorRuntimeOther

hipErrorRuntimeOther

Definition hip_runtime_api.h:221

hipErrorContextAlreadyCurrent

hipErrorContextAlreadyCurrent

Definition hip_runtime_api.h:134

hipErrorInvalidMemcpyDirection

hipErrorInvalidMemcpyDirection

Invalid memory copy direction.

Definition hip_runtime_api.h:125

hipErrorInvalidResourceConfiguration

hipErrorInvalidResourceConfiguration

Definition hip_runtime_api.h:214

linker_types.h

hip_impl

Definition hip_runtime_api.h:708

hip_impl::hip_init

hipError_t hip_init()

dim3

Definition hip_runtime_api.h:1405

dim3::y

uint32_t y

y

Definition hip_runtime_api.h:1407

dim3::z

uint32_t z

z

Definition hip_runtime_api.h:1408

dim3::x

uint32_t x

x

Definition hip_runtime_api.h:1406

dim3::dim3

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

Definition hip_runtime_api.h:1410

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