/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-6.2.1/include/hip/hip_runtime_api.h Source File

• include
• hip

hip_runtime_api.h

Go to the documentation of this file.

1/*

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

3

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

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

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

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

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

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

10

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

12all copies or substantial portions of the Software.

13

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

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

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

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

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

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

20THE SOFTWARE.

21*/

22

30#ifndef HIP_INCLUDE_HIP_HIP_RUNTIME_API_H

31#define HIP_INCLUDE_HIP_HIP_RUNTIME_API_H

32

33#include <string.h> // for getDeviceProp

34#include <hip/hip_version.h>

35#include <hip/hip_common.h>

36

37enum {

38 HIP_SUCCESS = 0,

39 HIP_ERROR_INVALID_VALUE,

40 HIP_ERROR_NOT_INITIALIZED,

41 HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

42};

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

53typedef struct {

54 // 32-bit Atomics

55 unsigned hasGlobalInt32Atomics : 1;

56 unsigned hasGlobalFloatAtomicExch : 1;

57 unsigned hasSharedInt32Atomics : 1;

58 unsigned hasSharedFloatAtomicExch : 1;

59 unsigned hasFloatAtomicAdd : 1;

60

61 // 64-bit Atomics

62 unsigned hasGlobalInt64Atomics : 1;

63 unsigned hasSharedInt64Atomics : 1;

64

65 // Doubles

66 unsigned hasDoubles : 1;

67

68 // Warp cross-lane operations

69 unsigned hasWarpVote : 1;

70 unsigned hasWarpBallot : 1;

71 unsigned hasWarpShuffle : 1;

72 unsigned hasFunnelShift : 1;

73

74 // Sync

75 unsigned hasThreadFenceSystem : 1;

76 unsigned hasSyncThreadsExt : 1;

77

78 // Misc

79 unsigned hasSurfaceFuncs : 1;

80 unsigned has3dGrid : 1;

81 unsigned hasDynamicParallelism : 1;

82} hipDeviceArch_t;

83

84typedef struct hipUUID_t {

85 char bytes[16];

86} hipUUID;

87

88//---

89// Common headers for both NVCC and HCC paths:

90

91#define hipGetDeviceProperties hipGetDevicePropertiesR0600

92#define hipDeviceProp_t hipDeviceProp_tR0600

93#define hipChooseDevice hipChooseDeviceR0600

94

99typedef struct hipDeviceProp_t {

100 char name[256];

101 hipUUID uuid;

102 char luid[8];

103 unsigned int luidDeviceNodeMask;

104 size_t totalGlobalMem;

105 size_t sharedMemPerBlock;

106 int regsPerBlock;

107 int warpSize;

108 size_t memPitch;

110 int maxThreadsPerBlock;

111 int maxThreadsDim[3];

112 int maxGridSize[3];

113 int clockRate;

114 size_t totalConstMem;

116 int major;

119 int minor;

122 size_t textureAlignment;

123 size_t texturePitchAlignment;

124 int deviceOverlap;

125 int multiProcessorCount;

126 int kernelExecTimeoutEnabled;

127 int integrated;

128 int canMapHostMemory;

129 int computeMode;

130 int maxTexture1D;

131 int maxTexture1DMipmap;

132 int maxTexture1DLinear;

133 int maxTexture2D[2];

134 int maxTexture2DMipmap[2];

135 int maxTexture2DLinear[3];

136 int maxTexture2DGather[2];

137 int maxTexture3D[3];

139 int maxTexture3DAlt[3];

140 int maxTextureCubemap;

141 int maxTexture1DLayered[2];

142 int maxTexture2DLayered[3];

143 int maxTextureCubemapLayered[2];

144 int maxSurface1D;

145 int maxSurface2D[2];

146 int maxSurface3D[3];

147 int maxSurface1DLayered[2];

148 int maxSurface2DLayered[3];

149 int maxSurfaceCubemap;

150 int maxSurfaceCubemapLayered[2];

151 size_t surfaceAlignment;

152 int concurrentKernels;

153 int ECCEnabled;

154 int pciBusID;

155 int pciDeviceID;

156 int pciDomainID;

157 int tccDriver;

158 int asyncEngineCount;

159 int unifiedAddressing;

160 int memoryClockRate;

161 int memoryBusWidth;

162 int l2CacheSize;

163 int persistingL2CacheMaxSize;

164 int maxThreadsPerMultiProcessor;

165 int streamPrioritiesSupported;

166 int globalL1CacheSupported;

167 int localL1CacheSupported;

168 size_t sharedMemPerMultiprocessor;

169 int regsPerMultiprocessor;

170 int managedMemory;

171 int isMultiGpuBoard;

172 int multiGpuBoardGroupID;

173 int hostNativeAtomicSupported;

174 int singleToDoublePrecisionPerfRatio;

175 int pageableMemoryAccess;

177 int concurrentManagedAccess;

179 int computePreemptionSupported;

180 int canUseHostPointerForRegisteredMem;

182 int cooperativeLaunch;

183 int cooperativeMultiDeviceLaunch;

185 size_t

186 sharedMemPerBlockOptin;

187 int pageableMemoryAccessUsesHostPageTables;

189 int directManagedMemAccessFromHost;

191 int maxBlocksPerMultiProcessor;

192 int accessPolicyMaxWindowSize;

193 size_t reservedSharedMemPerBlock;

194 int hostRegisterSupported;

195 int sparseHipArraySupported;

196 int hostRegisterReadOnlySupported;

198 int timelineSemaphoreInteropSupported;

199 int memoryPoolsSupported;

200 int gpuDirectRDMASupported;

201 unsigned int gpuDirectRDMAFlushWritesOptions;

203 int gpuDirectRDMAWritesOrdering;

204 unsigned int

205 memoryPoolSupportedHandleTypes;

206 int deferredMappingHipArraySupported;

208 int ipcEventSupported;

209 int clusterLaunch;

210 int unifiedFunctionPointers;

211 int reserved[63];

212

213 int hipReserved[32];

214

215 /* HIP Only struct members */

216 char gcnArchName[256];

217 size_t maxSharedMemoryPerMultiProcessor;

218 int clockInstructionRate;

220 hipDeviceArch_t arch;

221 unsigned int* hdpMemFlushCntl;

222 unsigned int* hdpRegFlushCntl;

223 int cooperativeMultiDeviceUnmatchedFunc;

226 int cooperativeMultiDeviceUnmatchedGridDim;

229 int cooperativeMultiDeviceUnmatchedBlockDim;

232 int cooperativeMultiDeviceUnmatchedSharedMem;

235 int isLargeBar;

236 int asicRevision;

237} hipDeviceProp_t;

238

245typedef enum hipMemoryType {

246 hipMemoryTypeUnregistered = 0,

247 hipMemoryTypeHost = 1,

248 hipMemoryTypeDevice = 2,

250 hipMemoryTypeManaged = 3,

253 hipMemoryTypeArray = 10,

255 hipMemoryTypeUnified = 11

256

257} hipMemoryType;

258

262typedef struct hipPointerAttribute_t {

263 enum hipMemoryType type;

264 int device;

265 void* devicePointer;

266 void* hostPointer;

267 int isManaged;

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

269 /* peers? */

270} hipPointerAttribute_t;

271

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

273// we can make that yield a warning

274#if __cplusplus >= 201703L

275#define __HIP_NODISCARD [[nodiscard]]

276#else

277#define __HIP_NODISCARD

278#endif

279

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

285// NVCC and HCC paths Also update the hipCUDAErrorTohipError function in NVCC path.

286

287typedef enum __HIP_NODISCARD hipError_t {

288 hipSuccess = 0,

289 hipErrorInvalidValue = 1,

291 hipErrorOutOfMemory = 2,

292 // Deprecated

293 hipErrorMemoryAllocation = 2,

294 hipErrorNotInitialized = 3,

295 // Deprecated

296 hipErrorInitializationError = 3,

297 hipErrorDeinitialized = 4,

298 hipErrorProfilerDisabled = 5,

299 hipErrorProfilerNotInitialized = 6,

300 hipErrorProfilerAlreadyStarted = 7,

301 hipErrorProfilerAlreadyStopped = 8,

302 hipErrorInvalidConfiguration = 9,

303 hipErrorInvalidPitchValue = 12,

304 hipErrorInvalidSymbol = 13,

305 hipErrorInvalidDevicePointer = 17,

306 hipErrorInvalidMemcpyDirection = 21,

307 hipErrorInsufficientDriver = 35,

308 hipErrorMissingConfiguration = 52,

309 hipErrorPriorLaunchFailure = 53,

310 hipErrorInvalidDeviceFunction = 98,

311 hipErrorNoDevice = 100,

312 hipErrorInvalidDevice = 101,

313 hipErrorInvalidImage = 200,

314 hipErrorInvalidContext = 201,

315 hipErrorContextAlreadyCurrent = 202,

316 hipErrorMapFailed = 205,

317 // Deprecated

318 hipErrorMapBufferObjectFailed = 205,

319 hipErrorUnmapFailed = 206,

320 hipErrorArrayIsMapped = 207,

321 hipErrorAlreadyMapped = 208,

322 hipErrorNoBinaryForGpu = 209,

323 hipErrorAlreadyAcquired = 210,

324 hipErrorNotMapped = 211,

325 hipErrorNotMappedAsArray = 212,

326 hipErrorNotMappedAsPointer = 213,

327 hipErrorECCNotCorrectable = 214,

328 hipErrorUnsupportedLimit = 215,

329 hipErrorContextAlreadyInUse = 216,

330 hipErrorPeerAccessUnsupported = 217,

331 hipErrorInvalidKernelFile = 218,

332 hipErrorInvalidGraphicsContext = 219,

333 hipErrorInvalidSource = 300,

334 hipErrorFileNotFound = 301,

335 hipErrorSharedObjectSymbolNotFound = 302,

336 hipErrorSharedObjectInitFailed = 303,

337 hipErrorOperatingSystem = 304,

338 hipErrorInvalidHandle = 400,

339 // Deprecated

340 hipErrorInvalidResourceHandle = 400,

341 hipErrorIllegalState = 401,

342 hipErrorNotFound = 500,

343 hipErrorNotReady = 600,

347 hipErrorIllegalAddress = 700,

348 hipErrorLaunchOutOfResources = 701,

349 hipErrorLaunchTimeOut = 702,

350 hipErrorPeerAccessAlreadyEnabled = 704,

352 hipErrorPeerAccessNotEnabled = 705,

353 hipErrorSetOnActiveProcess = 708,

354 hipErrorContextIsDestroyed = 709,

355 hipErrorAssert = 710,

356 hipErrorHostMemoryAlreadyRegistered = 712,

358 hipErrorHostMemoryNotRegistered = 713,

360 hipErrorLaunchFailure = 719,

361 hipErrorCooperativeLaunchTooLarge = 720,

365 hipErrorNotSupported = 801,

366 hipErrorStreamCaptureUnsupported = 900,

368 hipErrorStreamCaptureInvalidated = 901,

370 hipErrorStreamCaptureMerge = 902,

372 hipErrorStreamCaptureUnmatched = 903,

373 hipErrorStreamCaptureUnjoined = 904,

375 hipErrorStreamCaptureIsolation = 905,

379 hipErrorStreamCaptureImplicit = 906,

382 hipErrorCapturedEvent = 907,

384 hipErrorStreamCaptureWrongThread = 908,

388 hipErrorGraphExecUpdateFailure = 910,

392 hipErrorUnknown = 999,

393 // HSA Runtime Error Codes start here.

394 hipErrorRuntimeMemory = 1052,

396 hipErrorRuntimeOther = 1053,

398 hipErrorTbd

399} hipError_t;

400

401#undef __HIP_NODISCARD

402

407typedef enum hipDeviceAttribute_t {

408 hipDeviceAttributeCudaCompatibleBegin = 0,

409

410 hipDeviceAttributeEccEnabled = hipDeviceAttributeCudaCompatibleBegin,

411 hipDeviceAttributeAccessPolicyMaxWindowSize,

412 hipDeviceAttributeAsyncEngineCount,

413 hipDeviceAttributeCanMapHostMemory,

414 hipDeviceAttributeCanUseHostPointerForRegisteredMem,

416 hipDeviceAttributeClockRate,

417 hipDeviceAttributeComputeMode,

418 hipDeviceAttributeComputePreemptionSupported,

419 hipDeviceAttributeConcurrentKernels,

420 hipDeviceAttributeConcurrentManagedAccess,

421 hipDeviceAttributeCooperativeLaunch,

422 hipDeviceAttributeCooperativeMultiDeviceLaunch,

423 hipDeviceAttributeDeviceOverlap,

425 hipDeviceAttributeDirectManagedMemAccessFromHost,

427 hipDeviceAttributeGlobalL1CacheSupported,

428 hipDeviceAttributeHostNativeAtomicSupported,

429 hipDeviceAttributeIntegrated,

430 hipDeviceAttributeIsMultiGpuBoard,

431 hipDeviceAttributeKernelExecTimeout,

432 hipDeviceAttributeL2CacheSize,

433 hipDeviceAttributeLocalL1CacheSupported,

434 hipDeviceAttributeLuid,

435 hipDeviceAttributeLuidDeviceNodeMask,

436 hipDeviceAttributeComputeCapabilityMajor,

437 hipDeviceAttributeManagedMemory,

438 hipDeviceAttributeMaxBlocksPerMultiProcessor,

439 hipDeviceAttributeMaxBlockDimX,

440 hipDeviceAttributeMaxBlockDimY,

441 hipDeviceAttributeMaxBlockDimZ,

442 hipDeviceAttributeMaxGridDimX,

443 hipDeviceAttributeMaxGridDimY,

444 hipDeviceAttributeMaxGridDimZ,

445 hipDeviceAttributeMaxSurface1D,

446 hipDeviceAttributeMaxSurface1DLayered,

447 hipDeviceAttributeMaxSurface2D,

448 hipDeviceAttributeMaxSurface2DLayered,

449 hipDeviceAttributeMaxSurface3D,

450 hipDeviceAttributeMaxSurfaceCubemap,

451 hipDeviceAttributeMaxSurfaceCubemapLayered,

452 hipDeviceAttributeMaxTexture1DWidth,

453 hipDeviceAttributeMaxTexture1DLayered,

454 hipDeviceAttributeMaxTexture1DLinear,

456 hipDeviceAttributeMaxTexture1DMipmap,

457 hipDeviceAttributeMaxTexture2DWidth,

458 hipDeviceAttributeMaxTexture2DHeight,

459 hipDeviceAttributeMaxTexture2DGather,

460 hipDeviceAttributeMaxTexture2DLayered,

461 hipDeviceAttributeMaxTexture2DLinear,

462 hipDeviceAttributeMaxTexture2DMipmap,

463 hipDeviceAttributeMaxTexture3DWidth,

464 hipDeviceAttributeMaxTexture3DHeight,

465 hipDeviceAttributeMaxTexture3DDepth,

466 hipDeviceAttributeMaxTexture3DAlt,

467 hipDeviceAttributeMaxTextureCubemap,

468 hipDeviceAttributeMaxTextureCubemapLayered,

469 hipDeviceAttributeMaxThreadsDim,

470 hipDeviceAttributeMaxThreadsPerBlock,

471 hipDeviceAttributeMaxThreadsPerMultiProcessor,

472 hipDeviceAttributeMaxPitch,

473 hipDeviceAttributeMemoryBusWidth,

474 hipDeviceAttributeMemoryClockRate,

475 hipDeviceAttributeComputeCapabilityMinor,

476 hipDeviceAttributeMultiGpuBoardGroupID,

477 hipDeviceAttributeMultiprocessorCount,

478 hipDeviceAttributeUnused1,

479 hipDeviceAttributePageableMemoryAccess,

481 hipDeviceAttributePageableMemoryAccessUsesHostPageTables,

482 hipDeviceAttributePciBusId,

483 hipDeviceAttributePciDeviceId,

484 hipDeviceAttributePciDomainID,

485 hipDeviceAttributePersistingL2CacheMaxSize,

486 hipDeviceAttributeMaxRegistersPerBlock,

488 hipDeviceAttributeMaxRegistersPerMultiprocessor,

489 hipDeviceAttributeReservedSharedMemPerBlock,

490 hipDeviceAttributeMaxSharedMemoryPerBlock,

491 hipDeviceAttributeSharedMemPerBlockOptin,

492 hipDeviceAttributeSharedMemPerMultiprocessor,

493 hipDeviceAttributeSingleToDoublePrecisionPerfRatio,

494 hipDeviceAttributeStreamPrioritiesSupported,

495 hipDeviceAttributeSurfaceAlignment,

496 hipDeviceAttributeTccDriver,

497 hipDeviceAttributeTextureAlignment,

498 hipDeviceAttributeTexturePitchAlignment,

499 hipDeviceAttributeTotalConstantMemory,

500 hipDeviceAttributeTotalGlobalMem,

501 hipDeviceAttributeUnifiedAddressing,

502 hipDeviceAttributeUnused2,

503 hipDeviceAttributeWarpSize,

504 hipDeviceAttributeMemoryPoolsSupported,

505 hipDeviceAttributeVirtualMemoryManagementSupported,

506 hipDeviceAttributeHostRegisterSupported,

507 hipDeviceAttributeMemoryPoolSupportedHandleTypes,

508

509 hipDeviceAttributeCudaCompatibleEnd = 9999,

510 hipDeviceAttributeAmdSpecificBegin = 10000,

511

512 hipDeviceAttributeClockInstructionRate = hipDeviceAttributeAmdSpecificBegin,

513 hipDeviceAttributeUnused3,

514 hipDeviceAttributeMaxSharedMemoryPerMultiprocessor,

515 hipDeviceAttributeUnused4,

516 hipDeviceAttributeUnused5,

517 hipDeviceAttributeHdpMemFlushCntl,

518 hipDeviceAttributeHdpRegFlushCntl,

519 hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc,

521 hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim,

523 hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim,

525 hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem,

527 hipDeviceAttributeIsLargeBar,

528 hipDeviceAttributeAsicRevision,

529 hipDeviceAttributeCanUseStreamWaitValue,

531 hipDeviceAttributeImageSupport,

532 hipDeviceAttributePhysicalMultiProcessorCount,

534 hipDeviceAttributeFineGrainSupport,

535 hipDeviceAttributeWallClockRate,

536

537 hipDeviceAttributeAmdSpecificEnd = 19999,

538 hipDeviceAttributeVendorSpecificBegin = 20000,

539 // Extended attributes for vendors

540} hipDeviceAttribute_t;

541

542typedef enum hipDriverProcAddressQueryResult {

543 HIP_GET_PROC_ADDRESS_SUCCESS = 0,

544 HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND = 1,

545 HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT = 2

546} hipDriverProcAddressQueryResult;

547

548enum hipComputeMode {

549 hipComputeModeDefault = 0,

550 hipComputeModeExclusive = 1,

551 hipComputeModeProhibited = 2,

552 hipComputeModeExclusiveProcess = 3

553};

554

555enum hipFlushGPUDirectRDMAWritesOptions {

556 hipFlushGPUDirectRDMAWritesOptionHost = 1 << 0,

557 hipFlushGPUDirectRDMAWritesOptionMemOps = 1 << 1

558};

559

560enum hipGPUDirectRDMAWritesOrdering {

561 hipGPUDirectRDMAWritesOrderingNone = 0,

562 hipGPUDirectRDMAWritesOrderingOwner = 100,

563 hipGPUDirectRDMAWritesOrderingAllDevices = 200

564};

