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

33enum {

34 HIP_SUCCESS = 0,

35 HIP_ERROR_INVALID_VALUE,

36 HIP_ERROR_NOT_INITIALIZED,

37 HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

38};

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

49typedef struct {

50 // 32-bit Atomics

51 unsigned hasGlobalInt32Atomics : 1;

52 unsigned hasGlobalFloatAtomicExch : 1;

53 unsigned hasSharedInt32Atomics : 1;

54 unsigned hasSharedFloatAtomicExch : 1;

55 unsigned hasFloatAtomicAdd : 1;

56

57 // 64-bit Atomics

58 unsigned hasGlobalInt64Atomics : 1;

59 unsigned hasSharedInt64Atomics : 1;

60

61 // Doubles

62 unsigned hasDoubles : 1;

63

64 // Warp cross-lane operations

65 unsigned hasWarpVote : 1;

66 unsigned hasWarpBallot : 1;

67 unsigned hasWarpShuffle : 1;

68 unsigned hasFunnelShift : 1;

69

70 // Sync

71 unsigned hasThreadFenceSystem : 1;

72 unsigned hasSyncThreadsExt : 1;

73

74 // Misc

75 unsigned hasSurfaceFuncs : 1;

76 unsigned has3dGrid : 1;

77 unsigned hasDynamicParallelism : 1;

78} hipDeviceArch_t;

79

80typedef struct hipUUID_t {

81 char bytes[16];

82} hipUUID;

83

84//---

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

86

87#define hipGetDeviceProperties hipGetDevicePropertiesR0600

88#define hipDeviceProp_t hipDeviceProp_tR0600

89#define hipChooseDevice hipChooseDeviceR0600

90

95typedef struct hipDeviceProp_t {

96 char name[256];

97 hipUUID uuid;

98 char luid[8];

99 unsigned int luidDeviceNodeMask;

100 size_t totalGlobalMem;

101 size_t sharedMemPerBlock;

102 int regsPerBlock;

103 int warpSize;

104 size_t memPitch;

106 int maxThreadsPerBlock;

107 int maxThreadsDim[3];

108 int maxGridSize[3];

109 int clockRate;

110 size_t totalConstMem;

112 int major;

116 int minor;

121 size_t textureAlignment;

122 size_t texturePitchAlignment;

123 int deviceOverlap;

124 int multiProcessorCount;

128 int kernelExecTimeoutEnabled;

129 int integrated;

130 int canMapHostMemory;

131 int computeMode;

132 int maxTexture1D;

133 int maxTexture1DMipmap;

134 int maxTexture1DLinear;

135 int maxTexture2D[2];

136 int maxTexture2DMipmap[2];

137 int maxTexture2DLinear[3];

138 int maxTexture2DGather[2];

139 int maxTexture3D[3];

141 int maxTexture3DAlt[3];

142 int maxTextureCubemap;

143 int maxTexture1DLayered[2];

144 int maxTexture2DLayered[3];

145 int maxTextureCubemapLayered[2];

146 int maxSurface1D;

147 int maxSurface2D[2];

148 int maxSurface3D[3];

149 int maxSurface1DLayered[2];

150 int maxSurface2DLayered[3];

151 int maxSurfaceCubemap;

152 int maxSurfaceCubemapLayered[2];

153 size_t surfaceAlignment;

154 int concurrentKernels;

155 int ECCEnabled;

156 int pciBusID;

157 int pciDeviceID;

158 int pciDomainID;

159 int tccDriver;

160 int asyncEngineCount;

161 int unifiedAddressing;

162 int memoryClockRate;

163 int memoryBusWidth;

164 int l2CacheSize;

165 int persistingL2CacheMaxSize;

166 int maxThreadsPerMultiProcessor;

167 int streamPrioritiesSupported;

168 int globalL1CacheSupported;

169 int localL1CacheSupported;

170 size_t sharedMemPerMultiprocessor;

171 int regsPerMultiprocessor;

172 int managedMemory;

173 int isMultiGpuBoard;

174 int multiGpuBoardGroupID;

175 int hostNativeAtomicSupported;

176 int singleToDoublePrecisionPerfRatio;

177 int pageableMemoryAccess;

179 int concurrentManagedAccess;

181 int computePreemptionSupported;

182 int canUseHostPointerForRegisteredMem;

184 int cooperativeLaunch;

185 int cooperativeMultiDeviceLaunch;

187 size_t sharedMemPerBlockOptin;

188 int pageableMemoryAccessUsesHostPageTables;

190 int directManagedMemAccessFromHost;

192 int maxBlocksPerMultiProcessor;

193 int accessPolicyMaxWindowSize;

194 size_t reservedSharedMemPerBlock;

195 int hostRegisterSupported;

196 int sparseHipArraySupported;

197 int hostRegisterReadOnlySupported;

199 int timelineSemaphoreInteropSupported;

200 int memoryPoolsSupported;

201 int gpuDirectRDMASupported;

202 unsigned int gpuDirectRDMAFlushWritesOptions;

204 int gpuDirectRDMAWritesOrdering;

205 unsigned int

206 memoryPoolSupportedHandleTypes;

207 int deferredMappingHipArraySupported;

209 int ipcEventSupported;

210 int clusterLaunch;

211 int unifiedFunctionPointers;

212 int reserved[63];

213

214 int hipReserved[32];

215

216 /* HIP Only struct members */

217 char gcnArchName[256];

218 size_t maxSharedMemoryPerMultiProcessor;

219 int clockInstructionRate;

221 hipDeviceArch_t arch;

222 unsigned int* hdpMemFlushCntl;

223 unsigned int* hdpRegFlushCntl;

224 int cooperativeMultiDeviceUnmatchedFunc;

227 int cooperativeMultiDeviceUnmatchedGridDim;

230 int cooperativeMultiDeviceUnmatchedBlockDim;

233 int cooperativeMultiDeviceUnmatchedSharedMem;

236 int isLargeBar;

237 int asicRevision;

238} hipDeviceProp_t;

239

247typedef enum hipMemoryType {

248 hipMemoryTypeUnregistered = 0,

249 hipMemoryTypeHost = 1,

250 hipMemoryTypeDevice = 2,

252 hipMemoryTypeManaged = 3,

255 hipMemoryTypeArray = 10,

257 hipMemoryTypeUnified = 11

258

259} hipMemoryType;

260

264typedef struct hipPointerAttribute_t {

265 enum hipMemoryType type;

266 int device;

267 void* devicePointer;

268 void* hostPointer;

269 int isManaged;

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

271 /* peers? */

272} hipPointerAttribute_t;

273

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

275// we can make that yield a warning

276#if __cplusplus >= 201703L

277#define __HIP_NODISCARD [[nodiscard]]

278#else

279#define __HIP_NODISCARD

280#endif

281

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

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

288

289typedef enum __HIP_NODISCARD hipError_t {

290 hipSuccess = 0,

291 hipErrorInvalidValue = 1,

293 hipErrorOutOfMemory = 2,

294 // Deprecated

295 hipErrorMemoryAllocation = 2,

296 hipErrorNotInitialized = 3,

297 // Deprecated

298 hipErrorInitializationError = 3,

299 hipErrorDeinitialized = 4,

300 hipErrorProfilerDisabled = 5,

301 hipErrorProfilerNotInitialized = 6,

302 hipErrorProfilerAlreadyStarted = 7,

303 hipErrorProfilerAlreadyStopped = 8,

304 hipErrorInvalidConfiguration = 9,

305 hipErrorInvalidPitchValue = 12,

306 hipErrorInvalidSymbol = 13,

307 hipErrorInvalidDevicePointer = 17,

308 hipErrorInvalidMemcpyDirection = 21,

309 hipErrorInsufficientDriver = 35,

310 hipErrorMissingConfiguration = 52,

311 hipErrorPriorLaunchFailure = 53,

312 hipErrorInvalidDeviceFunction = 98,

313 hipErrorNoDevice = 100,

314 hipErrorInvalidDevice = 101,

315 hipErrorInvalidImage = 200,

316 hipErrorInvalidContext = 201,

317 hipErrorContextAlreadyCurrent = 202,

318 hipErrorMapFailed = 205,

319 // Deprecated

320 hipErrorMapBufferObjectFailed = 205,

321 hipErrorUnmapFailed = 206,

322 hipErrorArrayIsMapped = 207,

323 hipErrorAlreadyMapped = 208,

324 hipErrorNoBinaryForGpu = 209,

325 hipErrorAlreadyAcquired = 210,

326 hipErrorNotMapped = 211,

327 hipErrorNotMappedAsArray = 212,

328 hipErrorNotMappedAsPointer = 213,

329 hipErrorECCNotCorrectable = 214,

330 hipErrorUnsupportedLimit = 215,

331 hipErrorContextAlreadyInUse = 216,

332 hipErrorPeerAccessUnsupported = 217,

333 hipErrorInvalidKernelFile = 218,

334 hipErrorInvalidGraphicsContext = 219,

335 hipErrorInvalidSource = 300,

336 hipErrorFileNotFound = 301,

337 hipErrorSharedObjectSymbolNotFound = 302,

338 hipErrorSharedObjectInitFailed = 303,

339 hipErrorOperatingSystem = 304,

340 hipErrorInvalidHandle = 400,

341 // Deprecated

342 hipErrorInvalidResourceHandle = 400,

343 hipErrorIllegalState = 401,

344 hipErrorNotFound = 500,

345 hipErrorNotReady = 600,

349 hipErrorIllegalAddress = 700,

350 hipErrorLaunchOutOfResources = 701,

351 hipErrorLaunchTimeOut = 702,

352 hipErrorPeerAccessAlreadyEnabled = 704,

354 hipErrorPeerAccessNotEnabled = 705,

355 hipErrorSetOnActiveProcess = 708,

356 hipErrorContextIsDestroyed = 709,

357 hipErrorAssert = 710,

358 hipErrorHostMemoryAlreadyRegistered = 712,

360 hipErrorHostMemoryNotRegistered = 713,

362 hipErrorLaunchFailure = 719,

363 hipErrorCooperativeLaunchTooLarge = 720,

367 hipErrorNotSupported = 801,

368 hipErrorStreamCaptureUnsupported = 900,

370 hipErrorStreamCaptureInvalidated = 901,

372 hipErrorStreamCaptureMerge = 902,

374 hipErrorStreamCaptureUnmatched = 903,

375 hipErrorStreamCaptureUnjoined = 904,

377 hipErrorStreamCaptureIsolation = 905,

381 hipErrorStreamCaptureImplicit = 906,

384 hipErrorCapturedEvent = 907,

386 hipErrorStreamCaptureWrongThread = 908,

390 hipErrorGraphExecUpdateFailure = 910,

394 hipErrorInvalidChannelDescriptor = 911,

395 hipErrorInvalidTexture = 912,

396 hipErrorInvalidResourceType = 914,

397 hipErrorInvalidResourceConfiguration = 915,

399 hipErrorStreamDetached = 916,

400 hipErrorUnknown = 999,

401 // HSA Runtime Error Codes start here.

402 hipErrorRuntimeMemory = 1052,

404 hipErrorRuntimeOther = 1053,

406 hipErrorInvalidClusterSize = 1054,

409 hipErrorTbd

410} hipError_t;

411

412#undef __HIP_NODISCARD

413

418typedef enum hipDeviceAttribute_t {

419 hipDeviceAttributeCudaCompatibleBegin = 0,

420

421 hipDeviceAttributeEccEnabled =

422 hipDeviceAttributeCudaCompatibleBegin,

423 hipDeviceAttributeAccessPolicyMaxWindowSize,

425 hipDeviceAttributeAsyncEngineCount,

426 hipDeviceAttributeCanMapHostMemory,

428 hipDeviceAttributeCanUseHostPointerForRegisteredMem,

431 hipDeviceAttributeClockRate,

432 hipDeviceAttributeComputeMode,

433 hipDeviceAttributeComputePreemptionSupported,

434 hipDeviceAttributeConcurrentKernels,

436 hipDeviceAttributeConcurrentManagedAccess,

438 hipDeviceAttributeCooperativeLaunch,

439 hipDeviceAttributeCooperativeMultiDeviceLaunch,

441 hipDeviceAttributeDeviceOverlap,

443 hipDeviceAttributeDirectManagedMemAccessFromHost,

445 hipDeviceAttributeGlobalL1CacheSupported,

446 hipDeviceAttributeHostNativeAtomicSupported,

448 hipDeviceAttributeIntegrated,

449 hipDeviceAttributeIsMultiGpuBoard,

450 hipDeviceAttributeKernelExecTimeout,

451 hipDeviceAttributeL2CacheSize,

453 hipDeviceAttributeLocalL1CacheSupported,

454 hipDeviceAttributeLuid,

456 hipDeviceAttributeLuidDeviceNodeMask,

458 hipDeviceAttributeComputeCapabilityMajor,

459 hipDeviceAttributeManagedMemory,

460 hipDeviceAttributeMaxBlocksPerMultiProcessor,

461 hipDeviceAttributeMaxBlockDimX,

462 hipDeviceAttributeMaxBlockDimY,

463 hipDeviceAttributeMaxBlockDimZ,

464 hipDeviceAttributeMaxGridDimX,

465 hipDeviceAttributeMaxGridDimY,

466 hipDeviceAttributeMaxGridDimZ,

467 hipDeviceAttributeMaxSurface1D,

468 hipDeviceAttributeMaxSurface1DLayered,

469 hipDeviceAttributeMaxSurface2D,

470 hipDeviceAttributeMaxSurface2DLayered,

471 hipDeviceAttributeMaxSurface3D,

472 hipDeviceAttributeMaxSurfaceCubemap,

473 hipDeviceAttributeMaxSurfaceCubemapLayered,

475 hipDeviceAttributeMaxTexture1DWidth,

476 hipDeviceAttributeMaxTexture1DLayered,

477 hipDeviceAttributeMaxTexture1DLinear,

480 hipDeviceAttributeMaxTexture1DMipmap,

481 hipDeviceAttributeMaxTexture2DWidth,

482 hipDeviceAttributeMaxTexture2DHeight,

483 hipDeviceAttributeMaxTexture2DGather,

485 hipDeviceAttributeMaxTexture2DLayered,

486 hipDeviceAttributeMaxTexture2DLinear,

488 hipDeviceAttributeMaxTexture2DMipmap,

489 hipDeviceAttributeMaxTexture3DWidth,

490 hipDeviceAttributeMaxTexture3DHeight,

491 hipDeviceAttributeMaxTexture3DDepth,

492 hipDeviceAttributeMaxTexture3DAlt,

493 hipDeviceAttributeMaxTextureCubemap,

494 hipDeviceAttributeMaxTextureCubemapLayered,

495 hipDeviceAttributeMaxThreadsDim,

496 hipDeviceAttributeMaxThreadsPerBlock,

497 hipDeviceAttributeMaxThreadsPerMultiProcessor,

498 hipDeviceAttributeMaxPitch,

499 hipDeviceAttributeMemoryBusWidth,

500 hipDeviceAttributeMemoryClockRate,

501 hipDeviceAttributeComputeCapabilityMinor,

502 hipDeviceAttributeMultiGpuBoardGroupID,

504 hipDeviceAttributeMultiprocessorCount,

508 hipDeviceAttributeUnused1,

509 hipDeviceAttributePageableMemoryAccess,

511 hipDeviceAttributePageableMemoryAccessUsesHostPageTables,

513 hipDeviceAttributePciBusId,

514 hipDeviceAttributePciDeviceId,

515 hipDeviceAttributePciDomainId,

516 hipDeviceAttributePciDomainID =

517 hipDeviceAttributePciDomainId,

518 hipDeviceAttributePersistingL2CacheMaxSize,

519 hipDeviceAttributeMaxRegistersPerBlock,

522 hipDeviceAttributeMaxRegistersPerMultiprocessor,

523 hipDeviceAttributeReservedSharedMemPerBlock,

525 hipDeviceAttributeMaxSharedMemoryPerBlock,

527 hipDeviceAttributeSharedMemPerBlockOptin,

529 hipDeviceAttributeSharedMemPerMultiprocessor,

530 hipDeviceAttributeSingleToDoublePrecisionPerfRatio,

532 hipDeviceAttributeStreamPrioritiesSupported,

533 hipDeviceAttributeSurfaceAlignment,

534 hipDeviceAttributeTccDriver,

535 hipDeviceAttributeTextureAlignment,

536 hipDeviceAttributeTexturePitchAlignment,

538 hipDeviceAttributeTotalConstantMemory,

539 hipDeviceAttributeTotalGlobalMem,

540 hipDeviceAttributeUnifiedAddressing,

542 hipDeviceAttributeUnused2,

543 hipDeviceAttributeWarpSize,

544 hipDeviceAttributeMemoryPoolsSupported,

545 hipDeviceAttributeVirtualMemoryManagementSupported,

547 hipDeviceAttributeHostRegisterSupported,

549 hipDeviceAttributeMemoryPoolSupportedHandleTypes,

551 hipDeviceAttributeHostNumaId,

553 hipDeviceAttributeDmaBufSupported,

554 hipDeviceAttributeGPUDirectRDMAWithHipVMMSupported,

557 hipDeviceAttributeHandleTypeFabricSupported,

558

559 hipDeviceAttributeCudaCompatibleEnd = 9999,

560 hipDeviceAttributeAmdSpecificBegin = 10000,

561

562 hipDeviceAttributeClockInstructionRate =

563 hipDeviceAttributeAmdSpecificBegin,

565 hipDeviceAttributeUnused3,

566 hipDeviceAttributeMaxSharedMemoryPerMultiprocessor,

567 hipDeviceAttributeUnused4,

568 hipDeviceAttributeUnused5,

569 hipDeviceAttributeHdpMemFlushCntl,

570 hipDeviceAttributeHdpRegFlushCntl,

571 hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc,

574 hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim,

577 hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim,

580 hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem,

583 hipDeviceAttributeIsLargeBar,

584 hipDeviceAttributeAsicRevision,

585 hipDeviceAttributeCanUseStreamWaitValue,

587 hipDeviceAttributeImageSupport,

588 hipDeviceAttributePhysicalMultiProcessorCount,

590 hipDeviceAttributeFineGrainSupport,

591 hipDeviceAttributeWallClockRate,

592 hipDeviceAttributeNumberOfXccs,

599 hipDeviceAttributeMaxAvailableVgprsPerThread,

602 hipDeviceAttributePciChipId,

603 hipDeviceAttributeExpertSchedMode,

605 hipDeviceAttributeMaxDynDataPrefetchRegions,

607

608 hipDeviceAttributeAmdSpecificEnd = 19999,

609 hipDeviceAttributeVendorSpecificBegin = 20000,

610 // Extended attributes for vendors

611} hipDeviceAttribute_t;

612

613// Flags that can be used with hipGetProcAddress.

617#define HIP_GET_PROC_ADDRESS_DEFAULT 0x0

618

620#define HIP_GET_PROC_ADDRESS_LEGACY_STREAM 0x1

621

624#define HIP_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM 0x2

625

626typedef enum hipDriverProcAddressQueryResult {

627 HIP_GET_PROC_ADDRESS_SUCCESS = 0,

628 HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND = 1,

629 HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT = 2

630} hipDriverProcAddressQueryResult;

631

632enum hipComputeMode {

633 hipComputeModeDefault = 0,

634 hipComputeModeExclusive = 1,

635 hipComputeModeProhibited = 2,

636 hipComputeModeExclusiveProcess = 3

637};

638

639enum hipFlushGPUDirectRDMAWritesOptions {

640 hipFlushGPUDirectRDMAWritesOptionHost = 1 << 0,

641 hipFlushGPUDirectRDMAWritesOptionMemOps = 1 << 1

642};

643

644enum hipGPUDirectRDMAWritesOrdering {

645 hipGPUDirectRDMAWritesOrderingNone = 0,

646 hipGPUDirectRDMAWritesOrderingOwner = 100,

647 hipGPUDirectRDMAWritesOrderingAllDevices = 200

648};

649

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

651

652#ifndef GENERIC_GRID_LAUNCH

653#define GENERIC_GRID_LAUNCH 1

654#endif

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

656#include <hip/driver_types.h>

657#include <hip/texture_types.h>

658#include <hip/surface_types.h>

659#if defined(_MSC_VER)

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

661#else // !defined(_MSC_VER)

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

663#endif // !defined(_MSC_VER)

664#define HIP_DEPRECATED_MSG \

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

666 "details please refer " \

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

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

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

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

671#ifdef __cplusplus

672#define __dparm(x) = x

673#else

674#define __dparm(x)

675#endif

676#ifdef __GNUC__

677#pragma GCC visibility push(default)

678#endif

679#ifdef __cplusplus

680namespace hip_impl {

681hipError_t hip_init();

682} // namespace hip_impl

683#endif

684// Structure definitions:

685#ifdef __cplusplus