565

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

567

568#include <stdint.h>

569#include <stddef.h>

570#ifndef GENERIC_GRID_LAUNCH

571#define GENERIC_GRID_LAUNCH 1

572#endif

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

574#include <hip/driver_types.h>

575#include <hip/texture_types.h>

576#include <hip/surface_types.h>

577#if defined(_MSC_VER)

578#define DEPRECATED(msg) __declspec(deprecated(msg))

579#else // !defined(_MSC_VER)

580#define DEPRECATED(msg) __attribute__ ((deprecated(msg)))

581#endif // !defined(_MSC_VER)

582#define DEPRECATED_MSG "This API is marked as deprecated and may not be supported in future releases. For more details please refer https://github.com/ROCm/HIP/blob/develop/docs/reference/deprecated_api_list.md"

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

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

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

586#ifdef __cplusplus

587 #define __dparm(x) \

588 = x

589#else

590 #define __dparm(x)

591#endif

592#ifdef __GNUC__

593#pragma GCC visibility push (default)

594#endif

595#ifdef __cplusplus

596namespace hip_impl {

597hipError_t hip_init();

598} // namespace hip_impl

599#endif

600// Structure definitions:

601#ifdef __cplusplus

602extern "C" {

603#endif

604//---

605// API-visible structures

606typedef struct ihipCtx_t* hipCtx_t;

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

608typedef int hipDevice_t;

609typedef enum hipDeviceP2PAttr {

610 hipDevP2PAttrPerformanceRank = 0,

611 hipDevP2PAttrAccessSupported,

612 hipDevP2PAttrNativeAtomicSupported,

613 hipDevP2PAttrHipArrayAccessSupported

614} hipDeviceP2PAttr;

615typedef struct ihipStream_t* hipStream_t;

616#define hipIpcMemLazyEnablePeerAccess 0x01

617#define HIP_IPC_HANDLE_SIZE 64

618typedef struct hipIpcMemHandle_st {

619 char reserved[HIP_IPC_HANDLE_SIZE];

620} hipIpcMemHandle_t;

621typedef struct hipIpcEventHandle_st {

622 char reserved[HIP_IPC_HANDLE_SIZE];

623} hipIpcEventHandle_t;

624typedef struct ihipModule_t* hipModule_t;

625typedef struct ihipModuleSymbol_t* hipFunction_t;

629typedef struct ihipMemPoolHandle_t* hipMemPool_t;

630

631typedef struct hipFuncAttributes {

632 int binaryVersion;

633 int cacheModeCA;

634 size_t constSizeBytes;

635 size_t localSizeBytes;

636 int maxDynamicSharedSizeBytes;

637 int maxThreadsPerBlock;

638 int numRegs;

639 int preferredShmemCarveout;

640 int ptxVersion;

641 size_t sharedSizeBytes;

642} hipFuncAttributes;

643typedef struct ihipEvent_t* hipEvent_t;

644

651enum hipLimit_t {

652 hipLimitStackSize = 0x0,

655 hipLimitPrintfFifoSize = 0x01,

657 hipLimitMallocHeapSize = 0x02,

659 hipLimitRange

660};

664//Flags that can be used with hipStreamCreateWithFlags.

666#define hipStreamDefault 0x00

667

669#define hipStreamNonBlocking 0x01

670

671//Flags that can be used with hipEventCreateWithFlags.

673#define hipEventDefault 0x0

674

676#define hipEventBlockingSync 0x1

677

679#define hipEventDisableTiming 0x2

680

682#define hipEventInterprocess 0x4

683

692#define hipEventDisableSystemFence 0x20000000

693

696#define hipEventReleaseToDevice 0x40000000

697

700#define hipEventReleaseToSystem 0x80000000

701

702//Flags that can be used with hipHostMalloc.

704#define hipHostMallocDefault 0x0

705

707#define hipHostMallocPortable 0x1

708

711#define hipHostMallocMapped 0x2

712

716#define hipHostMallocWriteCombined 0x4

717

722#define hipHostMallocNumaUser 0x20000000

723

725#define hipHostMallocCoherent 0x40000000

726

728#define hipHostMallocNonCoherent 0x80000000

729

731#define hipMemAttachGlobal 0x01

732

734#define hipMemAttachHost 0x02

735

737#define hipMemAttachSingle 0x04

738

739#define hipDeviceMallocDefault 0x0

740

742#define hipDeviceMallocFinegrained 0x1

743

745#define hipMallocSignalMemory 0x2

746

748#define hipDeviceMallocUncached 0x3

749

751#define hipDeviceMallocContiguous 0x4

752

753//Flags that can be used with hipHostRegister.

755#define hipHostRegisterDefault 0x0

756

758#define hipHostRegisterPortable 0x1

759

762#define hipHostRegisterMapped 0x2

763

765#define hipHostRegisterIoMemory 0x4

766

768#define hipHostRegisterReadOnly 0x08

769

771#define hipExtHostRegisterCoarseGrained 0x8

772

774#define hipDeviceScheduleAuto 0x0

775

778#define hipDeviceScheduleSpin 0x1

779

782#define hipDeviceScheduleYield 0x2

783#define hipDeviceScheduleBlockingSync 0x4

784#define hipDeviceScheduleMask 0x7

785#define hipDeviceMapHost 0x8

786#define hipDeviceLmemResizeToMax 0x10

788#define hipArrayDefault 0x00

789#define hipArrayLayered 0x01

790#define hipArraySurfaceLoadStore 0x02

791#define hipArrayCubemap 0x04

792#define hipArrayTextureGather 0x08

793#define hipOccupancyDefault 0x00

794#define hipOccupancyDisableCachingOverride 0x01

795#define hipCooperativeLaunchMultiDeviceNoPreSync 0x01

796#define hipCooperativeLaunchMultiDeviceNoPostSync 0x02

797#define hipCpuDeviceId ((int)-1)

798#define hipInvalidDeviceId ((int)-2)

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

801#define hipExtAnyOrderLaunch 0x01

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

803#define hipStreamWaitValueGte 0x0

804#define hipStreamWaitValueEq 0x1

805#define hipStreamWaitValueAnd 0x2

806#define hipStreamWaitValueNor 0x3

807// Stream per thread

809#define hipStreamPerThread ((hipStream_t)2)

810

811#define hipStreamLegacy ((hipStream_t)1)

812

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

814#define hipExternalMemoryDedicated 0x1

820typedef enum hipMemoryAdvise {

821 hipMemAdviseSetReadMostly = 1,

823 hipMemAdviseUnsetReadMostly = 2,

824 hipMemAdviseSetPreferredLocation = 3,

826 hipMemAdviseUnsetPreferredLocation = 4,

827 hipMemAdviseSetAccessedBy = 5,

829 hipMemAdviseUnsetAccessedBy = 6,

831 hipMemAdviseSetCoarseGrain = 100,

836 hipMemAdviseUnsetCoarseGrain = 101

837} hipMemoryAdvise;

841typedef enum hipMemRangeCoherencyMode {

842 hipMemRangeCoherencyModeFineGrain = 0,

844 hipMemRangeCoherencyModeCoarseGrain = 1,

846 hipMemRangeCoherencyModeIndeterminate = 2

849} hipMemRangeCoherencyMode;

853typedef enum hipMemRangeAttribute {

854 hipMemRangeAttributeReadMostly = 1,

856 hipMemRangeAttributePreferredLocation = 2,

857 hipMemRangeAttributeAccessedBy = 3,

859 hipMemRangeAttributeLastPrefetchLocation = 4,

861 hipMemRangeAttributeCoherencyMode = 100,

863} hipMemRangeAttribute;

864

868typedef enum hipMemPoolAttr

869{

878 hipMemPoolReuseFollowEventDependencies = 0x1,

884 hipMemPoolReuseAllowOpportunistic = 0x2,

891 hipMemPoolReuseAllowInternalDependencies = 0x3,

900 hipMemPoolAttrReleaseThreshold = 0x4,

905 hipMemPoolAttrReservedMemCurrent = 0x5,

911 hipMemPoolAttrReservedMemHigh = 0x6,

916 hipMemPoolAttrUsedMemCurrent = 0x7,

922 hipMemPoolAttrUsedMemHigh = 0x8

923} hipMemPoolAttr;

927 typedef enum hipMemLocationType {

928 hipMemLocationTypeInvalid = 0,

929 hipMemLocationTypeDevice = 1

930} hipMemLocationType;

936typedef struct hipMemLocation {

937 hipMemLocationType type;

938 int id;

939} hipMemLocation;

944typedef enum hipMemAccessFlags {

945 hipMemAccessFlagsProtNone = 0,

946 hipMemAccessFlagsProtRead = 1,

947 hipMemAccessFlagsProtReadWrite = 3

948} hipMemAccessFlags;

952typedef struct hipMemAccessDesc {

953 hipMemLocation location;

954 hipMemAccessFlags flags;

955} hipMemAccessDesc;

959typedef enum hipMemAllocationType {

960 hipMemAllocationTypeInvalid = 0x0,

964 hipMemAllocationTypePinned = 0x1,

965 hipMemAllocationTypeMax = 0x7FFFFFFF

966} hipMemAllocationType;

971typedef enum hipMemAllocationHandleType {

972 hipMemHandleTypeNone = 0x0,

973 hipMemHandleTypePosixFileDescriptor = 0x1,

974 hipMemHandleTypeWin32 = 0x2,

975 hipMemHandleTypeWin32Kmt = 0x4

976} hipMemAllocationHandleType;

980typedef struct hipMemPoolProps {

981 hipMemAllocationType allocType;

982 hipMemAllocationHandleType handleTypes;

983 hipMemLocation location;

987 void* win32SecurityAttributes;

988 size_t maxSize;

989 unsigned char reserved[56];

990} hipMemPoolProps;

994typedef struct hipMemPoolPtrExportData {

995 unsigned char reserved[64];

996} hipMemPoolPtrExportData;

997

1001typedef enum hipJitOption {

1002 hipJitOptionMaxRegisters = 0,

1003 hipJitOptionThreadsPerBlock,

1004 hipJitOptionWallTime,

1005 hipJitOptionInfoLogBuffer,

1006 hipJitOptionInfoLogBufferSizeBytes,

1007 hipJitOptionErrorLogBuffer,

1008 hipJitOptionErrorLogBufferSizeBytes,

1009 hipJitOptionOptimizationLevel,

1010 hipJitOptionTargetFromContext,

1011 hipJitOptionTarget,

1012 hipJitOptionFallbackStrategy,

1013 hipJitOptionGenerateDebugInfo,

1014 hipJitOptionLogVerbose,

1015 hipJitOptionGenerateLineInfo,

1016 hipJitOptionCacheMode,

1017 hipJitOptionSm3xOpt,

1018 hipJitOptionFastCompile,

1019 hipJitOptionNumOptions

1020} hipJitOption;

1024typedef enum hipFuncAttribute {

1025 hipFuncAttributeMaxDynamicSharedMemorySize = 8,

1026 hipFuncAttributePreferredSharedMemoryCarveout = 9,

1027 hipFuncAttributeMax

1028} hipFuncAttribute;

1032typedef enum hipFuncCache_t {

1033 hipFuncCachePreferNone,

1034 hipFuncCachePreferShared,

1035 hipFuncCachePreferL1,

1036 hipFuncCachePreferEqual,

1037} hipFuncCache_t;

1041typedef enum hipSharedMemConfig {

1042 hipSharedMemBankSizeDefault,

1043 hipSharedMemBankSizeFourByte,

1045 hipSharedMemBankSizeEightByte

1047} hipSharedMemConfig;

1051typedef struct dim3 {

1052 uint32_t x;

1053 uint32_t y;

1054 uint32_t z;

1055#ifdef __cplusplus

1056 constexpr __host__ __device__ dim3(uint32_t _x = 1, uint32_t _y = 1, uint32_t _z = 1) : x(_x), y(_y), z(_z){};

1057#endif

1058} dim3;

1062typedef struct hipLaunchParams_t {

1063 void* func;

1064 dim3 gridDim;

1065 dim3 blockDim;

1066 void **args;

1067 size_t sharedMem;

1068 hipStream_t stream;

1069} hipLaunchParams;

1073typedef struct hipFunctionLaunchParams_t {

1074 hipFunction_t function;

1075 unsigned int gridDimX;

1076 unsigned int gridDimY;

1077 unsigned int gridDimZ;

1078 unsigned int blockDimX;

1079 unsigned int blockDimY;

1080 unsigned int blockDimZ;

1081 unsigned int sharedMemBytes;

1082 hipStream_t hStream;

1083 void **kernelParams;

1084} hipFunctionLaunchParams;

1085typedef enum hipExternalMemoryHandleType_enum {

1086 hipExternalMemoryHandleTypeOpaqueFd = 1,

1087 hipExternalMemoryHandleTypeOpaqueWin32 = 2,

1088 hipExternalMemoryHandleTypeOpaqueWin32Kmt = 3,

1089 hipExternalMemoryHandleTypeD3D12Heap = 4,

1090 hipExternalMemoryHandleTypeD3D12Resource = 5,

1091 hipExternalMemoryHandleTypeD3D11Resource = 6,

1092 hipExternalMemoryHandleTypeD3D11ResourceKmt = 7,

1093 hipExternalMemoryHandleTypeNvSciBuf = 8

1094} hipExternalMemoryHandleType;

1095typedef struct hipExternalMemoryHandleDesc_st {

1096 hipExternalMemoryHandleType type;

1097 union {

1098 int fd;

1099 struct {

1100 void *handle;

1101 const void *name;

1102 } win32;

1103 const void *nvSciBufObject;

1104 } handle;

1105 unsigned long long size;

1106 unsigned int flags;

1107 unsigned int reserved[16];

1108} hipExternalMemoryHandleDesc;

1109typedef struct hipExternalMemoryBufferDesc_st {

1110 unsigned long long offset;

1111 unsigned long long size;

1112 unsigned int flags;

1113 unsigned int reserved[16];

1114} hipExternalMemoryBufferDesc;

1115typedef struct hipExternalMemoryMipmappedArrayDesc_st {

1116 unsigned long long offset;

1117 hipChannelFormatDesc formatDesc;

1118 hipExtent extent;

1119 unsigned int flags;

1120 unsigned int numLevels;

1121} hipExternalMemoryMipmappedArrayDesc;

1122typedef void* hipExternalMemory_t;

1123typedef enum hipExternalSemaphoreHandleType_enum {

1124 hipExternalSemaphoreHandleTypeOpaqueFd = 1,

1125 hipExternalSemaphoreHandleTypeOpaqueWin32 = 2,

1126 hipExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3,

1127 hipExternalSemaphoreHandleTypeD3D12Fence = 4,

1128 hipExternalSemaphoreHandleTypeD3D11Fence = 5,

1129 hipExternalSemaphoreHandleTypeNvSciSync = 6,

1130 hipExternalSemaphoreHandleTypeKeyedMutex = 7,

1131 hipExternalSemaphoreHandleTypeKeyedMutexKmt = 8,

1132 hipExternalSemaphoreHandleTypeTimelineSemaphoreFd = 9,

1133 hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = 10

1134} hipExternalSemaphoreHandleType;

1135typedef struct hipExternalSemaphoreHandleDesc_st {

1136 hipExternalSemaphoreHandleType type;

1137 union {

1138 int fd;

1139 struct {

1140 void* handle;

1141 const void* name;

1142 } win32;

1143 const void* NvSciSyncObj;

1144 } handle;

1145 unsigned int flags;

1146 unsigned int reserved[16];

1147} hipExternalSemaphoreHandleDesc;

1148typedef void* hipExternalSemaphore_t;

1149typedef struct hipExternalSemaphoreSignalParams_st {

1150 struct {

1151 struct {

1152 unsigned long long value;

1153 } fence;

1154 union {

1155 void *fence;

1156 unsigned long long reserved;

1157 } nvSciSync;

1158 struct {

1159 unsigned long long key;

1160 } keyedMutex;

1161 unsigned int reserved[12];

1162 } params;

1163 unsigned int flags;

1164 unsigned int reserved[16];

1165} hipExternalSemaphoreSignalParams;

1169typedef struct hipExternalSemaphoreWaitParams_st {

1170 struct {

1171 struct {

1172 unsigned long long value;

1173 } fence;

1174 union {

1175 void *fence;

1176 unsigned long long reserved;

1177 } nvSciSync;

1178 struct {

1179 unsigned long long key;

1180 unsigned int timeoutMs;

1181 } keyedMutex;

1182 unsigned int reserved[10];

1183 } params;

1184 unsigned int flags;

1185 unsigned int reserved[16];

1186} hipExternalSemaphoreWaitParams;

1187

1188#if __HIP_HAS_GET_PCH

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

1194#endif

1195

1199typedef enum hipGraphicsRegisterFlags {

1200 hipGraphicsRegisterFlagsNone = 0,

1201 hipGraphicsRegisterFlagsReadOnly = 1,

1202 hipGraphicsRegisterFlagsWriteDiscard =

1203 2,

1204 hipGraphicsRegisterFlagsSurfaceLoadStore = 4,

1205 hipGraphicsRegisterFlagsTextureGather =

1206 8

1207} hipGraphicsRegisterFlags;

1208

1209typedef struct _hipGraphicsResource hipGraphicsResource;

1210

1211typedef hipGraphicsResource* hipGraphicsResource_t;

1212

1216typedef struct ihipGraph* hipGraph_t;

1220typedef struct hipGraphNode* hipGraphNode_t;

1224typedef struct hipGraphExec* hipGraphExec_t;

1225

1229typedef struct hipUserObject* hipUserObject_t;

1230

1231

1235typedef enum hipGraphNodeType {

1236 hipGraphNodeTypeKernel = 0,

1237 hipGraphNodeTypeMemcpy = 1,

1238 hipGraphNodeTypeMemset = 2,

1239 hipGraphNodeTypeHost = 3,

1240 hipGraphNodeTypeGraph = 4,

1241 hipGraphNodeTypeEmpty = 5,

1242 hipGraphNodeTypeWaitEvent = 6,

1243 hipGraphNodeTypeEventRecord = 7,

1244 hipGraphNodeTypeExtSemaphoreSignal = 8,

1245 hipGraphNodeTypeExtSemaphoreWait = 9,

1246 hipGraphNodeTypeMemAlloc = 10,

1247 hipGraphNodeTypeMemFree = 11,

1248 hipGraphNodeTypeMemcpyFromSymbol = 12,

1249 hipGraphNodeTypeMemcpyToSymbol = 13,

1250 hipGraphNodeTypeCount

1251} hipGraphNodeType;

1252

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

1254typedef struct hipHostNodeParams {

1255 hipHostFn_t fn;

1256 void* userData;

1257} hipHostNodeParams;

1258typedef struct hipKernelNodeParams {

1259 dim3 blockDim;

1260 void** extra;

1261 void* func;

1262 dim3 gridDim;

1263 void** kernelParams;

1264 unsigned int sharedMemBytes;

1265} hipKernelNodeParams;

1266typedef struct hipMemsetParams {

1267 void* dst;

1268 unsigned int elementSize;

1269 size_t height;

1270 size_t pitch;

1271 unsigned int value;

1272 size_t width;

1273} hipMemsetParams;

1274

1275typedef struct hipMemAllocNodeParams {

1276 hipMemPoolProps poolProps;

1278 const hipMemAccessDesc* accessDescs;

1279 size_t accessDescCount;

1281 size_t bytesize;

1282 void* dptr;

1283} hipMemAllocNodeParams;

1284

1285

1286typedef enum hipAccessProperty {

1287 hipAccessPropertyNormal = 0,

1288 hipAccessPropertyStreaming = 1,

1289 hipAccessPropertyPersisting = 2,

1290} hipAccessProperty;

1291typedef struct hipAccessPolicyWindow {

1292 void* base_ptr;

1293 hipAccessProperty hitProp;

1294 float hitRatio;

1295 hipAccessProperty missProp;

1296 size_t num_bytes;

1297} hipAccessPolicyWindow;

1298

1302typedef enum hipLaunchAttributeID {

1303 hipLaunchAttributeAccessPolicyWindow = 1,

1304 hipLaunchAttributeCooperative = 2,

1305 hipLaunchAttributePriority = 8,

1306} hipLaunchAttributeID;

1307

1311typedef union hipLaunchAttributeValue {

1312 hipAccessPolicyWindow accessPolicyWindow;

1314 int cooperative;

1315 int priority;

1317} hipLaunchAttributeValue;

1318

1322#define hipKernelNodeAttrID hipLaunchAttributeID

1323#define hipKernelNodeAttributeAccessPolicyWindow hipLaunchAttributeAccessPolicyWindow

1324#define hipKernelNodeAttributeCooperative hipLaunchAttributeCooperative

1325#define hipKernelNodeAttributePriority hipLaunchAttributePriority

1326

1330#define hipKernelNodeAttrValue hipLaunchAttributeValue

1331

1335typedef struct HIP_MEMSET_NODE_PARAMS {

1336 hipDeviceptr_t dst;

1337 size_t pitch;

1338 unsigned int value;

1339 unsigned int elementSize;

1340 size_t width;

1341 size_t height;

1342} HIP_MEMSET_NODE_PARAMS;

1343

1347typedef enum hipGraphExecUpdateResult {

1348 hipGraphExecUpdateSuccess = 0x0,

1349 hipGraphExecUpdateError = 0x1,

1351 hipGraphExecUpdateErrorTopologyChanged = 0x2,

1352 hipGraphExecUpdateErrorNodeTypeChanged = 0x3,

1353 hipGraphExecUpdateErrorFunctionChanged =

1354 0x4,

1355 hipGraphExecUpdateErrorParametersChanged =

1356 0x5,

1357 hipGraphExecUpdateErrorNotSupported =

1358 0x6,

1359 hipGraphExecUpdateErrorUnsupportedFunctionChange = 0x7

1360} hipGraphExecUpdateResult;

1361

1362typedef enum hipStreamCaptureMode {

1363 hipStreamCaptureModeGlobal = 0,

1364 hipStreamCaptureModeThreadLocal,

1365 hipStreamCaptureModeRelaxed

1366} hipStreamCaptureMode;

1367typedef enum hipStreamCaptureStatus {

1368 hipStreamCaptureStatusNone = 0,

1369 hipStreamCaptureStatusActive,

1370 hipStreamCaptureStatusInvalidated

1372} hipStreamCaptureStatus;

1373

1374typedef enum hipStreamUpdateCaptureDependenciesFlags {

1375 hipStreamAddCaptureDependencies = 0,

1376 hipStreamSetCaptureDependencies,

1377} hipStreamUpdateCaptureDependenciesFlags;

1378

1379typedef enum hipGraphMemAttributeType {

1380 hipGraphMemAttrUsedMemCurrent = 0,

1381 hipGraphMemAttrUsedMemHigh,

1382 hipGraphMemAttrReservedMemCurrent,

1383 hipGraphMemAttrReservedMemHigh,

1384}hipGraphMemAttributeType;

1385typedef enum hipUserObjectFlags {

1386 hipUserObjectNoDestructorSync = 0x1,

1387} hipUserObjectFlags;

1388

1389typedef enum hipUserObjectRetainFlags {

1390 hipGraphUserObjectMove = 0x1,

1391} hipUserObjectRetainFlags;

1392

1393typedef enum hipGraphInstantiateFlags {

1394 hipGraphInstantiateFlagAutoFreeOnLaunch =

1395 1,

1396 hipGraphInstantiateFlagUpload =

1397 2,

1398 hipGraphInstantiateFlagDeviceLaunch =

1399 4,

1400 hipGraphInstantiateFlagUseNodePriority =

1401 8,

1402} hipGraphInstantiateFlags;

1403

1404enum hipGraphDebugDotFlags {

1405 hipGraphDebugDotFlagsVerbose = 1

1406 << 0,

1407 hipGraphDebugDotFlagsKernelNodeParams = 1 << 2,

1408 hipGraphDebugDotFlagsMemcpyNodeParams = 1 << 3,

1409 hipGraphDebugDotFlagsMemsetNodeParams = 1 << 4,

1410 hipGraphDebugDotFlagsHostNodeParams = 1 << 5,

1411 hipGraphDebugDotFlagsEventNodeParams = 1

1412 << 6,

1413 hipGraphDebugDotFlagsExtSemasSignalNodeParams = 1

1414 << 7,

1415 hipGraphDebugDotFlagsExtSemasWaitNodeParams = 1

1416 << 8,

1417 hipGraphDebugDotFlagsKernelNodeAttributes = 1

1418 << 9,

1419 hipGraphDebugDotFlagsHandles = 1

1420 << 10

1421};

1422

1426typedef enum hipGraphInstantiateResult {

1427 hipGraphInstantiateSuccess = 0,

1428 hipGraphInstantiateError = 1,

1430 hipGraphInstantiateInvalidStructure = 2,

1432 hipGraphInstantiateNodeOperationNotSupported = 3,

1434 hipGraphInstantiateMultipleDevicesNotSupported = 4,

1436}hipGraphInstantiateResult;

1437

1441typedef struct hipGraphInstantiateParams {

1442 hipGraphNode_t errNode_out;

1443 unsigned long long flags;

1444 hipGraphInstantiateResult result_out;

1446 hipStream_t uploadStream;

1447} hipGraphInstantiateParams;

1448

1449

1453typedef struct hipMemAllocationProp {

1454 hipMemAllocationType type;

1455 hipMemAllocationHandleType requestedHandleType;

1456 hipMemLocation location;

1457 void* win32HandleMetaData;

1458 struct {

1459 unsigned char compressionType;

1460 unsigned char gpuDirectRDMACapable;

1461 unsigned short usage;

1462 } allocFlags;

1463} hipMemAllocationProp;

1464

1468typedef struct hipExternalSemaphoreSignalNodeParams {

1470 hipExternalSemaphore_t* extSemArray;

1472 const hipExternalSemaphoreSignalParams* paramsArray;

1474 unsigned int numExtSems;

1475} hipExternalSemaphoreSignalNodeParams;

1476

1480typedef struct hipExternalSemaphoreWaitNodeParams {

1482 hipExternalSemaphore_t* extSemArray;

1484 const hipExternalSemaphoreWaitParams* paramsArray;

1486 unsigned int numExtSems;

1487} hipExternalSemaphoreWaitNodeParams;

1488

1492typedef struct ihipMemGenericAllocationHandle* hipMemGenericAllocationHandle_t;

1493

1497typedef enum hipMemAllocationGranularity_flags {

1498 hipMemAllocationGranularityMinimum = 0x0,

1499 hipMemAllocationGranularityRecommended = 0x1

1500} hipMemAllocationGranularity_flags;

1501

1505typedef enum hipMemHandleType {

1506 hipMemHandleTypeGeneric = 0x0

1507} hipMemHandleType;

1508

1512typedef enum hipMemOperationType {

1513 hipMemOperationTypeMap = 0x1,

1514 hipMemOperationTypeUnmap = 0x2

1515} hipMemOperationType;

1516

1520typedef enum hipArraySparseSubresourceType {

1521 hipArraySparseSubresourceTypeSparseLevel = 0x0,

1522 hipArraySparseSubresourceTypeMiptail = 0x1

1523} hipArraySparseSubresourceType;

1524

1528typedef struct hipArrayMapInfo {

1529 hipResourceType resourceType;

1530 union {

1531 hipMipmappedArray mipmap;

1532 hipArray_t array;

1533 } resource;

1534 hipArraySparseSubresourceType subresourceType;

1535 union {

1536 struct {

1537 unsigned int level;

1538 unsigned int layer;

1539 unsigned int offsetX;

1540 unsigned int offsetY;

1541 unsigned int offsetZ;

1542 unsigned int extentWidth;

1543 unsigned int extentHeight;

1544 unsigned int extentDepth;

1545 } sparseLevel;

1546 struct {

1547 unsigned int layer;

1548 unsigned long long offset;

1549 unsigned long long size;

1550 } miptail;

1551 } subresource;

1552 hipMemOperationType memOperationType;

1553 hipMemHandleType memHandleType;

1554 union {

1555 hipMemGenericAllocationHandle_t memHandle;

1556 } memHandle;

1557 unsigned long long offset;

1558 unsigned int deviceBitMask;

1559 unsigned int flags;

1560 unsigned int reserved[2];

1561} hipArrayMapInfo;

1562

1566typedef struct hipMemcpyNodeParams {

1567 int flags;

1568 int reserved[3];

1569 hipMemcpy3DParms copyParams;

1570} hipMemcpyNodeParams;

1571

1575typedef struct hipChildGraphNodeParams {

1576 hipGraph_t graph;

1578} hipChildGraphNodeParams;

1579

1583typedef struct hipEventWaitNodeParams {

1584 hipEvent_t event;

1585} hipEventWaitNodeParams;

1586

1590typedef struct hipEventRecordNodeParams {

1591 hipEvent_t event;

1592} hipEventRecordNodeParams;

1593

1597typedef struct hipMemFreeNodeParams {

1598 void *dptr;

1599} hipMemFreeNodeParams;

1600

1604typedef struct hipGraphNodeParams {

1605 hipGraphNodeType type;

1606 int reserved0[3];

1607 union {

1608 long long reserved1[29];

1609 hipKernelNodeParams kernel;

1610 hipMemcpyNodeParams memcpy;

1611 hipMemsetParams memset;

1612 hipHostNodeParams host;

1613 hipChildGraphNodeParams graph;

1614 hipEventWaitNodeParams eventWait;

1615 hipEventRecordNodeParams eventRecord;

1616 hipExternalSemaphoreSignalNodeParams extSemSignal;

1617 hipExternalSemaphoreWaitNodeParams extSemWait;

1618 hipMemAllocNodeParams alloc;

1619 hipMemFreeNodeParams free;

1620 };

1621

1622 long long reserved2;

1623} hipGraphNodeParams;

1624

1628#define hipGraphKernelNodePortDefault 0

1629

1633#define hipGraphKernelNodePortLaunchCompletion 2

1634

1640#define hipGraphKernelNodePortProgrammatic 1

1641

1642typedef enum hipGraphDependencyType {

1643 hipGraphDependencyTypeDefault = 0,

1644 hipGraphDependencyTypeProgrammatic = 1

1645}hipGraphDependencyType;

1646

1647typedef struct hipGraphEdgeData {

1648 unsigned char

1649 from_port;

1656 unsigned char reserved[5];

1657 unsigned char

1658 to_port;

1659 unsigned char type;

1660} hipGraphEdgeData;

1661

1662// Doxygen end group GlobalDefs

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

1689hipError_t hipInit(unsigned int flags);

1690

1706hipError_t hipDriverGetVersion(int* driverVersion);

1721hipError_t hipRuntimeGetVersion(int* runtimeVersion);

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

1730

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

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

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

1770hipError_t hipDeviceGetP2PAttribute(int* value, hipDeviceP2PAttr attr,

1771 int srcDevice, int dstDevice);

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

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

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

1797// doxygen end initialization

1816hipError_t hipDeviceSynchronize(void);

1828hipError_t hipDeviceReset(void);

1860hipError_t hipSetDevice(int deviceId);

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

1886hipError_t hipGetDevice(int* deviceId);

1899hipError_t hipGetDeviceCount(int* count);

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

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

1946hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool);

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

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

1992hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig);

2003hipError_t hipDeviceGetCacheConfig(hipFuncCache_t* cacheConfig);

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

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

2049hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig* pConfig);

2057hipError_t hipGetDeviceFlags(unsigned int* flags);

2069hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config);

2094hipError_t hipSetDeviceFlags(unsigned flags);

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

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

2117// TODO: implement IPC apis

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

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

2195hipError_t hipIpcCloseMemHandle(void* devPtr);

2196

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

2214

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

2233

2234// end doxygen Device

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

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

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

2284//doxygen end execution

2306hipError_t hipGetLastError(void);

2307

2319hipError_t hipExtGetLastError(void);

2320

2331hipError_t hipPeekAtLastError(void);

2340const char* hipGetErrorName(hipError_t hip_error);

2349const char* hipGetErrorString(hipError_t hipError);

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

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

2370// end doxygen Error

2400hipError_t hipStreamCreate(hipStream_t* stream);

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

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

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

2468hipError_t hipStreamDestroy(hipStream_t stream);

2484hipError_t hipStreamQuery(hipStream_t stream);

2505hipError_t hipStreamSynchronize(hipStream_t stream);

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

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

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

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

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

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

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

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

2618 unsigned int flags);

2619// end doxygen Stream

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

2663 uint32_t mask __dparm(0xFFFFFFFF));

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

2697 uint64_t mask __dparm(0xFFFFFFFFFFFFFFFF));

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

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

2738// end doxygen Stream Memory Operations

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

2786hipError_t hipEventCreate(hipEvent_t* event);

2817#ifdef __cplusplus

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

2819#else

2820hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream);

2821#endif

2838hipError_t hipEventDestroy(hipEvent_t event);

2857hipError_t hipEventSynchronize(hipEvent_t event);

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

2903hipError_t hipEventQuery(hipEvent_t event);

2904// end doxygen Events

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

2936 hipDeviceptr_t ptr);

2937

2938

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

2973hipError_t hipPointerGetAttribute(void* data, hipPointer_attribute attribute,

2974 hipDeviceptr_t ptr);

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

2992 void** data, hipDeviceptr_t ptr);

3016hipError_t hipImportExternalSemaphore(hipExternalSemaphore_t* extSem_out,

3017 const hipExternalSemaphoreHandleDesc* semHandleDesc);

3033hipError_t hipSignalExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

3034 const hipExternalSemaphoreSignalParams* paramsArray,

3035 unsigned int numExtSems, hipStream_t stream);

3051hipError_t hipWaitExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

3052 const hipExternalSemaphoreWaitParams* paramsArray,

3053 unsigned int numExtSems, hipStream_t stream);

3066hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem);

3067

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

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

3101hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem);

3115hipError_t hipExternalMemoryGetMappedMipmappedArray(hipMipmappedArray_t* mipmap, hipExternalMemory_t extMem,

3116 const hipExternalMemoryMipmappedArrayDesc* mipmapDesc);

3117 // end of external resource

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

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

3155

3156

3179DEPRECATED("use hipHostMalloc instead")

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

3193DEPRECATED("use hipHostMalloc instead")

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

3195// end doxygen deprecated management memory

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

3265hipError_t hipMallocManaged(void** dev_ptr,

3266 size_t size,

3267 unsigned int flags __dparm(hipMemAttachGlobal));

3280hipError_t hipMemPrefetchAsync(const void* dev_ptr,

3281 size_t count,

3282 int device,

3283 hipStream_t stream __dparm(0));

3303hipError_t hipMemAdvise(const void* dev_ptr,

3304 size_t count,

3305 hipMemoryAdvise advice,

3306 int device);

3321hipError_t hipMemRangeGetAttribute(void* data,

3322 size_t data_size,

3323 hipMemRangeAttribute attribute,

3324 const void* dev_ptr,

3325 size_t count);

3342hipError_t hipMemRangeGetAttributes(void** data,

3343 size_t* data_sizes,

3344 hipMemRangeAttribute* attributes,

3345 size_t num_attributes,

3346 const void* dev_ptr,

3347 size_t count);

3363hipError_t hipStreamAttachMemAsync(hipStream_t stream,

3364 void* dev_ptr,

3365 size_t length __dparm(0),

3366 unsigned int flags __dparm(hipMemAttachSingle));

3367// end doxygen Managed Memory

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

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

3480hipError_t hipMemPoolTrimTo(hipMemPool_t mem_pool, size_t min_bytes_to_hold);

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

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

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

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

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

3647hipError_t hipMemPoolDestroy(hipMemPool_t mem_pool);

3681hipError_t hipMallocFromPoolAsync(void** dev_ptr, size_t size, hipMemPool_t mem_pool, hipStream_t stream);

3708hipError_t hipMemPoolExportToShareableHandle(

3709 void* shared_handle,

3710 hipMemPool_t mem_pool,

3711 hipMemAllocationHandleType handle_type,

3712 unsigned int flags);

3736hipError_t hipMemPoolImportFromShareableHandle(

3737 hipMemPool_t* mem_pool,

3738 void* shared_handle,

3739 hipMemAllocationHandleType handle_type,

3740 unsigned int flags);

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

3789hipError_t hipMemPoolImportPointer(

3790 void** dev_ptr,

3791 hipMemPool_t mem_pool,

3792 hipMemPoolPtrExportData* export_data);

3793// Doxygen end of ordered memory allocator

3812DEPRECATED("use hipHostMalloc instead")

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

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

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

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

3881hipError_t hipHostUnregister(void* hostPtr);

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

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

3924 unsigned int elementSizeBytes);

3938hipError_t hipFree(void* ptr);

3950DEPRECATED("use hipHostFree instead")

3951hipError_t hipFreeHost(void* ptr);

3965hipError_t hipHostFree(void* ptr);

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

4010hipError_t hipMemcpyWithStream(void* dst, const void* src, size_t sizeBytes,

4011 hipMemcpyKind kind, hipStream_t stream);

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

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

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

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

4085 size_t ByteCount);

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

4105 size_t ByteCount);

4106

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

4127 size_t srcOffset, size_t ByteCount);

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

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

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

4185 hipStream_t stream);

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

4206 size_t ByteCount, hipStream_t stream);

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

4227 size_t ByteCount, hipStream_t stream);

4242hipError_t hipModuleGetGlobal(hipDeviceptr_t* dptr, size_t* bytes,

4243 hipModule_t hmod, const char* name);

4244

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

4255

4256

4257

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

4268

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

4289 hipDriverProcAddressQueryResult* symbolStatus);

4290

4311hipError_t hipMemcpyToSymbol(const void* symbol, const void* src,

4312 size_t sizeBytes, size_t offset __dparm(0),

4313 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice));

4314

4328hipError_t hipMemcpyToSymbolAsync(const void* symbol, const void* src,

4329 size_t sizeBytes, size_t offset,

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

4331

4344hipError_t hipMemcpyFromSymbol(void* dst, const void* symbol,

4345 size_t sizeBytes, size_t offset __dparm(0),

4346 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost));

4347

4361hipError_t hipMemcpyFromSymbolAsync(void* dst, const void* symbol,

4362 size_t sizeBytes, size_t offset,

4363 hipMemcpyKind kind,

4364 hipStream_t stream __dparm(0));

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

4395 hipStream_t stream __dparm(0));

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

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

4431hipError_t hipMemsetD8Async(hipDeviceptr_t dest, unsigned char value, size_t count, hipStream_t stream __dparm(0));

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