686extern "C" {

687#endif

688//---

689// API-visible structures

690typedef struct ihipCtx_t* hipCtx_t;

691typedef struct ihipExecutionCtx_t* hipExecutionCtx_t;

692typedef struct ihipDevResourceDesc_t* hipDevResourceDesc_t;

693typedef enum hipDevResourceType {

694 hipDevResourceTypeInvalid = 0,

695 hipDevResourceTypeSm = 1,

696 hipDevResourceTypeWorkqueueConfig = 1000,

697 hipDevResourceTypeWorkqueue = 10000,

698} hipDevResourceType;

699typedef enum hipDevSmResourceGroup_flags {

700 hipDevSmResourceGroupDefault = 0,

701 hipDevSmResourceGroupBackfill = 0x1,

702} hipDevSmResourceGroup_flags;

703typedef enum hipDevSmResourceSplitByCount_flags {

704 hipDevSmResourceSplitIgnoreSmCoscheduling = 0x1,

705 hipDevSmResourceSplitMaxPotentialClusterSize = 0x2,

706} hipDevSmResourceSplitByCount_flags;

707typedef enum hipDevWorkqueueConfigScope {

708 hipDevWorkqueueConfigScopeDeviceCtx = 0,

709 hipDevWorkqueueConfigScopeGreenCtxBalanced = 1,

710} hipDevWorkqueueConfigScope;

711

712#define HIP_RESOURCE_ABI_BYTES 40

713

714typedef struct hipDevSmResource {

715 unsigned int smCount;

716 unsigned int minSmPartitionSize;

717 unsigned int smCoscheduledAlignment;

718 unsigned int flags;

719} hipDevSmResource;

720

721typedef struct hipDevWorkqueueConfigResource {

722 int device;

723 unsigned int wqConcurrencyLimit;

724 hipDevWorkqueueConfigScope sharingScope;

725} hipDevWorkqueueConfigResource;

726

727typedef struct hipDevWorkqueueResource {

728 unsigned char reserved[HIP_RESOURCE_ABI_BYTES];

729} hipDevWorkqueueResource;

730

731typedef struct hipDevResource_st {

732 hipDevResourceType type;

733 unsigned char _internal_padding[92];

734 union {

735 hipDevSmResource sm;

736 hipDevWorkqueueConfigResource wqConfig;

737 hipDevWorkqueueResource wq;

738 unsigned char _oversize[HIP_RESOURCE_ABI_BYTES];

739 };

740 struct hipDevResource_st* nextResource;

741} hipDevResource;

742

743typedef struct hipDevSmResourceGroupParams_st {

744 unsigned int smCount;

745 unsigned int coscheduledSmCount;

746 unsigned int preferredCoscheduledSmCount;

747 unsigned int flags;

748 unsigned int reserved[12];

749} hipDevSmResourceGroupParams;

750

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

752typedef int hipDevice_t;

753typedef enum hipDeviceP2PAttr {

754 hipDevP2PAttrPerformanceRank = 0,

755 hipDevP2PAttrAccessSupported,

756 hipDevP2PAttrNativeAtomicSupported,

757 hipDevP2PAttrHipArrayAccessSupported

758} hipDeviceP2PAttr;

759typedef enum hipDriverEntryPointQueryResult {

760 hipDriverEntryPointSuccess = 0,

761 hipDriverEntryPointSymbolNotFound = 1,

762 hipDriverEntryPointVersionNotSufficent = 2

763} hipDriverEntryPointQueryResult;

764typedef struct ihipStream_t* hipStream_t;

765#define hipIpcMemLazyEnablePeerAccess 0x01

766#define HIP_IPC_HANDLE_SIZE 64

767typedef struct hipIpcMemHandle_st {

768 char reserved[HIP_IPC_HANDLE_SIZE];

769} hipIpcMemHandle_t;

770typedef struct hipIpcEventHandle_st {

771 char reserved[HIP_IPC_HANDLE_SIZE];

772} hipIpcEventHandle_t;

773typedef struct hipMemFabricHandle_st {

774 unsigned char data[HIP_IPC_HANDLE_SIZE];

775} hipMemFabricHandle_t;

776typedef struct ihipModule_t* hipModule_t;

777typedef struct ihipModuleSymbol_t* hipFunction_t;

778typedef struct ihipLinkState_t* hipLinkState_t;

779typedef struct ihipLibrary_t* hipLibrary_t;

780typedef struct ihipKernel_t* hipKernel_t;

784typedef struct ihipMemPoolHandle_t* hipMemPool_t;

785

786typedef struct hipFuncAttributes {

787 int binaryVersion;

788 int cacheModeCA;

789 size_t constSizeBytes;

790 size_t localSizeBytes;

791 int maxDynamicSharedSizeBytes;

792 int maxThreadsPerBlock;

793 int numRegs;

794 int preferredShmemCarveout;

795 int ptxVersion;

796 size_t sharedSizeBytes;

797} hipFuncAttributes;

798typedef struct ihipEvent_t* hipEvent_t;

799

806enum hipLimit_t {

807 hipLimitStackSize = 0x0,

810 hipLimitPrintfFifoSize = 0x01,

812 hipLimitMallocHeapSize = 0x02,

814 hipExtLimitScratchMin = 0x1000,

816 hipExtLimitScratchMax = 0x1001,

818 hipExtLimitScratchCurrent = 0x1002,

822 hipLimitRange

823};

824

828// Flags that can be used with hipStreamCreateWithFlags.

830#define hipStreamDefault 0x00

831

833#define hipStreamNonBlocking 0x01

834

835// Flags that can be used with hipEventCreateWithFlags.

837#define hipEventDefault 0x0

838

840#define hipEventBlockingSync 0x1

841

843#define hipEventDisableTiming 0x2

844

846#define hipEventInterprocess 0x4

847

848// Flags that can be used with hipEventRecordWithFlags.

850#define hipEventRecordDefault 0x00

851

853#define hipEventRecordExternal 0x01

854

855//Flags that can be used with hipStreamWaitEvent.

857#define hipEventWaitDefault 0x00

858

860#define hipEventWaitExternal 0x01

861

870#define hipEventDisableSystemFence 0x20000000

871

874#define hipEventReleaseToDevice 0x40000000

875

878#define hipEventReleaseToSystem 0x80000000

879

880// Flags that can be used with hipGetDriverEntryPoint.

884#define hipEnableDefault 0x0

885

887#define hipEnableLegacyStream 0x1

888

891#define hipEnablePerThreadDefaultStream 0x2

892

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

895#define hipHostAllocDefault 0x0

896

899#define hipHostMallocDefault 0x0

900

902#define hipHostAllocPortable 0x1

903

906#define hipHostMallocPortable 0x1

907

910#define hipHostAllocMapped 0x2

911

915#define hipHostMallocMapped 0x2

916

922#define hipHostAllocWriteCombined 0x4

923

930#define hipHostMallocWriteCombined 0x4

931

937#define hipHostMallocUncached 0x10000000

938#define hipHostAllocUncached hipHostMallocUncached

939

944#define hipHostMallocNumaUser 0x20000000

945

947#define hipHostMallocCoherent 0x40000000

948

950#define hipHostMallocNonCoherent 0x80000000

951

953#define hipMemAttachGlobal 0x01

954

956#define hipMemAttachHost 0x02

957

959#define hipMemAttachSingle 0x04

960

961#define hipDeviceMallocDefault 0x0

962

964#define hipDeviceMallocFinegrained 0x1

965

967#define hipMallocSignalMemory 0x2

968

970#define hipDeviceMallocUncached 0x3

971

973#define hipDeviceMallocContiguous 0x4

974

975// Flags that can be used with hipHostRegister.

977#define hipHostRegisterDefault 0x0

978

980#define hipHostRegisterPortable 0x1

981

984#define hipHostRegisterMapped 0x2

985

990#define hipHostRegisterIoMemory 0x4

991

993#define hipHostRegisterReadOnly 0x08

994

996#define hipExtHostRegisterCoarseGrained 0x8

997

1001#define hipExtHostRegisterUncached 0x80000000

1002

1004#define hipDeviceScheduleAuto 0x0

1005

1008#define hipDeviceScheduleSpin 0x1

1009

1012#define hipDeviceScheduleYield 0x2

1013#define hipDeviceScheduleBlockingSync 0x4

1014#define hipDeviceScheduleMask 0x7

1015#define hipDeviceMapHost 0x8

1016#define hipDeviceLmemResizeToMax 0x10

1018#define hipArrayDefault 0x00

1019#define hipArrayLayered 0x01

1020#define hipArraySurfaceLoadStore 0x02

1021#define hipArrayCubemap 0x04

1022#define hipArrayTextureGather 0x08

1023#define hipOccupancyDefault 0x00

1024#define hipOccupancyDisableCachingOverride 0x01

1025#define hipCooperativeLaunchMultiDeviceNoPreSync 0x01

1026#define hipCooperativeLaunchMultiDeviceNoPostSync 0x02

1027#define hipCpuDeviceId ((int)-1)

1028#define hipInvalidDeviceId ((int)-2)

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

1031#define hipExtAnyOrderLaunch 0x01

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

1033#define hipStreamWaitValueGte 0x0

1034#define hipStreamWaitValueEq 0x1

1035#define hipStreamWaitValueAnd 0x2

1036#define hipStreamWaitValueNor 0x3

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

1038#define hipStreamWriteValueDefault 0x0

1039#define hipExtStreamWriteValueIncrement 0x1000

1040#define hipExtStreamWriteValueDecrement 0x1001

1041

1043typedef enum hipStreamBatchMemOpType {

1044 hipStreamMemOpWaitValue32 = 0x1,

1045 hipStreamMemOpWriteValue32 = 0x2,

1046 hipStreamMemOpWaitValue64 = 0x4,

1047 hipStreamMemOpWriteValue64 = 0x5,

1048 hipStreamMemOpBarrier = 0x6,

1049 hipStreamMemOpFlushRemoteWrites = 0x3

1050} hipStreamBatchMemOpType;

1051

1088typedef union hipStreamBatchMemOpParams_union {

1089 hipStreamBatchMemOpType operation;

1090 struct hipStreamMemOpWaitValueParams_t {

1091 hipStreamBatchMemOpType operation;

1092 hipDeviceptr_t address;

1093 union {

1094 uint32_t value;

1095 uint64_t value64;

1096 };

1097 unsigned int flags;

1098 hipDeviceptr_t alias;

1099 } waitValue;

1100 struct hipStreamMemOpWriteValueParams_t {

1101 hipStreamBatchMemOpType operation;

1102 hipDeviceptr_t address;

1103 union {

1104 uint32_t value;

1105 uint64_t value64;

1106 };

1107 unsigned int flags;

1108 hipDeviceptr_t alias;

1109 } writeValue;

1110 struct hipStreamMemOpFlushRemoteWritesParams_t {

1111 hipStreamBatchMemOpType operation;

1112 unsigned int flags;

1113 } flushRemoteWrites;

1114 struct hipStreamMemOpMemoryBarrierParams_t {

1115 hipStreamBatchMemOpType operation;

1116 unsigned int flags;

1117 } memoryBarrier;

1118 uint64_t pad[6];

1119} hipStreamBatchMemOpParams;

1120

1148typedef struct hipBatchMemOpNodeParams {

1149 hipCtx_t ctx;

1150 unsigned int count;

1151 hipStreamBatchMemOpParams* paramArray;

1152 unsigned int flags;

1153} hipBatchMemOpNodeParams;

1154

1155// Stream per thread

1157#define hipStreamPerThread ((hipStream_t)2)

1158

1159#define hipStreamLegacy ((hipStream_t)1)

1160

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

1162#define hipExternalMemoryDedicated 0x1

1168typedef enum hipMemoryAdvise {

1169 hipMemAdviseSetReadMostly = 1,

1171 hipMemAdviseUnsetReadMostly = 2,

1172 hipMemAdviseSetPreferredLocation = 3,

1174 hipMemAdviseUnsetPreferredLocation = 4,

1175 hipMemAdviseSetAccessedBy = 5,

1177 hipMemAdviseUnsetAccessedBy = 6,

1179 hipMemAdviseSetCoarseGrain = 100,

1184 hipMemAdviseUnsetCoarseGrain = 101

1185} hipMemoryAdvise;

1189typedef enum hipMemRangeCoherencyMode {

1190 hipMemRangeCoherencyModeFineGrain = 0,

1192 hipMemRangeCoherencyModeCoarseGrain = 1,

1194 hipMemRangeCoherencyModeIndeterminate = 2

1197} hipMemRangeCoherencyMode;

1201typedef enum hipMemRangeAttribute {

1202 hipMemRangeAttributeReadMostly = 1,

1204 hipMemRangeAttributePreferredLocation = 2,

1205 hipMemRangeAttributeAccessedBy = 3,

1207 hipMemRangeAttributeLastPrefetchLocation = 4,

1209 hipMemRangeAttributeCoherencyMode = 100,

1211} hipMemRangeAttribute;

1212

1216typedef enum hipMemPoolAttr {

1225 hipMemPoolReuseFollowEventDependencies = 0x1,

1231 hipMemPoolReuseAllowOpportunistic = 0x2,

1238 hipMemPoolReuseAllowInternalDependencies = 0x3,

1247 hipMemPoolAttrReleaseThreshold = 0x4,

1252 hipMemPoolAttrReservedMemCurrent = 0x5,

1258 hipMemPoolAttrReservedMemHigh = 0x6,

1263 hipMemPoolAttrUsedMemCurrent = 0x7,

1269 hipMemPoolAttrUsedMemHigh = 0x8

1270} hipMemPoolAttr;

1271

1276typedef enum hipMemAccessFlags {

1277 hipMemAccessFlagsProtNone = 0,

1278 hipMemAccessFlagsProtRead = 1,

1279 hipMemAccessFlagsProtReadWrite = 3

1280} hipMemAccessFlags;

1287typedef struct hipMemAccessDesc {

1288 hipMemLocation location;

1289 hipMemAccessFlags flags;

1290} hipMemAccessDesc;

1294typedef enum hipMemAllocationType {

1295 hipMemAllocationTypeInvalid = 0x0,

1299 hipMemAllocationTypePinned = 0x1,

1300 hipMemAllocationTypeManaged = 0x2,

1301 hipMemAllocationTypeUncached = 0x40000000,

1302 hipMemAllocationTypeMax = 0x7FFFFFFF

1303} hipMemAllocationType;

1308typedef enum hipMemAllocationHandleType {

1309 hipMemHandleTypeNone = 0x0,

1310 hipMemHandleTypePosixFileDescriptor =

1311 0x1,

1312 hipMemHandleTypeWin32 = 0x2,

1313 hipMemHandleTypeWin32Kmt = 0x4,

1314 hipMemHandleTypeFabric = 0x8

1315} hipMemAllocationHandleType;

1319typedef struct hipMemPoolProps {

1320 hipMemAllocationType

1321 allocType;

1322 hipMemAllocationHandleType

1323 handleTypes;

1324 hipMemLocation location;

1328 void* win32SecurityAttributes;

1329 size_t maxSize;

1330 unsigned char reserved[56];

1331} hipMemPoolProps;

1335typedef struct hipMemPoolPtrExportData {

1336 unsigned char reserved[64];

1337} hipMemPoolPtrExportData;

1338

1342typedef enum hipFuncAttribute {

1343 hipFuncAttributeMaxDynamicSharedMemorySize = 8,

1344 hipFuncAttributePreferredSharedMemoryCarveout = 9,

1345 hipFuncAttributeClusterDimMustBeSet = 10,

1346 hipFuncAttributeRequiredClusterWidth = 11,

1347 hipFuncAttributeRequiredClusterHeight = 12,

1348 hipFuncAttributeRequiredClusterDepth = 13,

1349 hipFuncAttributeNonPortableClusterSizeAllowed = 14,

1350 hipFuncAttributeClusterSchedulingPolicyPreference = 15,

1351 hipFuncAttributeMax

1352} hipFuncAttribute;

1356typedef enum hipFuncCache_t {

1357 hipFuncCachePreferNone,

1358 hipFuncCachePreferShared,

1359 hipFuncCachePreferL1,

1360 hipFuncCachePreferEqual,

1361} hipFuncCache_t;

1365typedef enum hipSharedMemConfig {

1366 hipSharedMemBankSizeDefault,

1367 hipSharedMemBankSizeFourByte,

1369 hipSharedMemBankSizeEightByte

1371} hipSharedMemConfig;

1375typedef struct dim3 {

1376 uint32_t x;

1377 uint32_t y;

1378 uint32_t z;

1379#ifdef __cplusplus

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

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

1382#endif

1383} dim3;

1387typedef struct hipLaunchParams_t {

1388 void* func;

1389 dim3 gridDim;

1390 dim3 blockDim;

1391 void** args;

1392 size_t sharedMem;

1393 hipStream_t stream;

1394} hipLaunchParams;

1398typedef struct hipFunctionLaunchParams_t {

1399 hipFunction_t function;

1400 unsigned int gridDimX;

1401 unsigned int gridDimY;

1402 unsigned int gridDimZ;

1403 unsigned int blockDimX;

1404 unsigned int blockDimY;

1405 unsigned int blockDimZ;

1406 unsigned int sharedMemBytes;

1407 hipStream_t hStream;

1408 void** kernelParams;

1409} hipFunctionLaunchParams;

1410typedef enum hipExternalMemoryHandleType_enum {

1411 hipExternalMemoryHandleTypeOpaqueFd = 1,

1412 hipExternalMemoryHandleTypeOpaqueWin32 = 2,

1413 hipExternalMemoryHandleTypeOpaqueWin32Kmt = 3,

1414 hipExternalMemoryHandleTypeD3D12Heap = 4,

1415 hipExternalMemoryHandleTypeD3D12Resource = 5,

1416 hipExternalMemoryHandleTypeD3D11Resource = 6,

1417 hipExternalMemoryHandleTypeD3D11ResourceKmt = 7,

1418 hipExternalMemoryHandleTypeNvSciBuf = 8

1419} hipExternalMemoryHandleType;

1420typedef struct hipExternalMemoryHandleDesc_st {

1421 hipExternalMemoryHandleType type;

1422 union {

1423 int fd;

1424 struct {

1425 void* handle;

1426 const void* name;

1427 } win32;

1428 const void* nvSciBufObject;

1429 } handle;

1430 unsigned long long size;

1431 unsigned int flags;

1432 unsigned int reserved[16];

1433} hipExternalMemoryHandleDesc;

1434typedef struct hipExternalMemoryBufferDesc_st {

1435 unsigned long long offset;

1436 unsigned long long size;

1437 unsigned int flags;

1438 unsigned int reserved[16];

1439} hipExternalMemoryBufferDesc;

1440typedef struct hipExternalMemoryMipmappedArrayDesc_st {

1441 unsigned long long offset;

1442 hipChannelFormatDesc formatDesc;

1443 hipExtent extent;

1444 unsigned int flags;

1445 unsigned int numLevels;

1446} hipExternalMemoryMipmappedArrayDesc;

1447typedef void* hipExternalMemory_t;

1448typedef enum hipExternalSemaphoreHandleType_enum {

1449 hipExternalSemaphoreHandleTypeOpaqueFd = 1,

1450 hipExternalSemaphoreHandleTypeOpaqueWin32 = 2,

1451 hipExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3,

1452 hipExternalSemaphoreHandleTypeD3D12Fence = 4,

1453 hipExternalSemaphoreHandleTypeD3D11Fence = 5,

1454 hipExternalSemaphoreHandleTypeNvSciSync = 6,

1455 hipExternalSemaphoreHandleTypeKeyedMutex = 7,

1456 hipExternalSemaphoreHandleTypeKeyedMutexKmt = 8,

1457 hipExternalSemaphoreHandleTypeTimelineSemaphoreFd = 9,

1458 hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = 10

1459} hipExternalSemaphoreHandleType;

1460typedef struct hipExternalSemaphoreHandleDesc_st {

1461 hipExternalSemaphoreHandleType type;

1462 union {

1463 int fd;

1464 struct {

1465 void* handle;

1466 const void* name;

1467 } win32;

1468 const void* NvSciSyncObj;

1469 } handle;

1470 unsigned int flags;

1471 unsigned int reserved[16];

1472} hipExternalSemaphoreHandleDesc;

1473typedef void* hipExternalSemaphore_t;

1474typedef struct hipExternalSemaphoreSignalParams_st {

1475 struct {

1476 struct {

1477 unsigned long long value;

1478 } fence;

1479 union {

1480 void* fence;

1481 unsigned long long reserved;

1482 } nvSciSync;

1483 struct {

1484 unsigned long long key;

1485 } keyedMutex;

1486 unsigned int reserved[12];

1487 } params;

1488 unsigned int flags;

1489 unsigned int reserved[16];

1490} hipExternalSemaphoreSignalParams;

1494typedef struct hipExternalSemaphoreWaitParams_st {

1495 struct {

1496 struct {

1497 unsigned long long value;

1498 } fence;

1499 union {

1500 void* fence;

1501 unsigned long long reserved;

1502 } nvSciSync;

1503 struct {

1504 unsigned long long key;

1505 unsigned int timeoutMs;

1506 } keyedMutex;

1507 unsigned int reserved[10];

1508 } params;

1509 unsigned int flags;

1510 unsigned int reserved[16];

1511} hipExternalSemaphoreWaitParams;

1512

1513#if __HIP_HAS_GET_PCH

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

1519#endif

1520

1524typedef enum hipGraphicsRegisterFlags {

1525 hipGraphicsRegisterFlagsNone = 0,

1526 hipGraphicsRegisterFlagsReadOnly = 1,

1527 hipGraphicsRegisterFlagsWriteDiscard =

1528 2,

1529 hipGraphicsRegisterFlagsSurfaceLoadStore = 4,

1530 hipGraphicsRegisterFlagsTextureGather =

1531 8

1532} hipGraphicsRegisterFlags;

1533

1534typedef struct _hipGraphicsResource hipGraphicsResource;

1535

1536typedef hipGraphicsResource* hipGraphicsResource_t;

1537

1541typedef struct ihipGraph* hipGraph_t;

1545typedef struct hipGraphNode* hipGraphNode_t;

1549typedef struct hipGraphExec* hipGraphExec_t;

1550

1554typedef struct hipUserObject* hipUserObject_t;

1555

1556

1560typedef enum hipGraphNodeType {

1561 hipGraphNodeTypeKernel = 0,

1562 hipGraphNodeTypeMemcpy = 1,

1563 hipGraphNodeTypeMemset = 2,

1564 hipGraphNodeTypeHost = 3,

1565 hipGraphNodeTypeGraph = 4,

1566 hipGraphNodeTypeEmpty = 5,

1567 hipGraphNodeTypeWaitEvent = 6,

1568 hipGraphNodeTypeEventRecord = 7,

1569 hipGraphNodeTypeExtSemaphoreSignal = 8,

1570 hipGraphNodeTypeExtSemaphoreWait = 9,

1571 hipGraphNodeTypeMemAlloc = 10,

1572 hipGraphNodeTypeMemFree = 11,

1573 hipGraphNodeTypeMemcpyFromSymbol = 12,

1574 hipGraphNodeTypeMemcpyToSymbol = 13,

1575 hipGraphNodeTypeBatchMemOp = 14,

1576 hipGraphNodeTypeCount

1577} hipGraphNodeType;

1578

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

1580typedef struct hipHostNodeParams {

1581 hipHostFn_t fn;

1582 void* userData;

1583} hipHostNodeParams;

1584typedef struct hipKernelNodeParams {

1585 dim3 blockDim;

1586 void** extra;

1587 void* func;

1588 dim3 gridDim;

1589 void** kernelParams;

1590 unsigned int sharedMemBytes;

1591} hipKernelNodeParams;

1592typedef struct hipMemsetParams {

1593 void* dst;

1594 unsigned int elementSize;

1595 size_t height;

1596 size_t pitch;

1597 unsigned int value;

1598 size_t width;

1599} hipMemsetParams;

1600

1601typedef struct hipMemAllocNodeParams {

1602 hipMemPoolProps poolProps;

1604 const hipMemAccessDesc* accessDescs;

1605 size_t accessDescCount;

1607 size_t bytesize;

1608 void* dptr;

1609} hipMemAllocNodeParams;

1610

1614typedef enum hipAccessProperty {

1615 hipAccessPropertyNormal = 0,

1616 hipAccessPropertyStreaming = 1,

1617 hipAccessPropertyPersisting = 2,

1618} hipAccessProperty;

1619

1620/***

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

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

1623 */

1624typedef struct hipAccessPolicyWindow {

1625 void* base_ptr;

1626 hipAccessProperty hitProp;

1627 float hitRatio;

1628 hipAccessProperty missProp;

1629 size_t num_bytes;

1630} hipAccessPolicyWindow;

1631

1635typedef struct hipLaunchMemSyncDomainMap {

1636 unsigned char default_;

1637 unsigned char remote;

1638} hipLaunchMemSyncDomainMap;

1639

1643typedef enum hipLaunchMemSyncDomain {

1644 hipLaunchMemSyncDomainDefault = 0,

1645 hipLaunchMemSyncDomainRemote = 1

1646} hipLaunchMemSyncDomain;

1647

1652typedef enum hipSynchronizationPolicy {

1653 hipSyncPolicyAuto = 1,

1654 hipSyncPolicySpin = 2,

1655 hipSyncPolicyYield = 3,

1656 hipSyncPolicyBlockingSync = 4

1657} hipSynchronizationPolicy;

1658/* Cluster scheduling policies passed to hipFuncSetAttribute

1659*/

1660typedef enum hipClusterSchedulingPolicy {

1661 hipClusterSchedulingPolicyDefault = 0,

1662 hipClusterSchedulingPolicySpread = 1,

1663 hipClusterSchedulingPolicyLoadBalancing =

1664 2,

1665} hipClusterSchedulingPolicy;

1666

1670typedef enum hipExtDynDataPrefetchTemporal {

1671 hipExtDynDataPrefetchTemporalRegular = 0,

1672 hipExtDynDataPrefetchTemporalHigh = 1,

1673} hipExtDynDataPrefetchTemporal;

1674

1683typedef struct hipExtDynDataPrefetchRegion {

1684 void* address;

1685 size_t stride;

1686 size_t width;

1687 size_t height;

1688} hipExtDynDataPrefetchRegion;

1689

1695#define HIP_EXT_DYN_DATA_PREFETCH_MAX_REGIONS 2

1696

1707typedef struct hipExtDynDataPrefetchConfig {

1708 unsigned int numRegions;

1709 hipExtDynDataPrefetchTemporal temporal;

1710 hipExtDynDataPrefetchRegion regions[HIP_EXT_DYN_DATA_PREFETCH_MAX_REGIONS];

1711} hipExtDynDataPrefetchConfig;

1712

1716typedef enum hipLaunchAttributeID {

1717 hipLaunchAttributeIgnore = 0,

1718 hipLaunchAttributeAccessPolicyWindow = 1,

1719 hipLaunchAttributeCooperative = 2,

1720 hipLaunchAttributeSynchronizationPolicy = 3,

1721 hipLaunchAttributeClusterDimension = 4,

1722 hipLaunchAttributeClusterSchedulingPolicyPreference = 5,

1723 hipLaunchAttributePriority = 8,

1724 hipLaunchAttributeMemSyncDomainMap = 9,

1725 hipLaunchAttributeMemSyncDomain = 10,

1726 hipLaunchAttributeExtDynDataPrefetch = 1024,

1727 hipLaunchAttributeMax

1728} hipLaunchAttributeID;

1729

1730

1734typedef union hipLaunchAttributeValue {

1735 char pad[64];

1736 hipAccessPolicyWindow

1737 accessPolicyWindow;

1738 int cooperative;

1740 int priority;

1742 hipSynchronizationPolicy

1743 syncPolicy;

1745 hipLaunchMemSyncDomainMap

1746 memSyncDomainMap;

1747 hipLaunchMemSyncDomain

1748 memSyncDomain;

1761 struct {

1762 unsigned int x;

1763 unsigned int y;

1764 unsigned int z;

1765 } clusterDim;

1766

1767 hipClusterSchedulingPolicy clusterSchedulingPolicyPreference;

1769 const hipExtDynDataPrefetchConfig* dynDataPrefetch;

1770} hipLaunchAttributeValue;

1771

1775#define hipStreamAttrID hipLaunchAttributeID

1776#define hipStreamAttributeAccessPolicyWindow hipLaunchAttributeAccessPolicyWindow

1777#define hipStreamAttributeSynchronizationPolicy hipLaunchAttributeSynchronizationPolicy

1778#define hipStreamAttributeMemSyncDomainMap hipLaunchAttributeMemSyncDomainMap

1779#define hipStreamAttributeMemSyncDomain hipLaunchAttributeMemSyncDomain

1780#define hipStreamAttributePriority hipLaunchAttributePriority

1781

1782#define hipStreamAttrValue hipLaunchAttributeValue

1783

1787#define hipKernelNodeAttrID hipLaunchAttributeID

1788#define hipKernelNodeAttributeAccessPolicyWindow hipLaunchAttributeAccessPolicyWindow

1789#define hipKernelNodeAttributeCooperative hipLaunchAttributeCooperative

1790#define hipKernelNodeAttributePriority hipLaunchAttributePriority

1791

1795#define hipKernelNodeAttrValue hipLaunchAttributeValue

1796

1800#define hipDrvLaunchAttributeCooperative hipLaunchAttributeCooperative

1801

1802#define hipDrvLaunchAttributeID hipLaunchAttributeID

1803#define hipDrvLaunchAttributeValue hipLaunchAttributeValue

1804#define hipDrvLaunchAttribute hipLaunchAttribute

1805

1809typedef enum hipGraphExecUpdateResult {

1810 hipGraphExecUpdateSuccess = 0x0,

1811 hipGraphExecUpdateError = 0x1,

1813 hipGraphExecUpdateErrorTopologyChanged = 0x2,

1814 hipGraphExecUpdateErrorNodeTypeChanged = 0x3,

1815 hipGraphExecUpdateErrorFunctionChanged =

1816 0x4,

1817 hipGraphExecUpdateErrorParametersChanged =

1818 0x5,

1819 hipGraphExecUpdateErrorNotSupported =

1820 0x6,

1821 hipGraphExecUpdateErrorUnsupportedFunctionChange = 0x7

1822} hipGraphExecUpdateResult;

1823

1824typedef enum hipStreamCaptureMode {

1825 hipStreamCaptureModeGlobal = 0,

1826 hipStreamCaptureModeThreadLocal,

1827 hipStreamCaptureModeRelaxed

1828} hipStreamCaptureMode;

1829typedef enum hipStreamCaptureStatus {

1830 hipStreamCaptureStatusNone = 0,

1831 hipStreamCaptureStatusActive,

1832 hipStreamCaptureStatusInvalidated

1834} hipStreamCaptureStatus;

1835

1836typedef enum hipStreamUpdateCaptureDependenciesFlags {

1837 hipStreamAddCaptureDependencies = 0,

1838 hipStreamSetCaptureDependencies,

1839} hipStreamUpdateCaptureDependenciesFlags;

1840

1841typedef enum hipGraphMemAttributeType {

1842 hipGraphMemAttrUsedMemCurrent =

1843 0,

1844 hipGraphMemAttrUsedMemHigh,

1846 hipGraphMemAttrReservedMemCurrent,

1848 hipGraphMemAttrReservedMemHigh,

1850} hipGraphMemAttributeType;

1851typedef enum hipUserObjectFlags {

1852 hipUserObjectNoDestructorSync = 0x1,

1853} hipUserObjectFlags;

1854

1855typedef enum hipUserObjectRetainFlags {

1856 hipGraphUserObjectMove = 0x1,

1857} hipUserObjectRetainFlags;

1858

1859typedef enum hipGraphInstantiateFlags {

1860 hipGraphInstantiateFlagAutoFreeOnLaunch =

1861 1,

1862 hipGraphInstantiateFlagUpload = 2,

1863 hipGraphInstantiateFlagDeviceLaunch =

1864 4,

1865 hipGraphInstantiateFlagUseNodePriority =

1866 8,

1868} hipGraphInstantiateFlags;

1869

1870enum hipGraphDebugDotFlags {

1871 hipGraphDebugDotFlagsVerbose =

1872 1 << 0,

1873 hipGraphDebugDotFlagsKernelNodeParams = 1 << 2,

1874 hipGraphDebugDotFlagsMemcpyNodeParams = 1 << 3,

1875 hipGraphDebugDotFlagsMemsetNodeParams = 1 << 4,

1876 hipGraphDebugDotFlagsHostNodeParams = 1 << 5,

1877 hipGraphDebugDotFlagsEventNodeParams =

1878 1 << 6,

1879 hipGraphDebugDotFlagsExtSemasSignalNodeParams =

1880 1 << 7,

1881 hipGraphDebugDotFlagsExtSemasWaitNodeParams =

1882 1 << 8,

1883 hipGraphDebugDotFlagsKernelNodeAttributes =

1884 1 << 9,

1885 hipGraphDebugDotFlagsHandles =

1886 1 << 10

1887};

1888

1892typedef enum hipGraphInstantiateResult {

1893 hipGraphInstantiateSuccess = 0,

1894 hipGraphInstantiateError = 1,

1896 hipGraphInstantiateInvalidStructure = 2,

1898 hipGraphInstantiateNodeOperationNotSupported = 3,

1900 hipGraphInstantiateMultipleDevicesNotSupported = 4,

1902} hipGraphInstantiateResult;

1903

1907typedef struct hipGraphInstantiateParams {

1908 hipGraphNode_t errNode_out;

1909 unsigned long long flags;

1910 hipGraphInstantiateResult result_out;

1912 hipStream_t uploadStream;

1913} hipGraphInstantiateParams;

1914

1915

1919typedef struct hipMemAllocationProp {

1920 hipMemAllocationType type;

1921 union {

1922 hipMemAllocationHandleType requestedHandleType;

1923 hipMemAllocationHandleType requestedHandleTypes;

1924 };

1925 hipMemLocation location;

1926 void* win32HandleMetaData;

1927 struct {

1928 unsigned char compressionType;

1929 unsigned char gpuDirectRDMACapable;

1930 unsigned short usage;

1931 } allocFlags;

1932} hipMemAllocationProp;

1933

1937typedef struct hipExternalSemaphoreSignalNodeParams {

1939 hipExternalSemaphore_t* extSemArray;

1941 const hipExternalSemaphoreSignalParams* paramsArray;

1943 unsigned int numExtSems;

1944} hipExternalSemaphoreSignalNodeParams;

1945

1949typedef struct hipExternalSemaphoreWaitNodeParams {

1951 hipExternalSemaphore_t* extSemArray;

1953 const hipExternalSemaphoreWaitParams* paramsArray;

1955 unsigned int numExtSems;

1956} hipExternalSemaphoreWaitNodeParams;

1957

1961typedef struct ihipMemGenericAllocationHandle* hipMemGenericAllocationHandle_t;

1962

1966typedef enum hipMemAllocationGranularity_flags {

1967 hipMemAllocationGranularityMinimum = 0x0,

1968 hipMemAllocationGranularityRecommended = 0x1

1969} hipMemAllocationGranularity_flags;

1970

1974typedef enum hipMemHandleType {

1975 hipMemHandleTypeGeneric = 0x0

1976} hipMemHandleType;

1977

1981typedef enum hipMemOperationType {

1982 hipMemOperationTypeMap = 0x1,

1983 hipMemOperationTypeUnmap = 0x2

1984} hipMemOperationType;

1985

1989typedef enum hipArraySparseSubresourceType {

1990 hipArraySparseSubresourceTypeSparseLevel = 0x0,

1991 hipArraySparseSubresourceTypeMiptail = 0x1

1992} hipArraySparseSubresourceType;

1993

1997typedef struct hipArrayMapInfo {

1998 hipResourceType resourceType;

1999 union {

2000 hipMipmappedArray mipmap;

2001 hipArray_t array;

2002 } resource;

2003 hipArraySparseSubresourceType subresourceType;

2004 union {

2005 struct {

2006 unsigned int

2007 level;

2008 unsigned int

2009 layer;

2010 unsigned int offsetX;

2011 unsigned int offsetY;

2012 unsigned int offsetZ;

2013 unsigned int extentWidth;

2014 unsigned int extentHeight;

2015 unsigned int extentDepth;

2016 } sparseLevel;

2017 struct {

2018 unsigned int

2019 layer;

2020 unsigned long long offset;

2021 unsigned long long size;

2022 } miptail;

2023 } subresource;

2024 hipMemOperationType memOperationType;

2025 hipMemHandleType memHandleType;

2026 union {

2027 hipMemGenericAllocationHandle_t memHandle;

2028 } memHandle;

2029 unsigned long long offset;

2030 unsigned int deviceBitMask;

2031 unsigned int flags;

2032 unsigned int reserved[2];

2033} hipArrayMapInfo;

2034

2038typedef struct hipMemcpyNodeParams {

2039 int flags;

2040 int reserved[3];

2041 hipMemcpy3DParms copyParams;

2042} hipMemcpyNodeParams;

2043

2047typedef struct hipChildGraphNodeParams {

2048 hipGraph_t graph;

2050} hipChildGraphNodeParams;

2051

2055typedef struct hipEventWaitNodeParams {

2056 hipEvent_t event;

2057} hipEventWaitNodeParams;

2058

2062typedef struct hipEventRecordNodeParams {

2063 hipEvent_t event;

2064} hipEventRecordNodeParams;

2065

2069typedef struct hipMemFreeNodeParams {

2070 void* dptr;

2071} hipMemFreeNodeParams;

2072

2076typedef struct hipGraphNodeParams {

2077 hipGraphNodeType type;

2078 int reserved0[3];

2079 union {

2080 long long reserved1[29];

2081 hipKernelNodeParams kernel;

2082 hipMemcpyNodeParams memcpy;

2083 hipMemsetParams memset;

2084 hipHostNodeParams host;

2085 hipChildGraphNodeParams graph;

2086 hipEventWaitNodeParams eventWait;

2087 hipEventRecordNodeParams eventRecord;

2088 hipExternalSemaphoreSignalNodeParams extSemSignal;

2089 hipExternalSemaphoreWaitNodeParams extSemWait;

2090 hipMemAllocNodeParams alloc;

2091 hipMemFreeNodeParams free;

2092 };

2093

2094 long long reserved2;

2095} hipGraphNodeParams;

2096

2100#define hipGraphKernelNodePortDefault 0

2101

2105#define hipGraphKernelNodePortLaunchCompletion 2

2106

2112#define hipGraphKernelNodePortProgrammatic 1

2113

2114typedef enum hipGraphDependencyType {

2115 hipGraphDependencyTypeDefault = 0,

2116 hipGraphDependencyTypeProgrammatic = 1

2117} hipGraphDependencyType;

2118

2119typedef struct hipGraphEdgeData {

2120 unsigned char

2121 from_port;

2128 unsigned char reserved[5];

2129 unsigned char

2130 to_port;

2131 unsigned char type;

2132} hipGraphEdgeData;

2133

2134

2138typedef struct hipLaunchAttribute_st {

2139 hipLaunchAttributeID id;

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

2141 union {

2142 hipLaunchAttributeValue val;

2143 hipLaunchAttributeValue value;

2144 };

2145} hipLaunchAttribute;

2146

2150typedef struct hipLaunchConfig_st {

2151 dim3 gridDim;

2152 dim3 blockDim;

2153 size_t dynamicSmemBytes;

2154 hipStream_t stream;

2155 hipLaunchAttribute* attrs;

2156 unsigned int numAttrs;

2157} hipLaunchConfig_t;

2158

2162typedef struct HIP_LAUNCH_CONFIG_st {

2163 unsigned int gridDimX;

2164 unsigned int gridDimY;

2165 unsigned int gridDimZ;

2166 unsigned int blockDimX;

2167 unsigned int blockDimY;

2168 unsigned int blockDimZ;

2169 unsigned int sharedMemBytes;

2170 hipStream_t hStream;

2171 hipLaunchAttribute* attrs;

2172 unsigned int numAttrs;

2173} HIP_LAUNCH_CONFIG;

2174

2178typedef struct hipArrayMemoryRequirements {

2179 size_t alignment;

2180 size_t size;

2181} hipArrayMemoryRequirements;

2182

2186typedef enum hipMemRangeHandleType {

2187 hipMemRangeHandleTypeDmaBufFd = 0x1,

2188 hipMemRangeHandleTypeMax = 0x7fffffff

2189} hipMemRangeHandleType;

2190

2194typedef enum hipMemRangeFlags {

2195 hipMemRangeFlagDmaBufMappingTypePcie = 0x1,

2196 hipMemRangeFlagsMax = 0x7fffffff

2197} hipMemRangeFlags;

2198

2199// Doxygen end group GlobalDefs

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

2232hipError_t hipInit(unsigned int flags);

2233

2251hipError_t hipDriverGetVersion(int* driverVersion);

2266hipError_t hipRuntimeGetVersion(int* runtimeVersion);

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

2275

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

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

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

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

2316 int dstDevice);

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

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

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