4457hipError_t hipMemsetD16Async(hipDeviceptr_t dest, unsigned short value, size_t count, hipStream_t stream __dparm(0));

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

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

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

4500 hipStream_t stream __dparm(0));

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

4523hipError_t hipMemset2DAsync(void* dst, size_t pitch, int value, size_t width, size_t height,hipStream_t stream __dparm(0));

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

4542hipError_t hipMemset3DAsync(hipPitchedPtr pitchedDevPtr, int value, hipExtent extent ,hipStream_t stream __dparm(0));

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

4560

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

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

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

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

4607hipError_t hipArrayDestroy(hipArray_t array);

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

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

4638hipError_t hipFreeArray(hipArray_t array);

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

4651 struct hipExtent extent, unsigned int flags);

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

4665 hipArray_t array);

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

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

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

4719 size_t height, hipMemcpyKind kind);

4729hipError_t hipMemcpyParam2D(const hip_Memcpy2D* pCopy);

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

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

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

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

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

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

4798 size_t spitch, size_t width, size_t height, hipMemcpyKind kind,

4799 hipStream_t stream __dparm(0));

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

4819 hipArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc,

4820 size_t width, size_t height, hipMemcpyKind kind);

4838DEPRECATED(DEPRECATED_MSG)

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

4840 size_t count, hipMemcpyKind kind);

4858DEPRECATED(DEPRECATED_MSG)

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

4860 size_t count, hipMemcpyKind kind);

4878hipError_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);

4897hipError_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 __dparm(0));

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

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

4936hipError_t hipMemcpy3D(const struct hipMemcpy3DParms* p);

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

4959hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D* pCopy);

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

4972// doxygen end Memory

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

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

5029hipError_t hipDeviceDisablePeerAccess(int peerDeviceId);

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

5043#ifndef USE_PEER_NON_UNIFIED

5044#define USE_PEER_NON_UNIFIED 1

5045#endif

5046#if USE_PEER_NON_UNIFIED == 1

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

5059 size_t sizeBytes);

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

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

5074#endif

5075// doxygen end PeerToPeer

5116DEPRECATED(DEPRECATED_MSG)

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

5131DEPRECATED(DEPRECATED_MSG)

5132hipError_t hipCtxDestroy(hipCtx_t ctx);

5146DEPRECATED(DEPRECATED_MSG)

5147hipError_t hipCtxPopCurrent(hipCtx_t* ctx);

5161DEPRECATED(DEPRECATED_MSG)

5162hipError_t hipCtxPushCurrent(hipCtx_t ctx);

5176DEPRECATED(DEPRECATED_MSG)

5177hipError_t hipCtxSetCurrent(hipCtx_t ctx);

5191DEPRECATED(DEPRECATED_MSG)

5192hipError_t hipCtxGetCurrent(hipCtx_t* ctx);

5206DEPRECATED(DEPRECATED_MSG)

5207hipError_t hipCtxGetDevice(hipDevice_t* device);

5228DEPRECATED(DEPRECATED_MSG)

5229hipError_t hipCtxGetApiVersion(hipCtx_t ctx, int* apiVersion);

5246DEPRECATED(DEPRECATED_MSG)

5247hipError_t hipCtxGetCacheConfig(hipFuncCache_t* cacheConfig);

5264DEPRECATED(DEPRECATED_MSG)

5265hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig);

5282DEPRECATED(DEPRECATED_MSG)

5283hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config);

5300DEPRECATED(DEPRECATED_MSG)

5301hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig* pConfig);

5316DEPRECATED(DEPRECATED_MSG)

5317hipError_t hipCtxSynchronize(void);

5331DEPRECATED(DEPRECATED_MSG)

5332hipError_t hipCtxGetFlags(unsigned int* flags);

5355DEPRECATED(DEPRECATED_MSG)

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

5376DEPRECATED(DEPRECATED_MSG)

5377hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx);

5378

5394DEPRECATED(DEPRECATED_MSG)

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

5411DEPRECATED(DEPRECATED_MSG)

5412hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev);

5427DEPRECATED(DEPRECATED_MSG)

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

5442DEPRECATED(DEPRECATED_MSG)

5443hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev);

5458DEPRECATED(DEPRECATED_MSG)

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

5460// doxygen end Context Management

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

5497hipError_t hipModuleUnload(hipModule_t module);

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

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

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

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

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

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

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

5571 hipJitOption* options, void** optionValues);

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

5601 unsigned int gridDimZ, unsigned int blockDimX,

5602 unsigned int blockDimY, unsigned int blockDimZ,

5603 unsigned int sharedMemBytes, hipStream_t stream,

5604 void** kernelParams, void** extra);

5633hipError_t hipModuleLaunchCooperativeKernel(hipFunction_t f, unsigned int gridDimX,

5634 unsigned int gridDimY, unsigned int gridDimZ,

5635 unsigned int blockDimX, unsigned int blockDimY,

5636 unsigned int blockDimZ, unsigned int sharedMemBytes,

5637 hipStream_t stream, void** kernelParams);

5652hipError_t hipModuleLaunchCooperativeKernelMultiDevice(hipFunctionLaunchParams* launchParamsList,

5653 unsigned int numDevices,

5654 unsigned int flags);

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

5674 void** kernelParams, unsigned int sharedMemBytes,

5675 hipStream_t stream);

5687hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

5688 int numDevices, unsigned int flags);

5689

5690// Doxygen end group ModuleCooperativeG

5704hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

5705 int numDevices, unsigned int flags);

5706// doxygen end Module

5733//TODO - Match CUoccupancyB2DSize

5734hipError_t hipModuleOccupancyMaxPotentialBlockSize(int* gridSize, int* blockSize,

5735 hipFunction_t f, size_t dynSharedMemPerBlk,

5736 int blockSizeLimit);

5752//TODO - Match CUoccupancyB2DSize

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

5754 hipFunction_t f, size_t dynSharedMemPerBlk,

5755 int blockSizeLimit, unsigned int flags);

5765hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(

5766 int* numBlocks, hipFunction_t f, int blockSize, size_t dynSharedMemPerBlk);

5777hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

5788hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(

5789 int* numBlocks, const void* f, int blockSize, size_t dynSharedMemPerBlk);

5800hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

5801 int* numBlocks, const void* f, int blockSize, size_t dynSharedMemPerBlk, unsigned int flags __dparm(hipOccupancyDefault));

5816hipError_t hipOccupancyMaxPotentialBlockSize(int* gridSize, int* blockSize,

5817 const void* f, size_t dynSharedMemPerBlk,

5818 int blockSizeLimit);

5819// doxygen end Occupancy

5833// TODO - expand descriptions:

5840DEPRECATED("use roctracer/rocTX instead")

5841hipError_t hipProfilerStart();

5848DEPRECATED("use roctracer/rocTX instead")

5849hipError_t hipProfilerStop();

5850// doxygen end profiler

5877hipError_t hipConfigureCall(dim3 gridDim, dim3 blockDim, size_t sharedMem __dparm(0), hipStream_t stream __dparm(0));

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

5897hipError_t hipLaunchByPtr(const void* func);

5914hipError_t __hipPushCallConfiguration(dim3 gridDim,

5915 dim3 blockDim,

5916 size_t sharedMem __dparm(0),

5917 hipStream_t stream __dparm(0));

5937hipError_t __hipPopCallConfiguration(dim3 *gridDim,

5938 dim3 *blockDim,

5939 size_t *sharedMem,

5940 hipStream_t *stream);

5956hipError_t hipLaunchKernel(const void* function_address,

5957 dim3 numBlocks,

5958 dim3 dimBlocks,

5959 void** args,

5960 size_t sharedMemBytes __dparm(0),

5961 hipStream_t stream __dparm(0));

5962

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

5989

5997hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D* pCopy);

5998//TODO: Move this to hip_ext.h

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

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

6021 hipEvent_t startEvent, hipEvent_t stopEvent, int flags);

6022// doxygen end Clang launch

6048hipError_t hipCreateTextureObject(

6049 hipTextureObject_t* pTexObject,

6050 const hipResourceDesc* pResDesc,

6051 const hipTextureDesc* pTexDesc,

6052 const struct hipResourceViewDesc* pResViewDesc);

6053

6062hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject);

6063

6073hipError_t hipGetChannelDesc(

6074 hipChannelFormatDesc* desc,

6075 hipArray_const_t array);

6076

6086hipError_t hipGetTextureObjectResourceDesc(

6087 hipResourceDesc* pResDesc,

6088 hipTextureObject_t textureObject);

6089

6099hipError_t hipGetTextureObjectResourceViewDesc(

6100 struct hipResourceViewDesc* pResViewDesc,

6101 hipTextureObject_t textureObject);

6102

6112hipError_t hipGetTextureObjectTextureDesc(

6113 hipTextureDesc* pTexDesc,

6114 hipTextureObject_t textureObject);

6115

6127hipError_t hipTexObjectCreate(

6128 hipTextureObject_t* pTexObject,

6129 const HIP_RESOURCE_DESC* pResDesc,

6130 const HIP_TEXTURE_DESC* pTexDesc,

6131 const HIP_RESOURCE_VIEW_DESC* pResViewDesc);

6132

6141hipError_t hipTexObjectDestroy(

6142 hipTextureObject_t texObject);

6143

6153hipError_t hipTexObjectGetResourceDesc(

6154 HIP_RESOURCE_DESC* pResDesc,

6155 hipTextureObject_t texObject);

6156

6166hipError_t hipTexObjectGetResourceViewDesc(

6167 HIP_RESOURCE_VIEW_DESC* pResViewDesc,

6168 hipTextureObject_t texObject);

6169

6179hipError_t hipTexObjectGetTextureDesc(

6180 HIP_TEXTURE_DESC* pTexDesc,

6181 hipTextureObject_t texObject);

6182

6197hipError_t hipMallocMipmappedArray(

6198 hipMipmappedArray_t *mipmappedArray,

6199 const struct hipChannelFormatDesc* desc,

6200 struct hipExtent extent,

6201 unsigned int numLevels,

6202 unsigned int flags __dparm(0));

6203

6214hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray);

6215

6228hipError_t hipGetMipmappedArrayLevel(

6229 hipArray_t *levelArray,

6230 hipMipmappedArray_const_t mipmappedArray,

6231 unsigned int level);

6232

6244hipError_t hipMipmappedArrayCreate(

6245 hipMipmappedArray_t* pHandle,

6246 HIP_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc,

6247 unsigned int numMipmapLevels);

6248

6259hipError_t hipMipmappedArrayDestroy(hipMipmappedArray_t hMipmappedArray);

6260

6273hipError_t hipMipmappedArrayGetLevel(

6274 hipArray_t* pLevelArray,

6275 hipMipmappedArray_t hMipMappedArray,

6276 unsigned int level);

6277

6296DEPRECATED(DEPRECATED_MSG)

6297hipError_t hipBindTextureToMipmappedArray(

6298 const textureReference* tex,

6299 hipMipmappedArray_const_t mipmappedArray,

6300 const hipChannelFormatDesc* desc);

6301

6312DEPRECATED(DEPRECATED_MSG)

6313hipError_t hipGetTextureReference(

6314 const textureReference** texref,

6315 const void* symbol);

6316

6327DEPRECATED(DEPRECATED_MSG)

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

6329

6341DEPRECATED(DEPRECATED_MSG)

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

6343

6355DEPRECATED(DEPRECATED_MSG)

6356hipError_t hipTexRefSetAddressMode(

6357 textureReference* texRef,

6358 int dim,

6359 enum hipTextureAddressMode am);

6372DEPRECATED(DEPRECATED_MSG)

6373hipError_t hipTexRefSetArray(

6374 textureReference* tex,

6375 hipArray_const_t array,

6376 unsigned int flags);

6388DEPRECATED(DEPRECATED_MSG)

6389hipError_t hipTexRefSetFilterMode(

6390 textureReference* texRef,

6391 enum hipTextureFilterMode fm);

6403DEPRECATED(DEPRECATED_MSG)

6404hipError_t hipTexRefSetFlags(

6405 textureReference* texRef,

6406 unsigned int Flags);

6419DEPRECATED(DEPRECATED_MSG)

6420hipError_t hipTexRefSetFormat(

6421 textureReference* texRef,

6422 hipArray_Format fmt,

6423 int NumPackedComponents);

6438DEPRECATED(DEPRECATED_MSG)

6439hipError_t hipBindTexture(

6440 size_t* offset,

6441 const textureReference* tex,

6442 const void* devPtr,

6443 const hipChannelFormatDesc* desc,

6444 size_t size __dparm(UINT_MAX));

6461DEPRECATED(DEPRECATED_MSG)

6462hipError_t hipBindTexture2D(

6463 size_t* offset,

6464 const textureReference* tex,

6465 const void* devPtr,

6466 const hipChannelFormatDesc* desc,

6467 size_t width,

6468 size_t height,

6469 size_t pitch);

6482DEPRECATED(DEPRECATED_MSG)

6483hipError_t hipBindTextureToArray(

6484 const textureReference* tex,

6485 hipArray_const_t array,

6486 const hipChannelFormatDesc* desc);

6498DEPRECATED(DEPRECATED_MSG)

6499hipError_t hipGetTextureAlignmentOffset(

6500 size_t* offset,

6501 const textureReference* texref);

6512DEPRECATED(DEPRECATED_MSG)

6513hipError_t hipUnbindTexture(const textureReference* tex);

6525DEPRECATED(DEPRECATED_MSG)

6526hipError_t hipTexRefGetAddress(

6527 hipDeviceptr_t* dev_ptr,

6528 const textureReference* texRef);

6541DEPRECATED(DEPRECATED_MSG)

6542hipError_t hipTexRefGetAddressMode(

6543 enum hipTextureAddressMode* pam,

6544 const textureReference* texRef,

6545 int dim);

6557DEPRECATED(DEPRECATED_MSG)

6558hipError_t hipTexRefGetFilterMode(

6559 enum hipTextureFilterMode* pfm,

6560 const textureReference* texRef);

6572DEPRECATED(DEPRECATED_MSG)

6573hipError_t hipTexRefGetFlags(

6574 unsigned int* pFlags,

6575 const textureReference* texRef);

6588DEPRECATED(DEPRECATED_MSG)

6589hipError_t hipTexRefGetFormat(

6590 hipArray_Format* pFormat,

6591 int* pNumChannels,

6592 const textureReference* texRef);

6604DEPRECATED(DEPRECATED_MSG)

6605hipError_t hipTexRefGetMaxAnisotropy(

6606 int* pmaxAnsio,

6607 const textureReference* texRef);

6619DEPRECATED(DEPRECATED_MSG)

6620hipError_t hipTexRefGetMipmapFilterMode(

6621 enum hipTextureFilterMode* pfm,

6622 const textureReference* texRef);

6634DEPRECATED(DEPRECATED_MSG)

6635hipError_t hipTexRefGetMipmapLevelBias(

6636 float* pbias,

6637 const textureReference* texRef);

6650DEPRECATED(DEPRECATED_MSG)

6651hipError_t hipTexRefGetMipmapLevelClamp(

6652 float* pminMipmapLevelClamp,

6653 float* pmaxMipmapLevelClamp,

6654 const textureReference* texRef);

6666DEPRECATED(DEPRECATED_MSG)

6667hipError_t hipTexRefGetMipMappedArray(

6668 hipMipmappedArray_t* pArray,

6669 const textureReference* texRef);

6683DEPRECATED(DEPRECATED_MSG)

6684hipError_t hipTexRefSetAddress(

6685 size_t* ByteOffset,

6686 textureReference* texRef,

6687 hipDeviceptr_t dptr,

6688 size_t bytes);

6702DEPRECATED(DEPRECATED_MSG)

6703hipError_t hipTexRefSetAddress2D(

6704 textureReference* texRef,

6705 const HIP_ARRAY_DESCRIPTOR* desc,

6706 hipDeviceptr_t dptr,

6707 size_t Pitch);

6719DEPRECATED(DEPRECATED_MSG)

6720hipError_t hipTexRefSetMaxAnisotropy(

6721 textureReference* texRef,

6722 unsigned int maxAniso);

6734DEPRECATED(DEPRECATED_MSG)

6735hipError_t hipTexRefSetBorderColor(

6736 textureReference* texRef,

6737 float* pBorderColor);

6749DEPRECATED(DEPRECATED_MSG)

6750hipError_t hipTexRefSetMipmapFilterMode(

6751 textureReference* texRef,

6752 enum hipTextureFilterMode fm);

6764DEPRECATED(DEPRECATED_MSG)

6765hipError_t hipTexRefSetMipmapLevelBias(

6766 textureReference* texRef,

6767 float bias);

6780DEPRECATED(DEPRECATED_MSG)

6781hipError_t hipTexRefSetMipmapLevelClamp(

6782 textureReference* texRef,

6783 float minMipMapLevelClamp,

6784 float maxMipMapLevelClamp);

6797DEPRECATED(DEPRECATED_MSG)

6798hipError_t hipTexRefSetMipmappedArray(

6799 textureReference* texRef,

6800 struct hipMipmappedArray* mipmappedArray,

6801 unsigned int Flags);

6802

6803// doxygen end deprecated texture management

6808// doxygen end Texture management

6820// This group is for HIPrtc

6821

6822// doxygen end Runtime

6841const char* hipApiName(uint32_t id);

6850const char* hipKernelNameRef(const hipFunction_t f);

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

6869int hipGetStreamDeviceId(hipStream_t stream);

6870

6871// doxygen end Callback

6896hipError_t hipStreamBeginCapture(hipStream_t stream, hipStreamCaptureMode mode);

6897

6917hipError_t hipStreamBeginCaptureToGraph(hipStream_t stream, hipGraph_t graph,

6918 const hipGraphNode_t* dependencies,

6919 const hipGraphEdgeData* dependencyData,

6920 size_t numDependencies, hipStreamCaptureMode mode);

6921

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

6935

6949hipError_t hipStreamGetCaptureInfo(hipStream_t stream, hipStreamCaptureStatus* pCaptureStatus,

6950 unsigned long long* pId);

6951

6968hipError_t hipStreamGetCaptureInfo_v2(hipStream_t stream, hipStreamCaptureStatus* captureStatus_out,

6969 unsigned long long* id_out __dparm(0),

6970 hipGraph_t* graph_out __dparm(0),

6971 const hipGraphNode_t** dependencies_out __dparm(0),

6972 size_t* numDependencies_out __dparm(0));

6973

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

6987

7002hipError_t hipStreamUpdateCaptureDependencies(hipStream_t stream, hipGraphNode_t* dependencies,

7003 size_t numDependencies,

7004 unsigned int flags __dparm(0));

7005

7016hipError_t hipThreadExchangeStreamCaptureMode(hipStreamCaptureMode* mode);

7017

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

7031

7043hipError_t hipGraphDestroy(hipGraph_t graph);

7044

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

7059 const hipGraphNode_t* to, size_t numDependencies);

7060

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

7075 const hipGraphNode_t* to, size_t numDependencies);

7076

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

7095 size_t* numEdges);

7096

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

7114

7131hipError_t hipGraphGetRootNodes(hipGraph_t graph, hipGraphNode_t* pRootNodes,

7132 size_t* pNumRootNodes);

7133

7150hipError_t hipGraphNodeGetDependencies(hipGraphNode_t node, hipGraphNode_t* pDependencies,

7151 size_t* pNumDependencies);

7152

7170hipError_t hipGraphNodeGetDependentNodes(hipGraphNode_t node, hipGraphNode_t* pDependentNodes,

7171 size_t* pNumDependentNodes);

7172

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

7185

7196hipError_t hipGraphDestroyNode(hipGraphNode_t node);

7197

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

7210

7223hipError_t hipGraphNodeFindInClone(hipGraphNode_t* pNode, hipGraphNode_t originalNode,

7224 hipGraph_t clonedGraph);

7225

7242hipError_t hipGraphInstantiate(hipGraphExec_t* pGraphExec, hipGraph_t graph,

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

7244

7257hipError_t hipGraphInstantiateWithFlags(hipGraphExec_t* pGraphExec, hipGraph_t graph,

7258 unsigned long long flags);

7259

7271hipError_t hipGraphInstantiateWithParams(hipGraphExec_t* pGraphExec, hipGraph_t graph,

7272 hipGraphInstantiateParams *instantiateParams);

7283hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream);

7284

7295hipError_t hipGraphUpload(hipGraphExec_t graphExec, hipStream_t stream);

7296

7309hipError_t hipGraphAddNode(hipGraphNode_t *pGraphNode, hipGraph_t graph,

7310 const hipGraphNode_t *pDependencies, size_t numDependencies,

7311 hipGraphNodeParams *nodeParams);

7312

7323hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec);

7324

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

7339hipError_t hipGraphExecUpdate(hipGraphExec_t hGraphExec, hipGraph_t hGraph,

7340 hipGraphNode_t* hErrorNode_out,

7341 hipGraphExecUpdateResult* updateResult_out);

7342

7355hipError_t hipGraphAddKernelNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7356 const hipGraphNode_t* pDependencies, size_t numDependencies,

7357 const hipKernelNodeParams* pNodeParams);

7358

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

7369

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

7380

7391hipError_t hipGraphExecKernelNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7392 const hipKernelNodeParams* pNodeParams);

7393

7407hipError_t hipDrvGraphAddMemcpyNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

7408 const hipGraphNode_t* dependencies,

7409 size_t numDependencies,

7410 const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);

7423hipError_t hipGraphAddMemcpyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7424 const hipGraphNode_t* pDependencies, size_t numDependencies,

7425 const hipMemcpy3DParms* pCopyParams);

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

7436

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

7447

7458hipError_t hipGraphKernelNodeSetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

7459 const hipKernelNodeAttrValue* value);

7470hipError_t hipGraphKernelNodeGetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

7471 hipKernelNodeAttrValue* value);

7482hipError_t hipGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7483 hipMemcpy3DParms* pNodeParams);

7484

7500hipError_t hipGraphAddMemcpyNode1D(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7501 const hipGraphNode_t* pDependencies, size_t numDependencies,

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

7503

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

7517 size_t count, hipMemcpyKind kind);

7518

7533hipError_t hipGraphExecMemcpyNodeSetParams1D(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

7535 hipMemcpyKind kind);

7536

7553hipError_t hipGraphAddMemcpyNodeFromSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7554 const hipGraphNode_t* pDependencies,

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

7556 size_t count, size_t offset, hipMemcpyKind kind);

7557

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

7572 size_t count, size_t offset, hipMemcpyKind kind);

7573

7589hipError_t hipGraphExecMemcpyNodeSetParamsFromSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

7591 size_t offset, hipMemcpyKind kind);

7592

7609hipError_t hipGraphAddMemcpyNodeToSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7610 const hipGraphNode_t* pDependencies,

7611 size_t numDependencies, const void* symbol,

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

7613 hipMemcpyKind kind);

7614

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

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

7630 hipMemcpyKind kind);

7631

7632

7647hipError_t hipGraphExecMemcpyNodeSetParamsToSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7648 const void* symbol, const void* src,

7649 size_t count, size_t offset, hipMemcpyKind kind);

7650

7663hipError_t hipGraphAddMemsetNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7664 const hipGraphNode_t* pDependencies, size_t numDependencies,

7665 const hipMemsetParams* pMemsetParams);

7666

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

7677

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

7688

7699hipError_t hipGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7700 const hipMemsetParams* pNodeParams);

7701

7714hipError_t hipGraphAddHostNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7715 const hipGraphNode_t* pDependencies, size_t numDependencies,

7716 const hipHostNodeParams* pNodeParams);

7717

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

7728

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

7739

7750hipError_t hipGraphExecHostNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7751 const hipHostNodeParams* pNodeParams);

7752

7765hipError_t hipGraphAddChildGraphNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7766 const hipGraphNode_t* pDependencies, size_t numDependencies,

7767 hipGraph_t childGraph);

7768

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

7779

7790hipError_t hipGraphExecChildGraphNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7791 hipGraph_t childGraph);

7792

7804hipError_t hipGraphAddEmptyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7805 const hipGraphNode_t* pDependencies, size_t numDependencies);

7806

7807

7820hipError_t hipGraphAddEventRecordNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7821 const hipGraphNode_t* pDependencies, size_t numDependencies,

7822 hipEvent_t event);

7823

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

7834

7844hipError_t hipGraphEventRecordNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

7845

7856hipError_t hipGraphExecEventRecordNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

7857 hipEvent_t event);

7858

7871hipError_t hipGraphAddEventWaitNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7872 const hipGraphNode_t* pDependencies, size_t numDependencies,

7873 hipEvent_t event);

7874

7875

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

7886

7896hipError_t hipGraphEventWaitNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

7897

7908hipError_t hipGraphExecEventWaitNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

7909 hipEvent_t event);

7910

7923hipError_t hipGraphAddMemAllocNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7924 const hipGraphNode_t* pDependencies, size_t numDependencies, hipMemAllocNodeParams* pNodeParams);

7925

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

7936

7949hipError_t hipGraphAddMemFreeNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7950 const hipGraphNode_t* pDependencies, size_t numDependencies, void* dev_ptr);

7951

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

7962

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

7974

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

7986

7996hipError_t hipDeviceGraphMemTrim(int device);

7997

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

8011 unsigned int initialRefcount, unsigned int flags);

8012

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

8023

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

8034

8046hipError_t hipGraphRetainUserObject(hipGraph_t graph, hipUserObject_t object,

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

8048

8059hipError_t hipGraphReleaseUserObject(hipGraph_t graph, hipUserObject_t object,

8060 unsigned int count __dparm(1));

8061

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

8073

8088hipError_t hipGraphKernelNodeCopyAttributes(hipGraphNode_t hSrc, hipGraphNode_t hDst);

8089

8112hipError_t hipGraphNodeSetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8113 unsigned int isEnabled);

8134hipError_t hipGraphNodeGetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8135 unsigned int* isEnabled);

8136

8149hipError_t hipGraphAddExternalSemaphoresWaitNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8150 const hipGraphNode_t* pDependencies, size_t numDependencies,

8151 const hipExternalSemaphoreWaitNodeParams* nodeParams);

8152

8165hipError_t hipGraphAddExternalSemaphoresSignalNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8166 const hipGraphNode_t* pDependencies, size_t numDependencies,

8167 const hipExternalSemaphoreSignalNodeParams* nodeParams);

8177hipError_t hipGraphExternalSemaphoresSignalNodeSetParams(hipGraphNode_t hNode,

8178 const hipExternalSemaphoreSignalNodeParams* nodeParams);

8188hipError_t hipGraphExternalSemaphoresWaitNodeSetParams(hipGraphNode_t hNode,

8189 const hipExternalSemaphoreWaitNodeParams* nodeParams);

8199hipError_t hipGraphExternalSemaphoresSignalNodeGetParams(hipGraphNode_t hNode,

8200 hipExternalSemaphoreSignalNodeParams* params_out);

8210hipError_t hipGraphExternalSemaphoresWaitNodeGetParams(hipGraphNode_t hNode,

8211 hipExternalSemaphoreWaitNodeParams* params_out);

8222hipError_t hipGraphExecExternalSemaphoresSignalNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8223 const hipExternalSemaphoreSignalNodeParams* nodeParams);

8234hipError_t hipGraphExecExternalSemaphoresWaitNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8235 const hipExternalSemaphoreWaitNodeParams* nodeParams);

8236

8250hipError_t hipDrvGraphAddMemsetNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

8251 const hipGraphNode_t* dependencies, size_t numDependencies,

8252 const HIP_MEMSET_NODE_PARAMS* memsetParams, hipCtx_t ctx);

8253

8254// doxygen end graph API

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

8286

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

8302

8316hipError_t hipMemCreate(hipMemGenericAllocationHandle_t* handle, size_t size, const hipMemAllocationProp* prop, unsigned long long flags);

8317

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

8332

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

8346

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

8361

8373hipError_t hipMemGetAllocationPropertiesFromHandle(hipMemAllocationProp* prop, hipMemGenericAllocationHandle_t handle);

8374

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

8388

8403hipError_t hipMemMap(void* ptr, size_t size, size_t offset, hipMemGenericAllocationHandle_t handle, unsigned long long flags);

8404

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

8416

8427hipError_t hipMemRelease(hipMemGenericAllocationHandle_t handle);

8428

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

8441

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

8456

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

8469

8470// doxygen end virtual memory management API

8492hipError_t hipGraphicsMapResources(int count, hipGraphicsResource_t* resources,

8493 hipStream_t stream __dparm(0) );

8507hipError_t hipGraphicsSubResourceGetMappedArray(hipArray_t* array, hipGraphicsResource_t resource,

8508 unsigned int arrayIndex, unsigned int mipLevel);

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

8520 hipGraphicsResource_t resource);

8531hipError_t hipGraphicsUnmapResources(int count, hipGraphicsResource_t* resources,

8532 hipStream_t stream __dparm(0));

8541hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource);

8542// doxygen end GL Interop

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

8576hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject);

8577// end of surface

8581#ifdef __cplusplus

8582} /* extern "c" */

8583#endif

8584#ifdef __cplusplus

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

8586template <typename T>

8587static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSize(int* gridSize, int* blockSize,

8588 T f, size_t dynSharedMemPerBlk = 0, int blockSizeLimit = 0) {

8589 return hipOccupancyMaxPotentialBlockSize(gridSize, blockSize, reinterpret_cast<const void*>(f),dynSharedMemPerBlk,blockSizeLimit);

8590}

8591template <typename T>

8592static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeWithFlags(int* gridSize, int* blockSize,

8593 T f, size_t dynSharedMemPerBlk = 0, int blockSizeLimit = 0, unsigned int flags = 0 ) {

8594 return hipOccupancyMaxPotentialBlockSize(gridSize, blockSize, reinterpret_cast<const void*>(f),dynSharedMemPerBlk,blockSizeLimit);

8595}

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

8597

8607template <typename T>

8608hipError_t hipGetSymbolAddress(void** devPtr, const T &symbol) {

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

8610}

8621template <typename T>

8622hipError_t hipGetSymbolSize(size_t* size, const T &symbol) {

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

8624}

8625

8634template <typename T>

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

8636 size_t offset __dparm(0),

8637 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice)) {

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

8639}

8648template <typename T>

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

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

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

8652}

8660template <typename T>

8661hipError_t hipMemcpyFromSymbol(void* dst, const T &symbol,

8662 size_t sizeBytes, size_t offset __dparm(0),

8663 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost)) {

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

8665}

8673template <typename T>

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

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

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

8677}

8678

8690template <class T>

8691inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(

8692 int* numBlocks, T f, int blockSize, size_t dynSharedMemPerBlk) {

8693 return hipOccupancyMaxActiveBlocksPerMultiprocessor(

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

8695}

8709template <class T>

8710inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

8712 return hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

8714}

8735template<typename UnaryFunction, class T>

8736static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(

8737 int* min_grid_size,

8738 int* block_size,

8739 T func,

8740 UnaryFunction block_size_to_dynamic_smem_size,

8741 int block_size_limit = 0,

8742 unsigned int flags = 0) {

8743 if (min_grid_size == nullptr || block_size == nullptr ||

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

8745 return hipErrorInvalidValue;

8746 }

8747

8748 int dev;

8749 hipError_t status;

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

8751 return status;

8752 }

8753

8754 int max_threads_per_cu;

8755 if ((status = hipDeviceGetAttribute(&max_threads_per_cu,

8756 hipDeviceAttributeMaxThreadsPerMultiProcessor, dev)) != hipSuccess) {

8757 return status;

8758 }

8759

8760 int warp_size;

8761 if ((status = hipDeviceGetAttribute(&warp_size,

8762 hipDeviceAttributeWarpSize, dev)) != hipSuccess) {

8763 return status;

8764 }

8765

8766 int max_cu_count;

8767 if ((status = hipDeviceGetAttribute(&max_cu_count,

8768 hipDeviceAttributeMultiprocessorCount, dev)) != hipSuccess) {

8769 return status;

8770 }

8771

8772 struct hipFuncAttributes attr;

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

8774 return status;

8775 }

8776

8777 // Initial limits for the execution

8778 const int func_max_threads_per_block = attr.maxThreadsPerBlock;

8779 if (block_size_limit == 0) {

8780 block_size_limit = func_max_threads_per_block;

8781 }

8782

8783 if (func_max_threads_per_block < block_size_limit) {

8784 block_size_limit = func_max_threads_per_block;

8785 }

8786

8787 const int block_size_limit_aligned =

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

8789

8790 // For maximum search

8791 int max_threads = 0;

8792 int max_block_size{};

8793 int max_num_blocks{};

8794 for (int block_size_check_aligned = block_size_limit_aligned;

8795 block_size_check_aligned > 0;

8796 block_size_check_aligned -= warp_size) {

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

8798 int block_size_check = (block_size_limit < block_size_check_aligned) ?

8799 block_size_limit : block_size_check_aligned;

8800

8801 size_t dyn_smem_size = block_size_to_dynamic_smem_size(block_size_check);

8802 int optimal_blocks;

8803 if ((status = hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

8805 return status;

8806 }

8807

8808 int total_threads = block_size_check * optimal_blocks;

8809 if (total_threads > max_threads) {

8810 max_block_size = block_size_check;

8811 max_num_blocks = optimal_blocks;

8812 max_threads = total_threads;

8813 }

8814

8815 // Break if the logic reached possible maximum

8816 if (max_threads_per_cu == max_threads) {

8817 break;

8818 }

8819 }

8820

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

8822 *min_grid_size = max_num_blocks * max_cu_count;

8823 *block_size = max_block_size;

8824

8825 return status;

8826}

8827

8847template<typename UnaryFunction, class T>

8848static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMem(

8849 int* min_grid_size,

8850 int* block_size,

8851 T func,

8852 UnaryFunction block_size_to_dynamic_smem_size,

8853 int block_size_limit = 0)

8854{

8855 return hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(min_grid_size, block_size, func,

8856 block_size_to_dynamic_smem_size, block_size_limit);

8857}

8872template <typename F>

8873inline hipError_t hipOccupancyMaxPotentialBlockSize(int* gridSize, int* blockSize,

8874 F kernel, size_t dynSharedMemPerBlk, uint32_t blockSizeLimit) {

8875return hipOccupancyMaxPotentialBlockSize(gridSize, blockSize,(hipFunction_t)kernel, dynSharedMemPerBlk, blockSizeLimit);

8876}

8898template <class T>

8899inline hipError_t hipLaunchCooperativeKernel(T f, dim3 gridDim, dim3 blockDim,

8900 void** kernelParams, unsigned int sharedMemBytes, hipStream_t stream) {

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

8902 blockDim, kernelParams, sharedMemBytes, stream);

8903}

8919template <class T>

8920inline hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

8921 unsigned int numDevices, unsigned int flags = 0) {

8922 return hipLaunchCooperativeKernelMultiDevice(launchParamsList, numDevices, flags);

8923}

8938template <class T>

8939inline hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

8940 unsigned int numDevices, unsigned int flags = 0) {

8941 return hipExtLaunchMultiKernelMultiDevice(launchParamsList, numDevices, flags);

8942}

8956template <class T, int dim, enum hipTextureReadMode readMode>

8957DEPRECATED(DEPRECATED_MSG)

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

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

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

8961}

8976template <class T, int dim, enum hipTextureReadMode readMode>

8977DEPRECATED(DEPRECATED_MSG)

8978static inline hipError_t

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

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

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

8982}

8998template<class T, int dim, enum hipTextureReadMode readMode>

8999DEPRECATED(DEPRECATED_MSG)

9000static inline hipError_t hipBindTexture2D(

9001 size_t *offset,

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

9003 const void *devPtr,

9004 size_t width,

9005 size_t height,

9006 size_t pitch)

9007{

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

9009}

9026template<class T, int dim, enum hipTextureReadMode readMode>

9027DEPRECATED(DEPRECATED_MSG)

9028static inline hipError_t hipBindTexture2D(

9029 size_t *offset,

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

9031 const void *devPtr,

9032 const struct hipChannelFormatDesc &desc,

9033 size_t width,

9034 size_t height,

9035 size_t pitch)

9036{

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

9038}

9050template<class T, int dim, enum hipTextureReadMode readMode>

9051DEPRECATED(DEPRECATED_MSG)

9052static inline hipError_t hipBindTextureToArray(

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

9054 hipArray_const_t array)

9055{

9056 struct hipChannelFormatDesc desc;

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

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

9059}

9072template<class T, int dim, enum hipTextureReadMode readMode>

9073DEPRECATED(DEPRECATED_MSG)

9074static inline hipError_t hipBindTextureToArray(

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

9076 hipArray_const_t array,

9077 const struct hipChannelFormatDesc &desc)

9078{

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

9080}

9092template<class T, int dim, enum hipTextureReadMode readMode>

9093DEPRECATED(DEPRECATED_MSG)

9094static inline hipError_t hipBindTextureToMipmappedArray(

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

9096 hipMipmappedArray_const_t mipmappedArray)

9097{

9098 struct hipChannelFormatDesc desc;

9099 hipArray_t levelArray;

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

9101 if (err != hipSuccess) {

9102 return err;

9103 }

9104 err = hipGetChannelDesc(&desc, levelArray);

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

9106}

9119template<class T, int dim, enum hipTextureReadMode readMode>

9120DEPRECATED(DEPRECATED_MSG)

9121static inline hipError_t hipBindTextureToMipmappedArray(

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

9123 hipMipmappedArray_const_t mipmappedArray,

9124 const struct hipChannelFormatDesc &desc)

9125{

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

9127}

9138template<class T, int dim, enum hipTextureReadMode readMode>

9139DEPRECATED(DEPRECATED_MSG)

9140static inline hipError_t hipUnbindTexture(

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

9142{

9143 return hipUnbindTexture(&tex);

9144}

9168static inline hipError_t hipMallocAsync(

9169 void** dev_ptr,

9170 size_t size,

9171 hipMemPool_t mem_pool,

9172 hipStream_t stream) {

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

9174}

9185template<class T>

9186static inline hipError_t hipMallocAsync(

9187 T** dev_ptr,

9188 size_t size,

9189 hipMemPool_t mem_pool,

9190 hipStream_t stream) {

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

9192}

9203template<class T>

9204static inline hipError_t hipMallocAsync(

9205 T** dev_ptr,

9206 size_t size,

9207 hipStream_t stream) {

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

9209}

9220template<class T>

9221static inline hipError_t hipMallocFromPoolAsync(

9222 T** dev_ptr,

9223 size_t size,

9224 hipMemPool_t mem_pool,

9225 hipStream_t stream) {

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

9227}

9233#endif // __cplusplus

9234

9235#ifdef __GNUC__

9236#pragma GCC visibility pop

9237#endif

9238

9239

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

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

9242#else

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

9244#endif

9245

9246

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

9259template <class T>

9260static inline hipError_t hipMalloc(T** devPtr, size_t size) {

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

9262}

9275template <class T>

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

9277 unsigned int flags = hipHostMallocDefault) {

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

9279}