2342// doxygen end initialization

2361hipError_t hipDeviceSynchronize(void);

2373hipError_t hipDeviceReset(void);

2405hipError_t hipSetDevice(int deviceId);

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

2432hipError_t hipGetDevice(int* deviceId);

2445hipError_t hipGetDeviceCount(int* count);

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

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

2492hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool);

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

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

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

2544 int device);

2556hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig);

2567hipError_t hipDeviceGetCacheConfig(hipFuncCache_t* cacheConfig);

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

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

2613hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig* pConfig);

2621hipError_t hipGetDeviceFlags(unsigned int* flags);

2633hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config);

2665hipError_t hipSetDeviceFlags(unsigned flags);

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

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

2689 uint32_t* hopcount);

2690// TODO: implement IPC apis

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

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

2768hipError_t hipIpcCloseMemHandle(void* devPtr);

2769

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

2787

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

2807

2808// end doxygen Device

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

2833

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

2850

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

2860

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

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

2887// doxygen end execution

2909hipError_t hipGetLastError(void);

2910

2922hipError_t hipExtGetLastError(void);

2923

2934hipError_t hipPeekAtLastError(void);

2943const char* hipGetErrorName(hipError_t hip_error);

2952const char* hipGetErrorString(hipError_t hipError);

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

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

2973// end doxygen Error

3006hipError_t hipStreamCreate(hipStream_t* stream);

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

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

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

3086hipError_t hipStreamDestroy(hipStream_t stream);

3102hipError_t hipStreamQuery(hipStream_t stream);

3124hipError_t hipStreamSynchronize(hipStream_t stream);

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

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

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

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

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

3213hipError_t hipExtStreamCreateWithCUMask(hipStream_t* stream, uint32_t cuMaskSize,

3214 const uint32_t* cuMask);

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

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

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

3248 unsigned int flags);

3249

3257hipError_t hipStreamSetAttribute(hipStream_t stream, hipStreamAttrID attr,

3258 const hipStreamAttrValue* value);

3259

3267hipError_t hipStreamGetAttribute(hipStream_t stream, hipStreamAttrID attr,

3268 hipStreamAttrValue* value_out);

3269

3276hipError_t hipStreamCopyAttributes(hipStream_t dst, hipStream_t src);

3277

3278// end doxygen Stream

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

3327 uint32_t mask __dparm(0xFFFFFFFF));

3328

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

3366 uint64_t mask __dparm(0xFFFFFFFFFFFFFFFF));

3367

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

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

3410

3430hipError_t hipStreamBatchMemOp(hipStream_t stream, unsigned int count,

3431 hipStreamBatchMemOpParams* paramArray, unsigned int flags);

3432

3450hipError_t hipGraphAddBatchMemOpNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

3451 const hipGraphNode_t* dependencies, size_t numDependencies,

3452 const hipBatchMemOpNodeParams* nodeParams);

3453

3474hipError_t hipGraphBatchMemOpNodeGetParams(hipGraphNode_t hNode,

3475 hipBatchMemOpNodeParams* nodeParams_out);

3476

3494hipError_t hipGraphBatchMemOpNodeSetParams(hipGraphNode_t hNode,

3495 hipBatchMemOpNodeParams* nodeParams);

3496

3516hipError_t hipGraphExecBatchMemOpNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

3517 const hipBatchMemOpNodeParams* nodeParams);

3518

3519// end doxygen Stream Memory Operations

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

3567hipError_t hipEventCreate(hipEvent_t* event);

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

3605 unsigned int flags __dparm(0));

3636#ifdef __cplusplus

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

3638#else

3639hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream);

3640#endif

3657hipError_t hipEventDestroy(hipEvent_t event);

3676hipError_t hipEventSynchronize(hipEvent_t event);

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

3722hipError_t hipEventQuery(hipEvent_t event);

3723// end doxygen Events

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

3755 hipDeviceptr_t ptr);

3756

3757

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

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

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

3810 void** data, hipDeviceptr_t ptr);

3834hipError_t hipImportExternalSemaphore(hipExternalSemaphore_t* extSem_out,

3835 const hipExternalSemaphoreHandleDesc* semHandleDesc);

3851hipError_t hipSignalExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

3852 const hipExternalSemaphoreSignalParams* paramsArray,

3853 unsigned int numExtSems, hipStream_t stream);

3869hipError_t hipWaitExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

3870 const hipExternalSemaphoreWaitParams* paramsArray,

3871 unsigned int numExtSems, hipStream_t stream);

3885hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem);

3886

3898hipError_t hipImportExternalMemory(hipExternalMemory_t* extMem_out,

3899 const hipExternalMemoryHandleDesc* memHandleDesc);

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

3912 const hipExternalMemoryBufferDesc* bufferDesc);

3922hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem);

3937hipError_t hipExternalMemoryGetMappedMipmappedArray(

3938 hipMipmappedArray_t* mipmap, hipExternalMemory_t extMem,

3939 const hipExternalMemoryMipmappedArrayDesc* mipmapDesc);

3940// end of external resource

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

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

3978

3979

4002HIP_DEPRECATED("use hipHostMalloc instead")

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

4016HIP_DEPRECATED("use hipHostMalloc instead")

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

4018// end doxygen deprecated management memory

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

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

4091 unsigned int flags __dparm(hipMemAttachGlobal));

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

4105 hipStream_t stream __dparm(0));

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

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

4121

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

4139 hipMemLocation* prefetch_locs, size_t* prefetch_loc_idxs,

4140 size_t num_prefetch_locs, unsigned long long flags,

4141 hipStream_t stream);

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

4167 unsigned long long flags, hipStream_t stream);

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

4189 unsigned long long flags, hipStream_t stream);

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

4220 hipMemLocation* prefetchLocs,

4221 size_t* prefetchLocIdxs,

4222 size_t numPrefetchLocs,

4223 unsigned long long flags, hipStream_t stream);

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

4243 hipMemLocation* prefetchLocs,

4244 size_t* prefetchLocIdxs,

4245 size_t numPrefetchLocs,

4246 unsigned long long flags, hipStream_t stream);

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

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

4287 hipMemLocation location);

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

4303 const void* dev_ptr, size_t count);

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

4321 hipMemRangeAttribute* attributes, size_t num_attributes,

4322 const void* dev_ptr, size_t count);

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

4339 unsigned int flags __dparm(hipMemAttachSingle));

4340// end doxygen Managed Memory

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

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

4453hipError_t hipMemPoolTrimTo(hipMemPool_t mem_pool, size_t min_bytes_to_hold);

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

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

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

4552 size_t count);

4572hipError_t hipMemPoolGetAccess(hipMemAccessFlags* flags, hipMemPool_t mem_pool,

4573 hipMemLocation* location);

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

4626hipError_t hipMemPoolDestroy(hipMemPool_t mem_pool);

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

4663 hipStream_t stream);

4690hipError_t hipMemPoolExportToShareableHandle(void* shared_handle, hipMemPool_t mem_pool,

4691 hipMemAllocationHandleType handle_type,

4692 unsigned int flags);

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

4717 hipMemAllocationHandleType handle_type,

4718 unsigned int flags);

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

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

4768 hipMemPoolPtrExportData* export_data);

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

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

4781 hipMemAllocationType type);

4782// Doxygen end of ordered memory allocator

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

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

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

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

4875hipError_t hipHostUnregister(void* hostPtr);

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

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

4918 unsigned int elementSizeBytes);

4932hipError_t hipFree(void* ptr);

4944hipError_t hipFreeHost(void* ptr);

4961hipError_t hipHostFree(void* ptr);

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

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

5010 hipStream_t stream);

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

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

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

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

5084 size_t ByteCount);

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

5104 size_t ByteCount);

5105

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

5126 size_t srcOffset, size_t ByteCount);

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

5146 hipStream_t stream);

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

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

5185 hipStream_t stream);

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

5206 size_t ByteCount, hipStream_t stream);

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

5227 size_t ByteCount, hipStream_t stream);

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

5245 const char* name);

5246

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

5257

5258

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

5269

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

5290 hipDriverProcAddressQueryResult* symbolStatus);

5291

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

5314 size_t offset __dparm(0),

5315 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice));

5316

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

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

5332

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

5346 size_t offset __dparm(0),

5347 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost));

5348

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

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

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

5393 hipStream_t stream __dparm(0));

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

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

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

5430 hipStream_t stream __dparm(0));

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

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

5457 hipStream_t stream __dparm(0));

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

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

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

5500 hipStream_t stream __dparm(0));

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

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

5524 hipStream_t stream __dparm(0));

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

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

5544 hipStream_t stream __dparm(0));

5545

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

5558 size_t height);

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

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

5573

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

5586 size_t height);

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

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

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

5613 size_t height);

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

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

5628

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

5646

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

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

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

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

5693hipError_t hipArrayDestroy(hipArray_t array);

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

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

5724hipError_t hipFreeArray(hipArray_t array);

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

5737 struct hipExtent extent, unsigned int flags);

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

5751 hipArray_t array);

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

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

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

5823 size_t height, hipMemcpyKind kind);

5833hipError_t hipMemcpyParam2D(const hip_Memcpy2D* pCopy);

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

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

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

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

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

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

5925 size_t spitch, size_t width, size_t height, hipMemcpyKind kind,

5926 hipStream_t stream __dparm(0));

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

5946 hipArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc,

5947 size_t width, size_t height, hipMemcpyKind kind);

5966HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5968 size_t count, hipMemcpyKind kind);

5987HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5989 size_t count, hipMemcpyKind kind);

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

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

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

6028 size_t hOffset, size_t width, size_t height,

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

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

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

6068hipError_t hipMemcpy3D(const struct hipMemcpy3DParms* p);

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

6091hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D* pCopy);

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

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

6117

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

6134 hipMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs,

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

6136

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

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

6151

6160hipError_t hipMemcpy3DPeer(hipMemcpy3DPeerParms* p);

6161

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

6171

6187hipError_t hipMipmappedArrayGetMemoryRequirements(hipArrayMemoryRequirements* memoryRequirements,

6188 hipMipmappedArray_t mipmap, hipDevice_t device);

6189// doxygen end Memory

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

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

6250hipError_t hipDeviceDisablePeerAccess(int peerDeviceId);

6251

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

6264 size_t sizeBytes);

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

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

6279

6280// doxygen end PeerToPeer

6301hipError_t hipDeviceGetDevResource(hipDevice_t device, hipDevResource* resource,

6302 hipDevResourceType type);

6303

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

6320 const hipDevResource* input, hipDevResource* remainder,

6321 unsigned int flags, unsigned int minCount);

6322

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

6340 const hipDevResource* input, hipDevResource* remainder,

6341 unsigned int flags,

6342 hipDevSmResourceGroupParams* groupParams);

6343

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

6355 unsigned int nbResources);

6356

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

6369 unsigned int flags);

6370

6378hipError_t hipExecutionCtxDestroy(hipExecutionCtx_t ctx);

6379

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

6389

6400hipError_t hipExecutionCtxStreamCreate(hipStream_t* stream, hipExecutionCtx_t greenctx,

6401 unsigned int flags, int priority);

6402

6412hipError_t hipExecutionCtxGetDevResource(hipExecutionCtx_t ctx, hipDevResource* resource,

6413 hipDevResourceType type);

6414

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

6424

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

6434

6444hipError_t hipStreamGetDevResource(hipStream_t hStream, hipDevResource* resource,

6445 hipDevResourceType type);

6446

6455hipError_t hipExecutionCtxRecordEvent(hipExecutionCtx_t ctx, hipEvent_t event);

6456

6464hipError_t hipExecutionCtxSynchronize(hipExecutionCtx_t ctx);

6465

6474hipError_t hipExecutionCtxWaitEvent(hipExecutionCtx_t ctx, hipEvent_t event);

6516HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6531HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6532hipError_t hipCtxDestroy(hipCtx_t ctx);

6546HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6547hipError_t hipCtxPopCurrent(hipCtx_t* ctx);

6561HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6562hipError_t hipCtxPushCurrent(hipCtx_t ctx);

6576HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6577hipError_t hipCtxSetCurrent(hipCtx_t ctx);

6591HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6592hipError_t hipCtxGetCurrent(hipCtx_t* ctx);

6606HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6607hipError_t hipCtxGetDevice(hipDevice_t* device);

6628HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6646HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6647hipError_t hipCtxGetCacheConfig(hipFuncCache_t* cacheConfig);

6664HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6665hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig);

6682HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6683hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config);

6700HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6701hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig* pConfig);

6716HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6717hipError_t hipCtxSynchronize(void);

6731HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6732hipError_t hipCtxGetFlags(unsigned int* flags);

6755HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6776HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6777hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx);

6778

6794HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6811HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6812hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev);

6827HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6842HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6843hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev);

6858HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6860// doxygen end Context Management

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

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

6908hipError_t hipModuleUnload(hipModule_t module);

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

6920

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

6931

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

6960 hipDevice_t dev);

6961

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

6976 void** jitOptionsValues, unsigned int numJitOptions,

6977 hipLibraryOption* libraryOptions, void** libraryOptionValues,

6978 unsigned int numLibraryOptions);

6979

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

6994 hipJitOption* jitOptions, void** jitOptionsValues,

6995 unsigned int numJitOptions, hipLibraryOption* libraryOptions,

6996 void** libraryOptionValues, unsigned int numLibraryOptions);

6997

7004hipError_t hipLibraryUnload(hipLibrary_t library);

7005

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

7015

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

7024

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

7040 const char* name);

7041

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

7059 const char* name);

7060

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

7070 hipLibrary_t library);

7071

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

7080

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

7089

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

7101 size_t* paramSize);

7102

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

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

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

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

7144 hipDriverEntryPointQueryResult* driverStatus);

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

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

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

7192 hipJitOption* options, void** optionValues);

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

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

7213 void** optionValues);

7214

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

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

7233

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

7249

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

7262 hipLinkState_t* stateOut);

7271hipError_t hipLinkDestroy(hipLinkState_t state);

7272

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

7302 unsigned int gridDimZ, unsigned int blockDimX,

7303 unsigned int blockDimY, unsigned int blockDimZ,

7304 unsigned int sharedMemBytes, hipStream_t stream,

7305 void** kernelParams, void** extra);

7334hipError_t hipModuleLaunchCooperativeKernel(hipFunction_t f, unsigned int gridDimX,

7335 unsigned int gridDimY, unsigned int gridDimZ,

7336 unsigned int blockDimX, unsigned int blockDimY,

7337 unsigned int blockDimZ, unsigned int sharedMemBytes,

7338 hipStream_t stream, void** kernelParams);

7353hipError_t hipModuleLaunchCooperativeKernelMultiDevice(hipFunctionLaunchParams* launchParamsList,

7354 unsigned int numDevices, unsigned int flags);

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

7376 void** kernelParams, unsigned int sharedMemBytes,

7377 hipStream_t stream);

7389hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList, int numDevices,

7390 unsigned int flags);

7391

7392// Doxygen end group ModuleCooperativeG

7406hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList, int numDevices,

7407 unsigned int flags);

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

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

7438 void** extra);

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

7454 hipMemRangeHandleType handleType,

7455 unsigned long long flags);

7456// doxygen end Module

7484// TODO - Match CUoccupancyB2DSize

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

7486 size_t dynSharedMemPerBlk, int blockSizeLimit);

7502// TODO - Match CUoccupancyB2DSize

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

7504 hipFunction_t f,

7505 size_t dynSharedMemPerBlk,

7506 int blockSizeLimit, unsigned int flags);

7516hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, hipFunction_t f,

7517 int blockSize,

7518 size_t dynSharedMemPerBlk);

7529hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

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

7541 int blockSize, size_t dynSharedMemPerBlk);

7552hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

7554 unsigned int flags __dparm(hipOccupancyDefault));

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

7570 size_t dynSharedMemPerBlk, int blockSizeLimit);

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

7587 int numBlocks, int blockSize);

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

7599 const hipLaunchConfig_t* config);

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

7611 const hipLaunchConfig_t* config);

7612

7613// doxygen end Occupancy

7627// TODO - expand descriptions:

7634HIP_DEPRECATED("use roctracer/rocTX instead")

7635hipError_t hipProfilerStart();

7642HIP_DEPRECATED("use roctracer/rocTX instead")

7643hipError_t hipProfilerStop();

7644// doxygen end profiler

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

7672 hipStream_t stream __dparm(0));

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

7692hipError_t hipLaunchByPtr(const void* func);

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

7710 hipStream_t stream __dparm(0));

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

7731 hipStream_t* stream);

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

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

7750 hipStream_t stream __dparm(0));

7751

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

7779

7787hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D* pCopy);

7788// TODO: Move this to hip_ext.h

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

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

7812 hipEvent_t startEvent, hipEvent_t stopEvent, int flags);

7813// doxygen end Clang launch

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

7840 const hipTextureDesc* pTexDesc,

7841 const struct hipResourceViewDesc* pResViewDesc);

7842

7851hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject);

7852

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

7863

7873hipError_t hipGetTextureObjectResourceDesc(hipResourceDesc* pResDesc,

7874 hipTextureObject_t textureObject);

7875

7885hipError_t hipGetTextureObjectResourceViewDesc(struct hipResourceViewDesc* pResViewDesc,

7886 hipTextureObject_t textureObject);

7887

7897hipError_t hipGetTextureObjectTextureDesc(hipTextureDesc* pTexDesc,

7898 hipTextureObject_t textureObject);

7899

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

7912 const HIP_TEXTURE_DESC* pTexDesc,

7913 const HIP_RESOURCE_VIEW_DESC* pResViewDesc);

7914

7923hipError_t hipTexObjectDestroy(hipTextureObject_t texObject);

7924

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

7935

7945hipError_t hipTexObjectGetResourceViewDesc(HIP_RESOURCE_VIEW_DESC* pResViewDesc,

7946 hipTextureObject_t texObject);

7947

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

7958

7973hipError_t hipMallocMipmappedArray(hipMipmappedArray_t* mipmappedArray,

7974 const struct hipChannelFormatDesc* desc, struct hipExtent extent,

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

7976

7987hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray);

7988

8001hipError_t hipGetMipmappedArrayLevel(hipArray_t* levelArray,

8002 hipMipmappedArray_const_t mipmappedArray, unsigned int level);

8003

8015hipError_t hipMipmappedArrayCreate(hipMipmappedArray_t* pHandle,

8016 HIP_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc,

8017 unsigned int numMipmapLevels);

8018

8029hipError_t hipMipmappedArrayDestroy(hipMipmappedArray_t hMipmappedArray);

8030

8043hipError_t hipMipmappedArrayGetLevel(hipArray_t* pLevelArray, hipMipmappedArray_t hMipMappedArray,

8044 unsigned int level);

8045

8064HIP_DEPRECATED(HIP_DEPRECATED_MSG)

8065hipError_t hipBindTextureToMipmappedArray(const textureReference* tex,

8066 hipMipmappedArray_const_t mipmappedArray,

8067 const hipChannelFormatDesc* desc);

8068

8079HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8081

8092HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8094

8106HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8108

8120HIP_DEPRECATED(HIP_DEPRECATED_MSG)

8121hipError_t hipTexRefSetAddressMode(textureReference* texRef, int dim,

8122 enum hipTextureAddressMode am);

8135HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8148HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8161HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8175HIP_DEPRECATED(HIP_DEPRECATED_MSG)

8176hipError_t hipTexRefSetFormat(textureReference* texRef, hipArray_Format fmt,

8177 int NumPackedComponents);

8192HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

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

8211HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

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

8214 size_t pitch);

8227HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8229 const hipChannelFormatDesc* desc);

8241HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8253HIP_DEPRECATED(HIP_DEPRECATED_MSG)

8254hipError_t hipUnbindTexture(const textureReference* tex);

8266HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8280HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8282 int dim);

8294HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8307HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8321HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8323 const textureReference* texRef);

8335HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8348HIP_DEPRECATED(HIP_DEPRECATED_MSG)

8349hipError_t hipTexRefGetMipmapFilterMode(enum hipTextureFilterMode* pfm,

8350 const textureReference* texRef);

8362HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8376HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8378 const textureReference* texRef);

8390HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8405HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8407 size_t bytes);

8421HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8423 hipDeviceptr_t dptr, size_t Pitch);

8435HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8448HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8461HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8474HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

8488HIP_DEPRECATED(HIP_DEPRECATED_MSG)

8489hipError_t hipTexRefSetMipmapLevelClamp(textureReference* texRef, float minMipMapLevelClamp,

8490 float maxMipMapLevelClamp);

8503HIP_DEPRECATED(HIP_DEPRECATED_MSG)

8504hipError_t hipTexRefSetMipmappedArray(textureReference* texRef,

8505 struct hipMipmappedArray* mipmappedArray, unsigned int Flags);

8506

8507// doxygen end deprecated texture management

8512// doxygen end Texture management

8524// This group is for HIPrtc

8525

8526// doxygen end Runtime

8545const char* hipApiName(uint32_t id);

8554const char* hipKernelNameRef(const hipFunction_t f);

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

8573int hipGetStreamDeviceId(hipStream_t stream);

8574

8575// doxygen end Callback

8597hipError_t hipStreamBeginCapture(hipStream_t stream, hipStreamCaptureMode mode);

8598

8618hipError_t hipStreamBeginCaptureToGraph(hipStream_t stream, hipGraph_t graph,

8619 const hipGraphNode_t* dependencies,

8620 const hipGraphEdgeData* dependencyData,

8621 size_t numDependencies, hipStreamCaptureMode mode);

8622

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

8633

8644hipError_t hipStreamGetCaptureInfo(hipStream_t stream, hipStreamCaptureStatus* pCaptureStatus,

8645 unsigned long long* pId);

8646

8661hipError_t hipStreamGetCaptureInfo_v2(hipStream_t stream, hipStreamCaptureStatus* captureStatus_out,

8662 unsigned long long* id_out __dparm(0),

8663 hipGraph_t* graph_out __dparm(0),

8664 const hipGraphNode_t** dependencies_out __dparm(0),

8665 size_t* numDependencies_out __dparm(0));

8666

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

8677

8689hipError_t hipStreamUpdateCaptureDependencies(hipStream_t stream, hipGraphNode_t* dependencies,

8690 size_t numDependencies,

8691 unsigned int flags __dparm(0));

8692

8700hipError_t hipThreadExchangeStreamCaptureMode(hipStreamCaptureMode* mode);

8701

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

8712

8721hipError_t hipGraphDestroy(hipGraph_t graph);

8722

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

8734 const hipGraphNode_t* to, size_t numDependencies);

8735

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

8747 const hipGraphNode_t* to, size_t numDependencies);

8748

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

8765 size_t* numEdges);

8766

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

8782

8797hipError_t hipGraphGetRootNodes(hipGraph_t graph, hipGraphNode_t* pRootNodes,

8798 size_t* pNumRootNodes);

8799

8814hipError_t hipGraphNodeGetDependencies(hipGraphNode_t node, hipGraphNode_t* pDependencies,

8815 size_t* pNumDependencies);

8816

8832hipError_t hipGraphNodeGetDependentNodes(hipGraphNode_t node, hipGraphNode_t* pDependentNodes,

8833 size_t* pNumDependentNodes);

8834

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

8844

8852hipError_t hipGraphDestroyNode(hipGraphNode_t node);

8853

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

8863

8873hipError_t hipGraphNodeFindInClone(hipGraphNode_t* pNode, hipGraphNode_t originalNode,

8874 hipGraph_t clonedGraph);

8875