9294template <class T>

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

9296 unsigned int flags = hipMemAttachGlobal) {

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

9298}

9299

9300

9301#endif

9302#endif

9303// doxygen end HIP API

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

9308

9309#if USE_PROF_API

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

9311#endif

driver_types.h

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.

hipCtxPopCurrent

hipError_t hipCtxPopCurrent(hipCtx_t *ctx)

Pop the current/default context and return the popped context.

hipCtxGetSharedMemConfig

hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig *pConfig)

Get Shared memory bank configuration.

hipDevicePrimaryCtxSetFlags

hipError_t hipDevicePrimaryCtxSetFlags(hipDevice_t dev, unsigned int flags)

Set flags for the primary context.

hipDevicePrimaryCtxGetState

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

Get the state of the primary context.

hipCtxGetCurrent

hipError_t hipCtxGetCurrent(hipCtx_t *ctx)

Get the handle of the current/ default context.

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.

hipCtxSetCurrent

hipError_t hipCtxSetCurrent(hipCtx_t ctx)

Set the passed context as current/default.

hipCtxEnablePeerAccess

hipError_t hipCtxEnablePeerAccess(hipCtx_t peerCtx, unsigned int flags)

Enables direct access to memory allocations in a peer context.

hipCtxGetDevice

hipError_t hipCtxGetDevice(hipDevice_t *device)

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

hipCtxDestroy

hipError_t hipCtxDestroy(hipCtx_t ctx)

Destroy a HIP context.

hipCtxPushCurrent

hipError_t hipCtxPushCurrent(hipCtx_t ctx)

Push the context to be set as current/ default context.

hipCtxGetCacheConfig

hipError_t hipCtxGetCacheConfig(hipFuncCache_t *cacheConfig)

Get Cache configuration for a specific function.

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.

hipCtxGetApiVersion

hipError_t hipCtxGetApiVersion(hipCtx_t ctx, int *apiVersion)

Returns the approximate HIP api version.

hipDevicePrimaryCtxReset

hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev)

Resets the primary context on the GPU.

hipCtxSynchronize

hipError_t hipCtxSynchronize(void)

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

hipCtxSetSharedMemConfig

hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config)

Set Shared memory bank configuration.

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.

hipSetDeviceFlags

hipError_t hipSetDeviceFlags(unsigned flags)

The current device behavior is changed according 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:376

hipPointer_attribute

hipPointer_attribute

Definition driver_types.h:517

hipArray_t

struct hipArray * hipArray_t

Definition driver_types.h:76

hipDeviceptr_t

void * hipDeviceptr_t

Definition driver_types.h:47

hipFunction_attribute

hipFunction_attribute

Definition driver_types.h:503

hipArray_const_t

const struct hipArray * hipArray_const_t

Definition driver_types.h:77

hipArray_Format

hipArray_Format

Definition driver_types.h:81

hipResourceType

hipResourceType

Definition driver_types.h:160

hipMemcpyDeviceToHost

@ hipMemcpyDeviceToHost

Device-to-Host Copy.

Definition driver_types.h:379

hipMemcpyHostToDevice

@ hipMemcpyHostToDevice

Host-to-Device Copy.

Definition driver_types.h:378

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.

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.

hipFuncSetSharedMemConfig

hipError_t hipFuncSetSharedMemConfig(const void *func, hipSharedMemConfig config)

Set shared memory configuation for a specific function.

hipFuncSetAttribute

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

Set attribute for a specific function.

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.

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.

hipLimit_t

hipLimit_t

Definition hip_runtime_api.h:651

hipMemAllocationHandleType

hipMemAllocationHandleType

Definition hip_runtime_api.h:971

hipGraphicsResource_t

hipGraphicsResource * hipGraphicsResource_t

Definition hip_runtime_api.h:1211

hipCtx_t

struct ihipCtx_t * hipCtx_t

Definition hip_runtime_api.h:606

__dparm

#define __dparm(x)

Definition hip_runtime_api.h:587

hipStream_t

struct ihipStream_t * hipStream_t

Definition hip_runtime_api.h:615

hipGraphInstantiateResult

hipGraphInstantiateResult

Definition hip_runtime_api.h:1426

hipDevice_t

int hipDevice_t

Definition hip_runtime_api.h:608

hipAccessProperty

hipAccessProperty

Definition hip_runtime_api.h:1286

hipGraphDependencyType

hipGraphDependencyType

Definition hip_runtime_api.h:1642

hipMemRangeAttribute

hipMemRangeAttribute

Definition hip_runtime_api.h:853

hipMemAttachSingle

#define hipMemAttachSingle

Definition hip_runtime_api.h:737

hipMemoryAdvise

hipMemoryAdvise

Definition hip_runtime_api.h:820

hipArrayDefault

#define hipArrayDefault

Definition hip_runtime_api.h:788

hipSharedMemConfig

hipSharedMemConfig

Definition hip_runtime_api.h:1041

hipKernelNodeAttrValue

#define hipKernelNodeAttrValue

Definition hip_runtime_api.h:1330

hipComputeMode

hipComputeMode

Definition hip_runtime_api.h:548

hipEvent_t

struct ihipEvent_t * hipEvent_t

Definition hip_runtime_api.h:643

hipStreamCaptureMode

hipStreamCaptureMode

Definition hip_runtime_api.h:1362

hipDriverProcAddressQueryResult

hipDriverProcAddressQueryResult

Definition hip_runtime_api.h:542

hipLaunchAttributeID

hipLaunchAttributeID

Definition hip_runtime_api.h:1302

hipGraphNodeType

hipGraphNodeType

Definition hip_runtime_api.h:1235

hipExternalMemoryHandleType

hipExternalMemoryHandleType

Definition hip_runtime_api.h:1085

hipMemAttachGlobal

#define hipMemAttachGlobal

Definition hip_runtime_api.h:731

hipFuncAttribute

hipFuncAttribute

Definition hip_runtime_api.h:1024

hipExternalSemaphoreHandleType

hipExternalSemaphoreHandleType

Definition hip_runtime_api.h:1123

hipJitOption

hipJitOption

Definition hip_runtime_api.h:1001

hipDeviceP2PAttr

hipDeviceP2PAttr

Definition hip_runtime_api.h:609

hipGraphDebugDotFlags

hipGraphDebugDotFlags

Definition hip_runtime_api.h:1404

hipUserObjectRetainFlags

hipUserObjectRetainFlags

Definition hip_runtime_api.h:1389

hipError_t

enum __HIP_NODISCARD hipError_t hipError_t

Definition hip_runtime_api.h:287

hipHostFn_t

void(* hipHostFn_t)(void *userData)

Definition hip_runtime_api.h:1253

hipOccupancyDefault

#define hipOccupancyDefault

Definition hip_runtime_api.h:793

hipStreamUpdateCaptureDependenciesFlags

hipStreamUpdateCaptureDependenciesFlags

Definition hip_runtime_api.h:1374

hipGraph_t

struct ihipGraph * hipGraph_t

Definition hip_runtime_api.h:1216

hipChooseDevice

#define hipChooseDevice

Definition hip_runtime_api.h:93

hipMemHandleType

hipMemHandleType

Definition hip_runtime_api.h:1505

hipFlushGPUDirectRDMAWritesOptions

hipFlushGPUDirectRDMAWritesOptions

Definition hip_runtime_api.h:555

hipFuncCache_t

hipFuncCache_t

Definition hip_runtime_api.h:1032

hipUserObjectFlags

hipUserObjectFlags

Definition hip_runtime_api.h:1385

__HIP_NODISCARD

#define __HIP_NODISCARD

Definition hip_runtime_api.h:277

DEPRECATED_MSG

#define DEPRECATED_MSG

Definition hip_runtime_api.h:582

hipGraphMemAttributeType

hipGraphMemAttributeType

Definition hip_runtime_api.h:1379

hipMemPoolAttr

hipMemPoolAttr

Definition hip_runtime_api.h:869

hipDeviceProp_t

#define hipDeviceProp_t

Definition hip_runtime_api.h:92

hipModule_t

struct ihipModule_t * hipModule_t

Definition hip_runtime_api.h:624

hipUserObject_t

struct hipUserObject * hipUserObject_t

Definition hip_runtime_api.h:1229

hipMemOperationType

hipMemOperationType

Definition hip_runtime_api.h:1512

hipExternalSemaphore_t

void * hipExternalSemaphore_t

Definition hip_runtime_api.h:1148

hipGraphicsRegisterFlags

hipGraphicsRegisterFlags

Definition hip_runtime_api.h:1199

hipMemRangeCoherencyMode

hipMemRangeCoherencyMode

Definition hip_runtime_api.h:841

hipMemAccessFlags

hipMemAccessFlags

Definition hip_runtime_api.h:944

hipMemAllocationGranularity_flags

hipMemAllocationGranularity_flags

Definition hip_runtime_api.h:1497

hipGraphExec_t

struct hipGraphExec * hipGraphExec_t

Definition hip_runtime_api.h:1224

hipGraphExecUpdateResult

hipGraphExecUpdateResult

Definition hip_runtime_api.h:1347

hipFunction_t

struct ihipModuleSymbol_t * hipFunction_t

Definition hip_runtime_api.h:625

hipKernelNodeAttrID

#define hipKernelNodeAttrID

Definition hip_runtime_api.h:1322

hipExternalMemory_t

void * hipExternalMemory_t

Definition hip_runtime_api.h:1122

hipStreamCaptureStatus

hipStreamCaptureStatus

Definition hip_runtime_api.h:1367

hipDeviceAttribute_t

hipDeviceAttribute_t

Definition hip_runtime_api.h:407

hipGPUDirectRDMAWritesOrdering

hipGPUDirectRDMAWritesOrdering

Definition hip_runtime_api.h:560

hipGetDeviceProperties

#define hipGetDeviceProperties

Definition hip_runtime_api.h:91

DEPRECATED

#define DEPRECATED(msg)

Definition hip_runtime_api.h:580

hipHostMallocDefault

#define hipHostMallocDefault

Definition hip_runtime_api.h:704

hipGraphicsResource

struct _hipGraphicsResource hipGraphicsResource

Definition hip_runtime_api.h:1209

hipMemAllocationType

hipMemAllocationType

Definition hip_runtime_api.h:959

hipGraphNode_t

struct hipGraphNode * hipGraphNode_t

Definition hip_runtime_api.h:1220

hipMemGenericAllocationHandle_t

struct ihipMemGenericAllocationHandle * hipMemGenericAllocationHandle_t

Definition hip_runtime_api.h:1492

hipMemoryType

hipMemoryType

Definition hip_runtime_api.h:245

hipGraphInstantiateFlags

hipGraphInstantiateFlags

Definition hip_runtime_api.h:1393

hipMemLocationType

hipMemLocationType

Definition hip_runtime_api.h:927

HIP_IPC_HANDLE_SIZE

#define HIP_IPC_HANDLE_SIZE

Definition hip_runtime_api.h:617

hipMemPool_t

struct ihipMemPoolHandle_t * hipMemPool_t

Definition hip_runtime_api.h:629

hipArraySparseSubresourceType

hipArraySparseSubresourceType

Definition hip_runtime_api.h:1520

hipLimitMallocHeapSize

@ hipLimitMallocHeapSize

Definition hip_runtime_api.h:657

hipLimitStackSize

@ hipLimitStackSize

Definition hip_runtime_api.h:652

hipLimitRange

@ hipLimitRange

Supported limit range.

Definition hip_runtime_api.h:659

hipLimitPrintfFifoSize

@ hipLimitPrintfFifoSize

Definition hip_runtime_api.h:655

hipMemHandleTypeWin32

@ hipMemHandleTypeWin32

Allows a Win32 NT handle for exporting. (HANDLE)

Definition hip_runtime_api.h:974

hipMemHandleTypeWin32Kmt

@ hipMemHandleTypeWin32Kmt

Allows a Win32 KMT handle for exporting. (D3DKMT_HANDLE)

Definition hip_runtime_api.h:975

hipMemHandleTypeNone

@ hipMemHandleTypeNone

Does not allow any export mechanism.

Definition hip_runtime_api.h:972

hipMemHandleTypePosixFileDescriptor

@ hipMemHandleTypePosixFileDescriptor

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

Definition hip_runtime_api.h:973

hipGraphInstantiateNodeOperationNotSupported

@ hipGraphInstantiateNodeOperationNotSupported

Definition hip_runtime_api.h:1432

hipGraphInstantiateMultipleDevicesNotSupported

@ hipGraphInstantiateMultipleDevicesNotSupported

Definition hip_runtime_api.h:1434

hipGraphInstantiateError

@ hipGraphInstantiateError

Definition hip_runtime_api.h:1428

hipGraphInstantiateInvalidStructure

@ hipGraphInstantiateInvalidStructure

Definition hip_runtime_api.h:1430

hipGraphInstantiateSuccess

@ hipGraphInstantiateSuccess

Definition hip_runtime_api.h:1427

hipAccessPropertyNormal

@ hipAccessPropertyNormal

Definition hip_runtime_api.h:1287

hipAccessPropertyPersisting

@ hipAccessPropertyPersisting

Definition hip_runtime_api.h:1289

hipAccessPropertyStreaming

@ hipAccessPropertyStreaming

Definition hip_runtime_api.h:1288

hipGraphDependencyTypeDefault

@ hipGraphDependencyTypeDefault

Definition hip_runtime_api.h:1643

hipGraphDependencyTypeProgrammatic

@ hipGraphDependencyTypeProgrammatic

Definition hip_runtime_api.h:1644

hipMemRangeAttributeLastPrefetchLocation

@ hipMemRangeAttributeLastPrefetchLocation

prefetched

Definition hip_runtime_api.h:859

hipMemRangeAttributePreferredLocation

@ hipMemRangeAttributePreferredLocation

The preferred location of the range.

Definition hip_runtime_api.h:856

hipMemRangeAttributeAccessedBy

@ hipMemRangeAttributeAccessedBy

Definition hip_runtime_api.h:857

hipMemRangeAttributeReadMostly

@ hipMemRangeAttributeReadMostly

Definition hip_runtime_api.h:854

hipMemRangeAttributeCoherencyMode

@ hipMemRangeAttributeCoherencyMode

Definition hip_runtime_api.h:861

hipMemAdviseUnsetAccessedBy

@ hipMemAdviseUnsetAccessedBy

Definition hip_runtime_api.h:829

hipMemAdviseUnsetCoarseGrain

@ hipMemAdviseUnsetCoarseGrain

Restores cache coherency policy back to fine-grain.

Definition hip_runtime_api.h:836

hipMemAdviseSetCoarseGrain

@ hipMemAdviseSetCoarseGrain

Definition hip_runtime_api.h:831

hipMemAdviseUnsetPreferredLocation

@ hipMemAdviseUnsetPreferredLocation

Clear the preferred location for the data.

Definition hip_runtime_api.h:826

hipMemAdviseSetAccessedBy

@ hipMemAdviseSetAccessedBy

Definition hip_runtime_api.h:827

hipMemAdviseSetPreferredLocation

@ hipMemAdviseSetPreferredLocation

Definition hip_runtime_api.h:824

hipMemAdviseSetReadMostly

@ hipMemAdviseSetReadMostly

Definition hip_runtime_api.h:821

hipMemAdviseUnsetReadMostly

@ hipMemAdviseUnsetReadMostly

Undo the effect of hipMemAdviseSetReadMostly.

Definition hip_runtime_api.h:823

hipSharedMemBankSizeFourByte

@ hipSharedMemBankSizeFourByte

Definition hip_runtime_api.h:1043

hipSharedMemBankSizeEightByte

@ hipSharedMemBankSizeEightByte

Definition hip_runtime_api.h:1045

hipSharedMemBankSizeDefault

@ hipSharedMemBankSizeDefault

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

Definition hip_runtime_api.h:1042

hipComputeModeProhibited

@ hipComputeModeProhibited

Definition hip_runtime_api.h:551

hipComputeModeExclusive

@ hipComputeModeExclusive

Definition hip_runtime_api.h:550

hipComputeModeDefault

@ hipComputeModeDefault

Definition hip_runtime_api.h:549

hipComputeModeExclusiveProcess

@ hipComputeModeExclusiveProcess

Definition hip_runtime_api.h:552

hipStreamCaptureModeRelaxed

@ hipStreamCaptureModeRelaxed

Definition hip_runtime_api.h:1365

hipStreamCaptureModeThreadLocal

@ hipStreamCaptureModeThreadLocal

Definition hip_runtime_api.h:1364

hipStreamCaptureModeGlobal

@ hipStreamCaptureModeGlobal

Definition hip_runtime_api.h:1363

HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND

@ HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND

Definition hip_runtime_api.h:544

HIP_GET_PROC_ADDRESS_SUCCESS

@ HIP_GET_PROC_ADDRESS_SUCCESS

Definition hip_runtime_api.h:543

HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT

@ HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT

Definition hip_runtime_api.h:545

hipLaunchAttributePriority

@ hipLaunchAttributePriority

Definition hip_runtime_api.h:1305

hipLaunchAttributeAccessPolicyWindow

@ hipLaunchAttributeAccessPolicyWindow

Definition hip_runtime_api.h:1303

hipLaunchAttributeCooperative

@ hipLaunchAttributeCooperative

Definition hip_runtime_api.h:1304

hipGraphNodeTypeGraph

@ hipGraphNodeTypeGraph

Node which executes an embedded graph.

Definition hip_runtime_api.h:1240

hipGraphNodeTypeMemset

@ hipGraphNodeTypeMemset

Memset node.

Definition hip_runtime_api.h:1238

hipGraphNodeTypeEventRecord

@ hipGraphNodeTypeEventRecord

External event record node.

Definition hip_runtime_api.h:1243

hipGraphNodeTypeExtSemaphoreSignal

@ hipGraphNodeTypeExtSemaphoreSignal

External Semaphore signal node.

Definition hip_runtime_api.h:1244

hipGraphNodeTypeMemcpy

@ hipGraphNodeTypeMemcpy

Memcpy node.

Definition hip_runtime_api.h:1237

hipGraphNodeTypeWaitEvent

@ hipGraphNodeTypeWaitEvent

External event wait node.

Definition hip_runtime_api.h:1242

hipGraphNodeTypeCount

@ hipGraphNodeTypeCount

Definition hip_runtime_api.h:1250

hipGraphNodeTypeKernel

@ hipGraphNodeTypeKernel

GPU kernel node.

Definition hip_runtime_api.h:1236

hipGraphNodeTypeHost

@ hipGraphNodeTypeHost

Host (executable) node.

Definition hip_runtime_api.h:1239

hipGraphNodeTypeMemAlloc

@ hipGraphNodeTypeMemAlloc

Memory alloc node.

Definition hip_runtime_api.h:1246

hipGraphNodeTypeMemFree

@ hipGraphNodeTypeMemFree

Memory free node.

Definition hip_runtime_api.h:1247

hipGraphNodeTypeMemcpyFromSymbol

@ hipGraphNodeTypeMemcpyFromSymbol

MemcpyFromSymbol node.

Definition hip_runtime_api.h:1248

hipGraphNodeTypeMemcpyToSymbol

@ hipGraphNodeTypeMemcpyToSymbol

MemcpyToSymbol node.

Definition hip_runtime_api.h:1249

hipGraphNodeTypeEmpty

@ hipGraphNodeTypeEmpty

Empty (no-op) node.

Definition hip_runtime_api.h:1241

hipGraphNodeTypeExtSemaphoreWait

@ hipGraphNodeTypeExtSemaphoreWait

External Semaphore wait node.

Definition hip_runtime_api.h:1245

hipExternalMemoryHandleTypeD3D11Resource

@ hipExternalMemoryHandleTypeD3D11Resource

Definition hip_runtime_api.h:1091

hipExternalMemoryHandleTypeD3D12Resource

@ hipExternalMemoryHandleTypeD3D12Resource

Definition hip_runtime_api.h:1090

hipExternalMemoryHandleTypeNvSciBuf

@ hipExternalMemoryHandleTypeNvSciBuf

Definition hip_runtime_api.h:1093

hipExternalMemoryHandleTypeOpaqueFd

@ hipExternalMemoryHandleTypeOpaqueFd

Definition hip_runtime_api.h:1086

hipExternalMemoryHandleTypeD3D12Heap

@ hipExternalMemoryHandleTypeD3D12Heap

Definition hip_runtime_api.h:1089

hipExternalMemoryHandleTypeOpaqueWin32Kmt

@ hipExternalMemoryHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:1088

hipExternalMemoryHandleTypeOpaqueWin32

@ hipExternalMemoryHandleTypeOpaqueWin32

Definition hip_runtime_api.h:1087

hipExternalMemoryHandleTypeD3D11ResourceKmt

@ hipExternalMemoryHandleTypeD3D11ResourceKmt

Definition hip_runtime_api.h:1092

hipFuncAttributePreferredSharedMemoryCarveout

@ hipFuncAttributePreferredSharedMemoryCarveout

Definition hip_runtime_api.h:1026

hipFuncAttributeMaxDynamicSharedMemorySize

@ hipFuncAttributeMaxDynamicSharedMemorySize

Definition hip_runtime_api.h:1025

hipFuncAttributeMax

@ hipFuncAttributeMax

Definition hip_runtime_api.h:1027

hipExternalSemaphoreHandleTypeNvSciSync

@ hipExternalSemaphoreHandleTypeNvSciSync

Definition hip_runtime_api.h:1129

hipExternalSemaphoreHandleTypeKeyedMutexKmt

@ hipExternalSemaphoreHandleTypeKeyedMutexKmt

Definition hip_runtime_api.h:1131

hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

@ hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:1126

hipExternalSemaphoreHandleTypeKeyedMutex

@ hipExternalSemaphoreHandleTypeKeyedMutex

Definition hip_runtime_api.h:1130

hipExternalSemaphoreHandleTypeD3D11Fence

@ hipExternalSemaphoreHandleTypeD3D11Fence

Definition hip_runtime_api.h:1128

hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

@ hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

Definition hip_runtime_api.h:1133

hipExternalSemaphoreHandleTypeOpaqueFd

@ hipExternalSemaphoreHandleTypeOpaqueFd

Definition hip_runtime_api.h:1124

hipExternalSemaphoreHandleTypeOpaqueWin32

@ hipExternalSemaphoreHandleTypeOpaqueWin32

Definition hip_runtime_api.h:1125

hipExternalSemaphoreHandleTypeTimelineSemaphoreFd

@ hipExternalSemaphoreHandleTypeTimelineSemaphoreFd

Definition hip_runtime_api.h:1132

hipExternalSemaphoreHandleTypeD3D12Fence

@ hipExternalSemaphoreHandleTypeD3D12Fence

Definition hip_runtime_api.h:1127

hipJitOptionCacheMode

@ hipJitOptionCacheMode

Definition hip_runtime_api.h:1016

hipJitOptionFastCompile

@ hipJitOptionFastCompile

Definition hip_runtime_api.h:1018

hipJitOptionInfoLogBuffer

@ hipJitOptionInfoLogBuffer

Definition hip_runtime_api.h:1005

hipJitOptionErrorLogBuffer

@ hipJitOptionErrorLogBuffer

Definition hip_runtime_api.h:1007

hipJitOptionTarget

@ hipJitOptionTarget

Definition hip_runtime_api.h:1011

hipJitOptionThreadsPerBlock

@ hipJitOptionThreadsPerBlock

Definition hip_runtime_api.h:1003

hipJitOptionNumOptions

@ hipJitOptionNumOptions

Definition hip_runtime_api.h:1019

hipJitOptionGenerateLineInfo

@ hipJitOptionGenerateLineInfo

Definition hip_runtime_api.h:1015

hipJitOptionOptimizationLevel

@ hipJitOptionOptimizationLevel

Definition hip_runtime_api.h:1009

hipJitOptionErrorLogBufferSizeBytes

@ hipJitOptionErrorLogBufferSizeBytes

Definition hip_runtime_api.h:1008

hipJitOptionWallTime

@ hipJitOptionWallTime

Definition hip_runtime_api.h:1004

hipJitOptionInfoLogBufferSizeBytes

@ hipJitOptionInfoLogBufferSizeBytes

Definition hip_runtime_api.h:1006

hipJitOptionTargetFromContext

@ hipJitOptionTargetFromContext

Definition hip_runtime_api.h:1010

hipJitOptionGenerateDebugInfo

@ hipJitOptionGenerateDebugInfo

Definition hip_runtime_api.h:1013

hipJitOptionLogVerbose

@ hipJitOptionLogVerbose

Definition hip_runtime_api.h:1014

hipJitOptionMaxRegisters

@ hipJitOptionMaxRegisters

Definition hip_runtime_api.h:1002

hipJitOptionSm3xOpt

@ hipJitOptionSm3xOpt

Definition hip_runtime_api.h:1017

hipJitOptionFallbackStrategy

@ hipJitOptionFallbackStrategy

Definition hip_runtime_api.h:1012

hipDevP2PAttrAccessSupported

@ hipDevP2PAttrAccessSupported

Definition hip_runtime_api.h:611

hipDevP2PAttrHipArrayAccessSupported

@ hipDevP2PAttrHipArrayAccessSupported

Definition hip_runtime_api.h:613

hipDevP2PAttrNativeAtomicSupported

@ hipDevP2PAttrNativeAtomicSupported

Definition hip_runtime_api.h:612

hipDevP2PAttrPerformanceRank

@ hipDevP2PAttrPerformanceRank

Definition hip_runtime_api.h:610

hipGraphDebugDotFlagsKernelNodeAttributes

@ hipGraphDebugDotFlagsKernelNodeAttributes

Definition hip_runtime_api.h:1417

hipGraphDebugDotFlagsMemsetNodeParams

@ hipGraphDebugDotFlagsMemsetNodeParams

Definition hip_runtime_api.h:1409

hipGraphDebugDotFlagsKernelNodeParams

@ hipGraphDebugDotFlagsKernelNodeParams

Definition hip_runtime_api.h:1407

hipGraphDebugDotFlagsExtSemasWaitNodeParams

@ hipGraphDebugDotFlagsExtSemasWaitNodeParams

Definition hip_runtime_api.h:1415

hipGraphDebugDotFlagsHandles

@ hipGraphDebugDotFlagsHandles

Definition hip_runtime_api.h:1419

hipGraphDebugDotFlagsExtSemasSignalNodeParams

@ hipGraphDebugDotFlagsExtSemasSignalNodeParams

Definition hip_runtime_api.h:1413

hipGraphDebugDotFlagsHostNodeParams

@ hipGraphDebugDotFlagsHostNodeParams

Definition hip_runtime_api.h:1410

hipGraphDebugDotFlagsEventNodeParams

@ hipGraphDebugDotFlagsEventNodeParams

Definition hip_runtime_api.h:1411

hipGraphDebugDotFlagsVerbose

@ hipGraphDebugDotFlagsVerbose

Definition hip_runtime_api.h:1405

hipGraphDebugDotFlagsMemcpyNodeParams

@ hipGraphDebugDotFlagsMemcpyNodeParams

Definition hip_runtime_api.h:1408

hipGraphUserObjectMove

@ hipGraphUserObjectMove

Add new reference or retain.

Definition hip_runtime_api.h:1390

hipStreamAddCaptureDependencies

@ hipStreamAddCaptureDependencies

Add new nodes to the dependency set.

Definition hip_runtime_api.h:1375

hipStreamSetCaptureDependencies

@ hipStreamSetCaptureDependencies

Replace the dependency set with the new nodes.

Definition hip_runtime_api.h:1376

hipMemHandleTypeGeneric

@ hipMemHandleTypeGeneric

Generic handle type.

Definition hip_runtime_api.h:1506

hipFlushGPUDirectRDMAWritesOptionHost

@ hipFlushGPUDirectRDMAWritesOptionHost

Definition hip_runtime_api.h:556

hipFlushGPUDirectRDMAWritesOptionMemOps

@ hipFlushGPUDirectRDMAWritesOptionMemOps

Definition hip_runtime_api.h:557

hipFuncCachePreferNone

@ hipFuncCachePreferNone

no preference for shared memory or L1 (default)

Definition hip_runtime_api.h:1033

hipFuncCachePreferEqual

@ hipFuncCachePreferEqual

prefer equal size L1 cache and shared memory

Definition hip_runtime_api.h:1036

hipFuncCachePreferL1

@ hipFuncCachePreferL1

prefer larger L1 cache and smaller shared memory

Definition hip_runtime_api.h:1035

hipFuncCachePreferShared

@ hipFuncCachePreferShared

prefer larger shared memory and smaller L1 cache

Definition hip_runtime_api.h:1034

hipUserObjectNoDestructorSync

@ hipUserObjectNoDestructorSync

Destructor execution is not synchronized.

Definition hip_runtime_api.h:1386

hipGraphMemAttrReservedMemHigh

@ hipGraphMemAttrReservedMemHigh

High watermark of memory, in bytes, currently allocated for graphs.

Definition hip_runtime_api.h:1383

hipGraphMemAttrUsedMemCurrent

@ hipGraphMemAttrUsedMemCurrent

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

Definition hip_runtime_api.h:1380

hipGraphMemAttrUsedMemHigh

@ hipGraphMemAttrUsedMemHigh

High watermark of memory, in bytes, associated with graphs since the last time.

Definition hip_runtime_api.h:1381

hipGraphMemAttrReservedMemCurrent

@ hipGraphMemAttrReservedMemCurrent

Amount of memory, in bytes, currently allocated for graphs.

Definition hip_runtime_api.h:1382

hipMemPoolAttrUsedMemCurrent

@ hipMemPoolAttrUsedMemCurrent

Definition hip_runtime_api.h:916

hipMemPoolAttrReservedMemHigh

@ hipMemPoolAttrReservedMemHigh

Definition hip_runtime_api.h:911

hipMemPoolAttrReservedMemCurrent

@ hipMemPoolAttrReservedMemCurrent

Definition hip_runtime_api.h:905

hipMemPoolAttrReleaseThreshold

@ hipMemPoolAttrReleaseThreshold

Definition hip_runtime_api.h:900

hipMemPoolAttrUsedMemHigh

@ hipMemPoolAttrUsedMemHigh

Definition hip_runtime_api.h:922

hipMemPoolReuseAllowInternalDependencies

@ hipMemPoolReuseAllowInternalDependencies

Definition hip_runtime_api.h:891

hipMemPoolReuseFollowEventDependencies

@ hipMemPoolReuseFollowEventDependencies

Definition hip_runtime_api.h:878

hipMemPoolReuseAllowOpportunistic

@ hipMemPoolReuseAllowOpportunistic

Definition hip_runtime_api.h:884

hipMemOperationTypeMap

@ hipMemOperationTypeMap

Map operation.

Definition hip_runtime_api.h:1513

hipMemOperationTypeUnmap

@ hipMemOperationTypeUnmap

Unmap operation.

Definition hip_runtime_api.h:1514

hipGraphicsRegisterFlagsReadOnly

@ hipGraphicsRegisterFlagsReadOnly

HIP will not write to this registered resource.

Definition hip_runtime_api.h:1201

hipGraphicsRegisterFlagsTextureGather

@ hipGraphicsRegisterFlagsTextureGather

HIP will perform texture gather operations on this registered resource.

Definition hip_runtime_api.h:1205

hipGraphicsRegisterFlagsWriteDiscard

@ hipGraphicsRegisterFlagsWriteDiscard

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

Definition hip_runtime_api.h:1202

hipGraphicsRegisterFlagsNone

@ hipGraphicsRegisterFlagsNone

Definition hip_runtime_api.h:1200

hipGraphicsRegisterFlagsSurfaceLoadStore

@ hipGraphicsRegisterFlagsSurfaceLoadStore

HIP will bind this resource to a surface.

Definition hip_runtime_api.h:1204

hipMemRangeCoherencyModeFineGrain

@ hipMemRangeCoherencyModeFineGrain

Definition hip_runtime_api.h:842

hipMemRangeCoherencyModeIndeterminate

@ hipMemRangeCoherencyModeIndeterminate

Definition hip_runtime_api.h:846

hipMemRangeCoherencyModeCoarseGrain

@ hipMemRangeCoherencyModeCoarseGrain

Definition hip_runtime_api.h:844

hipMemAccessFlagsProtRead

@ hipMemAccessFlagsProtRead

Set the address range read accessible.

Definition hip_runtime_api.h:946

hipMemAccessFlagsProtNone

@ hipMemAccessFlagsProtNone

Default, make the address range not accessible.

Definition hip_runtime_api.h:945

hipMemAccessFlagsProtReadWrite

@ hipMemAccessFlagsProtReadWrite

Set the address range read-write accessible.

Definition hip_runtime_api.h:947

hipMemAllocationGranularityMinimum

@ hipMemAllocationGranularityMinimum

Minimum granularity.

Definition hip_runtime_api.h:1498

hipMemAllocationGranularityRecommended

@ hipMemAllocationGranularityRecommended

Recommended granularity for performance.

Definition hip_runtime_api.h:1499

hipGraphExecUpdateErrorNotSupported

@ hipGraphExecUpdateErrorNotSupported

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

Definition hip_runtime_api.h:1357

hipGraphExecUpdateErrorNodeTypeChanged

@ hipGraphExecUpdateErrorNodeTypeChanged

The update failed because a node type changed.

Definition hip_runtime_api.h:1352

hipGraphExecUpdateErrorTopologyChanged

@ hipGraphExecUpdateErrorTopologyChanged

The update failed because the topology changed.

Definition hip_runtime_api.h:1351

hipGraphExecUpdateErrorUnsupportedFunctionChange

@ hipGraphExecUpdateErrorUnsupportedFunctionChange

Definition hip_runtime_api.h:1359

hipGraphExecUpdateError

@ hipGraphExecUpdateError

Definition hip_runtime_api.h:1349

hipGraphExecUpdateErrorFunctionChanged

@ hipGraphExecUpdateErrorFunctionChanged

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

Definition hip_runtime_api.h:1353

hipGraphExecUpdateSuccess

@ hipGraphExecUpdateSuccess

The update succeeded.

Definition hip_runtime_api.h:1348

hipGraphExecUpdateErrorParametersChanged

@ hipGraphExecUpdateErrorParametersChanged

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

Definition hip_runtime_api.h:1355

hipStreamCaptureStatusInvalidated

@ hipStreamCaptureStatusInvalidated

Definition hip_runtime_api.h:1370

hipStreamCaptureStatusNone

@ hipStreamCaptureStatusNone

Stream is not capturing.

Definition hip_runtime_api.h:1368

hipStreamCaptureStatusActive

@ hipStreamCaptureStatusActive

Stream is actively capturing.

Definition hip_runtime_api.h:1369

hipDeviceAttributeDirectManagedMemAccessFromHost

@ hipDeviceAttributeDirectManagedMemAccessFromHost

Definition hip_runtime_api.h:425

hipDeviceAttributeSurfaceAlignment

@ hipDeviceAttributeSurfaceAlignment

Alignment requirement for surfaces.

Definition hip_runtime_api.h:495

hipDeviceAttributeMaxGridDimX

@ hipDeviceAttributeMaxGridDimX

Max grid size in width.

Definition hip_runtime_api.h:442

hipDeviceAttributeMaxSurfaceCubemapLayered

@ hipDeviceAttributeMaxSurfaceCubemapLayered

Cuda only. Maximum dimension of Cubemap layered surface.

Definition hip_runtime_api.h:451

hipDeviceAttributeMaxSurface3D

@ hipDeviceAttributeMaxSurface3D

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

Definition hip_runtime_api.h:449

hipDeviceAttributeMaxPitch

@ hipDeviceAttributeMaxPitch

Maximum pitch in bytes allowed by memory copies.

Definition hip_runtime_api.h:472

hipDeviceAttributeTccDriver

@ hipDeviceAttributeTccDriver

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

Definition hip_runtime_api.h:496

hipDeviceAttributeHostNativeAtomicSupported

@ hipDeviceAttributeHostNativeAtomicSupported

Link between the device and the host supports native atomic operations.

Definition hip_runtime_api.h:428

hipDeviceAttributePageableMemoryAccessUsesHostPageTables

@ hipDeviceAttributePageableMemoryAccessUsesHostPageTables

Device accesses pageable memory via the host's page tables.

Definition hip_runtime_api.h:481

hipDeviceAttributeUnused5

@ hipDeviceAttributeUnused5

Previously hipDeviceAttributeGcnArchName.

Definition hip_runtime_api.h:516

hipDeviceAttributeMaxBlockDimY

@ hipDeviceAttributeMaxBlockDimY

Max block size in height.

Definition hip_runtime_api.h:440

hipDeviceAttributeMaxSurfaceCubemap

@ hipDeviceAttributeMaxSurfaceCubemap

Cuda only. Maximum dimensions of Cubemap surface.

Definition hip_runtime_api.h:450

hipDeviceAttributePageableMemoryAccess

@ hipDeviceAttributePageableMemoryAccess

Definition hip_runtime_api.h:479

hipDeviceAttributeClockRate

@ hipDeviceAttributeClockRate

Peak clock frequency in kilohertz.

Definition hip_runtime_api.h:416

hipDeviceAttributeCudaCompatibleEnd

@ hipDeviceAttributeCudaCompatibleEnd

Definition hip_runtime_api.h:509

hipDeviceAttributeMaxTexture1DMipmap

@ hipDeviceAttributeMaxTexture1DMipmap

Maximum size of 1D mipmapped texture.

Definition hip_runtime_api.h:456

hipDeviceAttributeComputeCapabilityMajor

@ hipDeviceAttributeComputeCapabilityMajor

Major compute capability version number.

Definition hip_runtime_api.h:436

hipDeviceAttributeGlobalL1CacheSupported

@ hipDeviceAttributeGlobalL1CacheSupported

Device supports caching globals in L1.

Definition hip_runtime_api.h:427

hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

Definition hip_runtime_api.h:525

hipDeviceAttributeAccessPolicyMaxWindowSize

@ hipDeviceAttributeAccessPolicyMaxWindowSize

Cuda only. The maximum size of the window policy in bytes.

Definition hip_runtime_api.h:411

hipDeviceAttributeMaxTexture3DHeight

@ hipDeviceAttributeMaxTexture3DHeight

Maximum dimension height of 3D texture.

Definition hip_runtime_api.h:464