8889hipError_t hipGraphInstantiate(hipGraphExec_t* pGraphExec, hipGraph_t graph,

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

8891

8902hipError_t hipGraphInstantiateWithFlags(hipGraphExec_t* pGraphExec, hipGraph_t graph,

8903 unsigned long long flags);

8904

8914hipError_t hipGraphInstantiateWithParams(hipGraphExec_t* pGraphExec, hipGraph_t graph,

8915 hipGraphInstantiateParams* instantiateParams);

8924hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream);

8925

8934hipError_t hipGraphUpload(hipGraphExec_t graphExec, hipStream_t stream);

8935

8947hipError_t hipGraphAddNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8948 const hipGraphNode_t* pDependencies, size_t numDependencies,

8949 hipGraphNodeParams* nodeParams);

8950

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

8960

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

8971

8982hipError_t hipGraphExecNodeSetParams(hipGraphExec_t graphExec, hipGraphNode_t node,

8983 hipGraphNodeParams* nodeParams);

8984

8993hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec);

8994

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

9007hipError_t hipGraphExecUpdate(hipGraphExec_t hGraphExec, hipGraph_t hGraph,

9008 hipGraphNode_t* hErrorNode_out,

9009 hipGraphExecUpdateResult* updateResult_out);

9010

9022hipError_t hipGraphAddKernelNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9023 const hipGraphNode_t* pDependencies, size_t numDependencies,

9024 const hipKernelNodeParams* pNodeParams);

9025

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

9035

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

9045

9055hipError_t hipGraphExecKernelNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

9056 const hipKernelNodeParams* pNodeParams);

9057

9070hipError_t hipDrvGraphAddMemcpyNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

9071 const hipGraphNode_t* dependencies, size_t numDependencies,

9072 const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);

9084hipError_t hipGraphAddMemcpyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9085 const hipGraphNode_t* pDependencies, size_t numDependencies,

9086 const hipMemcpy3DParms* pCopyParams);

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

9096

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

9106

9116hipError_t hipGraphKernelNodeSetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

9117 const hipKernelNodeAttrValue* value);

9127hipError_t hipGraphKernelNodeGetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

9128 hipKernelNodeAttrValue* value);

9138hipError_t hipGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

9139 hipMemcpy3DParms* pNodeParams);

9140

9155hipError_t hipGraphAddMemcpyNode1D(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9156 const hipGraphNode_t* pDependencies, size_t numDependencies,

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

9158

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

9171 size_t count, hipMemcpyKind kind);

9172

9186hipError_t hipGraphExecMemcpyNodeSetParams1D(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

9188 hipMemcpyKind kind);

9189

9205hipError_t hipGraphAddMemcpyNodeFromSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9206 const hipGraphNode_t* pDependencies,

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

9208 size_t count, size_t offset, hipMemcpyKind kind);

9209

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

9223 size_t count, size_t offset, hipMemcpyKind kind);

9224

9239hipError_t hipGraphExecMemcpyNodeSetParamsFromSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

9241 size_t offset, hipMemcpyKind kind);

9242

9258hipError_t hipGraphAddMemcpyNodeToSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9259 const hipGraphNode_t* pDependencies,

9260 size_t numDependencies, const void* symbol,

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

9262 hipMemcpyKind kind);

9263

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

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

9278 hipMemcpyKind kind);

9279

9280

9294hipError_t hipGraphExecMemcpyNodeSetParamsToSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

9295 const void* symbol, const void* src,

9296 size_t count, size_t offset, hipMemcpyKind kind);

9297

9309hipError_t hipGraphAddMemsetNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9310 const hipGraphNode_t* pDependencies, size_t numDependencies,

9311 const hipMemsetParams* pMemsetParams);

9312

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

9322

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

9332

9342hipError_t hipGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

9343 const hipMemsetParams* pNodeParams);

9344

9356hipError_t hipGraphAddHostNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9357 const hipGraphNode_t* pDependencies, size_t numDependencies,

9358 const hipHostNodeParams* pNodeParams);

9359

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

9369

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

9379

9389hipError_t hipGraphExecHostNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

9390 const hipHostNodeParams* pNodeParams);

9391

9403hipError_t hipGraphAddChildGraphNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9404 const hipGraphNode_t* pDependencies, size_t numDependencies,

9405 hipGraph_t childGraph);

9406

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

9416

9426hipError_t hipGraphExecChildGraphNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

9427 hipGraph_t childGraph);

9428

9439hipError_t hipGraphAddEmptyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9440 const hipGraphNode_t* pDependencies, size_t numDependencies);

9441

9442

9454hipError_t hipGraphAddEventRecordNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9455 const hipGraphNode_t* pDependencies, size_t numDependencies,

9456 hipEvent_t event);

9457

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

9467

9476hipError_t hipGraphEventRecordNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

9477

9487hipError_t hipGraphExecEventRecordNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9488 hipEvent_t event);

9489

9501hipError_t hipGraphAddEventWaitNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9502 const hipGraphNode_t* pDependencies, size_t numDependencies,

9503 hipEvent_t event);

9504

9505

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

9515

9524hipError_t hipGraphEventWaitNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

9525

9535hipError_t hipGraphExecEventWaitNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9536 hipEvent_t event);

9537

9550hipError_t hipGraphAddMemAllocNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9551 const hipGraphNode_t* pDependencies, size_t numDependencies,

9552 hipMemAllocNodeParams* pNodeParams);

9553

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

9563

9575hipError_t hipGraphAddMemFreeNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9576 const hipGraphNode_t* pDependencies, size_t numDependencies,

9577 void* dev_ptr);

9578

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

9588

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

9599

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

9610

9618hipError_t hipDeviceGraphMemTrim(int device);

9619

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

9632 unsigned int initialRefcount, unsigned int flags);

9633

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

9643

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

9653

9664hipError_t hipGraphRetainUserObject(hipGraph_t graph, hipUserObject_t object,

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

9666

9676hipError_t hipGraphReleaseUserObject(hipGraph_t graph, hipUserObject_t object,

9677 unsigned int count __dparm(1));

9678

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

9689

9703hipError_t hipGraphKernelNodeCopyAttributes(hipGraphNode_t hSrc, hipGraphNode_t hDst);

9704

9726hipError_t hipGraphNodeSetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9727 unsigned int isEnabled);

9747hipError_t hipGraphNodeGetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9748 unsigned int* isEnabled);

9749

9761hipError_t hipGraphAddExternalSemaphoresWaitNode(

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

9763 size_t numDependencies, const hipExternalSemaphoreWaitNodeParams* nodeParams);

9764

9776hipError_t hipGraphAddExternalSemaphoresSignalNode(

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

9778 size_t numDependencies, const hipExternalSemaphoreSignalNodeParams* nodeParams);

9787hipError_t hipGraphExternalSemaphoresSignalNodeSetParams(

9788 hipGraphNode_t hNode, const hipExternalSemaphoreSignalNodeParams* nodeParams);

9797hipError_t hipGraphExternalSemaphoresWaitNodeSetParams(

9798 hipGraphNode_t hNode, const hipExternalSemaphoreWaitNodeParams* nodeParams);

9807hipError_t hipGraphExternalSemaphoresSignalNodeGetParams(

9808 hipGraphNode_t hNode, hipExternalSemaphoreSignalNodeParams* params_out);

9817hipError_t hipGraphExternalSemaphoresWaitNodeGetParams(

9818 hipGraphNode_t hNode, hipExternalSemaphoreWaitNodeParams* params_out);

9828hipError_t hipGraphExecExternalSemaphoresSignalNodeSetParams(

9829 hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9830 const hipExternalSemaphoreSignalNodeParams* nodeParams);

9840hipError_t hipGraphExecExternalSemaphoresWaitNodeSetParams(

9841 hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9842 const hipExternalSemaphoreWaitNodeParams* nodeParams);

9843

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

9853

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

9863

9876hipError_t hipDrvGraphAddMemsetNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

9877 const hipGraphNode_t* dependencies, size_t numDependencies,

9878 const hipMemsetParams* memsetParams, hipCtx_t ctx);

9879

9891hipError_t hipDrvGraphAddMemFreeNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

9892 const hipGraphNode_t* dependencies, size_t numDependencies,

9893 hipDeviceptr_t dptr);

9894

9905hipError_t hipDrvGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9906 const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);

9907

9918hipError_t hipDrvGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9919 const hipMemsetParams* memsetParams, hipCtx_t ctx);

9920

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

9937 void** extra);

9938

9939// doxygen end graph API

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

9969

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

9983 unsigned long long flags);

9984

10002hipError_t hipMemCreate(hipMemGenericAllocationHandle_t* handle, size_t size,

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

10004

10016hipError_t hipMemExportToShareableHandle(void* shareableHandle,

10017 hipMemGenericAllocationHandle_t handle,

10018 hipMemAllocationHandleType handleType,

10019 unsigned long long flags);

10020

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

10032

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

10045 hipMemAllocationGranularity_flags option);

10046

10056hipError_t hipMemGetAllocationPropertiesFromHandle(hipMemAllocationProp* prop,

10057 hipMemGenericAllocationHandle_t handle);

10058

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

10070 hipMemAllocationHandleType shHandleType);

10071

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

10085 unsigned long long flags);

10086

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

10096 hipStream_t stream);

10097

10107hipError_t hipMemRelease(hipMemGenericAllocationHandle_t handle);

10108

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

10119

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

10133

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

10144

10145// doxygen end virtual memory management API

10167hipError_t hipGraphicsMapResources(int count, hipGraphicsResource_t* resources,

10168 hipStream_t stream __dparm(0));

10182hipError_t hipGraphicsSubResourceGetMappedArray(hipArray_t* array, hipGraphicsResource_t resource,

10183 unsigned int arrayIndex, unsigned int mipLevel);

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

10195 hipGraphicsResource_t resource);

10206hipError_t hipGraphicsUnmapResources(int count, hipGraphicsResource_t* resources,

10207 hipStream_t stream __dparm(0));

10216hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource);

10217// doxygen end GraphicsInterop

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

10251hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject);

10252// end of surface

10253

10254

10265hipError_t hipExtEnableLogging();

10276hipError_t hipExtDisableLogging();

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

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

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

10322 void** extra);

10326#ifdef __cplusplus

10327} /* extern "c" */

10328#endif

10329#ifdef __cplusplus

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

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

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

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

10334 dynSharedMemPerBlk, blockSizeLimit);

10335}

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

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

10338 unsigned int flags = 0) {

10339 (void)flags;

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

10341 dynSharedMemPerBlk, blockSizeLimit);

10342}

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

10344

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

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

10356}

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

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

10369}

10370

10379template <typename T>

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

10381 size_t offset __dparm(0),

10382 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice)) {

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

10384}

10393template <typename T>

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

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

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

10397}

10405template <typename T>

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

10407 size_t offset __dparm(0),

10408 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost)) {

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

10410}

10418template <typename T>

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

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

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

10422}

10423

10435template <class T>

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

10437 size_t dynSharedMemPerBlk) {

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

10439 blockSize, dynSharedMemPerBlk);

10440}

10454template <class T> inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

10456 return hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

10458}

10481template <typename UnaryFunction, class T>

10482static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(

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

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

10485 if (min_grid_size == nullptr || block_size == nullptr ||

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

10487 return hipErrorInvalidValue;

10488 }

10489

10490 int dev;

10491 hipError_t status;

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

10493 return status;

10494 }

10495

10496 int max_threads_per_cu;

10497 if ((status = hipDeviceGetAttribute(&max_threads_per_cu,

10498 hipDeviceAttributeMaxThreadsPerMultiProcessor, dev)) !=

10499 hipSuccess) {

10500 return status;

10501 }

10502

10503 int warp_size;

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

10505 return status;

10506 }

10507

10508 int max_cu_count;

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

10510 hipSuccess) {

10511 return status;

10512 }

10513

10514 struct hipFuncAttributes attr;

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

10516 return status;

10517 }

10518

10519 // Initial limits for the execution

10520 const int func_max_threads_per_block = attr.maxThreadsPerBlock;

10521 if (block_size_limit == 0) {

10522 block_size_limit = func_max_threads_per_block;

10523 }

10524

10525 if (func_max_threads_per_block < block_size_limit) {

10526 block_size_limit = func_max_threads_per_block;

10527 }

10528

10529 const int block_size_limit_aligned =

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

10531

10532 // For maximum search

10533 int max_threads = 0;

10534 int max_block_size{};

10535 int max_num_blocks{};

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

10537 block_size_check_aligned -= warp_size) {

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

10539 int block_size_check =

10540 (block_size_limit < block_size_check_aligned) ? block_size_limit : block_size_check_aligned;

10541

10542 size_t dyn_smem_size = block_size_to_dynamic_smem_size(block_size_check);

10543 int optimal_blocks;

10544 if ((status = hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

10546 return status;

10547 }

10548

10549 int total_threads = block_size_check * optimal_blocks;

10550 if (total_threads > max_threads) {

10551 max_block_size = block_size_check;

10552 max_num_blocks = optimal_blocks;

10553 max_threads = total_threads;

10554 }

10555

10556 // Break if the logic reached possible maximum

10557 if (max_threads_per_cu == max_threads) {

10558 break;

10559 }

10560 }

10561

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

10563 *min_grid_size = max_num_blocks * max_cu_count;

10564 *block_size = max_block_size;

10565

10566 return status;

10567}

10568

10590template <typename UnaryFunction, class T>

10591static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMem(

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

10593 int block_size_limit = 0) {

10594 return hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(

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

10596}

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

10613 int* blockSize, F kernel,

10614 size_t dynSharedMemPerBlk,

10615 uint32_t blockSizeLimit) {

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

10617 dynSharedMemPerBlk, blockSizeLimit);

10618}

10619

10635template <typename F>

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

10637 int numBlocks, int blockSize) {

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

10639 numBlocks, blockSize);

10640}

10662template <class T>

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

10664 unsigned int sharedMemBytes, hipStream_t stream) {

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

10666 kernelParams, sharedMemBytes, stream);

10667}

10683template <class T>

10684inline hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

10685 unsigned int numDevices,

10686 unsigned int flags = 0) {

10687 return hipLaunchCooperativeKernelMultiDevice(launchParamsList, numDevices, flags);

10688}

10701template <class T>

10702inline hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

10703 unsigned int numDevices,

10704 unsigned int flags = 0) {

10705 return hipExtLaunchMultiKernelMultiDevice(launchParamsList, numDevices, flags);

10706}

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

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

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

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

10724}

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

10740static inline hipError_t

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

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

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

10744}

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

10761static inline hipError_t

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

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

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

10765}

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

10783static inline hipError_t

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

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

10786 size_t height, size_t pitch) {

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

10788}

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

10801static inline hipError_t

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

10803 struct hipChannelFormatDesc desc;

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

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

10806}

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

10820static inline hipError_t

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

10822 const struct hipChannelFormatDesc& desc) {

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

10824}

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

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

10838 hipMipmappedArray_const_t mipmappedArray) {

10839 struct hipChannelFormatDesc desc;

10840 hipArray_t levelArray;

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

10842 if (err != hipSuccess) {

10843 return err;

10844 }

10845 err = hipGetChannelDesc(&desc, levelArray);

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

10847}

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

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

10862 hipMipmappedArray_const_t mipmappedArray,

10863 const struct hipChannelFormatDesc& desc) {

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

10865}

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

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

10878 return hipUnbindTexture(&tex);

10879}

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

10904 hipStream_t stream) {

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

10906}

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

10918 hipMemPool_t mem_pool,

10919 hipStream_t stream) {

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

10921}

10932template <class T>

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

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

10935}

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

10947 hipMemPool_t mem_pool,

10948 hipStream_t stream) {

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

10950}

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

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

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

10967 Params&&... args) {

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

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

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

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

10972}

10978#endif // __cplusplus

10979

10980#ifdef __GNUC__

10981#pragma GCC visibility pop

10982#endif

10983

10984

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

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

10987#else

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

10989#endif

10990

10991

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

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

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

11006}

11018template <class T>

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

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

11021}

11034template <class T>

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

11036 unsigned int flags = hipHostMallocDefault) {

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

11038}

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

11052 unsigned int flags = hipHostAllocDefault) {

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

11054}

11069template <class T>

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

11071 unsigned int flags = hipMemAttachGlobal) {

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

11073}

11074

11075

11076#endif

11077#endif

11078// doxygen end HIP API

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

11083

11084#if USE_PROF_API

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

11086#endif

driver_types.h

err

hipError_t err

Definition hip_runtime_api.h:10804

tex

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

Definition hip_runtime_api.h:10721

size

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

Definition hip_runtime_api.h:10722

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

levelArray

hipArray_t levelArray

Definition hip_runtime_api.h:10840

dim

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

Definition hip_runtime_api.h:10739

mipmappedArray

readMode hipMipmappedArray_const_t mipmappedArray

Definition hip_runtime_api.h:10838

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

devPtr

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

Definition hip_runtime_api.h:10722

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

array

readMode hipArray_const_t array

Definition hip_runtime_api.h:10802

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

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

hipGetDeviceFlags

hipError_t hipGetDeviceFlags(unsigned int *flags)

Gets the flags set for current device.

hipIpcGetEventHandle

hipError_t hipIpcGetEventHandle(hipIpcEventHandle_t *handle, hipEvent_t event)

Gets an opaque interprocess handle for an event.

hipDeviceGetDefaultMemPool

hipError_t hipDeviceGetDefaultMemPool(hipMemPool_t *mem_pool, int device)

Returns the default memory pool of the specified device.

hipDeviceGetSharedMemConfig

hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig *pConfig)

Returns bank width of shared memory for current device.

hipDeviceSetMemPool

hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool)

Sets the current memory pool of a device.

hipIpcOpenMemHandle

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

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

hipDeviceGetCacheConfig

hipError_t hipDeviceGetCacheConfig(hipFuncCache_t *cacheConfig)

Get Cache configuration for a specific Device.

hipSetDevice

hipError_t hipSetDevice(int deviceId)

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

hipExtGetLinkTypeAndHopCount

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

Returns the link type and hop count between two devices.

hipDeviceGetTexture1DLinearMaxWidth

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

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

hipSetDeviceFlags

hipError_t hipSetDeviceFlags(unsigned flags)

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

hipDeviceGetAttribute

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

Query for a specific device attribute.

hipGetDevice

hipError_t hipGetDevice(int *deviceId)

Return the default device id for the calling host thread.

hipGetDeviceCount

hipError_t hipGetDeviceCount(int *count)

Return number of compute-capable devices.

hipDeviceGetMemPool

hipError_t hipDeviceGetMemPool(hipMemPool_t *mem_pool, int device)

Gets the current memory pool for the specified device.

hipDeviceReset

hipError_t hipDeviceReset(void)

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

hipDeviceGetLimit

hipError_t hipDeviceGetLimit(size_t *pValue, enum hipLimit_t limit)

Gets resource limits of current device.

hipDeviceSetSharedMemConfig

hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config)

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

hipDeviceSetLimit

hipError_t hipDeviceSetLimit(enum hipLimit_t limit, size_t value)

Sets resource limits of current device.

hipDeviceSetCacheConfig

hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig)

Set L1/Shared cache partition.

hipIpcCloseMemHandle

hipError_t hipIpcCloseMemHandle(void *devPtr)

Close memory mapped with hipIpcOpenMemHandle.

hipSetValidDevices

hipError_t hipSetValidDevices(int *device_arr, int len)

Set a list of devices that can be used.

hipIpcOpenEventHandle

hipError_t hipIpcOpenEventHandle(hipEvent_t *event, hipIpcEventHandle_t handle)

Opens an interprocess event handles.

hipDeviceSynchronize

hipError_t hipDeviceSynchronize(void)

Waits on all active streams on current device.

hipIpcGetMemHandle

hipError_t hipIpcGetMemHandle(hipIpcMemHandle_t *handle, void *devPtr)

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

hipInit

hipError_t hipInit(unsigned int flags)

Explicitly initializes the HIP runtime.

hipDeviceComputeCapability

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

Returns the compute capability of the device.

hipDeviceGetName

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

Returns an identifer string for the device.

hipDeviceGetByPCIBusId

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

Returns a handle to a compute device.

hipDeviceGetUuid

hipError_t hipDeviceGetUuid(hipUUID *uuid, hipDevice_t device)

Returns an UUID for the device.[BETA].

hipDeviceTotalMem

hipError_t hipDeviceTotalMem(size_t *bytes, hipDevice_t device)

Returns the total amount of memory on the device.

hipDeviceGetPCIBusId

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

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

hipDeviceGet

hipError_t hipDeviceGet(hipDevice_t *device, int ordinal)

Returns a handle to a compute device.

hipRuntimeGetVersion

hipError_t hipRuntimeGetVersion(int *runtimeVersion)

Returns the approximate HIP Runtime version.

hipDeviceGetP2PAttribute

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

Returns a value for attribute of link between two devices.

hipDriverGetVersion

hipError_t hipDriverGetVersion(int *driverVersion)

Returns the approximate HIP driver version.

hipMemcpyKind

hipMemcpyKind

Definition driver_types.h: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:1091

hipDeviceArch_t::hasSharedInt64Atomics

unsigned hasSharedInt64Atomics

64-bit integer atomics for shared memory.

Definition hip_runtime_api.h:59

hipDeviceProp_t::ECCEnabled

int ECCEnabled

Device has ECC support enabled.

Definition hip_runtime_api.h:155

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::address

hipDeviceptr_t address

Definition hip_runtime_api.h:1102

hipDeviceProp_t::ipcEventSupported

int ipcEventSupported

Device supports IPC events.

Definition hip_runtime_api.h:209

hipGraphNodeParams::type

hipGraphNodeType type

Definition hip_runtime_api.h:2077

hipDeviceProp_t::computePreemptionSupported

int computePreemptionSupported

Is compute preemption supported on the device.

Definition hip_runtime_api.h:181

hipExternalMemoryHandleDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1431

hipExternalSemaphoreHandleDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1470

hipDeviceProp_t::maxTexture1DLinear

int maxTexture1DLinear

Maximum size for 1D textures bound to linear memory.

Definition hip_runtime_api.h:134

hipGraphNodeParams::reserved0

int reserved0[3]

Definition hip_runtime_api.h:2078

hipLaunchAttributeValue::priority

int priority

Definition hip_runtime_api.h:1740

hipFunctionLaunchParams::gridDimX

unsigned int gridDimX

Width(X) of grid in blocks.

Definition hip_runtime_api.h:1400

hipFunctionLaunchParams::blockDimX

unsigned int blockDimX

X dimension of each thread block.

Definition hip_runtime_api.h:1403

hipMemAllocationProp::win32HandleMetaData

void * win32HandleMetaData

Metadata for Win32 handles.

Definition hip_runtime_api.h:1926

hipDeviceProp_t::timelineSemaphoreInteropSupported

int timelineSemaphoreInteropSupported

Indicates external timeline semaphore support.

Definition hip_runtime_api.h:199

hipPointerAttribute_t::device

int device

Definition hip_runtime_api.h:266

hipMemAllocationProp::type

hipMemAllocationType type

Memory allocation type.

Definition hip_runtime_api.h:1920

hipDeviceProp_t::pciBusID

int pciBusID

PCI Bus ID.

Definition hip_runtime_api.h:156

hipArrayMapInfo::flags

unsigned int flags

flags for future use, must be zero now.

Definition hip_runtime_api.h:2031

hipDeviceArch_t::hasSharedInt32Atomics

unsigned hasSharedInt32Atomics

32-bit integer atomics for shared memory.

Definition hip_runtime_api.h:53

hipDeviceProp_t::maxTexture1D

int maxTexture1D

Maximum number of elements in 1D images.

Definition hip_runtime_api.h:132

hipAccessPolicyWindow::hitProp

hipAccessProperty hitProp

hipAccessProperty set for hit

Definition hip_runtime_api.h:1626

hipPointerAttribute_t::hostPointer

void * hostPointer

Definition hip_runtime_api.h:268

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::address

hipDeviceptr_t address

Definition hip_runtime_api.h:1092

hipAccessPolicyWindow::missProp

hipAccessProperty missProp

hipAccessProperty set for miss

Definition hip_runtime_api.h:1628

hipDeviceProp_t::memoryBusWidth

int memoryBusWidth

Global memory bus width in bits.

Definition hip_runtime_api.h:163

hipDeviceProp_t::maxTexture2DMipmap

int maxTexture2DMipmap[2]

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

Definition hip_runtime_api.h:136

hipDevWorkqueueConfigResource::sharingScope

hipDevWorkqueueConfigScope sharingScope

Definition hip_runtime_api.h:724

hipDeviceProp_t::clockRate

int clockRate

Max clock frequency of the multiProcessors in khz.

Definition hip_runtime_api.h:109

hipExternalMemoryMipmappedArrayDesc::extent

hipExtent extent

Definition hip_runtime_api.h:1443

hipMemPoolProps::maxSize

size_t maxSize

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

Definition hip_runtime_api.h:1329

hipLaunchAttributeValue::pad

char pad[64]

64 byte padding

Definition hip_runtime_api.h:1735

hipDevSmResource::flags

unsigned int flags

Definition hip_runtime_api.h:718

hipDevSmResourceGroupParams::flags

unsigned int flags

Definition hip_runtime_api.h:747

hipDeviceArch_t::hasFloatAtomicAdd

unsigned hasFloatAtomicAdd

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

Definition hip_runtime_api.h:55

hipDeviceProp_t::maxThreadsPerMultiProcessor

int maxThreadsPerMultiProcessor

Maximum resident threads per multi-processor.

Definition hip_runtime_api.h:166

hipDeviceProp_t::l2CacheSize

int l2CacheSize

L2 cache size.

Definition hip_runtime_api.h:164

hipDeviceProp_t::deferredMappingHipArraySupported

int deferredMappingHipArraySupported

Definition hip_runtime_api.h:207

hipArrayMemoryRequirements::size

size_t size

Definition hip_runtime_api.h:2180

hipDeviceProp_t::asyncEngineCount

int asyncEngineCount

Number of async engines.

Definition hip_runtime_api.h:160

hipMemsetParams::dst

void * dst

Definition hip_runtime_api.h:1593

hipDeviceProp_t::accessPolicyMaxWindowSize

int accessPolicyMaxWindowSize

Max value of access policy window.

Definition hip_runtime_api.h:193

hipPointerAttribute_t::type

enum hipMemoryType type

Definition hip_runtime_api.h:265

hipStreamBatchMemOpParams::hipStreamMemOpFlushRemoteWritesParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:1112

hipDeviceProp_t::totalConstMem

size_t totalConstMem

Definition hip_runtime_api.h:110

hipDeviceProp_t::memoryPoolsSupported

int memoryPoolsSupported

Indicates if device supports hipMallocAsync and hipMemPool APIs.

Definition hip_runtime_api.h:200

hipLaunchConfig_t::blockDim

dim3 blockDim

Block dimensions.

Definition hip_runtime_api.h:2152

hipKernelNodeParams::gridDim

dim3 gridDim

Definition hip_runtime_api.h:1588

hipExternalSemaphoreSignalNodeParams::paramsArray

const hipExternalSemaphoreSignalParams * paramsArray

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

Definition hip_runtime_api.h:1941

hipExtDynDataPrefetchRegion::address

void * address

Base address (must be cache-line aligned)

Definition hip_runtime_api.h:1684

hipDevResource::nextResource

struct hipDevResource_st * nextResource

Definition hip_runtime_api.h:740

hipHostNodeParams::fn

hipHostFn_t fn

Definition hip_runtime_api.h:1581

hipDeviceProp_t::unifiedFunctionPointers

int unifiedFunctionPointers

Indicates device supports unified function pointers.

Definition hip_runtime_api.h:211

hipDeviceArch_t::hasDoubles

unsigned hasDoubles

Double-precision floating point.

Definition hip_runtime_api.h:62

hipDeviceProp_t::maxTexture2DGather

int maxTexture2DGather[2]

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

Definition hip_runtime_api.h:138

hipStreamBatchMemOpParams::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:1089

hipFuncAttributes::cacheModeCA

int cacheModeCA

Definition hip_runtime_api.h:788

hipDeviceProp_t::memPitch

size_t memPitch

Definition hip_runtime_api.h:104

hipExtDynDataPrefetchConfig::regions

hipExtDynDataPrefetchRegion regions[HIP_EXT_DYN_DATA_PREFETCH_MAX_REGIONS]

Prefetch regions.

Definition hip_runtime_api.h:1710

hipMemAccessDesc::flags

hipMemAccessFlags flags

Accessibility flags to set.

Definition hip_runtime_api.h:1289

hipExtDynDataPrefetchConfig::numRegions

unsigned int numRegions

Number of valid regions (1-max)

Definition hip_runtime_api.h:1708

hipChildGraphNodeParams::graph

hipGraph_t graph

Definition hip_runtime_api.h:2048

hipDeviceProp_t::gpuDirectRDMAWritesOrdering

int gpuDirectRDMAWritesOrdering

value of hipGPUDirectRDMAWritesOrdering

Definition hip_runtime_api.h:204

hipMemsetParams::value

unsigned int value

Definition hip_runtime_api.h:1597

hipDeviceArch_t::hasWarpVote

unsigned hasWarpVote

Warp vote instructions (__any, __all).

Definition hip_runtime_api.h:65

hipDevSmResource::smCount

unsigned int smCount

Definition hip_runtime_api.h:715

hipDeviceProp_t::uuid

hipUUID uuid

UUID of a device.

Definition hip_runtime_api.h:97

hipExternalMemoryMipmappedArrayDesc::numLevels

unsigned int numLevels

Definition hip_runtime_api.h:1445

hipKernelNodeParams::sharedMemBytes

unsigned int sharedMemBytes

Definition hip_runtime_api.h:1590

hipArrayMapInfo::subresource

union hipArrayMapInfo::@38 subresource

HIP_LAUNCH_CONFIG::gridDimZ

unsigned int gridDimZ

Grid depth in blocks.

Definition hip_runtime_api.h:2165

hipLaunchMemSyncDomainMap::remote

unsigned char remote

Definition hip_runtime_api.h:1637

hipDeviceProp_t::sharedMemPerBlock

size_t sharedMemPerBlock

Size of shared memory per block (in bytes).

Definition hip_runtime_api.h:101

hipAccessPolicyWindow::hitRatio

float hitRatio

hitRatio specifies percentage of lines assigned hitProp

Definition hip_runtime_api.h:1627

hipDeviceProp_t::gpuDirectRDMAFlushWritesOptions

unsigned int gpuDirectRDMAFlushWritesOptions

Definition hip_runtime_api.h:202

hipDeviceArch_t::hasWarpShuffle

unsigned hasWarpShuffle

Warp shuffle operations. (__shfl_*).

Definition hip_runtime_api.h:67

hipDeviceProp_t::surfaceAlignment

size_t surfaceAlignment

Alignment requirement for surface.

Definition hip_runtime_api.h:153

hipExtDynDataPrefetchRegion::width

size_t width

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

Definition hip_runtime_api.h:1686

hipDeviceProp_t::reserved

int reserved[63]

CUDA Reserved.

Definition hip_runtime_api.h:212

hipDeviceProp_t::maxTexture2DLayered

int maxTexture2DLayered[3]

Maximum number of elements in 2D array images.

Definition hip_runtime_api.h:144

hipMemPoolProps::reserved

unsigned char reserved[56]

Reserved for future use, must be 0.

Definition hip_runtime_api.h:1330

hipArrayMapInfo::subresourceType

hipArraySparseSubresourceType subresourceType

Sparse subresource type.

Definition hip_runtime_api.h:2003

hipDeviceProp_t::streamPrioritiesSupported

int streamPrioritiesSupported

Device supports stream priority.

Definition hip_runtime_api.h:167

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

hipExternalSemaphoreWaitNodeParams::numExtSems

unsigned int numExtSems

Definition hip_runtime_api.h:1955

hipGraphInstantiateParams::result_out

hipGraphInstantiateResult result_out

Definition hip_runtime_api.h:1910

hipDevWorkqueueConfigResource::wqConcurrencyLimit

unsigned int wqConcurrencyLimit

Definition hip_runtime_api.h:723

hipFunctionLaunchParams::function

hipFunction_t function

Kernel to launch.

Definition hip_runtime_api.h:1399

HIP_LAUNCH_CONFIG::sharedMemBytes

unsigned int sharedMemBytes

Dynamic shared-memory size in bytes per block.

Definition hip_runtime_api.h:2169

hipLaunchAttributeValue::dynDataPrefetch

const hipExtDynDataPrefetchConfig * dynDataPrefetch

Value of launch attribute hipLaunchAttributeExtDynDataPrefetch.

Definition hip_runtime_api.h:1769

hipKernelNodeParams::blockDim

dim3 blockDim

Definition hip_runtime_api.h:1585

hipDeviceProp_t::cooperativeMultiDeviceLaunch

int cooperativeMultiDeviceLaunch

Definition hip_runtime_api.h:185

hipDeviceProp_t::hostRegisterSupported

int hostRegisterSupported

Device supports hipHostRegister.

Definition hip_runtime_api.h:195

hipExternalMemoryMipmappedArrayDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1444

hipLaunchConfig_t::gridDim

dim3 gridDim

Grid dimensions.

Definition hip_runtime_api.h:2151

hipLaunchConfig_t::numAttrs

unsigned int numAttrs

Number of attributes.

Definition hip_runtime_api.h:2156

hipDevSmResource::smCoscheduledAlignment

unsigned int smCoscheduledAlignment

Definition hip_runtime_api.h:717

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::alias

hipDeviceptr_t alias

Not valid for AMD backend. Initial value is unimportant.

Definition hip_runtime_api.h:1098

hipFuncAttributes::binaryVersion

int binaryVersion

Definition hip_runtime_api.h:787

hipExternalSemaphoreSignalParams::flags

unsigned int flags

Definition hip_runtime_api.h:1488

hipHostNodeParams::userData

void * userData

Definition hip_runtime_api.h:1582

hipLaunchAttributeValue::memSyncDomain

hipLaunchMemSyncDomain memSyncDomain

Value of launch attribute hipLaunchAttributeMemSyncDomain.

Definition hip_runtime_api.h:1748

hipArrayMemoryRequirements::alignment

size_t alignment

Definition hip_runtime_api.h:2179

hipDeviceProp_t::pageableMemoryAccess

int pageableMemoryAccess

Definition hip_runtime_api.h:177

hipDeviceProp_t::name

char name[256]

Device name.

Definition hip_runtime_api.h:96

hipMemPoolPtrExportData::reserved

unsigned char reserved[64]

Definition hip_runtime_api.h:1336

hipDeviceProp_t::textureAlignment

size_t textureAlignment

Alignment requirement for textures.

Definition hip_runtime_api.h:121

hipStreamBatchMemOpParams::hipStreamMemOpFlushRemoteWritesParams_t::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:1111

hipStreamBatchMemOpParams::hipStreamMemOpMemoryBarrierParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:1116

hipExternalSemaphoreHandleDesc::type

hipExternalSemaphoreHandleType type

Definition hip_runtime_api.h:1461

hipDeviceProp_t::globalL1CacheSupported

int globalL1CacheSupported

Indicates globals are cached in L1.

Definition hip_runtime_api.h:168

hipFuncAttributes::constSizeBytes

size_t constSizeBytes

Definition hip_runtime_api.h:789

hipMemAllocNodeParams::accessDescs

const hipMemAccessDesc * accessDescs

The number of memory access descriptors.

Definition hip_runtime_api.h:1604

hipDeviceProp_t::hostNativeAtomicSupported

int hostNativeAtomicSupported

Link between host and device supports native atomics.

Definition hip_runtime_api.h:175

hipArrayMapInfo::resourceType

hipResourceType resourceType

Resource type.

Definition hip_runtime_api.h:1998

hipDeviceProp_t::maxSurfaceCubemapLayered

int maxSurfaceCubemapLayered[2]

Maximum cubemap layered surface size.

Definition hip_runtime_api.h:152

hipPointerAttribute_t::isManaged

int isManaged

Definition hip_runtime_api.h:269

hipExternalMemoryHandleDesc::size

unsigned long long size

Definition hip_runtime_api.h:1430

hipDeviceProp_t::maxTextureCubemapLayered

int maxTextureCubemapLayered[2]

Maximum cubemaps layered texture dims.

Definition hip_runtime_api.h:145

hipDeviceProp_t::sharedMemPerBlockOptin

size_t sharedMemPerBlockOptin

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

Definition hip_runtime_api.h:187

hipDeviceProp_t::sharedMemPerMultiprocessor

size_t sharedMemPerMultiprocessor

Amount of shared memory available per multiprocessor.

Definition hip_runtime_api.h:170

hipDeviceProp_t::singleToDoublePrecisionPerfRatio

int singleToDoublePrecisionPerfRatio

Deprecated. CUDA only.

Definition hip_runtime_api.h:176

hipArrayMapInfo::memOperationType

hipMemOperationType memOperationType

Memory operation type.

Definition hip_runtime_api.h:2024

HIP_LAUNCH_CONFIG::blockDimY

unsigned int blockDimY

Thread block dimension in Y.

Definition hip_runtime_api.h:2167

hipDeviceProp_t::maxSurface2D

int maxSurface2D[2]

Maximum 2D surface size.

Definition hip_runtime_api.h:147

hipDeviceProp_t::memoryClockRate

int memoryClockRate

Max global memory clock frequency in khz.

Definition hip_runtime_api.h:162

hipEventWaitNodeParams::event

hipEvent_t event

Event to wait on.

Definition hip_runtime_api.h:2056

hipDeviceProp_t::maxTexture2DLinear

int maxTexture2DLinear[3]

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

Definition hip_runtime_api.h:137

hipDeviceProp_t::sparseHipArraySupported

int sparseHipArraySupported

Indicates if device supports sparse hip arrays.

Definition hip_runtime_api.h:196

hipArrayMapInfo::reserved

unsigned int reserved[2]

Reserved for future use, must be zero now.

Definition hip_runtime_api.h:2032

hipDevSmResource::minSmPartitionSize

unsigned int minSmPartitionSize

Definition hip_runtime_api.h:716

hipMemAccessDesc::location

hipMemLocation location

Location on which the accessibility has to change.

Definition hip_runtime_api.h:1288

hipDeviceProp_t::clockInstructionRate

int clockInstructionRate

Definition hip_runtime_api.h:219

hipMemPoolProps::location

hipMemLocation location

Location where allocations should reside.

Definition hip_runtime_api.h:1324

hipDeviceProp_t::localL1CacheSupported

int localL1CacheSupported

Locals are cahced in L1.

Definition hip_runtime_api.h:169

hipDeviceProp_t::regsPerMultiprocessor

int regsPerMultiprocessor

registers available per multiprocessor

Definition hip_runtime_api.h:171

hipDeviceProp_t::regsPerBlock

int regsPerBlock

Registers per block.

Definition hip_runtime_api.h:102

hipLaunchConfig_t::stream

hipStream_t stream

Stream identifier.

Definition hip_runtime_api.h:2154

hipMemAllocNodeParams::bytesize

size_t bytesize

The size of the requested allocation in bytes.

Definition hip_runtime_api.h:1607

hipMemcpyNodeParams::reserved

int reserved[3]

Must be zero.

Definition hip_runtime_api.h:2040

hipDevSmResourceGroupParams::preferredCoscheduledSmCount

unsigned int preferredCoscheduledSmCount

Definition hip_runtime_api.h:746

hipExternalSemaphoreWaitNodeParams::paramsArray

const hipExternalSemaphoreWaitParams * paramsArray

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

Definition hip_runtime_api.h:1953

hipDeviceProp_t::maxTexture2D

int maxTexture2D[2]

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

Definition hip_runtime_api.h:135

hipFuncAttributes::preferredShmemCarveout

int preferredShmemCarveout

Definition hip_runtime_api.h:794

hipDeviceProp_t::cooperativeLaunch

int cooperativeLaunch

HIP device supports cooperative launch.

Definition hip_runtime_api.h:184

hipDeviceProp_t::maxTexture3D

int maxTexture3D[3]

Definition hip_runtime_api.h:139

hipMemPoolProps::handleTypes

hipMemAllocationHandleType handleTypes

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

Definition hip_runtime_api.h:1323

hipDeviceProp_t::directManagedMemAccessFromHost

int directManagedMemAccessFromHost

Definition hip_runtime_api.h:190

HIP_LAUNCH_CONFIG::hStream

hipStream_t hStream

HIP stream identifier.

Definition hip_runtime_api.h:2170

hipBatchMemOpNodeParams::paramArray

hipStreamBatchMemOpParams * paramArray

Definition hip_runtime_api.h:1151

HIP_LAUNCH_CONFIG::attrs

hipLaunchAttribute * attrs

Attribute list.

Definition hip_runtime_api.h:2171

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedFunc

int cooperativeMultiDeviceUnmatchedFunc

Definition hip_runtime_api.h:224

hipMemPoolProps::allocType

hipMemAllocationType allocType

Allocation type. Currently must be specified as hipMemAllocationTypePinned.

Definition hip_runtime_api.h:1321

hipDeviceProp_t::deviceOverlap

int deviceOverlap

Deprecated. Use asyncEngineCount instead.

Definition hip_runtime_api.h:123

hipDeviceProp_t::pageableMemoryAccessUsesHostPageTables

int pageableMemoryAccessUsesHostPageTables

Definition hip_runtime_api.h:188

hipLaunchAttributeValue::cooperative

int cooperative

Definition hip_runtime_api.h:1738

hipExternalSemaphoreWaitNodeParams::extSemArray

hipExternalSemaphore_t * extSemArray

< Array containing external semaphore handles.

Definition hip_runtime_api.h:1951

hipKernelNodeParams::kernelParams

void ** kernelParams

Definition hip_runtime_api.h:1589

hipDeviceProp_t::hdpRegFlushCntl

unsigned int * hdpRegFlushCntl

Addres of HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:223

hipDeviceArch_t::hasGlobalInt32Atomics

unsigned hasGlobalInt32Atomics

32-bit integer atomics for global memory.

Definition hip_runtime_api.h:51

hipLaunchAttributeValue::accessPolicyWindow

hipAccessPolicyWindow accessPolicyWindow

Value of launch attribute hipLaunchAttributeAccessPolicyWindow.

Definition hip_runtime_api.h:1737

hipLaunchConfig_t::dynamicSmemBytes

size_t dynamicSmemBytes

Dynamic shared-memory size per thread block.

Definition hip_runtime_api.h:2153

hipDeviceProp_t::maxThreadsDim

int maxThreadsDim[3]

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

Definition hip_runtime_api.h:107

hipDeviceArch_t::hasGlobalFloatAtomicExch

unsigned hasGlobalFloatAtomicExch

32-bit float atomic exch for global memory.

Definition hip_runtime_api.h:52

hipDeviceProp_t::unifiedAddressing

int unifiedAddressing

Does device and host share unified address space.

Definition hip_runtime_api.h:161

hipDeviceArch_t::hasDynamicParallelism

unsigned hasDynamicParallelism

Dynamic parallelism.

Definition hip_runtime_api.h:77

hipFunctionLaunchParams::hStream

hipStream_t hStream

Stream identifier.

Definition hip_runtime_api.h:1407

hipArrayMapInfo::memHandleType

hipMemHandleType memHandleType

Memory handle type.

Definition hip_runtime_api.h:2025

hipGraphEdgeData::reserved

unsigned char reserved[5]

These bytes are unused and must be zeroed.

Definition hip_runtime_api.h:2128

hipExternalMemoryMipmappedArrayDesc::offset

unsigned long long offset

Definition hip_runtime_api.h:1441

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

hipEventRecordNodeParams::event

hipEvent_t event

The event to be recorded when node executes.

Definition hip_runtime_api.h:2063

hipDeviceProp_t::multiGpuBoardGroupID

int multiGpuBoardGroupID

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

Definition hip_runtime_api.h:174

hipGraphInstantiateParams::uploadStream

hipStream_t uploadStream

Definition hip_runtime_api.h:1912

hipDeviceProp_t::isMultiGpuBoard

int isMultiGpuBoard

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

Definition hip_runtime_api.h:173

hipMemAllocNodeParams::poolProps

hipMemPoolProps poolProps

Definition hip_runtime_api.h:1602

hipDevSmResourceGroupParams::smCount

unsigned int smCount

Definition hip_runtime_api.h:744

hipFuncAttributes::sharedSizeBytes

size_t sharedSizeBytes

Definition hip_runtime_api.h:796

hipMemAllocNodeParams::accessDescCount

size_t accessDescCount

Definition hip_runtime_api.h:1605

hipFuncAttributes::maxDynamicSharedSizeBytes

int maxDynamicSharedSizeBytes

Definition hip_runtime_api.h:791

hipFunctionLaunchParams::blockDimY

unsigned int blockDimY

Y dimension of each thread block.

Definition hip_runtime_api.h:1404

hipDeviceProp_t::canUseHostPointerForRegisteredMem

int canUseHostPointerForRegisteredMem

Definition hip_runtime_api.h:182

hipGraphEdgeData::type

unsigned char type

This should be populated with a value from hipGraphDependencyType.

Definition hip_runtime_api.h:2131

hipDeviceArch_t::hasSurfaceFuncs

unsigned hasSurfaceFuncs

Surface functions.

Definition hip_runtime_api.h:75

hipDeviceProp_t::maxTexture1DLayered

int maxTexture1DLayered[2]

Maximum number of elements in 1D array images.

Definition hip_runtime_api.h:143

hipGraphInstantiateParams::errNode_out

hipGraphNode_t errNode_out

Definition hip_runtime_api.h:1908

hipDeviceProp_t::pciDomainID

int pciDomainID

PCI Domain ID.

Definition hip_runtime_api.h:158

hipExternalSemaphoreSignalNodeParams::extSemArray

hipExternalSemaphore_t * extSemArray

< Array containing external semaphore handles.

Definition hip_runtime_api.h:1939

hipDevSmResourceGroupParams::coscheduledSmCount

unsigned int coscheduledSmCount

Definition hip_runtime_api.h:745

hipDeviceProp_t::maxSharedMemoryPerMultiProcessor

size_t maxSharedMemoryPerMultiProcessor

Maximum Shared Memory Per CU. HIP Only.

Definition hip_runtime_api.h:218

hipDevWorkqueueConfigResource::device

int device

Definition hip_runtime_api.h:722

hipMemAllocationProp::location

hipMemLocation location

Memory location.

Definition hip_runtime_api.h:1925

hipExtDynDataPrefetchConfig::temporal

hipExtDynDataPrefetchTemporal temporal

Cache retention policy for prefetched data.

Definition hip_runtime_api.h:1709

hipDeviceProp_t::maxTextureCubemap

int maxTextureCubemap

Maximum cubemap texture dims.

Definition hip_runtime_api.h:142

HIP_LAUNCH_CONFIG::blockDimZ

unsigned int blockDimZ

Thread block dimension in Z.

Definition hip_runtime_api.h:2168

hipDeviceArch_t::has3dGrid

unsigned has3dGrid

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

Definition hip_runtime_api.h:76

hipExternalSemaphoreSignalNodeParams::numExtSems

unsigned int numExtSems

Definition hip_runtime_api.h:1943

hipExternalMemoryHandleDesc::type

hipExternalMemoryHandleType type

Definition hip_runtime_api.h:1421

hipFuncAttributes::ptxVersion

int ptxVersion

Definition hip_runtime_api.h:795

hipKernelNodeParams::extra

void ** extra

Definition hip_runtime_api.h:1586

hipGraphInstantiateParams::flags

unsigned long long flags

Definition hip_runtime_api.h:1909

hipBatchMemOpNodeParams::count

unsigned int count

Definition hip_runtime_api.h:1150

HIP_LAUNCH_CONFIG::numAttrs

unsigned int numAttrs

Number of attributes.

Definition hip_runtime_api.h:2172

hipDeviceArch_t::hasFunnelShift

unsigned hasFunnelShift

Funnel two words into one with shift&mask caps.

Definition hip_runtime_api.h:68

hipDeviceProp_t::hipReserved

int hipReserved[32]

Reserved for adding new entries for HIP/CUDA.

Definition hip_runtime_api.h:214

hipMemAllocNodeParams::dptr

void * dptr

Returned device address of the allocation.

Definition hip_runtime_api.h:1608

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::alias

hipDeviceptr_t alias

Not valid for AMD backend. Initial value is unimportant.

Definition hip_runtime_api.h:1108

hipMemsetParams::elementSize

unsigned int elementSize

Definition hip_runtime_api.h:1594

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedGridDim

int cooperativeMultiDeviceUnmatchedGridDim

Definition hip_runtime_api.h:227

hipExternalSemaphoreWaitParams::flags

unsigned int flags

Definition hip_runtime_api.h:1509

hipDeviceProp_t::gpuDirectRDMASupported

int gpuDirectRDMASupported

Indicates device support of RDMA APIs.

Definition hip_runtime_api.h:201

hipArrayMapInfo::resource

union hipArrayMapInfo::@37 resource

HIP_LAUNCH_CONFIG::gridDimX

unsigned int gridDimX

Grid width in blocks.

Definition hip_runtime_api.h:2163

hipDeviceProp_t::minor

int minor

Definition hip_runtime_api.h:116

hipDeviceProp_t::gcnArchName

char gcnArchName[256]

AMD GCN Arch Name. HIP Only.

Definition hip_runtime_api.h:217

hipPointerAttribute_t::devicePointer

void * devicePointer

Definition hip_runtime_api.h:267

hipDeviceProp_t::luid

char luid[8]

8-byte unique identifier. Only valid on windows

Definition hip_runtime_api.h:98

hipLaunchConfig_t::attrs

hipLaunchAttribute * attrs

Attributes list.

Definition hip_runtime_api.h:2155

hipDeviceProp_t::kernelExecTimeoutEnabled

int kernelExecTimeoutEnabled

Run time limit for kernels executed on the device.

Definition hip_runtime_api.h:128

hipKernelNodeParams::func

void * func

Definition hip_runtime_api.h:1587

hipDeviceProp_t::memoryPoolSupportedHandleTypes

unsigned int memoryPoolSupportedHandleTypes

Bitmask of handle types support with mempool based IPC.

Definition hip_runtime_api.h:206

hipDeviceProp_t::hdpMemFlushCntl

unsigned int * hdpMemFlushCntl

Addres of HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:222

hipDeviceProp_t::concurrentManagedAccess

int concurrentManagedAccess

Definition hip_runtime_api.h:179

hipDeviceProp_t::integrated

int integrated

APU vs dGPU.

Definition hip_runtime_api.h:129

hipDeviceProp_t::canMapHostMemory

int canMapHostMemory

Check whether HIP can map host memory.

Definition hip_runtime_api.h:130

hipDeviceArch_t::hasThreadFenceSystem

unsigned hasThreadFenceSystem

__threadfence_system.

Definition hip_runtime_api.h:71

hipMemcpyNodeParams::flags

int flags

Must be zero.

Definition hip_runtime_api.h:2039

hipDeviceProp_t::reservedSharedMemPerBlock

size_t reservedSharedMemPerBlock

Shared memory reserved by driver per block.

Definition hip_runtime_api.h:194

hipDevResource::type

hipDevResourceType type

Definition hip_runtime_api.h:732

hipDeviceProp_t::maxSurfaceCubemap

int maxSurfaceCubemap

Maximum cubemap surface size.

Definition hip_runtime_api.h:151

hipDeviceProp_t::maxSurface3D

int maxSurface3D[3]

Maximum 3D surface size.

Definition hip_runtime_api.h:148

hipLaunchParams::args

void ** args

Arguments.

Definition hip_runtime_api.h:1391

hipDeviceProp_t::asicRevision

int asicRevision

Revision of the GPU in this device.

Definition hip_runtime_api.h:237

hipGraphEdgeData::from_port

unsigned char from_port

Definition hip_runtime_api.h:2121

hipLaunchParams::blockDim

dim3 blockDim

Block dimensions.

Definition hip_runtime_api.h:1390

hipLaunchAttribute::id

hipLaunchAttributeID id

Identifier of the launch attribute.

Definition hip_runtime_api.h:2139

hipArrayMapInfo::deviceBitMask

unsigned int deviceBitMask

Device ordinal bit mask.

Definition hip_runtime_api.h:2030

hipFunctionLaunchParams::gridDimY

unsigned int gridDimY

Height(Y) of grid in blocks.

Definition hip_runtime_api.h:1401

hipDeviceProp_t::totalGlobalMem

size_t totalGlobalMem

Size of global memory region (in bytes).

Definition hip_runtime_api.h:100

hipMemsetParams::width

size_t width

Definition hip_runtime_api.h:1598

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedBlockDim

int cooperativeMultiDeviceUnmatchedBlockDim

Definition hip_runtime_api.h:230

hipFunctionLaunchParams::gridDimZ

unsigned int gridDimZ

Depth(Z) of grid in blocks.

Definition hip_runtime_api.h:1402

hipPointerAttribute_t::allocationFlags

unsigned allocationFlags

Definition hip_runtime_api.h:270

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:1101

hipFunctionLaunchParams::sharedMemBytes

unsigned int sharedMemBytes

Shared memory.

Definition hip_runtime_api.h:1406

hipBatchMemOpNodeParams::flags

unsigned int flags

Definition hip_runtime_api.h:1152

hipDeviceProp_t::maxSurface1DLayered

int maxSurface1DLayered[2]

Maximum 1D layered surface size.

Definition hip_runtime_api.h:149

hipDeviceArch_t::hasGlobalInt64Atomics

unsigned hasGlobalInt64Atomics

64-bit integer atomics for global memory.

Definition hip_runtime_api.h:58

hipDeviceProp_t::persistingL2CacheMaxSize

int persistingL2CacheMaxSize

Device's max L2 persisting lines in bytes.

Definition hip_runtime_api.h:165

hipDeviceProp_t::maxSurface1D

int maxSurface1D

Maximum 1D surface size.

Definition hip_runtime_api.h:146

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:1107

hipDeviceProp_t::concurrentKernels

int concurrentKernels

Device can possibly execute multiple kernels concurrently.

Definition hip_runtime_api.h:154

hipDeviceProp_t::isLargeBar

int isLargeBar

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

Definition hip_runtime_api.h:236

hipDeviceProp_t::clusterLaunch

int clusterLaunch

Device supports cluster launch.

Definition hip_runtime_api.h:210

hipFuncAttributes::numRegs

int numRegs

Definition hip_runtime_api.h:793

hipDeviceProp_t::maxTexture1DMipmap

int maxTexture1DMipmap

Maximum 1D mipmap texture size.

Definition hip_runtime_api.h:133

hipDeviceProp_t::multiProcessorCount

int multiProcessorCount

Definition hip_runtime_api.h:124

hipMemAllocationProp::allocFlags

struct hipMemAllocationProp::@36 allocFlags

hipGraphNodeParams::reserved2

long long reserved2

Definition hip_runtime_api.h:2094

hipDeviceArch_t::hasSyncThreadsExt

unsigned hasSyncThreadsExt

__syncthreads_count, syncthreads_and, syncthreads_or.

Definition hip_runtime_api.h:72

hipExternalMemoryBufferDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1437

hipDevWorkqueueResource::reserved

unsigned char reserved[HIP_RESOURCE_ABI_BYTES]

Definition hip_runtime_api.h:728

hipDeviceProp_t::maxTexture3DAlt

int maxTexture3DAlt[3]

Maximum alternate 3D texture dims.

Definition hip_runtime_api.h:141

hipMemFreeNodeParams::dptr

void * dptr

the pointer to be freed

Definition hip_runtime_api.h:2070

hipDeviceProp_t::maxGridSize

int maxGridSize[3]

Max grid dimensions (XYZ).

Definition hip_runtime_api.h:108

hipAccessPolicyWindow::base_ptr

void * base_ptr

Starting address of the access policy window.

Definition hip_runtime_api.h:1625

hipDeviceProp_t::pciDeviceID

int pciDeviceID

PCI Device ID.

Definition hip_runtime_api.h:157

hipDeviceProp_t::maxBlocksPerMultiProcessor

int maxBlocksPerMultiProcessor

Max number of blocks on CU.

Definition hip_runtime_api.h:192

hipStreamBatchMemOpParams::hipStreamMemOpMemoryBarrierParams_t::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:1115

hipDeviceProp_t::computeMode

int computeMode

Compute mode.

Definition hip_runtime_api.h:131

hipLaunchAttributeValue::syncPolicy

hipSynchronizationPolicy syncPolicy

Definition hip_runtime_api.h:1743

hipMemPoolProps::win32SecurityAttributes

void * win32SecurityAttributes

Definition hip_runtime_api.h:1328

hipFunctionLaunchParams::blockDimZ