hipDeviceAttributeComputeCapabilityMinor

@ hipDeviceAttributeComputeCapabilityMinor

Minor compute capability version number.

Definition hip_runtime_api.h:475

hipDeviceAttributeMaxTextureCubemap

@ hipDeviceAttributeMaxTextureCubemap

Maximum dimensions of Cubemap texture.

Definition hip_runtime_api.h:467

hipDeviceAttributeDeviceOverlap

@ hipDeviceAttributeDeviceOverlap

Definition hip_runtime_api.h:423

hipDeviceAttributeMaxTexture2DLinear

@ hipDeviceAttributeMaxTexture2DLinear

Maximum dimensions (width, height, pitch) of 2D textures bound to pitched memory.

Definition hip_runtime_api.h:461

hipDeviceAttributeMaxSurface2D

@ hipDeviceAttributeMaxSurface2D

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

Definition hip_runtime_api.h:447

hipDeviceAttributeMaxSurface1DLayered

@ hipDeviceAttributeMaxSurface1DLayered

Cuda only. Maximum dimensions of 1D layered surface.

Definition hip_runtime_api.h:446

hipDeviceAttributeHdpRegFlushCntl

@ hipDeviceAttributeHdpRegFlushCntl

Address of the HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:518

hipDeviceAttributeComputeMode

@ hipDeviceAttributeComputeMode

Compute mode that device is currently in.

Definition hip_runtime_api.h:417

hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

Definition hip_runtime_api.h:519

hipDeviceAttributeAsicRevision

@ hipDeviceAttributeAsicRevision

Revision of the GPU in this device.

Definition hip_runtime_api.h:528

hipDeviceAttributeUnused4

@ hipDeviceAttributeUnused4

Previously hipDeviceAttributeGcnArch.

Definition hip_runtime_api.h:515

hipDeviceAttributeCooperativeMultiDeviceLaunch

@ hipDeviceAttributeCooperativeMultiDeviceLaunch

Support cooperative launch on multiple devices.

Definition hip_runtime_api.h:422

hipDeviceAttributeMaxTexture2DHeight

@ hipDeviceAttributeMaxTexture2DHeight

Maximum dimension hight of 2D texture.

Definition hip_runtime_api.h:458

hipDeviceAttributePersistingL2CacheMaxSize

@ hipDeviceAttributePersistingL2CacheMaxSize

Maximum l2 persisting lines capacity in bytes.

Definition hip_runtime_api.h:485

hipDeviceAttributeEccEnabled

@ hipDeviceAttributeEccEnabled

Whether ECC support is enabled.

Definition hip_runtime_api.h:410

hipDeviceAttributeCanUseHostPointerForRegisteredMem

@ hipDeviceAttributeCanUseHostPointerForRegisteredMem

Definition hip_runtime_api.h:414

hipDeviceAttributePciBusId

@ hipDeviceAttributePciBusId

PCI Bus ID.

Definition hip_runtime_api.h:482

hipDeviceAttributeL2CacheSize

@ hipDeviceAttributeL2CacheSize

Size of L2 cache in bytes. 0 if the device doesn't have L2 cache.

Definition hip_runtime_api.h:432

hipDeviceAttributeKernelExecTimeout

@ hipDeviceAttributeKernelExecTimeout

Run time limit for kernels executed on the device.

Definition hip_runtime_api.h:431

hipDeviceAttributeMaxThreadsDim

@ hipDeviceAttributeMaxThreadsDim

Maximum dimension of a block.

Definition hip_runtime_api.h:469

hipDeviceAttributeSingleToDoublePrecisionPerfRatio

@ hipDeviceAttributeSingleToDoublePrecisionPerfRatio

Cuda only. Performance ratio of single precision to double precision.

Definition hip_runtime_api.h:493

hipDeviceAttributeMaxGridDimY

@ hipDeviceAttributeMaxGridDimY

Max grid size in height.

Definition hip_runtime_api.h:443

hipDeviceAttributeMultiprocessorCount

@ hipDeviceAttributeMultiprocessorCount

Number of multiprocessors on the device.

Definition hip_runtime_api.h:477

hipDeviceAttributeAmdSpecificBegin

@ hipDeviceAttributeAmdSpecificBegin

Definition hip_runtime_api.h:510

hipDeviceAttributeMaxRegistersPerMultiprocessor

@ hipDeviceAttributeMaxRegistersPerMultiprocessor

32-bit registers available per block.

Definition hip_runtime_api.h:488

hipDeviceAttributeIsMultiGpuBoard

@ hipDeviceAttributeIsMultiGpuBoard

Multiple GPU devices.

Definition hip_runtime_api.h:430

hipDeviceAttributeSharedMemPerBlockOptin

@ hipDeviceAttributeSharedMemPerBlockOptin

Maximum shared memory per block usable by special opt in.

Definition hip_runtime_api.h:491

hipDeviceAttributeMaxSurface2DLayered

@ hipDeviceAttributeMaxSurface2DLayered

Cuda only. Maximum dimensions of 2D layered surface.

Definition hip_runtime_api.h:448

hipDeviceAttributeAmdSpecificEnd

@ hipDeviceAttributeAmdSpecificEnd

Definition hip_runtime_api.h:537

hipDeviceAttributeMemoryClockRate

@ hipDeviceAttributeMemoryClockRate

Peak memory clock frequency in kilohertz.

Definition hip_runtime_api.h:474

hipDeviceAttributeMaxGridDimZ

@ hipDeviceAttributeMaxGridDimZ

Max grid size in depth.

Definition hip_runtime_api.h:444

hipDeviceAttributeHdpMemFlushCntl

@ hipDeviceAttributeHdpMemFlushCntl

Address of the HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:517

hipDeviceAttributeUnused2

@ hipDeviceAttributeUnused2

Previously hipDeviceAttributeUuid.

Definition hip_runtime_api.h:502

hipDeviceAttributeFineGrainSupport

@ hipDeviceAttributeFineGrainSupport

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

Definition hip_runtime_api.h:534

hipDeviceAttributeCooperativeLaunch

@ hipDeviceAttributeCooperativeLaunch

Support cooperative launch.

Definition hip_runtime_api.h:421

hipDeviceAttributeUnifiedAddressing

@ hipDeviceAttributeUnifiedAddressing

Cuda only. An unified address space shared with the host.

Definition hip_runtime_api.h:501

hipDeviceAttributeAsyncEngineCount

@ hipDeviceAttributeAsyncEngineCount

Asynchronous engines number.

Definition hip_runtime_api.h:412

hipDeviceAttributeMultiGpuBoardGroupID

@ hipDeviceAttributeMultiGpuBoardGroupID

Unique ID of device group on the same multi-GPU board.

Definition hip_runtime_api.h:476

hipDeviceAttributeStreamPrioritiesSupported

@ hipDeviceAttributeStreamPrioritiesSupported

Whether to support stream priorities.

Definition hip_runtime_api.h:494

hipDeviceAttributeMaxSharedMemoryPerBlock

@ hipDeviceAttributeMaxSharedMemoryPerBlock

Maximum shared memory available per block in bytes.

Definition hip_runtime_api.h:490

hipDeviceAttributeLocalL1CacheSupported

@ hipDeviceAttributeLocalL1CacheSupported

caching locals in L1 is supported

Definition hip_runtime_api.h:433

hipDeviceAttributeCanUseStreamWaitValue

@ hipDeviceAttributeCanUseStreamWaitValue

Definition hip_runtime_api.h:529

hipDeviceAttributeMaxRegistersPerBlock

@ hipDeviceAttributeMaxRegistersPerBlock

Definition hip_runtime_api.h:486

hipDeviceAttributeMaxThreadsPerBlock

@ hipDeviceAttributeMaxThreadsPerBlock

Maximum number of threads per block.

Definition hip_runtime_api.h:470

hipDeviceAttributeMemoryBusWidth

@ hipDeviceAttributeMemoryBusWidth

Global memory bus width in bits.

Definition hip_runtime_api.h:473

hipDeviceAttributeMemoryPoolSupportedHandleTypes

@ hipDeviceAttributeMemoryPoolSupportedHandleTypes

Supported handle mask for HIP Stream Ordered Memory Allocator.

Definition hip_runtime_api.h:507

hipDeviceAttributeComputePreemptionSupported

@ hipDeviceAttributeComputePreemptionSupported

Device supports Compute Preemption.

Definition hip_runtime_api.h:418

hipDeviceAttributeMaxSurface1D

@ hipDeviceAttributeMaxSurface1D

Maximum size of 1D surface.

Definition hip_runtime_api.h:445

hipDeviceAttributeUnused1

@ hipDeviceAttributeUnused1

Previously hipDeviceAttributeName.

Definition hip_runtime_api.h:478

hipDeviceAttributeMaxTexture3DAlt

@ hipDeviceAttributeMaxTexture3DAlt

Maximum dimensions of alternate 3D texture.

Definition hip_runtime_api.h:466

hipDeviceAttributeMaxTexture1DLinear

@ hipDeviceAttributeMaxTexture1DLinear

Definition hip_runtime_api.h:454

hipDeviceAttributeMaxTexture2DGather

@ hipDeviceAttributeMaxTexture2DGather

Maximum dimensions of 2D texture if gather operations performed.

Definition hip_runtime_api.h:459

hipDeviceAttributeWallClockRate

@ hipDeviceAttributeWallClockRate

Constant frequency of wall clock in kilohertz.

Definition hip_runtime_api.h:535

hipDeviceAttributePciDeviceId

@ hipDeviceAttributePciDeviceId

PCI Device ID.

Definition hip_runtime_api.h:483

hipDeviceAttributeCanMapHostMemory

@ hipDeviceAttributeCanMapHostMemory

Whether host memory can be mapped into device address space.

Definition hip_runtime_api.h:413

hipDeviceAttributeMaxTexture1DWidth

@ hipDeviceAttributeMaxTexture1DWidth

Maximum size of 1D texture.

Definition hip_runtime_api.h:452

hipDeviceAttributeConcurrentManagedAccess

@ hipDeviceAttributeConcurrentManagedAccess

Device can coherently access managed memory concurrently with the CPU.

Definition hip_runtime_api.h:420

hipDeviceAttributeVendorSpecificBegin

@ hipDeviceAttributeVendorSpecificBegin

Definition hip_runtime_api.h:538

hipDeviceAttributeManagedMemory

@ hipDeviceAttributeManagedMemory

Device supports allocating managed memory on this system.

Definition hip_runtime_api.h:437

hipDeviceAttributeIntegrated

@ hipDeviceAttributeIntegrated

Device is integrated GPU.

Definition hip_runtime_api.h:429

hipDeviceAttributeMaxTexture2DLayered

@ hipDeviceAttributeMaxTexture2DLayered

Maximum dimensions of 2D layered texture.

Definition hip_runtime_api.h:460

hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

Definition hip_runtime_api.h:521

hipDeviceAttributeMaxTexture3DDepth

@ hipDeviceAttributeMaxTexture3DDepth

Maximum dimension depth of 3D texture.

Definition hip_runtime_api.h:465

hipDeviceAttributeImageSupport

@ hipDeviceAttributeImageSupport

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

Definition hip_runtime_api.h:531

hipDeviceAttributeTotalGlobalMem

@ hipDeviceAttributeTotalGlobalMem

Global memory available on devicice.

Definition hip_runtime_api.h:500

hipDeviceAttributeMaxBlocksPerMultiProcessor

@ hipDeviceAttributeMaxBlocksPerMultiProcessor

Max block size per multiprocessor.

Definition hip_runtime_api.h:438

hipDeviceAttributeIsLargeBar

@ hipDeviceAttributeIsLargeBar

Whether it is LargeBar.

Definition hip_runtime_api.h:527

hipDeviceAttributeMaxTexture2DWidth

@ hipDeviceAttributeMaxTexture2DWidth

Maximum dimension width of 2D texture.

Definition hip_runtime_api.h:457

hipDeviceAttributeMaxBlockDimX

@ hipDeviceAttributeMaxBlockDimX

Max block size in width.

Definition hip_runtime_api.h:439

hipDeviceAttributeMaxTexture3DWidth

@ hipDeviceAttributeMaxTexture3DWidth

Maximum dimension width of 3D texture.

Definition hip_runtime_api.h:463

hipDeviceAttributeUnused3

@ hipDeviceAttributeUnused3

Previously hipDeviceAttributeArch.

Definition hip_runtime_api.h:513

hipDeviceAttributeTotalConstantMemory

@ hipDeviceAttributeTotalConstantMemory

Constant memory size in bytes.

Definition hip_runtime_api.h:499

hipDeviceAttributeTextureAlignment

@ hipDeviceAttributeTextureAlignment

Alignment requirement for textures.

Definition hip_runtime_api.h:497

hipDeviceAttributeMaxTexture1DLayered

@ hipDeviceAttributeMaxTexture1DLayered

Maximum dimensions of 1D layered texture.

Definition hip_runtime_api.h:453

hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

@ hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

Maximum Shared Memory PerMultiprocessor.

Definition hip_runtime_api.h:514

hipDeviceAttributeReservedSharedMemPerBlock

@ hipDeviceAttributeReservedSharedMemPerBlock

Shared memory reserved by CUDA driver per block.

Definition hip_runtime_api.h:489

hipDeviceAttributeCudaCompatibleBegin

@ hipDeviceAttributeCudaCompatibleBegin

Definition hip_runtime_api.h:408

hipDeviceAttributeConcurrentKernels

@ hipDeviceAttributeConcurrentKernels

Device can possibly execute multiple kernels concurrently.

Definition hip_runtime_api.h:419

hipDeviceAttributeLuid

@ hipDeviceAttributeLuid

8-byte locally unique identifier in 8 bytes. Undefined on TCC and non-Windows platforms

Definition hip_runtime_api.h:434

hipDeviceAttributePciDomainID

@ hipDeviceAttributePciDomainID

PCI Domain ID.

Definition hip_runtime_api.h:484

hipDeviceAttributeMaxThreadsPerMultiProcessor

@ hipDeviceAttributeMaxThreadsPerMultiProcessor

Maximum resident threads per multiprocessor.

Definition hip_runtime_api.h:471

hipDeviceAttributeTexturePitchAlignment

@ hipDeviceAttributeTexturePitchAlignment

Pitch alignment requirement for 2D texture references bound to pitched memory;.

Definition hip_runtime_api.h:498

hipDeviceAttributePhysicalMultiProcessorCount

@ hipDeviceAttributePhysicalMultiProcessorCount

Definition hip_runtime_api.h:532

hipDeviceAttributeHostRegisterSupported

@ hipDeviceAttributeHostRegisterSupported

Can device support host memory registration via hipHostRegister.

Definition hip_runtime_api.h:506

hipDeviceAttributeSharedMemPerMultiprocessor

@ hipDeviceAttributeSharedMemPerMultiprocessor

Shared memory available per multiprocessor.

Definition hip_runtime_api.h:492

hipDeviceAttributeLuidDeviceNodeMask

@ hipDeviceAttributeLuidDeviceNodeMask

Luid device node mask. Undefined on TCC and non-Windows platforms.

Definition hip_runtime_api.h:435

hipDeviceAttributeMaxTextureCubemapLayered

@ hipDeviceAttributeMaxTextureCubemapLayered

Maximum dimensions of Cubemap layered texture.

Definition hip_runtime_api.h:468

hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

Definition hip_runtime_api.h:523

hipDeviceAttributeVirtualMemoryManagementSupported

@ hipDeviceAttributeVirtualMemoryManagementSupported

Device supports HIP virtual memory management.

Definition hip_runtime_api.h:505

hipDeviceAttributeMemoryPoolsSupported

@ hipDeviceAttributeMemoryPoolsSupported

Device supports HIP Stream Ordered Memory Allocator.

Definition hip_runtime_api.h:504

hipDeviceAttributeClockInstructionRate

@ hipDeviceAttributeClockInstructionRate

Frequency in khz of the timer used by the device-side "clock*".

Definition hip_runtime_api.h:512

hipDeviceAttributeMaxTexture2DMipmap

@ hipDeviceAttributeMaxTexture2DMipmap

Maximum dimensions of 2D mipmapped texture.

Definition hip_runtime_api.h:462

hipDeviceAttributeMaxBlockDimZ

@ hipDeviceAttributeMaxBlockDimZ

Max block size in depth.

Definition hip_runtime_api.h:441

hipDeviceAttributeWarpSize

@ hipDeviceAttributeWarpSize

Warp size in threads.

Definition hip_runtime_api.h:503

hipGPUDirectRDMAWritesOrderingOwner

@ hipGPUDirectRDMAWritesOrderingOwner

Definition hip_runtime_api.h:562

hipGPUDirectRDMAWritesOrderingNone

@ hipGPUDirectRDMAWritesOrderingNone

Definition hip_runtime_api.h:561

hipGPUDirectRDMAWritesOrderingAllDevices

@ hipGPUDirectRDMAWritesOrderingAllDevices

Definition hip_runtime_api.h:563

hipMemAllocationTypeMax

@ hipMemAllocationTypeMax

Definition hip_runtime_api.h:965

hipMemAllocationTypePinned

@ hipMemAllocationTypePinned

Definition hip_runtime_api.h:964

hipMemAllocationTypeInvalid

@ hipMemAllocationTypeInvalid

Definition hip_runtime_api.h:960

hipMemoryTypeDevice

@ hipMemoryTypeDevice

Definition hip_runtime_api.h:248

hipMemoryTypeHost

@ hipMemoryTypeHost

Memory is physically located on host.

Definition hip_runtime_api.h:247

hipMemoryTypeUnregistered

@ hipMemoryTypeUnregistered

Unregistered memory.

Definition hip_runtime_api.h:246

hipMemoryTypeArray

@ hipMemoryTypeArray

Definition hip_runtime_api.h:253

hipMemoryTypeManaged

@ hipMemoryTypeManaged

Definition hip_runtime_api.h:250

hipMemoryTypeUnified

@ hipMemoryTypeUnified

unified address space

Definition hip_runtime_api.h:255

hipGraphInstantiateFlagAutoFreeOnLaunch

@ hipGraphInstantiateFlagAutoFreeOnLaunch

Automatically free memory allocated in a graph before relaunching.

Definition hip_runtime_api.h:1394

hipGraphInstantiateFlagUseNodePriority

@ hipGraphInstantiateFlagUseNodePriority

Run the graph using the per-node priority attributes rather than the priority of the stream it is lau...

Definition hip_runtime_api.h:1400

hipGraphInstantiateFlagUpload

@ hipGraphInstantiateFlagUpload

Automatically upload the graph after instantiation.

Definition hip_runtime_api.h:1396

hipGraphInstantiateFlagDeviceLaunch

@ hipGraphInstantiateFlagDeviceLaunch

Instantiate the graph to be launched from the device.

Definition hip_runtime_api.h:1398

hipMemLocationTypeInvalid

@ hipMemLocationTypeInvalid

Definition hip_runtime_api.h:928

hipMemLocationTypeDevice

@ hipMemLocationTypeDevice

Device location, thus it's HIP device ID.

Definition hip_runtime_api.h:929

hipArraySparseSubresourceTypeSparseLevel

@ hipArraySparseSubresourceTypeSparseLevel

Sparse level.

Definition hip_runtime_api.h:1521

hipArraySparseSubresourceTypeMiptail

@ hipArraySparseSubresourceTypeMiptail

Miptail.

Definition hip_runtime_api.h:1522

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.

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.

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.

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.

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.