unsigned int blockDimZ

Z dimension of each thread block.

Definition hip_runtime_api.h:1405

hipExtDynDataPrefetchRegion::height

size_t height

Number of rows to prefetch.

Definition hip_runtime_api.h:1687

hipLaunchAttributeValue::clusterSchedulingPolicyPreference

hipClusterSchedulingPolicy clusterSchedulingPolicyPreference

Definition hip_runtime_api.h:1767

hipDeviceProp_t::maxSurface2DLayered

int maxSurface2DLayered[3]

Maximum 2D layared surface size.

Definition hip_runtime_api.h:150

hipDeviceProp_t::major

int major

Definition hip_runtime_api.h:112

hipArrayMapInfo::memHandle

union hipArrayMapInfo::@39 memHandle

hipLaunchMemSyncDomainMap::default_

unsigned char default_

Definition hip_runtime_api.h:1636

hipBatchMemOpNodeParams::ctx

hipCtx_t ctx

Definition hip_runtime_api.h:1149

hipLaunchParams::gridDim

dim3 gridDim

Grid dimensions.

Definition hip_runtime_api.h:1389

hipLaunchParams::func

void * func

Device function symbol.

Definition hip_runtime_api.h:1388

hipMemcpyNodeParams::copyParams

hipMemcpy3DParms copyParams

Params set for the memory copy.

Definition hip_runtime_api.h:2041

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:1097

hipDeviceArch_t::hasWarpBallot

unsigned hasWarpBallot

Warp ballot instructions (__ballot).

Definition hip_runtime_api.h:66

HIP_LAUNCH_CONFIG::gridDimY

unsigned int gridDimY

Grid height in blocks.

Definition hip_runtime_api.h:2164

hipExternalMemoryBufferDesc::offset

unsigned long long offset

Definition hip_runtime_api.h:1435

hipDeviceProp_t::warpSize

int warpSize

Warp size.

Definition hip_runtime_api.h:103

hipDeviceProp_t::tccDriver

int tccDriver

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

Definition hip_runtime_api.h:159

hipDeviceProp_t::luidDeviceNodeMask

unsigned int luidDeviceNodeMask

LUID node mask.

Definition hip_runtime_api.h:99

hipMemsetParams::pitch

size_t pitch

Definition hip_runtime_api.h:1596

hipExternalMemoryMipmappedArrayDesc::formatDesc

hipChannelFormatDesc formatDesc

Definition hip_runtime_api.h:1442

hipMemsetParams::height

size_t height

Definition hip_runtime_api.h:1595

hipFunctionLaunchParams::kernelParams

void ** kernelParams

Kernel parameters.

Definition hip_runtime_api.h:1408

hipDeviceProp_t::hostRegisterReadOnlySupported

int hostRegisterReadOnlySupported

Definition hip_runtime_api.h:197

hipFuncAttributes::localSizeBytes

size_t localSizeBytes

Definition hip_runtime_api.h:790

hipExternalMemoryBufferDesc::size

unsigned long long size

Definition hip_runtime_api.h:1436

HIP_LAUNCH_CONFIG::blockDimX

unsigned int blockDimX

Thread block dimension in X.

Definition hip_runtime_api.h:2166

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedSharedMem

int cooperativeMultiDeviceUnmatchedSharedMem

Definition hip_runtime_api.h:233

hipArrayMapInfo::offset

unsigned long long offset

Offset within the memory.

Definition hip_runtime_api.h:2029

hipLaunchParams::stream

hipStream_t stream

Stream identifier.

Definition hip_runtime_api.h:1393

hipFuncAttributes::maxThreadsPerBlock

int maxThreadsPerBlock

Definition hip_runtime_api.h:792

hipExtDynDataPrefetchRegion::stride

size_t stride

Stride between row starts in bytes.

Definition hip_runtime_api.h:1685

hipDeviceProp_t::maxThreadsPerBlock

int maxThreadsPerBlock

Max work items per work group or workgroup max size.

Definition hip_runtime_api.h:106

hipAccessPolicyWindow::num_bytes

size_t num_bytes

Size in bytes of the window policy.

Definition hip_runtime_api.h:1629

hipDeviceProp_t::arch

hipDeviceArch_t arch

Architectural feature flags. New for HIP.

Definition hip_runtime_api.h:221

hipLaunchAttributeValue::memSyncDomainMap

hipLaunchMemSyncDomainMap memSyncDomainMap

Value of launch attribute hipLaunchAttributeMemSyncDomainMap.

Definition hip_runtime_api.h:1746

hipDeviceProp_t::managedMemory

int managedMemory

Device supports allocating managed memory on this system.

Definition hip_runtime_api.h:172

hipDeviceArch_t::hasSharedFloatAtomicExch

unsigned hasSharedFloatAtomicExch

32-bit float atomic exch for shared memory.

Definition hip_runtime_api.h:54

hipDeviceProp_t::texturePitchAlignment

size_t texturePitchAlignment

Pitch alignment requirement for texture references bound to.

Definition hip_runtime_api.h:122

hipLimit_t

hipLimit_t

Definition hip_runtime_api.h:806

hipMemRangeHandleType

hipMemRangeHandleType

Definition hip_runtime_api.h:2186

hipExecutionCtx_t

struct ihipExecutionCtx_t * hipExecutionCtx_t

Definition hip_runtime_api.h:691

hipMemAllocationHandleType

hipMemAllocationHandleType

Definition hip_runtime_api.h:1308

hipGraphicsResource_t

hipGraphicsResource * hipGraphicsResource_t

Definition hip_runtime_api.h:1536

hipCtx_t

struct ihipCtx_t * hipCtx_t

Definition hip_runtime_api.h:690

__dparm

#define __dparm(x)

Definition hip_runtime_api.h:672

hipStream_t

struct ihipStream_t * hipStream_t

Definition hip_runtime_api.h:764

hipGraphInstantiateResult

hipGraphInstantiateResult

Definition hip_runtime_api.h:1892

hipDevice_t

int hipDevice_t

Definition hip_runtime_api.h:752

hipAccessProperty

hipAccessProperty

Definition hip_runtime_api.h:1614

hipLinkState_t

struct ihipLinkState_t * hipLinkState_t

Definition hip_runtime_api.h:778

hipGraphDependencyType

hipGraphDependencyType

Definition hip_runtime_api.h:2114

hipMemRangeAttribute

hipMemRangeAttribute

Definition hip_runtime_api.h:1201

hipMemAttachSingle

#define hipMemAttachSingle

Definition hip_runtime_api.h:959

hipMemoryAdvise

hipMemoryAdvise

Definition hip_runtime_api.h:1168

hipArrayDefault

#define hipArrayDefault

Definition hip_runtime_api.h:1018

hipSharedMemConfig

hipSharedMemConfig

Definition hip_runtime_api.h:1365

hipKernelNodeAttrValue

#define hipKernelNodeAttrValue

Definition hip_runtime_api.h:1795

hipComputeMode

hipComputeMode

Definition hip_runtime_api.h:632

hipEvent_t

struct ihipEvent_t * hipEvent_t

Definition hip_runtime_api.h:798

hipStreamCaptureMode

hipStreamCaptureMode

Definition hip_runtime_api.h:1824

hipStreamBatchMemOpType

hipStreamBatchMemOpType

Definition hip_runtime_api.h:1043

hipDriverProcAddressQueryResult

hipDriverProcAddressQueryResult

Definition hip_runtime_api.h:626

HIP_DEPRECATED_MSG

#define HIP_DEPRECATED_MSG

Definition hip_runtime_api.h:664

hipLaunchAttributeID

hipLaunchAttributeID

Definition hip_runtime_api.h:1716

hipKernel_t

struct ihipKernel_t * hipKernel_t

Definition hip_runtime_api.h:780

hipSynchronizationPolicy

hipSynchronizationPolicy

Definition hip_runtime_api.h:1652

hipGraphNodeType

hipGraphNodeType

Definition hip_runtime_api.h:1560

hipExternalMemoryHandleType

hipExternalMemoryHandleType

Definition hip_runtime_api.h:1410

hipMemAttachGlobal

#define hipMemAttachGlobal

Definition hip_runtime_api.h:953

hipLibrary_t

struct ihipLibrary_t * hipLibrary_t

Definition hip_runtime_api.h:779

hipFuncAttribute

hipFuncAttribute

Definition hip_runtime_api.h:1342

hipExternalSemaphoreHandleType

hipExternalSemaphoreHandleType

Definition hip_runtime_api.h:1448

hipLaunchMemSyncDomain

hipLaunchMemSyncDomain

Definition hip_runtime_api.h:1643

hipDevResourceDesc_t

struct ihipDevResourceDesc_t * hipDevResourceDesc_t

Definition hip_runtime_api.h:692

hipDeviceP2PAttr

hipDeviceP2PAttr

Definition hip_runtime_api.h:753

hipGraphDebugDotFlags

hipGraphDebugDotFlags

Definition hip_runtime_api.h:1870

hipDevSmResourceGroup_flags

hipDevSmResourceGroup_flags

Definition hip_runtime_api.h:699

hipUserObjectRetainFlags

hipUserObjectRetainFlags

Definition hip_runtime_api.h:1855

hipStreamAttrID

#define hipStreamAttrID

Definition hip_runtime_api.h:1775

hipError_t

enum __HIP_NODISCARD hipError_t hipError_t

Definition hip_runtime_api.h:289

hipHostAllocDefault

#define hipHostAllocDefault

Definition hip_runtime_api.h:895

hipHostFn_t

void(* hipHostFn_t)(void *userData)

Definition hip_runtime_api.h:1579

hipOccupancyDefault

#define hipOccupancyDefault

Definition hip_runtime_api.h:1023

hipStreamUpdateCaptureDependenciesFlags

hipStreamUpdateCaptureDependenciesFlags

Definition hip_runtime_api.h:1836

hipGraph_t

struct ihipGraph * hipGraph_t

Definition hip_runtime_api.h:1541

hipChooseDevice

#define hipChooseDevice

Definition hip_runtime_api.h:89

hipMemHandleType

hipMemHandleType

Definition hip_runtime_api.h:1974

hipFlushGPUDirectRDMAWritesOptions

hipFlushGPUDirectRDMAWritesOptions

Definition hip_runtime_api.h:639

hipFuncCache_t

hipFuncCache_t

Definition hip_runtime_api.h:1356

hipUserObjectFlags

hipUserObjectFlags

Definition hip_runtime_api.h:1851

__HIP_NODISCARD

#define __HIP_NODISCARD

Definition hip_runtime_api.h:279

hipDevWorkqueueConfigScope

hipDevWorkqueueConfigScope

Definition hip_runtime_api.h:707

hipGraphMemAttributeType

hipGraphMemAttributeType

Definition hip_runtime_api.h:1841

hipMemPoolAttr

hipMemPoolAttr

Definition hip_runtime_api.h:1216

hipDriverEntryPointQueryResult

hipDriverEntryPointQueryResult

Definition hip_runtime_api.h:759

hipMemRangeFlags

hipMemRangeFlags

Definition hip_runtime_api.h:2194

hipDevSmResourceSplitByCount_flags

hipDevSmResourceSplitByCount_flags

Definition hip_runtime_api.h:703

hipDeviceProp_t

#define hipDeviceProp_t

Definition hip_runtime_api.h:88

HIP_RESOURCE_ABI_BYTES

#define HIP_RESOURCE_ABI_BYTES

Definition hip_runtime_api.h:712

hipModule_t

struct ihipModule_t * hipModule_t

Definition hip_runtime_api.h:776

hipUserObject_t

struct hipUserObject * hipUserObject_t

Definition hip_runtime_api.h:1554

hipMemOperationType

hipMemOperationType

Definition hip_runtime_api.h:1981

hipExternalSemaphore_t

void * hipExternalSemaphore_t

Definition hip_runtime_api.h:1473

hipGraphicsRegisterFlags

hipGraphicsRegisterFlags

Definition hip_runtime_api.h:1524

HIP_EXT_DYN_DATA_PREFETCH_MAX_REGIONS

#define HIP_EXT_DYN_DATA_PREFETCH_MAX_REGIONS

Definition hip_runtime_api.h:1695

hipStreamAttrValue

#define hipStreamAttrValue

Definition hip_runtime_api.h:1782

hipMemRangeCoherencyMode

hipMemRangeCoherencyMode

Definition hip_runtime_api.h:1189

hipMemAccessFlags

hipMemAccessFlags

Definition hip_runtime_api.h:1276

hipMemAllocationGranularity_flags

hipMemAllocationGranularity_flags

Definition hip_runtime_api.h:1966

hipExtDynDataPrefetchTemporal

hipExtDynDataPrefetchTemporal

Temporal locality hint for dynamic data prefetch.

Definition hip_runtime_api.h:1670

hipGraphExec_t

struct hipGraphExec * hipGraphExec_t

Definition hip_runtime_api.h:1549

hipGraphExecUpdateResult

hipGraphExecUpdateResult

Definition hip_runtime_api.h:1809

hipFunction_t

struct ihipModuleSymbol_t * hipFunction_t

Definition hip_runtime_api.h:777

hipKernelNodeAttrID

#define hipKernelNodeAttrID

Definition hip_runtime_api.h:1787

hipExternalMemory_t

void * hipExternalMemory_t

Definition hip_runtime_api.h:1447

hipStreamCaptureStatus

hipStreamCaptureStatus

Definition hip_runtime_api.h:1829

hipDeviceAttribute_t

hipDeviceAttribute_t

Definition hip_runtime_api.h:418

hipGPUDirectRDMAWritesOrdering

hipGPUDirectRDMAWritesOrdering

Definition hip_runtime_api.h:644

hipGetDeviceProperties

#define hipGetDeviceProperties

Definition hip_runtime_api.h:87

hipHostMallocDefault

#define hipHostMallocDefault

Definition hip_runtime_api.h:899

HIP_DEPRECATED

#define HIP_DEPRECATED(msg)

Definition hip_runtime_api.h:662

hipGraphicsResource

struct _hipGraphicsResource hipGraphicsResource

Definition hip_runtime_api.h:1534

hipMemAllocationType

hipMemAllocationType

Definition hip_runtime_api.h:1294

hipGraphNode_t

struct hipGraphNode * hipGraphNode_t

Definition hip_runtime_api.h:1545

hipMemGenericAllocationHandle_t

struct ihipMemGenericAllocationHandle * hipMemGenericAllocationHandle_t

Definition hip_runtime_api.h:1961

hipClusterSchedulingPolicy

hipClusterSchedulingPolicy

Definition hip_runtime_api.h:1660

hipMemoryType

hipMemoryType

Definition hip_runtime_api.h:247

hipGraphInstantiateFlags

hipGraphInstantiateFlags

Definition hip_runtime_api.h:1859

HIP_IPC_HANDLE_SIZE

#define HIP_IPC_HANDLE_SIZE

Definition hip_runtime_api.h:766

hipMemPool_t

struct ihipMemPoolHandle_t * hipMemPool_t

Definition hip_runtime_api.h:784

hipDevResourceType

hipDevResourceType

Definition hip_runtime_api.h:693

hipArraySparseSubresourceType

hipArraySparseSubresourceType

Definition hip_runtime_api.h:1989

hipExtLimitScratchMin

@ hipExtLimitScratchMin

Definition hip_runtime_api.h:814

hipLimitMallocHeapSize

@ hipLimitMallocHeapSize

Definition hip_runtime_api.h:812

hipLimitStackSize

@ hipLimitStackSize

Definition hip_runtime_api.h:807

hipLimitRange

@ hipLimitRange

Supported limit range.

Definition hip_runtime_api.h:822

hipLimitPrintfFifoSize

@ hipLimitPrintfFifoSize

Definition hip_runtime_api.h:810

hipExtLimitScratchMax

@ hipExtLimitScratchMax

Definition hip_runtime_api.h:816

hipExtLimitScratchCurrent

@ hipExtLimitScratchCurrent

Definition hip_runtime_api.h:818

hipMemRangeHandleTypeMax

@ hipMemRangeHandleTypeMax

Definition hip_runtime_api.h:2188

hipMemRangeHandleTypeDmaBufFd

@ hipMemRangeHandleTypeDmaBufFd

Definition hip_runtime_api.h:2187

hipMemHandleTypeWin32

@ hipMemHandleTypeWin32

Allows a Win32 NT handle for exporting. (HANDLE)

Definition hip_runtime_api.h:1312

hipMemHandleTypeWin32Kmt

@ hipMemHandleTypeWin32Kmt

Allows a Win32 KMT handle for exporting. (D3DKMT_HANDLE)

Definition hip_runtime_api.h:1313

hipMemHandleTypeNone

@ hipMemHandleTypeNone

Does not allow any export mechanism.

Definition hip_runtime_api.h:1309

hipMemHandleTypePosixFileDescriptor

@ hipMemHandleTypePosixFileDescriptor

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

Definition hip_runtime_api.h:1310

hipMemHandleTypeFabric

@ hipMemHandleTypeFabric

Allows a fabric handle to be used for exporting.

Definition hip_runtime_api.h:1314

hipGraphInstantiateNodeOperationNotSupported

@ hipGraphInstantiateNodeOperationNotSupported

Definition hip_runtime_api.h:1898

hipGraphInstantiateMultipleDevicesNotSupported

@ hipGraphInstantiateMultipleDevicesNotSupported

Definition hip_runtime_api.h:1900

hipGraphInstantiateError

@ hipGraphInstantiateError

Definition hip_runtime_api.h:1894

hipGraphInstantiateInvalidStructure

@ hipGraphInstantiateInvalidStructure

Definition hip_runtime_api.h:1896

hipGraphInstantiateSuccess

@ hipGraphInstantiateSuccess

Definition hip_runtime_api.h:1893

hipAccessPropertyNormal

@ hipAccessPropertyNormal

Normal cache persistence.

Definition hip_runtime_api.h:1615

hipAccessPropertyPersisting

@ hipAccessPropertyPersisting

Persisting access is more likely to persist in cache.

Definition hip_runtime_api.h:1617

hipAccessPropertyStreaming

@ hipAccessPropertyStreaming

Streaming access is less likely to persist from cache.

Definition hip_runtime_api.h:1616

hipGraphDependencyTypeDefault

@ hipGraphDependencyTypeDefault

Definition hip_runtime_api.h:2115

hipGraphDependencyTypeProgrammatic

@ hipGraphDependencyTypeProgrammatic

Definition hip_runtime_api.h:2116

hipMemRangeAttributeLastPrefetchLocation

@ hipMemRangeAttributeLastPrefetchLocation

Definition hip_runtime_api.h:1207

hipMemRangeAttributePreferredLocation

@ hipMemRangeAttributePreferredLocation

The preferred location of the range.

Definition hip_runtime_api.h:1204

hipMemRangeAttributeAccessedBy

@ hipMemRangeAttributeAccessedBy

Definition hip_runtime_api.h:1205

hipMemRangeAttributeReadMostly

@ hipMemRangeAttributeReadMostly

Definition hip_runtime_api.h:1202

hipMemRangeAttributeCoherencyMode

@ hipMemRangeAttributeCoherencyMode

Definition hip_runtime_api.h:1209

hipMemAdviseUnsetAccessedBy

@ hipMemAdviseUnsetAccessedBy

Definition hip_runtime_api.h:1177

hipMemAdviseUnsetCoarseGrain

@ hipMemAdviseUnsetCoarseGrain

Restores cache coherency policy back to fine-grain.

Definition hip_runtime_api.h:1184

hipMemAdviseSetCoarseGrain

@ hipMemAdviseSetCoarseGrain

Definition hip_runtime_api.h:1179

hipMemAdviseUnsetPreferredLocation

@ hipMemAdviseUnsetPreferredLocation

Clear the preferred location for the data.

Definition hip_runtime_api.h:1174

hipMemAdviseSetAccessedBy

@ hipMemAdviseSetAccessedBy

Definition hip_runtime_api.h:1175

hipMemAdviseSetPreferredLocation

@ hipMemAdviseSetPreferredLocation

Definition hip_runtime_api.h:1172

hipMemAdviseSetReadMostly

@ hipMemAdviseSetReadMostly

Definition hip_runtime_api.h:1169

hipMemAdviseUnsetReadMostly

@ hipMemAdviseUnsetReadMostly

Undo the effect of hipMemAdviseSetReadMostly.

Definition hip_runtime_api.h:1171

hipSharedMemBankSizeFourByte

@ hipSharedMemBankSizeFourByte

Definition hip_runtime_api.h:1367

hipSharedMemBankSizeEightByte

@ hipSharedMemBankSizeEightByte

Definition hip_runtime_api.h:1369

hipSharedMemBankSizeDefault

@ hipSharedMemBankSizeDefault

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

Definition hip_runtime_api.h:1366

hipComputeModeProhibited

@ hipComputeModeProhibited

Definition hip_runtime_api.h:635

hipComputeModeExclusive

@ hipComputeModeExclusive

Definition hip_runtime_api.h:634

hipComputeModeDefault

@ hipComputeModeDefault

Definition hip_runtime_api.h:633

hipComputeModeExclusiveProcess

@ hipComputeModeExclusiveProcess

Definition hip_runtime_api.h:636

hipStreamCaptureModeRelaxed

@ hipStreamCaptureModeRelaxed

Definition hip_runtime_api.h:1827

hipStreamCaptureModeThreadLocal

@ hipStreamCaptureModeThreadLocal

Definition hip_runtime_api.h:1826

hipStreamCaptureModeGlobal

@ hipStreamCaptureModeGlobal

Definition hip_runtime_api.h:1825

hipStreamMemOpWriteValue64

@ hipStreamMemOpWriteValue64

Definition hip_runtime_api.h:1047

hipStreamMemOpBarrier

@ hipStreamMemOpBarrier

Currently not supported.

Definition hip_runtime_api.h:1048

hipStreamMemOpWriteValue32

@ hipStreamMemOpWriteValue32

Definition hip_runtime_api.h:1045

hipStreamMemOpWaitValue32

@ hipStreamMemOpWaitValue32

Definition hip_runtime_api.h:1044

hipStreamMemOpWaitValue64

@ hipStreamMemOpWaitValue64

Definition hip_runtime_api.h:1046

hipStreamMemOpFlushRemoteWrites

@ hipStreamMemOpFlushRemoteWrites

Currently not supported.

Definition hip_runtime_api.h:1049

HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND

@ HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND

Definition hip_runtime_api.h:628

HIP_GET_PROC_ADDRESS_SUCCESS

@ HIP_GET_PROC_ADDRESS_SUCCESS

Definition hip_runtime_api.h:627

HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT

@ HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT

Definition hip_runtime_api.h:629

hipLaunchAttributePriority

@ hipLaunchAttributePriority

Valid for graph node, streams, launches.

Definition hip_runtime_api.h:1723

hipLaunchAttributeMax

@ hipLaunchAttributeMax

Definition hip_runtime_api.h:1727

hipLaunchAttributeClusterDimension

@ hipLaunchAttributeClusterDimension

Valid for graph nodes, launches.

Definition hip_runtime_api.h:1721

hipLaunchAttributeMemSyncDomain

@ hipLaunchAttributeMemSyncDomain

Valid for streams, graph nodes, launches.

Definition hip_runtime_api.h:1725

hipLaunchAttributeMemSyncDomainMap

@ hipLaunchAttributeMemSyncDomainMap

Valid for streams, graph nodes, launches.

Definition hip_runtime_api.h:1724

hipLaunchAttributeIgnore

@ hipLaunchAttributeIgnore

Ignored entry.

Definition hip_runtime_api.h:1717

hipLaunchAttributeSynchronizationPolicy

@ hipLaunchAttributeSynchronizationPolicy

Valid for streams.

Definition hip_runtime_api.h:1720

hipLaunchAttributeExtDynDataPrefetch

@ hipLaunchAttributeExtDynDataPrefetch

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

Definition hip_runtime_api.h:1726

hipLaunchAttributeClusterSchedulingPolicyPreference

@ hipLaunchAttributeClusterSchedulingPolicyPreference

Valid for graph nodes, launches.

Definition hip_runtime_api.h:1722

hipLaunchAttributeAccessPolicyWindow

@ hipLaunchAttributeAccessPolicyWindow

Valid for Streams, graph nodes, launches.

Definition hip_runtime_api.h:1718

hipLaunchAttributeCooperative

@ hipLaunchAttributeCooperative

Valid for graph nodes, launches.

Definition hip_runtime_api.h:1719

hipSyncPolicyYield

@ hipSyncPolicyYield

Definition hip_runtime_api.h:1655

hipSyncPolicyBlockingSync

@ hipSyncPolicyBlockingSync

Definition hip_runtime_api.h:1656

hipSyncPolicyAuto

@ hipSyncPolicyAuto

Definition hip_runtime_api.h:1653

hipSyncPolicySpin

@ hipSyncPolicySpin

Definition hip_runtime_api.h:1654

hipGraphNodeTypeBatchMemOp

@ hipGraphNodeTypeBatchMemOp

BatchMemOp node.

Definition hip_runtime_api.h:1575

hipGraphNodeTypeGraph

@ hipGraphNodeTypeGraph

Node which executes an embedded graph.

Definition hip_runtime_api.h:1565

hipGraphNodeTypeMemset

@ hipGraphNodeTypeMemset

Memset node.

Definition hip_runtime_api.h:1563

hipGraphNodeTypeEventRecord

@ hipGraphNodeTypeEventRecord

External event record node.

Definition hip_runtime_api.h:1568

hipGraphNodeTypeExtSemaphoreSignal

@ hipGraphNodeTypeExtSemaphoreSignal

External Semaphore signal node.

Definition hip_runtime_api.h:1569

hipGraphNodeTypeMemcpy

@ hipGraphNodeTypeMemcpy

Memcpy node.

Definition hip_runtime_api.h:1562

hipGraphNodeTypeWaitEvent

@ hipGraphNodeTypeWaitEvent

External event wait node.

Definition hip_runtime_api.h:1567

hipGraphNodeTypeCount

@ hipGraphNodeTypeCount

Definition hip_runtime_api.h:1576

hipGraphNodeTypeKernel

@ hipGraphNodeTypeKernel

GPU kernel node.

Definition hip_runtime_api.h:1561

hipGraphNodeTypeHost

@ hipGraphNodeTypeHost

Host (executable) node.

Definition hip_runtime_api.h:1564

hipGraphNodeTypeMemAlloc

@ hipGraphNodeTypeMemAlloc

Memory alloc node.

Definition hip_runtime_api.h:1571

hipGraphNodeTypeMemFree

@ hipGraphNodeTypeMemFree

Memory free node.

Definition hip_runtime_api.h:1572

hipGraphNodeTypeMemcpyFromSymbol

@ hipGraphNodeTypeMemcpyFromSymbol

MemcpyFromSymbol node.

Definition hip_runtime_api.h:1573

hipGraphNodeTypeMemcpyToSymbol

@ hipGraphNodeTypeMemcpyToSymbol

MemcpyToSymbol node.

Definition hip_runtime_api.h:1574

hipGraphNodeTypeEmpty

@ hipGraphNodeTypeEmpty

Empty (no-op) node.

Definition hip_runtime_api.h:1566

hipGraphNodeTypeExtSemaphoreWait

@ hipGraphNodeTypeExtSemaphoreWait

External Semaphore wait node.

Definition hip_runtime_api.h:1570

hipExternalMemoryHandleTypeD3D11Resource

@ hipExternalMemoryHandleTypeD3D11Resource

Definition hip_runtime_api.h:1416

hipExternalMemoryHandleTypeD3D12Resource

@ hipExternalMemoryHandleTypeD3D12Resource

Definition hip_runtime_api.h:1415

hipExternalMemoryHandleTypeNvSciBuf

@ hipExternalMemoryHandleTypeNvSciBuf

Definition hip_runtime_api.h:1418

hipExternalMemoryHandleTypeOpaqueFd

@ hipExternalMemoryHandleTypeOpaqueFd

Definition hip_runtime_api.h:1411

hipExternalMemoryHandleTypeD3D12Heap

@ hipExternalMemoryHandleTypeD3D12Heap

Definition hip_runtime_api.h:1414

hipExternalMemoryHandleTypeOpaqueWin32Kmt

@ hipExternalMemoryHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:1413

hipExternalMemoryHandleTypeOpaqueWin32

@ hipExternalMemoryHandleTypeOpaqueWin32

Definition hip_runtime_api.h:1412

hipExternalMemoryHandleTypeD3D11ResourceKmt

@ hipExternalMemoryHandleTypeD3D11ResourceKmt

Definition hip_runtime_api.h:1417

hipFuncAttributeClusterSchedulingPolicyPreference

@ hipFuncAttributeClusterSchedulingPolicyPreference

The block scheduling policy of a function.

Definition hip_runtime_api.h:1350

hipFuncAttributePreferredSharedMemoryCarveout

@ hipFuncAttributePreferredSharedMemoryCarveout

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

Definition hip_runtime_api.h:1344

hipFuncAttributeRequiredClusterWidth

@ hipFuncAttributeRequiredClusterWidth

The required cluster width in blocks.

Definition hip_runtime_api.h:1346

hipFuncAttributeMaxDynamicSharedMemorySize

@ hipFuncAttributeMaxDynamicSharedMemorySize

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

Definition hip_runtime_api.h:1343

hipFuncAttributeMax

@ hipFuncAttributeMax

Definition hip_runtime_api.h:1351

hipFuncAttributeRequiredClusterDepth

@ hipFuncAttributeRequiredClusterDepth

The required cluster depth in blocks.

Definition hip_runtime_api.h:1348

hipFuncAttributeRequiredClusterHeight

@ hipFuncAttributeRequiredClusterHeight

The required cluster height in blocks.

Definition hip_runtime_api.h:1347

hipFuncAttributeClusterDimMustBeSet

@ hipFuncAttributeClusterDimMustBeSet

The kernel must launch with a valid cluster size specified.

Definition hip_runtime_api.h:1345

hipFuncAttributeNonPortableClusterSizeAllowed

@ hipFuncAttributeNonPortableClusterSizeAllowed

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

Definition hip_runtime_api.h:1349

hipExternalSemaphoreHandleTypeNvSciSync

@ hipExternalSemaphoreHandleTypeNvSciSync

Definition hip_runtime_api.h:1454

hipExternalSemaphoreHandleTypeKeyedMutexKmt

@ hipExternalSemaphoreHandleTypeKeyedMutexKmt

Definition hip_runtime_api.h:1456

hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

@ hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:1451

hipExternalSemaphoreHandleTypeKeyedMutex

@ hipExternalSemaphoreHandleTypeKeyedMutex

Definition hip_runtime_api.h:1455

hipExternalSemaphoreHandleTypeD3D11Fence

@ hipExternalSemaphoreHandleTypeD3D11Fence

Definition hip_runtime_api.h:1453

hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

@ hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

Definition hip_runtime_api.h:1458

hipExternalSemaphoreHandleTypeOpaqueFd

@ hipExternalSemaphoreHandleTypeOpaqueFd

Definition hip_runtime_api.h:1449

hipExternalSemaphoreHandleTypeOpaqueWin32

@ hipExternalSemaphoreHandleTypeOpaqueWin32

Definition hip_runtime_api.h:1450

hipExternalSemaphoreHandleTypeTimelineSemaphoreFd

@ hipExternalSemaphoreHandleTypeTimelineSemaphoreFd

Definition hip_runtime_api.h:1457

hipExternalSemaphoreHandleTypeD3D12Fence

@ hipExternalSemaphoreHandleTypeD3D12Fence

Definition hip_runtime_api.h:1452

hipLaunchMemSyncDomainRemote

@ hipLaunchMemSyncDomainRemote

Definition hip_runtime_api.h:1645

hipLaunchMemSyncDomainDefault

@ hipLaunchMemSyncDomainDefault

Definition hip_runtime_api.h:1644

hipDevP2PAttrAccessSupported

@ hipDevP2PAttrAccessSupported

Definition hip_runtime_api.h:755

hipDevP2PAttrHipArrayAccessSupported

@ hipDevP2PAttrHipArrayAccessSupported

Definition hip_runtime_api.h:757

hipDevP2PAttrNativeAtomicSupported

@ hipDevP2PAttrNativeAtomicSupported

Definition hip_runtime_api.h:756

hipDevP2PAttrPerformanceRank

@ hipDevP2PAttrPerformanceRank

Definition hip_runtime_api.h:754

hipGraphDebugDotFlagsKernelNodeAttributes

@ hipGraphDebugDotFlagsKernelNodeAttributes

Definition hip_runtime_api.h:1883

hipGraphDebugDotFlagsMemsetNodeParams

@ hipGraphDebugDotFlagsMemsetNodeParams

Definition hip_runtime_api.h:1875

hipGraphDebugDotFlagsKernelNodeParams

@ hipGraphDebugDotFlagsKernelNodeParams

Definition hip_runtime_api.h:1873

hipGraphDebugDotFlagsExtSemasWaitNodeParams

@ hipGraphDebugDotFlagsExtSemasWaitNodeParams

Definition hip_runtime_api.h:1881

hipGraphDebugDotFlagsHandles

@ hipGraphDebugDotFlagsHandles

Definition hip_runtime_api.h:1885

hipGraphDebugDotFlagsExtSemasSignalNodeParams

@ hipGraphDebugDotFlagsExtSemasSignalNodeParams

Definition hip_runtime_api.h:1879

hipGraphDebugDotFlagsHostNodeParams

@ hipGraphDebugDotFlagsHostNodeParams

Definition hip_runtime_api.h:1876

hipGraphDebugDotFlagsEventNodeParams

@ hipGraphDebugDotFlagsEventNodeParams

Definition hip_runtime_api.h:1877

hipGraphDebugDotFlagsVerbose

@ hipGraphDebugDotFlagsVerbose

Definition hip_runtime_api.h:1871

hipGraphDebugDotFlagsMemcpyNodeParams

@ hipGraphDebugDotFlagsMemcpyNodeParams

Definition hip_runtime_api.h:1874

hipDevSmResourceGroupBackfill

@ hipDevSmResourceGroupBackfill

Definition hip_runtime_api.h:701

hipDevSmResourceGroupDefault

@ hipDevSmResourceGroupDefault

Definition hip_runtime_api.h:700

hipGraphUserObjectMove

@ hipGraphUserObjectMove

Add new reference or retain.

Definition hip_runtime_api.h:1856

hipStreamAddCaptureDependencies

@ hipStreamAddCaptureDependencies

Add new nodes to the dependency set.

Definition hip_runtime_api.h:1837

hipStreamSetCaptureDependencies

@ hipStreamSetCaptureDependencies

Replace the dependency set with the new nodes.

Definition hip_runtime_api.h:1838

hipMemHandleTypeGeneric

@ hipMemHandleTypeGeneric

Generic handle type.

Definition hip_runtime_api.h:1975

hipFlushGPUDirectRDMAWritesOptionHost

@ hipFlushGPUDirectRDMAWritesOptionHost

Definition hip_runtime_api.h:640

hipFlushGPUDirectRDMAWritesOptionMemOps

@ hipFlushGPUDirectRDMAWritesOptionMemOps

Definition hip_runtime_api.h:641

hipFuncCachePreferNone

@ hipFuncCachePreferNone

no preference for shared memory or L1 (default)

Definition hip_runtime_api.h:1357

hipFuncCachePreferEqual

@ hipFuncCachePreferEqual

prefer equal size L1 cache and shared memory

Definition hip_runtime_api.h:1360

hipFuncCachePreferL1

@ hipFuncCachePreferL1

prefer larger L1 cache and smaller shared memory

Definition hip_runtime_api.h:1359

hipFuncCachePreferShared

@ hipFuncCachePreferShared

prefer larger shared memory and smaller L1 cache

Definition hip_runtime_api.h:1358

hipUserObjectNoDestructorSync

@ hipUserObjectNoDestructorSync

Destructor execution is not synchronized.

Definition hip_runtime_api.h:1852

hipDevWorkqueueConfigScopeDeviceCtx

@ hipDevWorkqueueConfigScopeDeviceCtx

Definition hip_runtime_api.h:708

hipDevWorkqueueConfigScopeGreenCtxBalanced

@ hipDevWorkqueueConfigScopeGreenCtxBalanced

Definition hip_runtime_api.h:709

hipGraphMemAttrReservedMemHigh

@ hipGraphMemAttrReservedMemHigh

Definition hip_runtime_api.h:1848

hipGraphMemAttrUsedMemCurrent

@ hipGraphMemAttrUsedMemCurrent

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

Definition hip_runtime_api.h:1842

hipGraphMemAttrUsedMemHigh

@ hipGraphMemAttrUsedMemHigh

Definition hip_runtime_api.h:1844

hipGraphMemAttrReservedMemCurrent

@ hipGraphMemAttrReservedMemCurrent

Definition hip_runtime_api.h:1846

hipMemPoolAttrUsedMemCurrent

@ hipMemPoolAttrUsedMemCurrent

Definition hip_runtime_api.h:1263

hipMemPoolAttrReservedMemHigh

@ hipMemPoolAttrReservedMemHigh

Definition hip_runtime_api.h:1258

hipMemPoolAttrReservedMemCurrent

@ hipMemPoolAttrReservedMemCurrent

Definition hip_runtime_api.h:1252

hipMemPoolAttrReleaseThreshold

@ hipMemPoolAttrReleaseThreshold

Definition hip_runtime_api.h:1247

hipMemPoolAttrUsedMemHigh

@ hipMemPoolAttrUsedMemHigh

Definition hip_runtime_api.h:1269

hipMemPoolReuseAllowInternalDependencies

@ hipMemPoolReuseAllowInternalDependencies

Definition hip_runtime_api.h:1238

hipMemPoolReuseFollowEventDependencies

@ hipMemPoolReuseFollowEventDependencies

Definition hip_runtime_api.h:1225

hipMemPoolReuseAllowOpportunistic

@ hipMemPoolReuseAllowOpportunistic

Definition hip_runtime_api.h:1231

hipDriverEntryPointSuccess

@ hipDriverEntryPointSuccess

Definition hip_runtime_api.h:760

hipDriverEntryPointSymbolNotFound

@ hipDriverEntryPointSymbolNotFound

Definition hip_runtime_api.h:761

hipDriverEntryPointVersionNotSufficent

@ hipDriverEntryPointVersionNotSufficent

Definition hip_runtime_api.h:762

hipMemRangeFlagsMax

@ hipMemRangeFlagsMax

Definition hip_runtime_api.h:2196

hipMemRangeFlagDmaBufMappingTypePcie

@ hipMemRangeFlagDmaBufMappingTypePcie

Definition hip_runtime_api.h:2195

hipDevSmResourceSplitMaxPotentialClusterSize

@ hipDevSmResourceSplitMaxPotentialClusterSize

Definition hip_runtime_api.h:705

hipDevSmResourceSplitIgnoreSmCoscheduling

@ hipDevSmResourceSplitIgnoreSmCoscheduling

Definition hip_runtime_api.h:704

hipMemOperationTypeMap

@ hipMemOperationTypeMap

Map operation.

Definition hip_runtime_api.h:1982

hipMemOperationTypeUnmap

@ hipMemOperationTypeUnmap

Unmap operation.

Definition hip_runtime_api.h:1983

hipGraphicsRegisterFlagsReadOnly

@ hipGraphicsRegisterFlagsReadOnly

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

Definition hip_runtime_api.h:1526

hipGraphicsRegisterFlagsTextureGather

@ hipGraphicsRegisterFlagsTextureGather

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

Definition hip_runtime_api.h:1530

hipGraphicsRegisterFlagsWriteDiscard

@ hipGraphicsRegisterFlagsWriteDiscard

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

Definition hip_runtime_api.h:1527

hipGraphicsRegisterFlagsNone

@ hipGraphicsRegisterFlagsNone

Definition hip_runtime_api.h:1525

hipGraphicsRegisterFlagsSurfaceLoadStore

@ hipGraphicsRegisterFlagsSurfaceLoadStore

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

Definition hip_runtime_api.h:1529

hipMemRangeCoherencyModeFineGrain

@ hipMemRangeCoherencyModeFineGrain

Definition hip_runtime_api.h:1190

hipMemRangeCoherencyModeIndeterminate

@ hipMemRangeCoherencyModeIndeterminate

Definition hip_runtime_api.h:1194

hipMemRangeCoherencyModeCoarseGrain

@ hipMemRangeCoherencyModeCoarseGrain

Definition hip_runtime_api.h:1192

hipMemAccessFlagsProtRead

@ hipMemAccessFlagsProtRead

Set the address range read accessible.

Definition hip_runtime_api.h:1278

hipMemAccessFlagsProtNone

@ hipMemAccessFlagsProtNone

Default, make the address range not accessible.

Definition hip_runtime_api.h:1277

hipMemAccessFlagsProtReadWrite

@ hipMemAccessFlagsProtReadWrite

Set the address range read-write accessible.

Definition hip_runtime_api.h:1279

hipMemAllocationGranularityMinimum

@ hipMemAllocationGranularityMinimum

Minimum granularity.

Definition hip_runtime_api.h:1967

hipMemAllocationGranularityRecommended

@ hipMemAllocationGranularityRecommended

Recommended granularity for performance.

Definition hip_runtime_api.h:1968

hipExtDynDataPrefetchTemporalRegular

@ hipExtDynDataPrefetchTemporalRegular

Regular temporal locality.

Definition hip_runtime_api.h:1671

hipExtDynDataPrefetchTemporalHigh

@ hipExtDynDataPrefetchTemporalHigh

High temporal locality (prefer caching)

Definition hip_runtime_api.h:1672

hipGraphExecUpdateErrorNotSupported

@ hipGraphExecUpdateErrorNotSupported

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

Definition hip_runtime_api.h:1819

hipGraphExecUpdateErrorNodeTypeChanged

@ hipGraphExecUpdateErrorNodeTypeChanged

The update failed because a node type changed.

Definition hip_runtime_api.h:1814

hipGraphExecUpdateErrorTopologyChanged

@ hipGraphExecUpdateErrorTopologyChanged

The update failed because the topology changed.

Definition hip_runtime_api.h:1813

hipGraphExecUpdateErrorUnsupportedFunctionChange

@ hipGraphExecUpdateErrorUnsupportedFunctionChange

Definition hip_runtime_api.h:1821

hipGraphExecUpdateError

@ hipGraphExecUpdateError

Definition hip_runtime_api.h:1811

hipGraphExecUpdateErrorFunctionChanged

@ hipGraphExecUpdateErrorFunctionChanged

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

Definition hip_runtime_api.h:1815

hipGraphExecUpdateSuccess

@ hipGraphExecUpdateSuccess

The update succeeded.

Definition hip_runtime_api.h:1810

hipGraphExecUpdateErrorParametersChanged

@ hipGraphExecUpdateErrorParametersChanged

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

Definition hip_runtime_api.h:1817

hipStreamCaptureStatusInvalidated

@ hipStreamCaptureStatusInvalidated

Definition hip_runtime_api.h:1832

hipStreamCaptureStatusNone

@ hipStreamCaptureStatusNone

Stream is not capturing.

Definition hip_runtime_api.h:1830

hipStreamCaptureStatusActive

@ hipStreamCaptureStatusActive

Stream is actively capturing.

Definition hip_runtime_api.h:1831

hipDeviceAttributeDirectManagedMemAccessFromHost

@ hipDeviceAttributeDirectManagedMemAccessFromHost

Definition hip_runtime_api.h:443

hipDeviceAttributeSurfaceAlignment

@ hipDeviceAttributeSurfaceAlignment

Alignment requirement for surfaces.

Definition hip_runtime_api.h:533

hipDeviceAttributeMaxGridDimX

@ hipDeviceAttributeMaxGridDimX

Max grid size in width.

Definition hip_runtime_api.h:464

hipDeviceAttributeMaxSurfaceCubemapLayered

@ hipDeviceAttributeMaxSurfaceCubemapLayered

Definition hip_runtime_api.h:473

hipDeviceAttributeMaxSurface3D

@ hipDeviceAttributeMaxSurface3D

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

Definition hip_runtime_api.h:471

hipDeviceAttributeMaxPitch

@ hipDeviceAttributeMaxPitch

Maximum pitch in bytes allowed by memory copies.

Definition hip_runtime_api.h:498

hipDeviceAttributeTccDriver

@ hipDeviceAttributeTccDriver

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

Definition hip_runtime_api.h:534

hipDeviceAttributeHostNativeAtomicSupported

@ hipDeviceAttributeHostNativeAtomicSupported

Definition hip_runtime_api.h:446

hipDeviceAttributePageableMemoryAccessUsesHostPageTables

@ hipDeviceAttributePageableMemoryAccessUsesHostPageTables

Definition hip_runtime_api.h:511

hipDeviceAttributeUnused5

@ hipDeviceAttributeUnused5

Previously hipDeviceAttributeGcnArchName.

Definition hip_runtime_api.h:568

hipDeviceAttributeMaxBlockDimY

@ hipDeviceAttributeMaxBlockDimY

Max block size in height.

Definition hip_runtime_api.h:462

hipDeviceAttributeMaxSurfaceCubemap

@ hipDeviceAttributeMaxSurfaceCubemap

Cuda only. Maximum dimensions of Cubemap surface.

Definition hip_runtime_api.h:472

hipDeviceAttributePageableMemoryAccess

@ hipDeviceAttributePageableMemoryAccess

Definition hip_runtime_api.h:509

hipDeviceAttributeClockRate

@ hipDeviceAttributeClockRate

Peak clock frequency in kilohertz.

Definition hip_runtime_api.h:431

hipDeviceAttributeCudaCompatibleEnd

@ hipDeviceAttributeCudaCompatibleEnd

Definition hip_runtime_api.h:559

hipDeviceAttributeMaxTexture1DMipmap

@ hipDeviceAttributeMaxTexture1DMipmap

Maximum size of 1D mipmapped texture.

Definition hip_runtime_api.h:480

hipDeviceAttributeComputeCapabilityMajor

@ hipDeviceAttributeComputeCapabilityMajor

Major compute capability version number.

Definition hip_runtime_api.h:458

hipDeviceAttributeGlobalL1CacheSupported

@ hipDeviceAttributeGlobalL1CacheSupported

Device supports caching globals in L1.

Definition hip_runtime_api.h:445

hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

Definition hip_runtime_api.h:580

hipDeviceAttributeAccessPolicyMaxWindowSize

@ hipDeviceAttributeAccessPolicyMaxWindowSize

Definition hip_runtime_api.h:423

hipDeviceAttributeMaxTexture3DHeight

@ hipDeviceAttributeMaxTexture3DHeight

Maximum dimension height of 3D texture.

Definition hip_runtime_api.h:490

hipDeviceAttributeComputeCapabilityMinor

@ hipDeviceAttributeComputeCapabilityMinor

Minor compute capability version number.

Definition hip_runtime_api.h:501

hipDeviceAttributeNumberOfXccs

@ hipDeviceAttributeNumberOfXccs

Definition hip_runtime_api.h:592

hipDeviceAttributeMaxTextureCubemap

@ hipDeviceAttributeMaxTextureCubemap

Maximum dimensions of Cubemap texture.

Definition hip_runtime_api.h:493

hipDeviceAttributeDeviceOverlap

@ hipDeviceAttributeDeviceOverlap

Definition hip_runtime_api.h:441

hipDeviceAttributeMaxTexture2DLinear

@ hipDeviceAttributeMaxTexture2DLinear

Definition hip_runtime_api.h:486

hipDeviceAttributeMaxSurface2D

@ hipDeviceAttributeMaxSurface2D

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

Definition hip_runtime_api.h:469

hipDeviceAttributeMaxSurface1DLayered

@ hipDeviceAttributeMaxSurface1DLayered

Cuda only. Maximum dimensions of 1D layered surface.

Definition hip_runtime_api.h:468

hipDeviceAttributeHdpRegFlushCntl

@ hipDeviceAttributeHdpRegFlushCntl

Address of the HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:570

hipDeviceAttributeMaxAvailableVgprsPerThread

@ hipDeviceAttributeMaxAvailableVgprsPerThread

Definition hip_runtime_api.h:599

hipDeviceAttributeComputeMode

@ hipDeviceAttributeComputeMode

Compute mode that device is currently in.

Definition hip_runtime_api.h:432

hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

Definition hip_runtime_api.h:571

hipDeviceAttributeAsicRevision

@ hipDeviceAttributeAsicRevision

Revision of the GPU in this device.

Definition hip_runtime_api.h:584

hipDeviceAttributeUnused4

@ hipDeviceAttributeUnused4

Previously hipDeviceAttributeGcnArch.

Definition hip_runtime_api.h:567

hipDeviceAttributeCooperativeMultiDeviceLaunch

@ hipDeviceAttributeCooperativeMultiDeviceLaunch

Definition hip_runtime_api.h:439

hipDeviceAttributeMaxTexture2DHeight

@ hipDeviceAttributeMaxTexture2DHeight

Maximum dimension hight of 2D texture.

Definition hip_runtime_api.h:482

hipDeviceAttributePersistingL2CacheMaxSize

@ hipDeviceAttributePersistingL2CacheMaxSize

Maximum l2 persisting lines capacity in bytes.

Definition hip_runtime_api.h:518

hipDeviceAttributeEccEnabled

@ hipDeviceAttributeEccEnabled

Whether ECC support is enabled.

Definition hip_runtime_api.h:421

hipDeviceAttributeDmaBufSupported

@ hipDeviceAttributeDmaBufSupported

Device supports DMABuf buffer sharing.

Definition hip_runtime_api.h:553

hipDeviceAttributeExpertSchedMode

@ hipDeviceAttributeExpertSchedMode

Definition hip_runtime_api.h:603

hipDeviceAttributeCanUseHostPointerForRegisteredMem

@ hipDeviceAttributeCanUseHostPointerForRegisteredMem

Definition hip_runtime_api.h:428

hipDeviceAttributePciBusId

@ hipDeviceAttributePciBusId

PCI Bus ID.

Definition hip_runtime_api.h:513

hipDeviceAttributeL2CacheSize

@ hipDeviceAttributeL2CacheSize

Definition hip_runtime_api.h:451

hipDeviceAttributeKernelExecTimeout

@ hipDeviceAttributeKernelExecTimeout

Run time limit for kernels executed on the device.

Definition hip_runtime_api.h:450

hipDeviceAttributeMaxThreadsDim

@ hipDeviceAttributeMaxThreadsDim

Maximum dimension of a block.

Definition hip_runtime_api.h:495

hipDeviceAttributeSingleToDoublePrecisionPerfRatio

@ hipDeviceAttributeSingleToDoublePrecisionPerfRatio

Definition hip_runtime_api.h:530

hipDeviceAttributeMaxGridDimY

@ hipDeviceAttributeMaxGridDimY

Max grid size in height.

Definition hip_runtime_api.h:465

hipDeviceAttributeMultiprocessorCount

@ hipDeviceAttributeMultiprocessorCount

Definition hip_runtime_api.h:504

hipDeviceAttributeAmdSpecificBegin

@ hipDeviceAttributeAmdSpecificBegin

Definition hip_runtime_api.h:560

hipDeviceAttributeMaxRegistersPerMultiprocessor

@ hipDeviceAttributeMaxRegistersPerMultiprocessor

32-bit registers available per block.

Definition hip_runtime_api.h:522

hipDeviceAttributeIsMultiGpuBoard

@ hipDeviceAttributeIsMultiGpuBoard

Multiple GPU devices.

Definition hip_runtime_api.h:449

hipDeviceAttributeSharedMemPerBlockOptin

@ hipDeviceAttributeSharedMemPerBlockOptin

Definition hip_runtime_api.h:527

hipDeviceAttributeMaxSurface2DLayered

@ hipDeviceAttributeMaxSurface2DLayered

Cuda only. Maximum dimensions of 2D layered surface.

Definition hip_runtime_api.h:470

hipDeviceAttributeAmdSpecificEnd

@ hipDeviceAttributeAmdSpecificEnd

Definition hip_runtime_api.h:608

hipDeviceAttributeMemoryClockRate

@ hipDeviceAttributeMemoryClockRate

Peak memory clock frequency in kilohertz.

Definition hip_runtime_api.h:500

hipDeviceAttributeMaxGridDimZ

@ hipDeviceAttributeMaxGridDimZ

Max grid size in depth.

Definition hip_runtime_api.h:466

hipDeviceAttributeHdpMemFlushCntl

@ hipDeviceAttributeHdpMemFlushCntl

Address of the HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:569

hipDeviceAttributeUnused2

@ hipDeviceAttributeUnused2

Previously hipDeviceAttributeUuid.

Definition hip_runtime_api.h:542

hipDeviceAttributeFineGrainSupport

@ hipDeviceAttributeFineGrainSupport

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

Definition hip_runtime_api.h:590

hipDeviceAttributeCooperativeLaunch

@ hipDeviceAttributeCooperativeLaunch

Support cooperative launch.

Definition hip_runtime_api.h:438

hipDeviceAttributeUnifiedAddressing

@ hipDeviceAttributeUnifiedAddressing

Definition hip_runtime_api.h:540

hipDeviceAttributeAsyncEngineCount

@ hipDeviceAttributeAsyncEngineCount

Asynchronous engines number.

Definition hip_runtime_api.h:425

hipDeviceAttributeMultiGpuBoardGroupID

@ hipDeviceAttributeMultiGpuBoardGroupID

Definition hip_runtime_api.h:502

hipDeviceAttributeStreamPrioritiesSupported

@ hipDeviceAttributeStreamPrioritiesSupported

Whether to support stream priorities.

Definition hip_runtime_api.h:532

hipDeviceAttributeMaxSharedMemoryPerBlock

@ hipDeviceAttributeMaxSharedMemoryPerBlock

Definition hip_runtime_api.h:525

hipDeviceAttributeLocalL1CacheSupported

@ hipDeviceAttributeLocalL1CacheSupported

caching locals in L1 is supported

Definition hip_runtime_api.h:453

hipDeviceAttributeCanUseStreamWaitValue

@ hipDeviceAttributeCanUseStreamWaitValue

Definition hip_runtime_api.h:585

hipDeviceAttributeMaxRegistersPerBlock

@ hipDeviceAttributeMaxRegistersPerBlock

Definition hip_runtime_api.h:519

hipDeviceAttributeMaxThreadsPerBlock

@ hipDeviceAttributeMaxThreadsPerBlock

Maximum number of threads per block.

Definition hip_runtime_api.h:496

hipDeviceAttributePciDomainId

@ hipDeviceAttributePciDomainId

PCI Domain Id.

Definition hip_runtime_api.h:515

hipDeviceAttributeMemoryBusWidth

@ hipDeviceAttributeMemoryBusWidth

Global memory bus width in bits.

Definition hip_runtime_api.h:499

hipDeviceAttributeMemoryPoolSupportedHandleTypes

@ hipDeviceAttributeMemoryPoolSupportedHandleTypes

Definition hip_runtime_api.h:549

hipDeviceAttributeComputePreemptionSupported

@ hipDeviceAttributeComputePreemptionSupported

Device supports Compute Preemption.

Definition hip_runtime_api.h:433

hipDeviceAttributeMaxSurface1D

@ hipDeviceAttributeMaxSurface1D

Maximum size of 1D surface.

Definition hip_runtime_api.h:467

hipDeviceAttributeUnused1

@ hipDeviceAttributeUnused1

Previously hipDeviceAttributeName.

Definition hip_runtime_api.h:508

hipDeviceAttributeMaxTexture3DAlt

@ hipDeviceAttributeMaxTexture3DAlt

Maximum dimensions of alternate 3D texture.

Definition hip_runtime_api.h:492

hipDeviceAttributeMaxTexture1DLinear

@ hipDeviceAttributeMaxTexture1DLinear

Definition hip_runtime_api.h:477

hipDeviceAttributeMaxTexture2DGather

@ hipDeviceAttributeMaxTexture2DGather

Definition hip_runtime_api.h:483

hipDeviceAttributeWallClockRate

@ hipDeviceAttributeWallClockRate

Constant frequency of wall clock in kilohertz.

Definition hip_runtime_api.h:591

hipDeviceAttributePciDeviceId

@ hipDeviceAttributePciDeviceId

PCI Device ID. Returns pcie slot id.

Definition hip_runtime_api.h:514

hipDeviceAttributeCanMapHostMemory

@ hipDeviceAttributeCanMapHostMemory

Definition hip_runtime_api.h:426

hipDeviceAttributeMaxTexture1DWidth

@ hipDeviceAttributeMaxTexture1DWidth

Maximum size of 1D texture.

Definition hip_runtime_api.h:475

hipDeviceAttributeConcurrentManagedAccess

@ hipDeviceAttributeConcurrentManagedAccess

Definition hip_runtime_api.h:436

hipDeviceAttributeVendorSpecificBegin

@ hipDeviceAttributeVendorSpecificBegin

Definition hip_runtime_api.h:609

hipDeviceAttributeManagedMemory

@ hipDeviceAttributeManagedMemory

Device supports allocating managed memory on this system.

Definition hip_runtime_api.h:459

hipDeviceAttributeHostNumaId

@ hipDeviceAttributeHostNumaId

Definition hip_runtime_api.h:551

hipDeviceAttributeIntegrated

@ hipDeviceAttributeIntegrated

Device is integrated GPU.

Definition hip_runtime_api.h:448

hipDeviceAttributeMaxTexture2DLayered

@ hipDeviceAttributeMaxTexture2DLayered

Maximum dimensions of 2D layered texture.

Definition hip_runtime_api.h:485

hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

Definition hip_runtime_api.h:574

hipDeviceAttributeMaxTexture3DDepth

@ hipDeviceAttributeMaxTexture3DDepth

Maximum dimension depth of 3D texture.

Definition hip_runtime_api.h:491

hipDeviceAttributePciChipId

@ hipDeviceAttributePciChipId

GPU Manufacturer device id.

Definition hip_runtime_api.h:602

hipDeviceAttributeImageSupport

@ hipDeviceAttributeImageSupport

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

Definition hip_runtime_api.h:587

hipDeviceAttributeTotalGlobalMem

@ hipDeviceAttributeTotalGlobalMem

Global memory available on devicice.

Definition hip_runtime_api.h:539

hipDeviceAttributeMaxBlocksPerMultiProcessor

@ hipDeviceAttributeMaxBlocksPerMultiProcessor

Max block size per multiprocessor.

Definition hip_runtime_api.h:460

hipDeviceAttributeHandleTypeFabricSupported

@ hipDeviceAttributeHandleTypeFabricSupported

Device supports exporting memory to a fabric handle.

Definition hip_runtime_api.h:557

hipDeviceAttributeIsLargeBar

@ hipDeviceAttributeIsLargeBar

Whether it is LargeBar.

Definition hip_runtime_api.h:583

hipDeviceAttributeMaxTexture2DWidth

@ hipDeviceAttributeMaxTexture2DWidth

Maximum dimension width of 2D texture.

Definition hip_runtime_api.h:481

hipDeviceAttributeMaxBlockDimX

@ hipDeviceAttributeMaxBlockDimX

Max block size in width.

Definition hip_runtime_api.h:461

hipDeviceAttributeMaxTexture3DWidth

@ hipDeviceAttributeMaxTexture3DWidth

Maximum dimension width of 3D texture.

Definition hip_runtime_api.h:489

hipDeviceAttributeUnused3

@ hipDeviceAttributeUnused3

Previously hipDeviceAttributeArch.

Definition hip_runtime_api.h:565

hipDeviceAttributeTotalConstantMemory

@ hipDeviceAttributeTotalConstantMemory

Constant memory size in bytes.

Definition hip_runtime_api.h:538

hipDeviceAttributeTextureAlignment

@ hipDeviceAttributeTextureAlignment

Alignment requirement for textures.

Definition hip_runtime_api.h:535

hipDeviceAttributeMaxTexture1DLayered

@ hipDeviceAttributeMaxTexture1DLayered

Maximum dimensions of 1D layered texture.

Definition hip_runtime_api.h:476

hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

@ hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

Maximum Shared Memory PerMultiprocessor.

Definition hip_runtime_api.h:566

hipDeviceAttributeGPUDirectRDMAWithHipVMMSupported

@ hipDeviceAttributeGPUDirectRDMAWithHipVMMSupported

Definition hip_runtime_api.h:554

hipDeviceAttributeReservedSharedMemPerBlock

@ hipDeviceAttributeReservedSharedMemPerBlock

Definition hip_runtime_api.h:523

hipDeviceAttributeCudaCompatibleBegin

@ hipDeviceAttributeCudaCompatibleBegin

Definition hip_runtime_api.h:419

hipDeviceAttributeConcurrentKernels

@ hipDeviceAttributeConcurrentKernels

Definition hip_runtime_api.h:434

hipDeviceAttributeLuid

@ hipDeviceAttributeLuid

Definition hip_runtime_api.h:454

hipDeviceAttributePciDomainID

@ hipDeviceAttributePciDomainID

PCI Domain ID, for backward compatibility.

Definition hip_runtime_api.h:516

hipDeviceAttributeMaxThreadsPerMultiProcessor

@ hipDeviceAttributeMaxThreadsPerMultiProcessor

Maximum resident threads per multiprocessor.

Definition hip_runtime_api.h:497

hipDeviceAttributeTexturePitchAlignment

@ hipDeviceAttributeTexturePitchAlignment

Definition hip_runtime_api.h:536

hipDeviceAttributePhysicalMultiProcessorCount

@ hipDeviceAttributePhysicalMultiProcessorCount

Definition hip_runtime_api.h:588

hipDeviceAttributeHostRegisterSupported

@ hipDeviceAttributeHostRegisterSupported

Definition hip_runtime_api.h:547

hipDeviceAttributeSharedMemPerMultiprocessor

@ hipDeviceAttributeSharedMemPerMultiprocessor

Shared memory available per multiprocessor.

Definition hip_runtime_api.h:529

hipDeviceAttributeLuidDeviceNodeMask

@ hipDeviceAttributeLuidDeviceNodeMask

Definition hip_runtime_api.h:456

hipDeviceAttributeMaxTextureCubemapLayered

@ hipDeviceAttributeMaxTextureCubemapLayered

Maximum dimensions of Cubemap layered texture.

Definition hip_runtime_api.h:494

hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

Definition hip_runtime_api.h:577

hipDeviceAttributeVirtualMemoryManagementSupported

@ hipDeviceAttributeVirtualMemoryManagementSupported

Definition hip_runtime_api.h:545

hipDeviceAttributeMemoryPoolsSupported

@ hipDeviceAttributeMemoryPoolsSupported

Device supports HIP Stream Ordered Memory Allocator.

Definition hip_runtime_api.h:544

hipDeviceAttributeClockInstructionRate

@ hipDeviceAttributeClockInstructionRate

Definition hip_runtime_api.h:562

hipDeviceAttributeMaxTexture2DMipmap

@ hipDeviceAttributeMaxTexture2DMipmap

Maximum dimensions of 2D mipmapped texture.

Definition hip_runtime_api.h:488

hipDeviceAttributeMaxDynDataPrefetchRegions

@ hipDeviceAttributeMaxDynDataPrefetchRegions

Definition hip_runtime_api.h:605

hipDeviceAttributeMaxBlockDimZ

@ hipDeviceAttributeMaxBlockDimZ

Max block size in depth.

Definition hip_runtime_api.h:463

hipDeviceAttributeWarpSize

@ hipDeviceAttributeWarpSize

Warp size in threads.

Definition hip_runtime_api.h:543

hipGPUDirectRDMAWritesOrderingOwner

@ hipGPUDirectRDMAWritesOrderingOwner

Definition hip_runtime_api.h:646

hipGPUDirectRDMAWritesOrderingNone

@ hipGPUDirectRDMAWritesOrderingNone

Definition hip_runtime_api.h:645

hipGPUDirectRDMAWritesOrderingAllDevices

@ hipGPUDirectRDMAWritesOrderingAllDevices

Definition hip_runtime_api.h:647

hipMemAllocationTypeManaged

@ hipMemAllocationTypeManaged

Definition hip_runtime_api.h:1300

hipMemAllocationTypeMax

@ hipMemAllocationTypeMax

Definition hip_runtime_api.h:1302

hipMemAllocationTypePinned

@ hipMemAllocationTypePinned

Definition hip_runtime_api.h:1299

hipMemAllocationTypeUncached

@ hipMemAllocationTypeUncached

Definition hip_runtime_api.h:1301

hipMemAllocationTypeInvalid

@ hipMemAllocationTypeInvalid

Definition hip_runtime_api.h:1295

hipClusterSchedulingPolicyDefault

@ hipClusterSchedulingPolicyDefault

the default scheduling policy

Definition hip_runtime_api.h:1661

hipClusterSchedulingPolicyLoadBalancing

@ hipClusterSchedulingPolicyLoadBalancing

Dynamically balance block assignment to optimize resource usage.

Definition hip_runtime_api.h:1663

hipClusterSchedulingPolicySpread

@ hipClusterSchedulingPolicySpread

distribute blocks evenly across cluster's CUs

Definition hip_runtime_api.h:1662

hipMemoryTypeDevice

@ hipMemoryTypeDevice

Definition hip_runtime_api.h:250

hipMemoryTypeHost

@ hipMemoryTypeHost

Memory is physically located on host.

Definition hip_runtime_api.h:249

hipMemoryTypeUnregistered

@ hipMemoryTypeUnregistered

Unregistered memory.

Definition hip_runtime_api.h:248

hipMemoryTypeArray

@ hipMemoryTypeArray

Definition hip_runtime_api.h:255

hipMemoryTypeManaged

@ hipMemoryTypeManaged

Definition hip_runtime_api.h:252

hipMemoryTypeUnified

@ hipMemoryTypeUnified

unified address space

Definition hip_runtime_api.h:257

hipGraphInstantiateFlagAutoFreeOnLaunch

@ hipGraphInstantiateFlagAutoFreeOnLaunch

Automatically free memory allocated in a graph before relaunching.

Definition hip_runtime_api.h:1860

hipGraphInstantiateFlagUseNodePriority

@ hipGraphInstantiateFlagUseNodePriority

Definition hip_runtime_api.h:1865

hipGraphInstantiateFlagUpload

@ hipGraphInstantiateFlagUpload

Automatically upload the graph after instantiation.

Definition hip_runtime_api.h:1862

hipGraphInstantiateFlagDeviceLaunch

@ hipGraphInstantiateFlagDeviceLaunch

Instantiate the graph to be launched from the device.

Definition hip_runtime_api.h:1863

hipDevResourceTypeWorkqueue

@ hipDevResourceTypeWorkqueue

Definition hip_runtime_api.h:697

hipDevResourceTypeSm

@ hipDevResourceTypeSm

Definition hip_runtime_api.h:695

hipDevResourceTypeInvalid

@ hipDevResourceTypeInvalid

Definition hip_runtime_api.h:694

hipDevResourceTypeWorkqueueConfig

@ hipDevResourceTypeWorkqueueConfig

Definition hip_runtime_api.h:696

hipArraySparseSubresourceTypeSparseLevel

@ hipArraySparseSubresourceTypeSparseLevel

Sparse level.

Definition hip_runtime_api.h:1990

hipArraySparseSubresourceTypeMiptail

@ hipArraySparseSubresourceTypeMiptail

Miptail.

Definition hip_runtime_api.h:1991

HIP_LAUNCH_CONFIG

Definition hip_runtime_api.h:2162

hipAccessPolicyWindow

Definition hip_runtime_api.h:1624

hipArrayMapInfo

Definition hip_runtime_api.h:1997

hipArrayMemoryRequirements

Definition hip_runtime_api.h:2178

hipBatchMemOpNodeParams

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

Definition hip_runtime_api.h:1148

hipChildGraphNodeParams

Definition hip_runtime_api.h:2047

hipDevResource

Definition hip_runtime_api.h:731

hipDevSmResource

Definition hip_runtime_api.h:714

hipDevSmResourceGroupParams

Definition hip_runtime_api.h:743

hipDevWorkqueueConfigResource

Definition hip_runtime_api.h:721

hipDevWorkqueueResource

Definition hip_runtime_api.h:727

hipDeviceArch_t

Definition hip_runtime_api.h:49

hipDeviceProp_t

Definition hip_runtime_api.h:95

hipEventRecordNodeParams

Definition hip_runtime_api.h:2062

hipEventWaitNodeParams

Definition hip_runtime_api.h:2055

hipExtDynDataPrefetchConfig

Configuration for dynamic data prefetch.

Definition hip_runtime_api.h:1707

hipExtDynDataPrefetchRegion

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

Definition hip_runtime_api.h:1683

hipExternalMemoryBufferDesc

Definition hip_runtime_api.h:1434

hipExternalMemoryHandleDesc

Definition hip_runtime_api.h:1420

hipExternalMemoryMipmappedArrayDesc

Definition hip_runtime_api.h:1440

hipExternalSemaphoreHandleDesc

Definition hip_runtime_api.h:1460

hipExternalSemaphoreSignalNodeParams

Definition hip_runtime_api.h:1937

hipExternalSemaphoreSignalParams

Definition hip_runtime_api.h:1474

hipExternalSemaphoreWaitNodeParams

Definition hip_runtime_api.h:1949

hipExternalSemaphoreWaitParams

Definition hip_runtime_api.h:1494

hipFuncAttributes

Definition hip_runtime_api.h:786

hipFunctionLaunchParams

Definition hip_runtime_api.h:1398

hipGraphEdgeData

Definition hip_runtime_api.h:2119

hipGraphInstantiateParams

Definition hip_runtime_api.h:1907

hipGraphNodeParams

Definition hip_runtime_api.h:2076

hipHostNodeParams

Definition hip_runtime_api.h:1580

hipIpcEventHandle_t

Definition hip_runtime_api.h:770

hipIpcMemHandle_t

Definition hip_runtime_api.h:767

hipKernelNodeParams

Definition hip_runtime_api.h:1584

hipLaunchAttribute

Definition hip_runtime_api.h:2138

hipLaunchConfig_t

Definition hip_runtime_api.h:2150

hipLaunchMemSyncDomainMap

Definition hip_runtime_api.h:1635

hipLaunchParams

Definition hip_runtime_api.h:1387

hipMemAccessDesc

Definition hip_runtime_api.h:1287

hipMemAllocNodeParams

Definition hip_runtime_api.h:1601

hipMemAllocationProp

Definition hip_runtime_api.h:1919

hipMemFabricHandle_t

Definition hip_runtime_api.h:773

hipMemFreeNodeParams

Definition hip_runtime_api.h:2069

hipMemPoolProps

Definition hip_runtime_api.h:1319

hipMemPoolPtrExportData

Definition hip_runtime_api.h:1335

hipMemcpyNodeParams

Definition hip_runtime_api.h:2038

hipMemsetParams

Definition hip_runtime_api.h:1592

hipPointerAttribute_t

Definition hip_runtime_api.h:264

hipStreamBatchMemOpParams::hipStreamMemOpFlushRemoteWritesParams_t

Definition hip_runtime_api.h:1110

hipStreamBatchMemOpParams::hipStreamMemOpMemoryBarrierParams_t

Definition hip_runtime_api.h:1114

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t

Definition hip_runtime_api.h:1090

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t

Definition hip_runtime_api.h:1100

hipUUID

Definition hip_runtime_api.h:80

hipLaunchAttributeValue

Definition hip_runtime_api.h:1734

hipStreamBatchMemOpParams

Union representing batch memory operation parameters for HIP streams.

Definition hip_runtime_api.h:1088

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.

hipMemAdvise

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

Advise about the usage of a given memory range to HIP.

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)

Advise about the usage of a given memory range to HIP.

hipModuleLaunchCooperativeKernelMultiDevice

hipError_t hipModuleLaunchCooperativeKernelMultiDevice(hipFunctionLaunchParams *launchParamsList, unsigned int numDevices, unsigned int flags)

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

hipLaunchCooperativeKernelMultiDevice

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

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

hipModuleLaunchCooperativeKernel

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

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

hipLaunchCooperativeKernel

hipError_t hipLaunchCooperativeKernel(const void *f, dim3 gridDim, dim3 blockDimX, void **kernelParams, unsigned int sharedMemBytes, hipStream_t stream)

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

hipModuleGetTexRef

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

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

hipLinkComplete

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

Completes the linking of the given program.

hipModuleGetFunctionCount

hipError_t hipModuleGetFunctionCount(unsigned int *count, hipModule_t mod)

Returns the number of functions within a module.

hipModuleLoad

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

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

hipModuleGetGlobal

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

Returns a global pointer from a module.

hipModuleLoadDataEx

hipError_t hipModuleLoadDataEx(hipModule_t *module, const void *image, unsigned int numOptions, hipJitOption *options, void **optionValues)

builds module from code object which resides in host memory. Image is pointer to that location....

hipLibraryUnload

hipError_t hipLibraryUnload(hipLibrary_t library)

Unload HIP Library.

hipLinkAddFile

hipError_t hipLinkAddFile(hipLinkState_t state, hipJitInputType type, const char *path, unsigned int numOptions, hipJitOption *options, void **optionValues)

Adds a file with bitcode to be linked with options.

hipGetFuncBySymbol

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

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

hipLinkDestroy

hipError_t hipLinkDestroy(hipLinkState_t state)

Deletes the linker instance.

hipLibraryLoadFromFile

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

Load hip Library from file.

hipMemGetHandleForAddressRange

hipError_t hipMemGetHandleForAddressRange(void *handle, hipDeviceptr_t dptr, size_t size, hipMemRangeHandleType handleType, unsigned long long flags)

Returns a handle for the address range requested.

hipLibraryEnumerateKernels

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

Retrieve kernel handles within a library.

hipLibraryGetKernel

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

Get Kernel object from library.

hipKernelGetName

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

Returns a Kernel Name.

hipModuleGetFunction

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

Function with kname will be extracted if present in module.

hipLinkCreate

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

Creates a linker instance with options.

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

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.

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

hipErrorStreamDetached

hipErrorStreamDetached

The stream is detached.

Definition hip_runtime_api.h:399

hipErrorIllegalAddress

hipErrorIllegalAddress

Definition hip_runtime_api.h:349

hipErrorMemoryAllocation

hipErrorMemoryAllocation

Memory allocation error.

Definition hip_runtime_api.h:295

hipErrorNotFound

hipErrorNotFound

Not found.

Definition hip_runtime_api.h:344

hipErrorProfilerDisabled

hipErrorProfilerDisabled

Definition hip_runtime_api.h:300

hipErrorInvalidDevicePointer

hipErrorInvalidDevicePointer

Invalid Device Pointer.

Definition hip_runtime_api.h:307

HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

@ HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

Definition hip_runtime_api.h:37

HIP_ERROR_INVALID_VALUE

@ HIP_ERROR_INVALID_VALUE

Definition hip_runtime_api.h:35

HIP_SUCCESS

@ HIP_SUCCESS

Definition hip_runtime_api.h:34

HIP_ERROR_NOT_INITIALIZED

@ HIP_ERROR_NOT_INITIALIZED

Definition hip_runtime_api.h:36

hipErrorRuntimeMemory

hipErrorRuntimeMemory

Definition hip_runtime_api.h:402

hipErrorInvalidImage

hipErrorInvalidImage

Invalid image.

Definition hip_runtime_api.h:315

hipErrorPeerAccessUnsupported

hipErrorPeerAccessUnsupported

Definition hip_runtime_api.h:332

hipErrorArrayIsMapped

hipErrorArrayIsMapped

Definition hip_runtime_api.h:322

hipErrorStreamCaptureIsolation

hipErrorStreamCaptureIsolation

Definition hip_runtime_api.h:377

hipErrorInvalidKernelFile

hipErrorInvalidKernelFile

In CUDA DRV, it is CUDA_ERROR_INVALID_PTX.

Definition hip_runtime_api.h:333

hipErrorNotMapped

hipErrorNotMapped

Definition hip_runtime_api.h:326

hipErrorInvalidClusterSize

hipErrorInvalidClusterSize

calculations

Definition hip_runtime_api.h:406

hipErrorGraphExecUpdateFailure

hipErrorGraphExecUpdateFailure

Definition hip_runtime_api.h:390

hipErrorNotInitialized

hipErrorNotInitialized

Invalid not initialized.

Definition hip_runtime_api.h:296

hipErrorInvalidResourceHandle

hipErrorInvalidResourceHandle

Resource handle (hipEvent_t or hipStream_t) invalid.

Definition hip_runtime_api.h:342

hipErrorSharedObjectInitFailed

hipErrorSharedObjectInitFailed

Failed to initialize shared object.

Definition hip_runtime_api.h:338

hipErrorInvalidPitchValue

hipErrorInvalidPitchValue

Invalid pitch value.

Definition hip_runtime_api.h:305

hipErrorNoBinaryForGpu

hipErrorNoBinaryForGpu

Definition hip_runtime_api.h:324

hipErrorInvalidContext

hipErrorInvalidContext

Produced when input context is invalid.

Definition hip_runtime_api.h:316

hipErrorStreamCaptureUnsupported

hipErrorStreamCaptureUnsupported

Definition hip_runtime_api.h:368

hipErrorPeerAccessNotEnabled

hipErrorPeerAccessNotEnabled

Peer access was never enabled from the current device.

Definition hip_runtime_api.h:354

hipErrorOperatingSystem

hipErrorOperatingSystem

Not the correct operating system.

Definition hip_runtime_api.h:339

hipErrorStreamCaptureUnjoined

hipErrorStreamCaptureUnjoined

Definition hip_runtime_api.h:375

hipErrorInitializationError

hipErrorInitializationError

Definition hip_runtime_api.h:298

hipErrorNotMappedAsPointer

hipErrorNotMappedAsPointer

Definition hip_runtime_api.h:328

hipErrorPriorLaunchFailure

hipErrorPriorLaunchFailure

Definition hip_runtime_api.h:311

hipErrorContextIsDestroyed

hipErrorContextIsDestroyed

The context is already destroyed.

Definition hip_runtime_api.h:356

hipErrorInvalidValue

hipErrorInvalidValue

Definition hip_runtime_api.h:291

hipErrorLaunchTimeOut

hipErrorLaunchTimeOut

Timeout for the launch.

Definition hip_runtime_api.h:351

hipErrorUnmapFailed

hipErrorUnmapFailed

Definition hip_runtime_api.h:321

hipErrorSetOnActiveProcess

hipErrorSetOnActiveProcess

The process is active.

Definition hip_runtime_api.h:355

hipErrorFileNotFound

hipErrorFileNotFound

the file is not found.

Definition hip_runtime_api.h:336

hipErrorLaunchFailure

hipErrorLaunchFailure

An exception occurred on the device while executing a kernel.

Definition hip_runtime_api.h:362

hipErrorInvalidDevice

hipErrorInvalidDevice

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

Definition hip_runtime_api.h:314

hipErrorUnsupportedLimit

hipErrorUnsupportedLimit

Unsupported limit.

Definition hip_runtime_api.h:330

hipErrorMapBufferObjectFailed

hipErrorMapBufferObjectFailed

Produced when the IPC memory attach failed from ROCr.

Definition hip_runtime_api.h:320

hipErrorHostMemoryAlreadyRegistered

hipErrorHostMemoryAlreadyRegistered

Definition hip_runtime_api.h:358

hipErrorMissingConfiguration

hipErrorMissingConfiguration

Definition hip_runtime_api.h:310

hipErrorSharedObjectSymbolNotFound

hipErrorSharedObjectSymbolNotFound

Definition hip_runtime_api.h:337

hipErrorECCNotCorrectable

hipErrorECCNotCorrectable

Definition hip_runtime_api.h:329

hipErrorStreamCaptureWrongThread

hipErrorStreamCaptureWrongThread

Definition hip_runtime_api.h:386

hipErrorAssert

hipErrorAssert

Produced when the kernel calls assert.

Definition hip_runtime_api.h:357

hipErrorContextAlreadyInUse

hipErrorContextAlreadyInUse

The context is already in use.

Definition hip_runtime_api.h:331

hipErrorNotReady

hipErrorNotReady

Definition hip_runtime_api.h:345

hipErrorInvalidSource

hipErrorInvalidSource

Invalid source.

Definition hip_runtime_api.h:335

hipErrorLaunchOutOfResources

hipErrorLaunchOutOfResources

Out of resources error.

Definition hip_runtime_api.h:350

hipErrorInvalidDeviceFunction

hipErrorInvalidDeviceFunction

Invalid device function.

Definition hip_runtime_api.h:312

hipErrorCooperativeLaunchTooLarge

hipErrorCooperativeLaunchTooLarge

Definition hip_runtime_api.h:363

hipErrorAlreadyMapped

hipErrorAlreadyMapped

Definition hip_runtime_api.h:323

hipErrorInvalidResourceType

hipErrorInvalidResourceType

Resource type is not valid for the operation.

Definition hip_runtime_api.h:396

hipErrorProfilerNotInitialized

hipErrorProfilerNotInitialized

Definition hip_runtime_api.h:301

hipErrorProfilerAlreadyStarted

hipErrorProfilerAlreadyStarted

Definition hip_runtime_api.h:302

hipErrorInvalidChannelDescriptor

hipErrorInvalidChannelDescriptor

Invalid channel descriptor.

Definition hip_runtime_api.h:394

hipErrorNoDevice

hipErrorNoDevice

Call to hipGetDeviceCount returned 0 devices.

Definition hip_runtime_api.h:313

hipErrorMapFailed

hipErrorMapFailed

Definition hip_runtime_api.h:318

hipErrorStreamCaptureInvalidated

hipErrorStreamCaptureInvalidated

Definition hip_runtime_api.h:370

hipErrorProfilerAlreadyStopped

hipErrorProfilerAlreadyStopped

Definition hip_runtime_api.h:303

hipErrorDeinitialized

hipErrorDeinitialized

Deinitialized.

Definition hip_runtime_api.h:299

hipErrorPeerAccessAlreadyEnabled

hipErrorPeerAccessAlreadyEnabled

Definition hip_runtime_api.h:352

hipErrorNotMappedAsArray

hipErrorNotMappedAsArray

Definition hip_runtime_api.h:327

hipErrorNotSupported

hipErrorNotSupported

Produced when the hip API is not supported/implemented.

Definition hip_runtime_api.h:367

hipErrorInvalidConfiguration

hipErrorInvalidConfiguration

Invalide configuration.

Definition hip_runtime_api.h:304

hipErrorStreamCaptureImplicit

hipErrorStreamCaptureImplicit

Definition hip_runtime_api.h:381

hipErrorStreamCaptureMerge

hipErrorStreamCaptureMerge

Definition hip_runtime_api.h:372

hipErrorInvalidGraphicsContext

hipErrorInvalidGraphicsContext

Definition hip_runtime_api.h:334

hipErrorIllegalState

hipErrorIllegalState

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

Definition hip_runtime_api.h:343

hipErrorOutOfMemory

hipErrorOutOfMemory

out of memory range.

Definition hip_runtime_api.h:293

hipErrorInvalidSymbol

hipErrorInvalidSymbol

Invalid symbol.

Definition hip_runtime_api.h:306

hipSuccess

hipSuccess

Successful completion.

Definition hip_runtime_api.h:290

hipErrorUnknown

hipErrorUnknown

Unknown error.

Definition hip_runtime_api.h:400

hipErrorInvalidHandle

hipErrorInvalidHandle

Invalide handle.

Definition hip_runtime_api.h:340

hipErrorStreamCaptureUnmatched

hipErrorStreamCaptureUnmatched

The capture was not initiated in this stream.

Definition hip_runtime_api.h:374

hipErrorCapturedEvent

hipErrorCapturedEvent

Definition hip_runtime_api.h:384

hipErrorAlreadyAcquired

hipErrorAlreadyAcquired

Definition hip_runtime_api.h:325

hipErrorInsufficientDriver

hipErrorInsufficientDriver

Definition hip_runtime_api.h:309

hipErrorHostMemoryNotRegistered

hipErrorHostMemoryNotRegistered

Definition hip_runtime_api.h:360

hipErrorInvalidTexture

hipErrorInvalidTexture

Invalid texture.

Definition hip_runtime_api.h:395

hipErrorRuntimeOther

hipErrorRuntimeOther

Definition hip_runtime_api.h:404

hipErrorContextAlreadyCurrent

hipErrorContextAlreadyCurrent

Definition hip_runtime_api.h:317

hipErrorInvalidMemcpyDirection

hipErrorInvalidMemcpyDirection

Invalid memory copy direction.

Definition hip_runtime_api.h:308

hipErrorInvalidResourceConfiguration

hipErrorInvalidResourceConfiguration

Definition hip_runtime_api.h:397

linker_types.h

hip_impl

Definition hip_runtime_api.h:680

hip_impl::hip_init

hipError_t hip_init()

dim3

Definition hip_runtime_api.h:1375

dim3::y

uint32_t y

y

Definition hip_runtime_api.h:1377

dim3::z

uint32_t z

z

Definition hip_runtime_api.h:1378

dim3::x

uint32_t x

x

Definition hip_runtime_api.h:1376

dim3::dim3

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

Definition hip_runtime_api.h:1380

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