/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/latest/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;

120 int minor;

125 size_t textureAlignment;

126 size_t texturePitchAlignment;

127 int deviceOverlap;

128 int multiProcessorCount;

129 int kernelExecTimeoutEnabled;

130 int integrated;

131 int canMapHostMemory;

132 int computeMode;

133 int maxTexture1D;

134 int maxTexture1DMipmap;

135 int maxTexture1DLinear;

136 int maxTexture2D[2];

137 int maxTexture2DMipmap[2];

138 int maxTexture2DLinear[3];

139 int maxTexture2DGather[2];

140 int maxTexture3D[3];

142 int maxTexture3DAlt[3];

143 int maxTextureCubemap;

144 int maxTexture1DLayered[2];

145 int maxTexture2DLayered[3];

146 int maxTextureCubemapLayered[2];

147 int maxSurface1D;

148 int maxSurface2D[2];

149 int maxSurface3D[3];

150 int maxSurface1DLayered[2];

151 int maxSurface2DLayered[3];

152 int maxSurfaceCubemap;

153 int maxSurfaceCubemapLayered[2];

154 size_t surfaceAlignment;

155 int concurrentKernels;

156 int ECCEnabled;

157 int pciBusID;

158 int pciDeviceID;

159 int pciDomainID;

160 int tccDriver;

161 int asyncEngineCount;

162 int unifiedAddressing;

163 int memoryClockRate;

164 int memoryBusWidth;

165 int l2CacheSize;

166 int persistingL2CacheMaxSize;

167 int maxThreadsPerMultiProcessor;

168 int streamPrioritiesSupported;

169 int globalL1CacheSupported;

170 int localL1CacheSupported;

171 size_t sharedMemPerMultiprocessor;

172 int regsPerMultiprocessor;

173 int managedMemory;

174 int isMultiGpuBoard;

175 int multiGpuBoardGroupID;

176 int hostNativeAtomicSupported;

177 int singleToDoublePrecisionPerfRatio;

178 int pageableMemoryAccess;

180 int concurrentManagedAccess;

182 int computePreemptionSupported;

183 int canUseHostPointerForRegisteredMem;

185 int cooperativeLaunch;

186 int cooperativeMultiDeviceLaunch;

188 size_t

189 sharedMemPerBlockOptin;

190 int pageableMemoryAccessUsesHostPageTables;

192 int directManagedMemAccessFromHost;

194 int maxBlocksPerMultiProcessor;

195 int accessPolicyMaxWindowSize;

196 size_t reservedSharedMemPerBlock;

197 int hostRegisterSupported;

198 int sparseHipArraySupported;

199 int hostRegisterReadOnlySupported;

201 int timelineSemaphoreInteropSupported;

202 int memoryPoolsSupported;

203 int gpuDirectRDMASupported;

204 unsigned int gpuDirectRDMAFlushWritesOptions;

206 int gpuDirectRDMAWritesOrdering;

207 unsigned int

208 memoryPoolSupportedHandleTypes;

209 int deferredMappingHipArraySupported;

211 int ipcEventSupported;

212 int clusterLaunch;

213 int unifiedFunctionPointers;

214 int reserved[63];

215

216 int hipReserved[32];

217

218 /* HIP Only struct members */

219 char gcnArchName[256];

220 size_t maxSharedMemoryPerMultiProcessor;

221 int clockInstructionRate;

223 hipDeviceArch_t arch;

224 unsigned int* hdpMemFlushCntl;

225 unsigned int* hdpRegFlushCntl;

226 int cooperativeMultiDeviceUnmatchedFunc;

229 int cooperativeMultiDeviceUnmatchedGridDim;

232 int cooperativeMultiDeviceUnmatchedBlockDim;

235 int cooperativeMultiDeviceUnmatchedSharedMem;

238 int isLargeBar;

239 int asicRevision;

240} hipDeviceProp_t;

241

248typedef enum hipMemoryType {

249 hipMemoryTypeUnregistered = 0,

250 hipMemoryTypeHost = 1,

251 hipMemoryTypeDevice = 2,

253 hipMemoryTypeManaged = 3,

256 hipMemoryTypeArray = 10,

258 hipMemoryTypeUnified = 11

259

260} hipMemoryType;

261

265typedef struct hipPointerAttribute_t {

266 enum hipMemoryType type;

267 int device;

268 void* devicePointer;

269 void* hostPointer;

270 int isManaged;

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

272 /* peers? */

273} hipPointerAttribute_t;

274

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

276// we can make that yield a warning

277#if __cplusplus >= 201703L

278#define __HIP_NODISCARD [[nodiscard]]

279#else

280#define __HIP_NODISCARD

281#endif

282

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

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

289

290typedef enum __HIP_NODISCARD hipError_t {

291 hipSuccess = 0,

292 hipErrorInvalidValue = 1,

294 hipErrorOutOfMemory = 2,

295 // Deprecated

296 hipErrorMemoryAllocation = 2,

297 hipErrorNotInitialized = 3,

298 // Deprecated

299 hipErrorInitializationError = 3,

300 hipErrorDeinitialized = 4,

301 hipErrorProfilerDisabled = 5,

302 hipErrorProfilerNotInitialized = 6,

303 hipErrorProfilerAlreadyStarted = 7,

304 hipErrorProfilerAlreadyStopped = 8,

305 hipErrorInvalidConfiguration = 9,

306 hipErrorInvalidPitchValue = 12,

307 hipErrorInvalidSymbol = 13,

308 hipErrorInvalidDevicePointer = 17,

309 hipErrorInvalidMemcpyDirection = 21,

310 hipErrorInsufficientDriver = 35,

311 hipErrorMissingConfiguration = 52,

312 hipErrorPriorLaunchFailure = 53,

313 hipErrorInvalidDeviceFunction = 98,

314 hipErrorNoDevice = 100,

315 hipErrorInvalidDevice = 101,

316 hipErrorInvalidImage = 200,

317 hipErrorInvalidContext = 201,

318 hipErrorContextAlreadyCurrent = 202,

319 hipErrorMapFailed = 205,

320 // Deprecated

321 hipErrorMapBufferObjectFailed = 205,

322 hipErrorUnmapFailed = 206,

323 hipErrorArrayIsMapped = 207,

324 hipErrorAlreadyMapped = 208,

325 hipErrorNoBinaryForGpu = 209,

326 hipErrorAlreadyAcquired = 210,

327 hipErrorNotMapped = 211,

328 hipErrorNotMappedAsArray = 212,

329 hipErrorNotMappedAsPointer = 213,

330 hipErrorECCNotCorrectable = 214,

331 hipErrorUnsupportedLimit = 215,

332 hipErrorContextAlreadyInUse = 216,

333 hipErrorPeerAccessUnsupported = 217,

334 hipErrorInvalidKernelFile = 218,

335 hipErrorInvalidGraphicsContext = 219,

336 hipErrorInvalidSource = 300,

337 hipErrorFileNotFound = 301,

338 hipErrorSharedObjectSymbolNotFound = 302,

339 hipErrorSharedObjectInitFailed = 303,

340 hipErrorOperatingSystem = 304,

341 hipErrorInvalidHandle = 400,

342 // Deprecated

343 hipErrorInvalidResourceHandle = 400,

344 hipErrorIllegalState = 401,

345 hipErrorNotFound = 500,

346 hipErrorNotReady = 600,

350 hipErrorIllegalAddress = 700,

351 hipErrorLaunchOutOfResources = 701,

352 hipErrorLaunchTimeOut = 702,

353 hipErrorPeerAccessAlreadyEnabled = 704,

355 hipErrorPeerAccessNotEnabled = 705,

356 hipErrorSetOnActiveProcess = 708,

357 hipErrorContextIsDestroyed = 709,

358 hipErrorAssert = 710,

359 hipErrorHostMemoryAlreadyRegistered = 712,

361 hipErrorHostMemoryNotRegistered = 713,

363 hipErrorLaunchFailure = 719,

364 hipErrorCooperativeLaunchTooLarge = 720,

368 hipErrorNotSupported = 801,

369 hipErrorStreamCaptureUnsupported = 900,

371 hipErrorStreamCaptureInvalidated = 901,

373 hipErrorStreamCaptureMerge = 902,

375 hipErrorStreamCaptureUnmatched = 903,

376 hipErrorStreamCaptureUnjoined = 904,

378 hipErrorStreamCaptureIsolation = 905,

382 hipErrorStreamCaptureImplicit = 906,

385 hipErrorCapturedEvent = 907,

387 hipErrorStreamCaptureWrongThread = 908,

391 hipErrorGraphExecUpdateFailure = 910,

395 hipErrorUnknown = 999,

396 // HSA Runtime Error Codes start here.

397 hipErrorRuntimeMemory = 1052,

399 hipErrorRuntimeOther = 1053,

401 hipErrorTbd

402} hipError_t;

403

404#undef __HIP_NODISCARD

405

410typedef enum hipDeviceAttribute_t {

411 hipDeviceAttributeCudaCompatibleBegin = 0,

412

413 hipDeviceAttributeEccEnabled = hipDeviceAttributeCudaCompatibleBegin,

414 hipDeviceAttributeAccessPolicyMaxWindowSize,

415 hipDeviceAttributeAsyncEngineCount,

416 hipDeviceAttributeCanMapHostMemory,

417 hipDeviceAttributeCanUseHostPointerForRegisteredMem,

419 hipDeviceAttributeClockRate,

420 hipDeviceAttributeComputeMode,

421 hipDeviceAttributeComputePreemptionSupported,

422 hipDeviceAttributeConcurrentKernels,

423 hipDeviceAttributeConcurrentManagedAccess,

424 hipDeviceAttributeCooperativeLaunch,

425 hipDeviceAttributeCooperativeMultiDeviceLaunch,

426 hipDeviceAttributeDeviceOverlap,

428 hipDeviceAttributeDirectManagedMemAccessFromHost,

430 hipDeviceAttributeGlobalL1CacheSupported,

431 hipDeviceAttributeHostNativeAtomicSupported,

432 hipDeviceAttributeIntegrated,

433 hipDeviceAttributeIsMultiGpuBoard,

434 hipDeviceAttributeKernelExecTimeout,

435 hipDeviceAttributeL2CacheSize,

436 hipDeviceAttributeLocalL1CacheSupported,

437 hipDeviceAttributeLuid,

438 hipDeviceAttributeLuidDeviceNodeMask,

439 hipDeviceAttributeComputeCapabilityMajor,

440 hipDeviceAttributeManagedMemory,

441 hipDeviceAttributeMaxBlocksPerMultiProcessor,

442 hipDeviceAttributeMaxBlockDimX,

443 hipDeviceAttributeMaxBlockDimY,

444 hipDeviceAttributeMaxBlockDimZ,

445 hipDeviceAttributeMaxGridDimX,

446 hipDeviceAttributeMaxGridDimY,

447 hipDeviceAttributeMaxGridDimZ,

448 hipDeviceAttributeMaxSurface1D,

449 hipDeviceAttributeMaxSurface1DLayered,

450 hipDeviceAttributeMaxSurface2D,

451 hipDeviceAttributeMaxSurface2DLayered,

452 hipDeviceAttributeMaxSurface3D,

453 hipDeviceAttributeMaxSurfaceCubemap,

454 hipDeviceAttributeMaxSurfaceCubemapLayered,

455 hipDeviceAttributeMaxTexture1DWidth,

456 hipDeviceAttributeMaxTexture1DLayered,

457 hipDeviceAttributeMaxTexture1DLinear,

459 hipDeviceAttributeMaxTexture1DMipmap,

460 hipDeviceAttributeMaxTexture2DWidth,

461 hipDeviceAttributeMaxTexture2DHeight,

462 hipDeviceAttributeMaxTexture2DGather,

463 hipDeviceAttributeMaxTexture2DLayered,

464 hipDeviceAttributeMaxTexture2DLinear,

465 hipDeviceAttributeMaxTexture2DMipmap,

466 hipDeviceAttributeMaxTexture3DWidth,

467 hipDeviceAttributeMaxTexture3DHeight,

468 hipDeviceAttributeMaxTexture3DDepth,

469 hipDeviceAttributeMaxTexture3DAlt,

470 hipDeviceAttributeMaxTextureCubemap,

471 hipDeviceAttributeMaxTextureCubemapLayered,

472 hipDeviceAttributeMaxThreadsDim,

473 hipDeviceAttributeMaxThreadsPerBlock,

474 hipDeviceAttributeMaxThreadsPerMultiProcessor,

475 hipDeviceAttributeMaxPitch,

476 hipDeviceAttributeMemoryBusWidth,

477 hipDeviceAttributeMemoryClockRate,

478 hipDeviceAttributeComputeCapabilityMinor,

479 hipDeviceAttributeMultiGpuBoardGroupID,

480 hipDeviceAttributeMultiprocessorCount,

481 hipDeviceAttributeUnused1,

482 hipDeviceAttributePageableMemoryAccess,

484 hipDeviceAttributePageableMemoryAccessUsesHostPageTables,

485 hipDeviceAttributePciBusId,

486 hipDeviceAttributePciDeviceId,

487 hipDeviceAttributePciDomainID,

488 hipDeviceAttributePersistingL2CacheMaxSize,

489 hipDeviceAttributeMaxRegistersPerBlock,

491 hipDeviceAttributeMaxRegistersPerMultiprocessor,

492 hipDeviceAttributeReservedSharedMemPerBlock,

493 hipDeviceAttributeMaxSharedMemoryPerBlock,

494 hipDeviceAttributeSharedMemPerBlockOptin,

495 hipDeviceAttributeSharedMemPerMultiprocessor,

496 hipDeviceAttributeSingleToDoublePrecisionPerfRatio,

497 hipDeviceAttributeStreamPrioritiesSupported,

498 hipDeviceAttributeSurfaceAlignment,

499 hipDeviceAttributeTccDriver,

500 hipDeviceAttributeTextureAlignment,

501 hipDeviceAttributeTexturePitchAlignment,

502 hipDeviceAttributeTotalConstantMemory,

503 hipDeviceAttributeTotalGlobalMem,

504 hipDeviceAttributeUnifiedAddressing,

505 hipDeviceAttributeUnused2,

506 hipDeviceAttributeWarpSize,

507 hipDeviceAttributeMemoryPoolsSupported,

508 hipDeviceAttributeVirtualMemoryManagementSupported,

509 hipDeviceAttributeHostRegisterSupported,

510 hipDeviceAttributeMemoryPoolSupportedHandleTypes,

511

512 hipDeviceAttributeCudaCompatibleEnd = 9999,

513 hipDeviceAttributeAmdSpecificBegin = 10000,

514

515 hipDeviceAttributeClockInstructionRate = hipDeviceAttributeAmdSpecificBegin,

516 hipDeviceAttributeUnused3,

517 hipDeviceAttributeMaxSharedMemoryPerMultiprocessor,

518 hipDeviceAttributeUnused4,

519 hipDeviceAttributeUnused5,

520 hipDeviceAttributeHdpMemFlushCntl,

521 hipDeviceAttributeHdpRegFlushCntl,

522 hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc,

524 hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim,

526 hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim,

528 hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem,

530 hipDeviceAttributeIsLargeBar,

531 hipDeviceAttributeAsicRevision,

532 hipDeviceAttributeCanUseStreamWaitValue,

534 hipDeviceAttributeImageSupport,

535 hipDeviceAttributePhysicalMultiProcessorCount,

537 hipDeviceAttributeFineGrainSupport,

538 hipDeviceAttributeWallClockRate,

539

540 hipDeviceAttributeAmdSpecificEnd = 19999,

541 hipDeviceAttributeVendorSpecificBegin = 20000,

542 // Extended attributes for vendors

543} hipDeviceAttribute_t;

544

545typedef enum hipDriverProcAddressQueryResult {

546 HIP_GET_PROC_ADDRESS_SUCCESS = 0,

547 HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND = 1,

548 HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT = 2

549} hipDriverProcAddressQueryResult;

550

551enum hipComputeMode {

552 hipComputeModeDefault = 0,

553 hipComputeModeExclusive = 1,

554 hipComputeModeProhibited = 2,

555 hipComputeModeExclusiveProcess = 3

556};

557

558enum hipFlushGPUDirectRDMAWritesOptions {

559 hipFlushGPUDirectRDMAWritesOptionHost = 1 << 0,

560 hipFlushGPUDirectRDMAWritesOptionMemOps = 1 << 1

561};

562

563enum hipGPUDirectRDMAWritesOrdering {

564 hipGPUDirectRDMAWritesOrderingNone = 0,

565 hipGPUDirectRDMAWritesOrderingOwner = 100,

566 hipGPUDirectRDMAWritesOrderingAllDevices = 200

567};

568

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

570

571#include <stdint.h>

572#include <stddef.h>

573#ifndef GENERIC_GRID_LAUNCH

574#define GENERIC_GRID_LAUNCH 1

575#endif

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

577#include <hip/driver_types.h>

578#include <hip/texture_types.h>

579#include <hip/surface_types.h>

580#if defined(_MSC_VER)

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

582#else // !defined(_MSC_VER)

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

584#endif // !defined(_MSC_VER)

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

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

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

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

589#ifdef __cplusplus

590 #define __dparm(x) \

591 = x

592#else

593 #define __dparm(x)

594#endif

595#ifdef __GNUC__

596#pragma GCC visibility push (default)

597#endif

598#ifdef __cplusplus

599namespace hip_impl {

600hipError_t hip_init();

601} // namespace hip_impl

602#endif

603// Structure definitions:

604#ifdef __cplusplus

605extern "C" {

606#endif

607//---

608// API-visible structures

609typedef struct ihipCtx_t* hipCtx_t;

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

611typedef int hipDevice_t;

612typedef enum hipDeviceP2PAttr {

613 hipDevP2PAttrPerformanceRank = 0,

614 hipDevP2PAttrAccessSupported,

615 hipDevP2PAttrNativeAtomicSupported,

616 hipDevP2PAttrHipArrayAccessSupported

617} hipDeviceP2PAttr;

618typedef struct ihipStream_t* hipStream_t;

619#define hipIpcMemLazyEnablePeerAccess 0x01

620#define HIP_IPC_HANDLE_SIZE 64

621typedef struct hipIpcMemHandle_st {

622 char reserved[HIP_IPC_HANDLE_SIZE];

623} hipIpcMemHandle_t;

624typedef struct hipIpcEventHandle_st {

625 char reserved[HIP_IPC_HANDLE_SIZE];

626} hipIpcEventHandle_t;

627typedef struct ihipModule_t* hipModule_t;

628typedef struct ihipModuleSymbol_t* hipFunction_t;

632typedef struct ihipMemPoolHandle_t* hipMemPool_t;

633

634typedef struct hipFuncAttributes {

635 int binaryVersion;

636 int cacheModeCA;

637 size_t constSizeBytes;

638 size_t localSizeBytes;

639 int maxDynamicSharedSizeBytes;

640 int maxThreadsPerBlock;

641 int numRegs;

642 int preferredShmemCarveout;

643 int ptxVersion;

644 size_t sharedSizeBytes;

645} hipFuncAttributes;

646typedef struct ihipEvent_t* hipEvent_t;

647

654enum hipLimit_t {

655 hipLimitStackSize = 0x0,

658 hipLimitPrintfFifoSize = 0x01,

660 hipLimitMallocHeapSize = 0x02,

662 hipLimitRange

663};

667//Flags that can be used with hipStreamCreateWithFlags.

669#define hipStreamDefault 0x00

670

672#define hipStreamNonBlocking 0x01

673

674//Flags that can be used with hipEventCreateWithFlags.

676#define hipEventDefault 0x0

677

679#define hipEventBlockingSync 0x1

680

682#define hipEventDisableTiming 0x2

683

685#define hipEventInterprocess 0x4

686

695#define hipEventDisableSystemFence 0x20000000

696

699#define hipEventReleaseToDevice 0x40000000

700

703#define hipEventReleaseToSystem 0x80000000

704

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

707#define hipHostMallocDefault 0x0

708#define hipHostAllocDefault 0x0

709

711#define hipHostMallocPortable 0x1

712#define hipHostAllocPortable 0x1

713

716#define hipHostMallocMapped 0x2

717#define hipHostAllocMapped 0x2

718

722#define hipHostMallocWriteCombined 0x4

723#define hipHostAllocWriteCombined 0x4

724

729#define hipHostMallocNumaUser 0x20000000

730

732#define hipHostMallocCoherent 0x40000000

733

735#define hipHostMallocNonCoherent 0x80000000

736

738#define hipMemAttachGlobal 0x01

739

741#define hipMemAttachHost 0x02

742

744#define hipMemAttachSingle 0x04

745

746#define hipDeviceMallocDefault 0x0

747

749#define hipDeviceMallocFinegrained 0x1

750

752#define hipMallocSignalMemory 0x2

753

755#define hipDeviceMallocUncached 0x3

756

758#define hipDeviceMallocContiguous 0x4

759

760//Flags that can be used with hipHostRegister.

762#define hipHostRegisterDefault 0x0

763

765#define hipHostRegisterPortable 0x1

766

769#define hipHostRegisterMapped 0x2

770

772#define hipHostRegisterIoMemory 0x4

773

775#define hipHostRegisterReadOnly 0x08

776

778#define hipExtHostRegisterCoarseGrained 0x8

779

781#define hipDeviceScheduleAuto 0x0

782

785#define hipDeviceScheduleSpin 0x1

786

789#define hipDeviceScheduleYield 0x2

790#define hipDeviceScheduleBlockingSync 0x4

791#define hipDeviceScheduleMask 0x7

792#define hipDeviceMapHost 0x8

793#define hipDeviceLmemResizeToMax 0x10

795#define hipArrayDefault 0x00

796#define hipArrayLayered 0x01

797#define hipArraySurfaceLoadStore 0x02

798#define hipArrayCubemap 0x04

799#define hipArrayTextureGather 0x08

800#define hipOccupancyDefault 0x00

801#define hipOccupancyDisableCachingOverride 0x01

802#define hipCooperativeLaunchMultiDeviceNoPreSync 0x01

803#define hipCooperativeLaunchMultiDeviceNoPostSync 0x02

804#define hipCpuDeviceId ((int)-1)

805#define hipInvalidDeviceId ((int)-2)

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

808#define hipExtAnyOrderLaunch 0x01

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

810#define hipStreamWaitValueGte 0x0

811#define hipStreamWaitValueEq 0x1

812#define hipStreamWaitValueAnd 0x2

813#define hipStreamWaitValueNor 0x3

814// Stream per thread

816#define hipStreamPerThread ((hipStream_t)2)

817

818#define hipStreamLegacy ((hipStream_t)1)

819

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

821#define hipExternalMemoryDedicated 0x1

827typedef enum hipMemoryAdvise {

828 hipMemAdviseSetReadMostly = 1,

830 hipMemAdviseUnsetReadMostly = 2,

831 hipMemAdviseSetPreferredLocation = 3,

833 hipMemAdviseUnsetPreferredLocation = 4,

834 hipMemAdviseSetAccessedBy = 5,

836 hipMemAdviseUnsetAccessedBy = 6,

838 hipMemAdviseSetCoarseGrain = 100,

843 hipMemAdviseUnsetCoarseGrain = 101

844} hipMemoryAdvise;

848typedef enum hipMemRangeCoherencyMode {

849 hipMemRangeCoherencyModeFineGrain = 0,

851 hipMemRangeCoherencyModeCoarseGrain = 1,

853 hipMemRangeCoherencyModeIndeterminate = 2

856} hipMemRangeCoherencyMode;

860typedef enum hipMemRangeAttribute {

861 hipMemRangeAttributeReadMostly = 1,

863 hipMemRangeAttributePreferredLocation = 2,

864 hipMemRangeAttributeAccessedBy = 3,

866 hipMemRangeAttributeLastPrefetchLocation = 4,

868 hipMemRangeAttributeCoherencyMode = 100,

870} hipMemRangeAttribute;

871

875typedef enum hipMemPoolAttr

876{

885 hipMemPoolReuseFollowEventDependencies = 0x1,

891 hipMemPoolReuseAllowOpportunistic = 0x2,

898 hipMemPoolReuseAllowInternalDependencies = 0x3,

907 hipMemPoolAttrReleaseThreshold = 0x4,

912 hipMemPoolAttrReservedMemCurrent = 0x5,

918 hipMemPoolAttrReservedMemHigh = 0x6,

923 hipMemPoolAttrUsedMemCurrent = 0x7,

929 hipMemPoolAttrUsedMemHigh = 0x8

930} hipMemPoolAttr;

934 typedef enum hipMemLocationType {

935 hipMemLocationTypeInvalid = 0,

936 hipMemLocationTypeDevice = 1

937} hipMemLocationType;

943typedef struct hipMemLocation {

944 hipMemLocationType type;

945 int id;

946} hipMemLocation;

951typedef enum hipMemAccessFlags {

952 hipMemAccessFlagsProtNone = 0,

953 hipMemAccessFlagsProtRead = 1,

954 hipMemAccessFlagsProtReadWrite = 3

955} hipMemAccessFlags;

962typedef struct hipMemAccessDesc {

963 hipMemLocation location;

964 hipMemAccessFlags flags;

965} hipMemAccessDesc;

969typedef enum hipMemAllocationType {

970 hipMemAllocationTypeInvalid = 0x0,

974 hipMemAllocationTypePinned = 0x1,

975 hipMemAllocationTypeMax = 0x7FFFFFFF

976} hipMemAllocationType;

981typedef enum hipMemAllocationHandleType {

982 hipMemHandleTypeNone = 0x0,

983 hipMemHandleTypePosixFileDescriptor = 0x1,

984 hipMemHandleTypeWin32 = 0x2,

985 hipMemHandleTypeWin32Kmt = 0x4

986} hipMemAllocationHandleType;

990typedef struct hipMemPoolProps {

991 hipMemAllocationType allocType;

992 hipMemAllocationHandleType handleTypes;

993 hipMemLocation location;

997 void* win32SecurityAttributes;

998 size_t maxSize;

999 unsigned char reserved[56];

1000} hipMemPoolProps;

1004typedef struct hipMemPoolPtrExportData {

1005 unsigned char reserved[64];

1006} hipMemPoolPtrExportData;

1007

1011typedef enum hipJitOption {

1012 hipJitOptionMaxRegisters = 0,

1013 hipJitOptionThreadsPerBlock,

1014 hipJitOptionWallTime,

1015 hipJitOptionInfoLogBuffer,

1016 hipJitOptionInfoLogBufferSizeBytes,

1017 hipJitOptionErrorLogBuffer,

1018 hipJitOptionErrorLogBufferSizeBytes,

1019 hipJitOptionOptimizationLevel,

1020 hipJitOptionTargetFromContext,

1021 hipJitOptionTarget,

1022 hipJitOptionFallbackStrategy,

1023 hipJitOptionGenerateDebugInfo,

1024 hipJitOptionLogVerbose,

1025 hipJitOptionGenerateLineInfo,

1026 hipJitOptionCacheMode,

1027 hipJitOptionSm3xOpt,

1028 hipJitOptionFastCompile,

1029 hipJitOptionNumOptions

1030} hipJitOption;

1034typedef enum hipFuncAttribute {

1035 hipFuncAttributeMaxDynamicSharedMemorySize = 8,

1036 hipFuncAttributePreferredSharedMemoryCarveout = 9,

1037 hipFuncAttributeMax

1038} hipFuncAttribute;

1042typedef enum hipFuncCache_t {

1043 hipFuncCachePreferNone,

1044 hipFuncCachePreferShared,

1045 hipFuncCachePreferL1,

1046 hipFuncCachePreferEqual,

1047} hipFuncCache_t;

1051typedef enum hipSharedMemConfig {

1052 hipSharedMemBankSizeDefault,

1053 hipSharedMemBankSizeFourByte,

1055 hipSharedMemBankSizeEightByte

1057} hipSharedMemConfig;

1061typedef struct dim3 {

1062 uint32_t x;

1063 uint32_t y;

1064 uint32_t z;

1065#ifdef __cplusplus

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

1067#endif

1068} dim3;

1072typedef struct hipLaunchParams_t {

1073 void* func;

1074 dim3 gridDim;

1075 dim3 blockDim;

1076 void **args;

1077 size_t sharedMem;

1078 hipStream_t stream;

1079} hipLaunchParams;

1083typedef struct hipFunctionLaunchParams_t {

1084 hipFunction_t function;

1085 unsigned int gridDimX;

1086 unsigned int gridDimY;

1087 unsigned int gridDimZ;

1088 unsigned int blockDimX;

1089 unsigned int blockDimY;

1090 unsigned int blockDimZ;

1091 unsigned int sharedMemBytes;

1092 hipStream_t hStream;

1093 void **kernelParams;

1094} hipFunctionLaunchParams;

1095typedef enum hipExternalMemoryHandleType_enum {

1096 hipExternalMemoryHandleTypeOpaqueFd = 1,

1097 hipExternalMemoryHandleTypeOpaqueWin32 = 2,

1098 hipExternalMemoryHandleTypeOpaqueWin32Kmt = 3,

1099 hipExternalMemoryHandleTypeD3D12Heap = 4,

1100 hipExternalMemoryHandleTypeD3D12Resource = 5,

1101 hipExternalMemoryHandleTypeD3D11Resource = 6,

1102 hipExternalMemoryHandleTypeD3D11ResourceKmt = 7,

1103 hipExternalMemoryHandleTypeNvSciBuf = 8

1104} hipExternalMemoryHandleType;

1105typedef struct hipExternalMemoryHandleDesc_st {

1106 hipExternalMemoryHandleType type;

1107 union {

1108 int fd;

1109 struct {

1110 void *handle;

1111 const void *name;

1112 } win32;

1113 const void *nvSciBufObject;

1114 } handle;

1115 unsigned long long size;

1116 unsigned int flags;

1117 unsigned int reserved[16];

1118} hipExternalMemoryHandleDesc;

1119typedef struct hipExternalMemoryBufferDesc_st {

1120 unsigned long long offset;

1121 unsigned long long size;

1122 unsigned int flags;

1123 unsigned int reserved[16];

1124} hipExternalMemoryBufferDesc;

1125typedef struct hipExternalMemoryMipmappedArrayDesc_st {

1126 unsigned long long offset;

1127 hipChannelFormatDesc formatDesc;

1128 hipExtent extent;

1129 unsigned int flags;

1130 unsigned int numLevels;

1131} hipExternalMemoryMipmappedArrayDesc;

1132typedef void* hipExternalMemory_t;

1133typedef enum hipExternalSemaphoreHandleType_enum {

1134 hipExternalSemaphoreHandleTypeOpaqueFd = 1,

1135 hipExternalSemaphoreHandleTypeOpaqueWin32 = 2,

1136 hipExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3,

1137 hipExternalSemaphoreHandleTypeD3D12Fence = 4,

1138 hipExternalSemaphoreHandleTypeD3D11Fence = 5,

1139 hipExternalSemaphoreHandleTypeNvSciSync = 6,

1140 hipExternalSemaphoreHandleTypeKeyedMutex = 7,

1141 hipExternalSemaphoreHandleTypeKeyedMutexKmt = 8,

1142 hipExternalSemaphoreHandleTypeTimelineSemaphoreFd = 9,

1143 hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = 10

1144} hipExternalSemaphoreHandleType;

1145typedef struct hipExternalSemaphoreHandleDesc_st {

1146 hipExternalSemaphoreHandleType type;

1147 union {

1148 int fd;

1149 struct {

1150 void* handle;

1151 const void* name;

1152 } win32;

1153 const void* NvSciSyncObj;

1154 } handle;

1155 unsigned int flags;

1156 unsigned int reserved[16];

1157} hipExternalSemaphoreHandleDesc;

1158typedef void* hipExternalSemaphore_t;

1159typedef struct hipExternalSemaphoreSignalParams_st {

1160 struct {

1161 struct {

1162 unsigned long long value;

1163 } fence;

1164 union {

1165 void *fence;

1166 unsigned long long reserved;

1167 } nvSciSync;

1168 struct {

1169 unsigned long long key;

1170 } keyedMutex;

1171 unsigned int reserved[12];

1172 } params;

1173 unsigned int flags;

1174 unsigned int reserved[16];

1175} hipExternalSemaphoreSignalParams;

1179typedef struct hipExternalSemaphoreWaitParams_st {

1180 struct {

1181 struct {

1182 unsigned long long value;

1183 } fence;

1184 union {

1185 void *fence;

1186 unsigned long long reserved;

1187 } nvSciSync;

1188 struct {

1189 unsigned long long key;

1190 unsigned int timeoutMs;

1191 } keyedMutex;

1192 unsigned int reserved[10];

1193 } params;

1194 unsigned int flags;

1195 unsigned int reserved[16];

1196} hipExternalSemaphoreWaitParams;

1197

1198#if __HIP_HAS_GET_PCH

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

1204#endif

1205

1209typedef enum hipGraphicsRegisterFlags {

1210 hipGraphicsRegisterFlagsNone = 0,

1211 hipGraphicsRegisterFlagsReadOnly = 1,

1212 hipGraphicsRegisterFlagsWriteDiscard =

1213 2,

1214 hipGraphicsRegisterFlagsSurfaceLoadStore = 4,

1215 hipGraphicsRegisterFlagsTextureGather =

1216 8

1217} hipGraphicsRegisterFlags;

1218

1219typedef struct _hipGraphicsResource hipGraphicsResource;

1220

1221typedef hipGraphicsResource* hipGraphicsResource_t;

1222

1226typedef struct ihipGraph* hipGraph_t;

1230typedef struct hipGraphNode* hipGraphNode_t;

1234typedef struct hipGraphExec* hipGraphExec_t;

1235

1239typedef struct hipUserObject* hipUserObject_t;

1240

1241

1245typedef enum hipGraphNodeType {

1246 hipGraphNodeTypeKernel = 0,

1247 hipGraphNodeTypeMemcpy = 1,

1248 hipGraphNodeTypeMemset = 2,

1249 hipGraphNodeTypeHost = 3,

1250 hipGraphNodeTypeGraph = 4,

1251 hipGraphNodeTypeEmpty = 5,

1252 hipGraphNodeTypeWaitEvent = 6,

1253 hipGraphNodeTypeEventRecord = 7,

1254 hipGraphNodeTypeExtSemaphoreSignal = 8,

1255 hipGraphNodeTypeExtSemaphoreWait = 9,

1256 hipGraphNodeTypeMemAlloc = 10,

1257 hipGraphNodeTypeMemFree = 11,

1258 hipGraphNodeTypeMemcpyFromSymbol = 12,

1259 hipGraphNodeTypeMemcpyToSymbol = 13,

1260 hipGraphNodeTypeCount

1261} hipGraphNodeType;

1262

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

1264typedef struct hipHostNodeParams {

1265 hipHostFn_t fn;

1266 void* userData;

1267} hipHostNodeParams;

1268typedef struct hipKernelNodeParams {

1269 dim3 blockDim;

1270 void** extra;

1271 void* func;

1272 dim3 gridDim;

1273 void** kernelParams;

1274 unsigned int sharedMemBytes;

1275} hipKernelNodeParams;

1276typedef struct hipMemsetParams {

1277 void* dst;

1278 unsigned int elementSize;

1279 size_t height;

1280 size_t pitch;

1281 unsigned int value;

1282 size_t width;

1283} hipMemsetParams;

1284

1285typedef struct hipMemAllocNodeParams {

1286 hipMemPoolProps poolProps;

1288 const hipMemAccessDesc* accessDescs;

1289 size_t accessDescCount;

1291 size_t bytesize;

1292 void* dptr;

1293} hipMemAllocNodeParams;

1294

1295

1296typedef enum hipAccessProperty {

1297 hipAccessPropertyNormal = 0,

1298 hipAccessPropertyStreaming = 1,

1299 hipAccessPropertyPersisting = 2,

1300} hipAccessProperty;

1301typedef struct hipAccessPolicyWindow {

1302 void* base_ptr;

1303 hipAccessProperty hitProp;

1304 float hitRatio;

1305 hipAccessProperty missProp;

1306 size_t num_bytes;

1307} hipAccessPolicyWindow;

1308

1312typedef enum hipLaunchAttributeID {

1313 hipLaunchAttributeAccessPolicyWindow = 1,

1314 hipLaunchAttributeCooperative = 2,

1315 hipLaunchAttributePriority = 8,

1316} hipLaunchAttributeID;

1317

1321typedef union hipLaunchAttributeValue {

1322 hipAccessPolicyWindow accessPolicyWindow;

1324 int cooperative;

1325 int priority;

1327} hipLaunchAttributeValue;

1328

1332#define hipKernelNodeAttrID hipLaunchAttributeID

1333#define hipKernelNodeAttributeAccessPolicyWindow hipLaunchAttributeAccessPolicyWindow

1334#define hipKernelNodeAttributeCooperative hipLaunchAttributeCooperative

1335#define hipKernelNodeAttributePriority hipLaunchAttributePriority

1336

1340#define hipKernelNodeAttrValue hipLaunchAttributeValue

1341

1345typedef struct HIP_MEMSET_NODE_PARAMS {

1346 hipDeviceptr_t dst;

1347 size_t pitch;

1348 unsigned int value;

1349 unsigned int elementSize;

1350 size_t width;

1351 size_t height;

1352} HIP_MEMSET_NODE_PARAMS;

1353

1357typedef enum hipGraphExecUpdateResult {

1358 hipGraphExecUpdateSuccess = 0x0,

1359 hipGraphExecUpdateError = 0x1,

1361 hipGraphExecUpdateErrorTopologyChanged = 0x2,

1362 hipGraphExecUpdateErrorNodeTypeChanged = 0x3,

1363 hipGraphExecUpdateErrorFunctionChanged =

1364 0x4,

1365 hipGraphExecUpdateErrorParametersChanged =

1366 0x5,

1367 hipGraphExecUpdateErrorNotSupported =

1368 0x6,

1369 hipGraphExecUpdateErrorUnsupportedFunctionChange = 0x7

1370} hipGraphExecUpdateResult;

1371

1372typedef enum hipStreamCaptureMode {

1373 hipStreamCaptureModeGlobal = 0,

1374 hipStreamCaptureModeThreadLocal,

1375 hipStreamCaptureModeRelaxed

1376} hipStreamCaptureMode;

1377typedef enum hipStreamCaptureStatus {

1378 hipStreamCaptureStatusNone = 0,

1379 hipStreamCaptureStatusActive,

1380 hipStreamCaptureStatusInvalidated

1382} hipStreamCaptureStatus;

1383

1384typedef enum hipStreamUpdateCaptureDependenciesFlags {

1385 hipStreamAddCaptureDependencies = 0,

1386 hipStreamSetCaptureDependencies,

1387} hipStreamUpdateCaptureDependenciesFlags;

1388

1389typedef enum hipGraphMemAttributeType {

1390 hipGraphMemAttrUsedMemCurrent = 0,

1391 hipGraphMemAttrUsedMemHigh,

1392 hipGraphMemAttrReservedMemCurrent,

1393 hipGraphMemAttrReservedMemHigh,

1394}hipGraphMemAttributeType;

1395typedef enum hipUserObjectFlags {

1396 hipUserObjectNoDestructorSync = 0x1,

1397} hipUserObjectFlags;

1398

1399typedef enum hipUserObjectRetainFlags {

1400 hipGraphUserObjectMove = 0x1,

1401} hipUserObjectRetainFlags;

1402

1403typedef enum hipGraphInstantiateFlags {

1404 hipGraphInstantiateFlagAutoFreeOnLaunch =

1405 1,

1406 hipGraphInstantiateFlagUpload =

1407 2,

1408 hipGraphInstantiateFlagDeviceLaunch =

1409 4,

1410 hipGraphInstantiateFlagUseNodePriority =

1411 8,

1412} hipGraphInstantiateFlags;

1413

1414enum hipGraphDebugDotFlags {

1415 hipGraphDebugDotFlagsVerbose = 1

1416 << 0,

1417 hipGraphDebugDotFlagsKernelNodeParams = 1 << 2,

1418 hipGraphDebugDotFlagsMemcpyNodeParams = 1 << 3,

1419 hipGraphDebugDotFlagsMemsetNodeParams = 1 << 4,

1420 hipGraphDebugDotFlagsHostNodeParams = 1 << 5,

1421 hipGraphDebugDotFlagsEventNodeParams = 1

1422 << 6,

1423 hipGraphDebugDotFlagsExtSemasSignalNodeParams = 1

1424 << 7,

1425 hipGraphDebugDotFlagsExtSemasWaitNodeParams = 1

1426 << 8,

1427 hipGraphDebugDotFlagsKernelNodeAttributes = 1

1428 << 9,

1429 hipGraphDebugDotFlagsHandles = 1

1430 << 10

1431};

1432

1436typedef enum hipGraphInstantiateResult {

1437 hipGraphInstantiateSuccess = 0,

1438 hipGraphInstantiateError = 1,

1440 hipGraphInstantiateInvalidStructure = 2,

1442 hipGraphInstantiateNodeOperationNotSupported = 3,

1444 hipGraphInstantiateMultipleDevicesNotSupported = 4,

1446}hipGraphInstantiateResult;

1447

1451typedef struct hipGraphInstantiateParams {

1452 hipGraphNode_t errNode_out;

1453 unsigned long long flags;

1454 hipGraphInstantiateResult result_out;

1456 hipStream_t uploadStream;

1457} hipGraphInstantiateParams;

1458

1459

1463typedef struct hipMemAllocationProp {

1464 hipMemAllocationType type;

1465 hipMemAllocationHandleType requestedHandleType;

1466 hipMemLocation location;

1467 void* win32HandleMetaData;

1468 struct {

1469 unsigned char compressionType;

1470 unsigned char gpuDirectRDMACapable;

1471 unsigned short usage;

1472 } allocFlags;

1473} hipMemAllocationProp;

1474

1478typedef struct hipExternalSemaphoreSignalNodeParams {

1480 hipExternalSemaphore_t* extSemArray;

1482 const hipExternalSemaphoreSignalParams* paramsArray;

1484 unsigned int numExtSems;

1485} hipExternalSemaphoreSignalNodeParams;

1486

1490typedef struct hipExternalSemaphoreWaitNodeParams {

1492 hipExternalSemaphore_t* extSemArray;

1494 const hipExternalSemaphoreWaitParams* paramsArray;

1496 unsigned int numExtSems;

1497} hipExternalSemaphoreWaitNodeParams;

1498

1502typedef struct ihipMemGenericAllocationHandle* hipMemGenericAllocationHandle_t;

1503

1507typedef enum hipMemAllocationGranularity_flags {

1508 hipMemAllocationGranularityMinimum = 0x0,

1509 hipMemAllocationGranularityRecommended = 0x1

1510} hipMemAllocationGranularity_flags;

1511

1515typedef enum hipMemHandleType {

1516 hipMemHandleTypeGeneric = 0x0

1517} hipMemHandleType;

1518

1522typedef enum hipMemOperationType {

1523 hipMemOperationTypeMap = 0x1,

1524 hipMemOperationTypeUnmap = 0x2

1525} hipMemOperationType;

1526

1530typedef enum hipArraySparseSubresourceType {

1531 hipArraySparseSubresourceTypeSparseLevel = 0x0,

1532 hipArraySparseSubresourceTypeMiptail = 0x1

1533} hipArraySparseSubresourceType;

1534

1538typedef struct hipArrayMapInfo {

1539 hipResourceType resourceType;

1540 union {

1541 hipMipmappedArray mipmap;

1542 hipArray_t array;

1543 } resource;

1544 hipArraySparseSubresourceType subresourceType;

1545 union {

1546 struct {

1547 unsigned int level;

1548 unsigned int layer;

1549 unsigned int offsetX;

1550 unsigned int offsetY;

1551 unsigned int offsetZ;

1552 unsigned int extentWidth;

1553 unsigned int extentHeight;

1554 unsigned int extentDepth;

1555 } sparseLevel;

1556 struct {

1557 unsigned int layer;

1558 unsigned long long offset;

1559 unsigned long long size;

1560 } miptail;

1561 } subresource;

1562 hipMemOperationType memOperationType;

1563 hipMemHandleType memHandleType;

1564 union {

1565 hipMemGenericAllocationHandle_t memHandle;

1566 } memHandle;

1567 unsigned long long offset;

1568 unsigned int deviceBitMask;

1569 unsigned int flags;

1570 unsigned int reserved[2];

1571} hipArrayMapInfo;

1572

1576typedef struct hipMemcpyNodeParams {

1577 int flags;

1578 int reserved[3];

1579 hipMemcpy3DParms copyParams;

1580} hipMemcpyNodeParams;

1581

1585typedef struct hipChildGraphNodeParams {

1586 hipGraph_t graph;

1588} hipChildGraphNodeParams;

1589

1593typedef struct hipEventWaitNodeParams {

1594 hipEvent_t event;

1595} hipEventWaitNodeParams;

1596

1600typedef struct hipEventRecordNodeParams {

1601 hipEvent_t event;

1602} hipEventRecordNodeParams;

1603

1607typedef struct hipMemFreeNodeParams {

1608 void *dptr;

1609} hipMemFreeNodeParams;

1610

1614typedef struct hipGraphNodeParams {

1615 hipGraphNodeType type;

1616 int reserved0[3];

1617 union {

1618 long long reserved1[29];

1619 hipKernelNodeParams kernel;

1620 hipMemcpyNodeParams memcpy;

1621 hipMemsetParams memset;

1622 hipHostNodeParams host;

1623 hipChildGraphNodeParams graph;

1624 hipEventWaitNodeParams eventWait;

1625 hipEventRecordNodeParams eventRecord;

1626 hipExternalSemaphoreSignalNodeParams extSemSignal;

1627 hipExternalSemaphoreWaitNodeParams extSemWait;

1628 hipMemAllocNodeParams alloc;

1629 hipMemFreeNodeParams free;

1630 };

1631

1632 long long reserved2;

1633} hipGraphNodeParams;

1634

1638#define hipGraphKernelNodePortDefault 0

1639

1643#define hipGraphKernelNodePortLaunchCompletion 2

1644

1650#define hipGraphKernelNodePortProgrammatic 1

1651

1652typedef enum hipGraphDependencyType {

1653 hipGraphDependencyTypeDefault = 0,

1654 hipGraphDependencyTypeProgrammatic = 1

1655}hipGraphDependencyType;

1656

1657typedef struct hipGraphEdgeData {

1658 unsigned char

1659 from_port;

1666 unsigned char reserved[5];

1667 unsigned char

1668 to_port;

1669 unsigned char type;

1670} hipGraphEdgeData;

1671

1672// Doxygen end group GlobalDefs

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

1699hipError_t hipInit(unsigned int flags);

1700

1716hipError_t hipDriverGetVersion(int* driverVersion);

1731hipError_t hipRuntimeGetVersion(int* runtimeVersion);

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

1740

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

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

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

1780hipError_t hipDeviceGetP2PAttribute(int* value, hipDeviceP2PAttr attr,

1781 int srcDevice, int dstDevice);

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

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

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

1807// doxygen end initialization

1826hipError_t hipDeviceSynchronize(void);

1838hipError_t hipDeviceReset(void);

1870hipError_t hipSetDevice(int deviceId);

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

1896hipError_t hipGetDevice(int* deviceId);

1909hipError_t hipGetDeviceCount(int* count);

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

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

1956hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool);

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

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

2002hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig);

2013hipError_t hipDeviceGetCacheConfig(hipFuncCache_t* cacheConfig);

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

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

2059hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig* pConfig);

2067hipError_t hipGetDeviceFlags(unsigned int* flags);

2079hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config);

2104hipError_t hipSetDeviceFlags(unsigned flags);

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

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

2127// TODO: implement IPC apis

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

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

2205hipError_t hipIpcCloseMemHandle(void* devPtr);

2206

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

2224

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

2243

2244// end doxygen Device

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

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

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

2294//doxygen end execution

2316hipError_t hipGetLastError(void);

2317

2329hipError_t hipExtGetLastError(void);

2330

2341hipError_t hipPeekAtLastError(void);

2350const char* hipGetErrorName(hipError_t hip_error);

2359const char* hipGetErrorString(hipError_t hipError);

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

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

2380// end doxygen Error

2410hipError_t hipStreamCreate(hipStream_t* stream);

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

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

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

2478hipError_t hipStreamDestroy(hipStream_t stream);

2494hipError_t hipStreamQuery(hipStream_t stream);

2515hipError_t hipStreamSynchronize(hipStream_t stream);

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

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

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

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

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

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

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

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

2628 unsigned int flags);

2629// end doxygen Stream

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

2673 uint32_t mask __dparm(0xFFFFFFFF));

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

2707 uint64_t mask __dparm(0xFFFFFFFFFFFFFFFF));

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

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

2748// end doxygen Stream Memory Operations

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

2796hipError_t hipEventCreate(hipEvent_t* event);

2827#ifdef __cplusplus

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

2829#else

2830hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream);

2831#endif

2848hipError_t hipEventDestroy(hipEvent_t event);

2867hipError_t hipEventSynchronize(hipEvent_t event);

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

2913hipError_t hipEventQuery(hipEvent_t event);

2914// end doxygen Events

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

2946 hipDeviceptr_t ptr);

2947

2948

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

2983hipError_t hipPointerGetAttribute(void* data, hipPointer_attribute attribute,

2984 hipDeviceptr_t ptr);

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

3002 void** data, hipDeviceptr_t ptr);

3026hipError_t hipImportExternalSemaphore(hipExternalSemaphore_t* extSem_out,

3027 const hipExternalSemaphoreHandleDesc* semHandleDesc);

3043hipError_t hipSignalExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

3044 const hipExternalSemaphoreSignalParams* paramsArray,

3045 unsigned int numExtSems, hipStream_t stream);

3061hipError_t hipWaitExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

3062 const hipExternalSemaphoreWaitParams* paramsArray,

3063 unsigned int numExtSems, hipStream_t stream);

3076hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem);

3077

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

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

3111hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem);

3125hipError_t hipExternalMemoryGetMappedMipmappedArray(hipMipmappedArray_t* mipmap, hipExternalMemory_t extMem,

3126 const hipExternalMemoryMipmappedArrayDesc* mipmapDesc);

3127 // end of external resource

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

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

3165

3166

3189HIP_DEPRECATED("use hipHostMalloc instead")

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

3203HIP_DEPRECATED("use hipHostMalloc instead")

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

3205// end doxygen deprecated management memory

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

3276hipError_t hipMallocManaged(void** dev_ptr,

3277 size_t size,

3278 unsigned int flags __dparm(hipMemAttachGlobal));

3291hipError_t hipMemPrefetchAsync(const void* dev_ptr,

3292 size_t count,

3293 int device,

3294 hipStream_t stream __dparm(0));

3314hipError_t hipMemAdvise(const void* dev_ptr,

3315 size_t count,

3316 hipMemoryAdvise advice,

3317 int device);

3332hipError_t hipMemRangeGetAttribute(void* data,

3333 size_t data_size,

3334 hipMemRangeAttribute attribute,

3335 const void* dev_ptr,

3336 size_t count);

3353hipError_t hipMemRangeGetAttributes(void** data,

3354 size_t* data_sizes,

3355 hipMemRangeAttribute* attributes,

3356 size_t num_attributes,

3357 const void* dev_ptr,

3358 size_t count);

3374hipError_t hipStreamAttachMemAsync(hipStream_t stream,

3375 void* dev_ptr,

3376 size_t length __dparm(0),

3377 unsigned int flags __dparm(hipMemAttachSingle));

3378// end doxygen Managed Memory

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

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

3491hipError_t hipMemPoolTrimTo(hipMemPool_t mem_pool, size_t min_bytes_to_hold);

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

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

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

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

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

3658hipError_t hipMemPoolDestroy(hipMemPool_t mem_pool);

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

3719hipError_t hipMemPoolExportToShareableHandle(

3720 void* shared_handle,

3721 hipMemPool_t mem_pool,

3722 hipMemAllocationHandleType handle_type,

3723 unsigned int flags);

3747hipError_t hipMemPoolImportFromShareableHandle(

3748 hipMemPool_t* mem_pool,

3749 void* shared_handle,

3750 hipMemAllocationHandleType handle_type,

3751 unsigned int flags);

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

3800hipError_t hipMemPoolImportPointer(

3801 void** dev_ptr,

3802 hipMemPool_t mem_pool,

3803 hipMemPoolPtrExportData* export_data);

3804// Doxygen end of ordered memory allocator

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

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

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

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

3894hipError_t hipHostUnregister(void* hostPtr);

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

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

3937 unsigned int elementSizeBytes);

3951hipError_t hipFree(void* ptr);

3963hipError_t hipFreeHost(void* ptr);

3979hipError_t hipHostFree(void* ptr);

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

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

4025 hipMemcpyKind kind, hipStream_t stream);

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

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

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

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

4099 size_t ByteCount);

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

4119 size_t ByteCount);

4120

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

4141 size_t srcOffset, size_t ByteCount);

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

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

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

4199 hipStream_t stream);

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

4220 size_t ByteCount, hipStream_t stream);

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

4241 size_t ByteCount, hipStream_t stream);

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

4257 hipModule_t hmod, const char* name);

4258

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

4269

4270

4271

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

4282

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

4303 hipDriverProcAddressQueryResult* symbolStatus);

4304

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

4326 size_t sizeBytes, size_t offset __dparm(0),

4327 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice));

4328

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

4343 size_t sizeBytes, size_t offset,

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

4345

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

4359 size_t sizeBytes, size_t offset __dparm(0),

4360 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost));

4361

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

4376 size_t sizeBytes, size_t offset,

4377 hipMemcpyKind kind,

4378 hipStream_t stream __dparm(0));

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

4409 hipStream_t stream __dparm(0));

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

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

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

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

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

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

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

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

4514 hipStream_t stream __dparm(0));

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

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

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

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

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

4574

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

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

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

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

4621hipError_t hipArrayDestroy(hipArray_t array);

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

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

4652hipError_t hipFreeArray(hipArray_t array);

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

4665 struct hipExtent extent, unsigned int flags);

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

4679 hipArray_t array);

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

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

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

4733 size_t height, hipMemcpyKind kind);

4743hipError_t hipMemcpyParam2D(const hip_Memcpy2D* pCopy);

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

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

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

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

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

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

4812 size_t spitch, size_t width, size_t height, hipMemcpyKind kind,

4813 hipStream_t stream __dparm(0));

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

4833 hipArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc,

4834 size_t width, size_t height, hipMemcpyKind kind);

4853HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

4855 size_t count, hipMemcpyKind kind);

4874HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

4876 size_t count, hipMemcpyKind kind);

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

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

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

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

4952hipError_t hipMemcpy3D(const struct hipMemcpy3DParms* p);

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

4975hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D* pCopy);

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

4988// doxygen end Memory

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

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

5045hipError_t hipDeviceDisablePeerAccess(int peerDeviceId);

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

5059#ifndef USE_PEER_NON_UNIFIED

5060#define USE_PEER_NON_UNIFIED 1

5061#endif

5062#if USE_PEER_NON_UNIFIED == 1

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

5075 size_t sizeBytes);

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

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

5090#endif

5091// doxygen end PeerToPeer

5132HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5147HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5148hipError_t hipCtxDestroy(hipCtx_t ctx);

5162HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5163hipError_t hipCtxPopCurrent(hipCtx_t* ctx);

5177HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5178hipError_t hipCtxPushCurrent(hipCtx_t ctx);

5192HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5193hipError_t hipCtxSetCurrent(hipCtx_t ctx);

5207HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5208hipError_t hipCtxGetCurrent(hipCtx_t* ctx);

5222HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5223hipError_t hipCtxGetDevice(hipDevice_t* device);

5244HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5262HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5263hipError_t hipCtxGetCacheConfig(hipFuncCache_t* cacheConfig);

5280HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5281hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig);

5298HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5299hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config);

5316HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5317hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig* pConfig);

5332HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5333hipError_t hipCtxSynchronize(void);

5347HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5348hipError_t hipCtxGetFlags(unsigned int* flags);

5371HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5392HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5393hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx);

5394

5410HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5427HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5428hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev);

5443HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5458HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5459hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev);

5474HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5476// doxygen end Context Management

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

5513hipError_t hipModuleUnload(hipModule_t module);

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

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

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

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

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

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

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

5587 hipJitOption* options, void** optionValues);

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

5617 unsigned int gridDimZ, unsigned int blockDimX,

5618 unsigned int blockDimY, unsigned int blockDimZ,

5619 unsigned int sharedMemBytes, hipStream_t stream,

5620 void** kernelParams, void** extra);

5649hipError_t hipModuleLaunchCooperativeKernel(hipFunction_t f, unsigned int gridDimX,

5650 unsigned int gridDimY, unsigned int gridDimZ,

5651 unsigned int blockDimX, unsigned int blockDimY,

5652 unsigned int blockDimZ, unsigned int sharedMemBytes,

5653 hipStream_t stream, void** kernelParams);

5668hipError_t hipModuleLaunchCooperativeKernelMultiDevice(hipFunctionLaunchParams* launchParamsList,

5669 unsigned int numDevices,

5670 unsigned int flags);

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

5692 void** kernelParams, unsigned int sharedMemBytes,

5693 hipStream_t stream);

5705hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

5706 int numDevices, unsigned int flags);

5707

5708// Doxygen end group ModuleCooperativeG

5722hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

5723 int numDevices, unsigned int flags);

5724// doxygen end Module

5751//TODO - Match CUoccupancyB2DSize

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

5753 hipFunction_t f, size_t dynSharedMemPerBlk,

5754 int blockSizeLimit);

5770//TODO - Match CUoccupancyB2DSize

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

5772 hipFunction_t f, size_t dynSharedMemPerBlk,

5773 int blockSizeLimit, unsigned int flags);

5783hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(

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

5795hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

5806hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(

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

5818hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

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

5835 const void* f, size_t dynSharedMemPerBlk,

5836 int blockSizeLimit);

5837// doxygen end Occupancy

5851// TODO - expand descriptions:

5858HIP_DEPRECATED("use roctracer/rocTX instead")

5859hipError_t hipProfilerStart();

5866HIP_DEPRECATED("use roctracer/rocTX instead")

5867hipError_t hipProfilerStop();

5868// doxygen end profiler

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

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

5915hipError_t hipLaunchByPtr(const void* func);

5932hipError_t __hipPushCallConfiguration(dim3 gridDim,

5933 dim3 blockDim,

5934 size_t sharedMem __dparm(0),

5935 hipStream_t stream __dparm(0));

5955hipError_t __hipPopCallConfiguration(dim3 *gridDim,

5956 dim3 *blockDim,

5957 size_t *sharedMem,

5958 hipStream_t *stream);

5975hipError_t hipLaunchKernel(const void* function_address,

5976 dim3 numBlocks,

5977 dim3 dimBlocks,

5978 void** args,

5979 size_t sharedMemBytes __dparm(0),

5980 hipStream_t stream __dparm(0));

5981

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

6008

6016hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D* pCopy);

6017//TODO: Move this to hip_ext.h

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

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

6041 hipEvent_t startEvent, hipEvent_t stopEvent, int flags);

6042// doxygen end Clang launch

6068hipError_t hipCreateTextureObject(

6069 hipTextureObject_t* pTexObject,

6070 const hipResourceDesc* pResDesc,

6071 const hipTextureDesc* pTexDesc,

6072 const struct hipResourceViewDesc* pResViewDesc);

6073

6082hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject);

6083

6093hipError_t hipGetChannelDesc(

6094 hipChannelFormatDesc* desc,

6095 hipArray_const_t array);

6096

6106hipError_t hipGetTextureObjectResourceDesc(

6107 hipResourceDesc* pResDesc,

6108 hipTextureObject_t textureObject);

6109

6119hipError_t hipGetTextureObjectResourceViewDesc(

6120 struct hipResourceViewDesc* pResViewDesc,

6121 hipTextureObject_t textureObject);

6122

6132hipError_t hipGetTextureObjectTextureDesc(

6133 hipTextureDesc* pTexDesc,

6134 hipTextureObject_t textureObject);

6135

6147hipError_t hipTexObjectCreate(

6148 hipTextureObject_t* pTexObject,

6149 const HIP_RESOURCE_DESC* pResDesc,

6150 const HIP_TEXTURE_DESC* pTexDesc,

6151 const HIP_RESOURCE_VIEW_DESC* pResViewDesc);

6152

6161hipError_t hipTexObjectDestroy(

6162 hipTextureObject_t texObject);

6163

6173hipError_t hipTexObjectGetResourceDesc(

6174 HIP_RESOURCE_DESC* pResDesc,

6175 hipTextureObject_t texObject);

6176

6186hipError_t hipTexObjectGetResourceViewDesc(

6187 HIP_RESOURCE_VIEW_DESC* pResViewDesc,

6188 hipTextureObject_t texObject);

6189

6199hipError_t hipTexObjectGetTextureDesc(

6200 HIP_TEXTURE_DESC* pTexDesc,

6201 hipTextureObject_t texObject);

6202

6217hipError_t hipMallocMipmappedArray(

6218 hipMipmappedArray_t *mipmappedArray,

6219 const struct hipChannelFormatDesc* desc,

6220 struct hipExtent extent,

6221 unsigned int numLevels,

6222 unsigned int flags __dparm(0));

6223

6234hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray);

6235

6248hipError_t hipGetMipmappedArrayLevel(

6249 hipArray_t *levelArray,

6250 hipMipmappedArray_const_t mipmappedArray,

6251 unsigned int level);

6252

6264hipError_t hipMipmappedArrayCreate(

6265 hipMipmappedArray_t* pHandle,

6266 HIP_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc,

6267 unsigned int numMipmapLevels);

6268

6279hipError_t hipMipmappedArrayDestroy(hipMipmappedArray_t hMipmappedArray);

6280

6293hipError_t hipMipmappedArrayGetLevel(

6294 hipArray_t* pLevelArray,

6295 hipMipmappedArray_t hMipMappedArray,

6296 unsigned int level);

6297

6316HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6317hipError_t hipBindTextureToMipmappedArray(

6318 const textureReference* tex,

6319 hipMipmappedArray_const_t mipmappedArray,

6320 const hipChannelFormatDesc* desc);

6321

6332HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6333hipError_t hipGetTextureReference(

6334 const textureReference** texref,

6335 const void* symbol);

6336

6347HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6349

6361HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6363

6375HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6376hipError_t hipTexRefSetAddressMode(

6377 textureReference* texRef,

6378 int dim,

6379 enum hipTextureAddressMode am);

6392HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6393hipError_t hipTexRefSetArray(

6394 textureReference* tex,

6395 hipArray_const_t array,

6396 unsigned int flags);

6408HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6409hipError_t hipTexRefSetFilterMode(

6410 textureReference* texRef,

6411 enum hipTextureFilterMode fm);

6423HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6424hipError_t hipTexRefSetFlags(

6425 textureReference* texRef,

6426 unsigned int Flags);

6439HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6440hipError_t hipTexRefSetFormat(

6441 textureReference* texRef,

6442 hipArray_Format fmt,

6443 int NumPackedComponents);

6458HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6459hipError_t hipBindTexture(

6460 size_t* offset,

6461 const textureReference* tex,

6462 const void* devPtr,

6463 const hipChannelFormatDesc* desc,

6464 size_t size __dparm(UINT_MAX));

6481HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6482hipError_t hipBindTexture2D(

6483 size_t* offset,

6484 const textureReference* tex,

6485 const void* devPtr,

6486 const hipChannelFormatDesc* desc,

6487 size_t width,

6488 size_t height,

6489 size_t pitch);

6502HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6503hipError_t hipBindTextureToArray(

6504 const textureReference* tex,

6505 hipArray_const_t array,

6506 const hipChannelFormatDesc* desc);

6518HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6519hipError_t hipGetTextureAlignmentOffset(

6520 size_t* offset,

6521 const textureReference* texref);

6532HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6533hipError_t hipUnbindTexture(const textureReference* tex);

6545HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6546hipError_t hipTexRefGetAddress(

6547 hipDeviceptr_t* dev_ptr,

6548 const textureReference* texRef);

6561HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6562hipError_t hipTexRefGetAddressMode(

6563 enum hipTextureAddressMode* pam,

6564 const textureReference* texRef,

6565 int dim);

6577HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6578hipError_t hipTexRefGetFilterMode(

6579 enum hipTextureFilterMode* pfm,

6580 const textureReference* texRef);

6592HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6593hipError_t hipTexRefGetFlags(

6594 unsigned int* pFlags,

6595 const textureReference* texRef);

6608HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6609hipError_t hipTexRefGetFormat(

6610 hipArray_Format* pFormat,

6611 int* pNumChannels,

6612 const textureReference* texRef);

6624HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6625hipError_t hipTexRefGetMaxAnisotropy(

6626 int* pmaxAnsio,

6627 const textureReference* texRef);

6639HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6640hipError_t hipTexRefGetMipmapFilterMode(

6641 enum hipTextureFilterMode* pfm,

6642 const textureReference* texRef);

6654HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6655hipError_t hipTexRefGetMipmapLevelBias(

6656 float* pbias,

6657 const textureReference* texRef);

6670HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6671hipError_t hipTexRefGetMipmapLevelClamp(

6672 float* pminMipmapLevelClamp,

6673 float* pmaxMipmapLevelClamp,

6674 const textureReference* texRef);

6686HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6687hipError_t hipTexRefGetMipMappedArray(

6688 hipMipmappedArray_t* pArray,

6689 const textureReference* texRef);

6703HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6704hipError_t hipTexRefSetAddress(

6705 size_t* ByteOffset,

6706 textureReference* texRef,

6707 hipDeviceptr_t dptr,

6708 size_t bytes);

6722HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6723hipError_t hipTexRefSetAddress2D(

6724 textureReference* texRef,

6725 const HIP_ARRAY_DESCRIPTOR* desc,

6726 hipDeviceptr_t dptr,

6727 size_t Pitch);

6739HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6740hipError_t hipTexRefSetMaxAnisotropy(

6741 textureReference* texRef,

6742 unsigned int maxAniso);

6754HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6755hipError_t hipTexRefSetBorderColor(

6756 textureReference* texRef,

6757 float* pBorderColor);

6769HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6770hipError_t hipTexRefSetMipmapFilterMode(

6771 textureReference* texRef,

6772 enum hipTextureFilterMode fm);

6784HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6785hipError_t hipTexRefSetMipmapLevelBias(

6786 textureReference* texRef,

6787 float bias);

6800HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6801hipError_t hipTexRefSetMipmapLevelClamp(

6802 textureReference* texRef,

6803 float minMipMapLevelClamp,

6804 float maxMipMapLevelClamp);

6817HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6818hipError_t hipTexRefSetMipmappedArray(

6819 textureReference* texRef,

6820 struct hipMipmappedArray* mipmappedArray,

6821 unsigned int Flags);

6822

6823// doxygen end deprecated texture management

6828// doxygen end Texture management

6840// This group is for HIPrtc

6841

6842// doxygen end Runtime

6861const char* hipApiName(uint32_t id);

6870const char* hipKernelNameRef(const hipFunction_t f);

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

6889int hipGetStreamDeviceId(hipStream_t stream);

6890

6891// doxygen end Callback

6916hipError_t hipStreamBeginCapture(hipStream_t stream, hipStreamCaptureMode mode);

6917

6937hipError_t hipStreamBeginCaptureToGraph(hipStream_t stream, hipGraph_t graph,

6938 const hipGraphNode_t* dependencies,

6939 const hipGraphEdgeData* dependencyData,

6940 size_t numDependencies, hipStreamCaptureMode mode);

6941

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

6955

6969hipError_t hipStreamGetCaptureInfo(hipStream_t stream, hipStreamCaptureStatus* pCaptureStatus,

6970 unsigned long long* pId);

6971

6988hipError_t hipStreamGetCaptureInfo_v2(hipStream_t stream, hipStreamCaptureStatus* captureStatus_out,

6989 unsigned long long* id_out __dparm(0),

6990 hipGraph_t* graph_out __dparm(0),

6991 const hipGraphNode_t** dependencies_out __dparm(0),

6992 size_t* numDependencies_out __dparm(0));

6993

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

7007

7022hipError_t hipStreamUpdateCaptureDependencies(hipStream_t stream, hipGraphNode_t* dependencies,

7023 size_t numDependencies,

7024 unsigned int flags __dparm(0));

7025

7036hipError_t hipThreadExchangeStreamCaptureMode(hipStreamCaptureMode* mode);

7037

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

7051

7063hipError_t hipGraphDestroy(hipGraph_t graph);

7064

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

7079 const hipGraphNode_t* to, size_t numDependencies);

7080

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

7095 const hipGraphNode_t* to, size_t numDependencies);

7096

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

7115 size_t* numEdges);

7116

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

7134

7151hipError_t hipGraphGetRootNodes(hipGraph_t graph, hipGraphNode_t* pRootNodes,

7152 size_t* pNumRootNodes);

7153

7170hipError_t hipGraphNodeGetDependencies(hipGraphNode_t node, hipGraphNode_t* pDependencies,

7171 size_t* pNumDependencies);

7172

7190hipError_t hipGraphNodeGetDependentNodes(hipGraphNode_t node, hipGraphNode_t* pDependentNodes,

7191 size_t* pNumDependentNodes);

7192

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

7205

7216hipError_t hipGraphDestroyNode(hipGraphNode_t node);

7217

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

7230

7243hipError_t hipGraphNodeFindInClone(hipGraphNode_t* pNode, hipGraphNode_t originalNode,

7244 hipGraph_t clonedGraph);

7245

7262hipError_t hipGraphInstantiate(hipGraphExec_t* pGraphExec, hipGraph_t graph,

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

7264

7277hipError_t hipGraphInstantiateWithFlags(hipGraphExec_t* pGraphExec, hipGraph_t graph,

7278 unsigned long long flags);

7279

7291hipError_t hipGraphInstantiateWithParams(hipGraphExec_t* pGraphExec, hipGraph_t graph,

7292 hipGraphInstantiateParams *instantiateParams);

7303hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream);

7304

7315hipError_t hipGraphUpload(hipGraphExec_t graphExec, hipStream_t stream);

7316

7329hipError_t hipGraphAddNode(hipGraphNode_t *pGraphNode, hipGraph_t graph,

7330 const hipGraphNode_t *pDependencies, size_t numDependencies,

7331 hipGraphNodeParams *nodeParams);

7332

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

7343

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

7354

7365hipError_t hipGraphExecNodeSetParams(hipGraphExec_t graphExec, hipGraphNode_t node, hipGraphNodeParams* nodeParams);

7366

7377hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec);

7378

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

7393hipError_t hipGraphExecUpdate(hipGraphExec_t hGraphExec, hipGraph_t hGraph,

7394 hipGraphNode_t* hErrorNode_out,

7395 hipGraphExecUpdateResult* updateResult_out);

7396

7409hipError_t hipGraphAddKernelNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7410 const hipGraphNode_t* pDependencies, size_t numDependencies,

7411 const hipKernelNodeParams* pNodeParams);

7412

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

7423

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

7434

7445hipError_t hipGraphExecKernelNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7446 const hipKernelNodeParams* pNodeParams);

7447

7461hipError_t hipDrvGraphAddMemcpyNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

7462 const hipGraphNode_t* dependencies,

7463 size_t numDependencies,

7464 const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);

7477hipError_t hipGraphAddMemcpyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7478 const hipGraphNode_t* pDependencies, size_t numDependencies,

7479 const hipMemcpy3DParms* pCopyParams);

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

7490

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

7501

7512hipError_t hipGraphKernelNodeSetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

7513 const hipKernelNodeAttrValue* value);

7524hipError_t hipGraphKernelNodeGetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

7525 hipKernelNodeAttrValue* value);

7536hipError_t hipGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7537 hipMemcpy3DParms* pNodeParams);

7538

7554hipError_t hipGraphAddMemcpyNode1D(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7555 const hipGraphNode_t* pDependencies, size_t numDependencies,

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

7557

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

7571 size_t count, hipMemcpyKind kind);

7572

7587hipError_t hipGraphExecMemcpyNodeSetParams1D(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

7589 hipMemcpyKind kind);

7590

7607hipError_t hipGraphAddMemcpyNodeFromSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7608 const hipGraphNode_t* pDependencies,

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

7610 size_t count, size_t offset, hipMemcpyKind kind);

7611

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

7626 size_t count, size_t offset, hipMemcpyKind kind);

7627

7643hipError_t hipGraphExecMemcpyNodeSetParamsFromSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

7645 size_t offset, hipMemcpyKind kind);

7646

7663hipError_t hipGraphAddMemcpyNodeToSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7664 const hipGraphNode_t* pDependencies,

7665 size_t numDependencies, const void* symbol,

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

7667 hipMemcpyKind kind);

7668

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

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

7684 hipMemcpyKind kind);

7685

7686

7701hipError_t hipGraphExecMemcpyNodeSetParamsToSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7702 const void* symbol, const void* src,

7703 size_t count, size_t offset, hipMemcpyKind kind);

7704

7717hipError_t hipGraphAddMemsetNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7718 const hipGraphNode_t* pDependencies, size_t numDependencies,

7719 const hipMemsetParams* pMemsetParams);

7720

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

7731

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

7742

7753hipError_t hipGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7754 const hipMemsetParams* pNodeParams);

7755

7768hipError_t hipGraphAddHostNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7769 const hipGraphNode_t* pDependencies, size_t numDependencies,

7770 const hipHostNodeParams* pNodeParams);

7771

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

7782

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

7793

7804hipError_t hipGraphExecHostNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7805 const hipHostNodeParams* pNodeParams);

7806

7819hipError_t hipGraphAddChildGraphNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7820 const hipGraphNode_t* pDependencies, size_t numDependencies,

7821 hipGraph_t childGraph);

7822

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

7833

7844hipError_t hipGraphExecChildGraphNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7845 hipGraph_t childGraph);

7846

7858hipError_t hipGraphAddEmptyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7859 const hipGraphNode_t* pDependencies, size_t numDependencies);

7860

7861

7874hipError_t hipGraphAddEventRecordNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7875 const hipGraphNode_t* pDependencies, size_t numDependencies,

7876 hipEvent_t event);

7877

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

7888

7898hipError_t hipGraphEventRecordNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

7899

7910hipError_t hipGraphExecEventRecordNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

7911 hipEvent_t event);

7912

7925hipError_t hipGraphAddEventWaitNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7926 const hipGraphNode_t* pDependencies, size_t numDependencies,

7927 hipEvent_t event);

7928

7929

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

7940

7950hipError_t hipGraphEventWaitNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

7951

7962hipError_t hipGraphExecEventWaitNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

7963 hipEvent_t event);

7964

7977hipError_t hipGraphAddMemAllocNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

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

7979

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

7990

8003hipError_t hipGraphAddMemFreeNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

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

8005

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

8016

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

8028

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

8040

8050hipError_t hipDeviceGraphMemTrim(int device);

8051

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

8065 unsigned int initialRefcount, unsigned int flags);

8066

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

8077

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

8088

8100hipError_t hipGraphRetainUserObject(hipGraph_t graph, hipUserObject_t object,

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

8102

8113hipError_t hipGraphReleaseUserObject(hipGraph_t graph, hipUserObject_t object,

8114 unsigned int count __dparm(1));

8115

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

8127

8142hipError_t hipGraphKernelNodeCopyAttributes(hipGraphNode_t hSrc, hipGraphNode_t hDst);

8143

8166hipError_t hipGraphNodeSetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8167 unsigned int isEnabled);

8188hipError_t hipGraphNodeGetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8189 unsigned int* isEnabled);

8190

8203hipError_t hipGraphAddExternalSemaphoresWaitNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8204 const hipGraphNode_t* pDependencies, size_t numDependencies,

8205 const hipExternalSemaphoreWaitNodeParams* nodeParams);

8206

8219hipError_t hipGraphAddExternalSemaphoresSignalNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8220 const hipGraphNode_t* pDependencies, size_t numDependencies,

8221 const hipExternalSemaphoreSignalNodeParams* nodeParams);

8231hipError_t hipGraphExternalSemaphoresSignalNodeSetParams(hipGraphNode_t hNode,

8232 const hipExternalSemaphoreSignalNodeParams* nodeParams);

8242hipError_t hipGraphExternalSemaphoresWaitNodeSetParams(hipGraphNode_t hNode,

8243 const hipExternalSemaphoreWaitNodeParams* nodeParams);

8253hipError_t hipGraphExternalSemaphoresSignalNodeGetParams(hipGraphNode_t hNode,

8254 hipExternalSemaphoreSignalNodeParams* params_out);

8264hipError_t hipGraphExternalSemaphoresWaitNodeGetParams(hipGraphNode_t hNode,

8265 hipExternalSemaphoreWaitNodeParams* params_out);

8276hipError_t hipGraphExecExternalSemaphoresSignalNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8277 const hipExternalSemaphoreSignalNodeParams* nodeParams);

8288hipError_t hipGraphExecExternalSemaphoresWaitNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8289 const hipExternalSemaphoreWaitNodeParams* nodeParams);

8290

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

8301

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

8312

8326hipError_t hipDrvGraphAddMemsetNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

8327 const hipGraphNode_t* dependencies, size_t numDependencies,

8328 const HIP_MEMSET_NODE_PARAMS* memsetParams, hipCtx_t ctx);

8329

8342hipError_t hipDrvGraphAddMemFreeNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

8343 const hipGraphNode_t* dependencies, size_t numDependencies,

8344 hipDeviceptr_t dptr);

8345

8357hipError_t hipDrvGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8358 const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);

8359

8371hipError_t hipDrvGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8372 const HIP_MEMSET_NODE_PARAMS* memsetParams, hipCtx_t ctx);

8373

8374// doxygen end graph API

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

8406

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

8422

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

8437

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

8452

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

8466

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

8481

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

8494

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

8508

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

8524

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

8536

8547hipError_t hipMemRelease(hipMemGenericAllocationHandle_t handle);

8548

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

8561

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

8576

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

8589

8590// doxygen end virtual memory management API

8612hipError_t hipGraphicsMapResources(int count, hipGraphicsResource_t* resources,

8613 hipStream_t stream __dparm(0) );

8627hipError_t hipGraphicsSubResourceGetMappedArray(hipArray_t* array, hipGraphicsResource_t resource,

8628 unsigned int arrayIndex, unsigned int mipLevel);

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

8640 hipGraphicsResource_t resource);

8651hipError_t hipGraphicsUnmapResources(int count, hipGraphicsResource_t* resources,

8652 hipStream_t stream __dparm(0));

8661hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource);

8662// doxygen end GL Interop

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

8696hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject);

8697// end of surface

8701#ifdef __cplusplus

8702} /* extern "c" */

8703#endif

8704#ifdef __cplusplus

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

8706template <typename T>

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

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

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

8710}

8711template <typename T>

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

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

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

8715}

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

8717

8727template <typename T>

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

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

8730}

8741template <typename T>

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

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

8744}

8745

8754template <typename T>

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

8756 size_t offset __dparm(0),

8757 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice)) {

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

8759}

8768template <typename T>

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

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

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

8772}

8780template <typename T>

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

8782 size_t sizeBytes, size_t offset __dparm(0),

8783 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost)) {

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

8785}

8793template <typename T>

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

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

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

8797}

8798

8810template <class T>

8811inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(

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

8813 return hipOccupancyMaxActiveBlocksPerMultiprocessor(

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

8815}

8829template <class T>

8830inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

8832 return hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

8834}

8855template<typename UnaryFunction, class T>

8856static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(

8857 int* min_grid_size,

8858 int* block_size,

8859 T func,

8860 UnaryFunction block_size_to_dynamic_smem_size,

8861 int block_size_limit = 0,

8862 unsigned int flags = 0) {

8863 if (min_grid_size == nullptr || block_size == nullptr ||

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

8865 return hipErrorInvalidValue;

8866 }

8867

8868 int dev;

8869 hipError_t status;

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

8871 return status;

8872 }

8873

8874 int max_threads_per_cu;

8875 if ((status = hipDeviceGetAttribute(&max_threads_per_cu,

8876 hipDeviceAttributeMaxThreadsPerMultiProcessor, dev)) != hipSuccess) {

8877 return status;

8878 }

8879

8880 int warp_size;

8881 if ((status = hipDeviceGetAttribute(&warp_size,

8882 hipDeviceAttributeWarpSize, dev)) != hipSuccess) {

8883 return status;

8884 }

8885

8886 int max_cu_count;

8887 if ((status = hipDeviceGetAttribute(&max_cu_count,

8888 hipDeviceAttributeMultiprocessorCount, dev)) != hipSuccess) {

8889 return status;

8890 }

8891

8892 struct hipFuncAttributes attr;

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

8894 return status;

8895 }

8896

8897 // Initial limits for the execution

8898 const int func_max_threads_per_block = attr.maxThreadsPerBlock;

8899 if (block_size_limit == 0) {

8900 block_size_limit = func_max_threads_per_block;

8901 }

8902

8903 if (func_max_threads_per_block < block_size_limit) {

8904 block_size_limit = func_max_threads_per_block;

8905 }

8906

8907 const int block_size_limit_aligned =

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

8909

8910 // For maximum search

8911 int max_threads = 0;

8912 int max_block_size{};

8913 int max_num_blocks{};

8914 for (int block_size_check_aligned = block_size_limit_aligned;

8915 block_size_check_aligned > 0;

8916 block_size_check_aligned -= warp_size) {

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

8918 int block_size_check = (block_size_limit < block_size_check_aligned) ?

8919 block_size_limit : block_size_check_aligned;

8920

8921 size_t dyn_smem_size = block_size_to_dynamic_smem_size(block_size_check);

8922 int optimal_blocks;

8923 if ((status = hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

8925 return status;

8926 }

8927

8928 int total_threads = block_size_check * optimal_blocks;

8929 if (total_threads > max_threads) {

8930 max_block_size = block_size_check;

8931 max_num_blocks = optimal_blocks;

8932 max_threads = total_threads;

8933 }

8934

8935 // Break if the logic reached possible maximum

8936 if (max_threads_per_cu == max_threads) {

8937 break;

8938 }

8939 }

8940

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

8942 *min_grid_size = max_num_blocks * max_cu_count;

8943 *block_size = max_block_size;

8944

8945 return status;

8946}

8947

8967template<typename UnaryFunction, class T>

8968static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMem(

8969 int* min_grid_size,

8970 int* block_size,

8971 T func,

8972 UnaryFunction block_size_to_dynamic_smem_size,

8973 int block_size_limit = 0)

8974{

8975 return hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(min_grid_size, block_size, func,

8976 block_size_to_dynamic_smem_size, block_size_limit);

8977}

8992template <typename F>

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

8994 F kernel, size_t dynSharedMemPerBlk, uint32_t blockSizeLimit) {

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

8996}

9018template <class T>

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

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

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

9022 blockDim, kernelParams, sharedMemBytes, stream);

9023}

9039template <class T>

9040inline hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

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

9042 return hipLaunchCooperativeKernelMultiDevice(launchParamsList, numDevices, flags);

9043}

9058template <class T>

9059inline hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

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

9061 return hipExtLaunchMultiKernelMultiDevice(launchParamsList, numDevices, flags);

9062}

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

9077HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

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

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

9081}

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

9097HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9098static inline hipError_t

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

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

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

9102}

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

9119HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9120static inline hipError_t hipBindTexture2D(

9121 size_t *offset,

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

9123 const void *devPtr,

9124 size_t width,

9125 size_t height,

9126 size_t pitch)

9127{

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

9129}

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

9147HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9148static inline hipError_t hipBindTexture2D(

9149 size_t *offset,

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

9151 const void *devPtr,

9152 const struct hipChannelFormatDesc &desc,

9153 size_t width,

9154 size_t height,

9155 size_t pitch)

9156{

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

9158}

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

9171HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9172static inline hipError_t hipBindTextureToArray(

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

9174 hipArray_const_t array)

9175{

9176 struct hipChannelFormatDesc desc;

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

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

9179}

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

9193HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9194static inline hipError_t hipBindTextureToArray(

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

9196 hipArray_const_t array,

9197 const struct hipChannelFormatDesc &desc)

9198{

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

9200}

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

9213HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9214static inline hipError_t hipBindTextureToMipmappedArray(

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

9216 hipMipmappedArray_const_t mipmappedArray)

9217{

9218 struct hipChannelFormatDesc desc;

9219 hipArray_t levelArray;

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

9221 if (err != hipSuccess) {

9222 return err;

9223 }

9224 err = hipGetChannelDesc(&desc, levelArray);

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

9226}

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

9240HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9241static inline hipError_t hipBindTextureToMipmappedArray(

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

9243 hipMipmappedArray_const_t mipmappedArray,

9244 const struct hipChannelFormatDesc &desc)

9245{

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

9247}

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

9259HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9260static inline hipError_t hipUnbindTexture(

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

9262{

9263 return hipUnbindTexture(&tex);

9264}

9288static inline hipError_t hipMallocAsync(

9289 void** dev_ptr,

9290 size_t size,

9291 hipMemPool_t mem_pool,

9292 hipStream_t stream) {

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

9294}

9305template<class T>

9306static inline hipError_t hipMallocAsync(

9307 T** dev_ptr,

9308 size_t size,

9309 hipMemPool_t mem_pool,

9310 hipStream_t stream) {

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

9312}

9323template<class T>

9324static inline hipError_t hipMallocAsync(

9325 T** dev_ptr,

9326 size_t size,

9327 hipStream_t stream) {

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

9329}

9340template<class T>

9341static inline hipError_t hipMallocFromPoolAsync(

9342 T** dev_ptr,

9343 size_t size,

9344 hipMemPool_t mem_pool,

9345 hipStream_t stream) {

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

9347}

9353#endif // __cplusplus

9354

9355#ifdef __GNUC__

9356#pragma GCC visibility pop

9357#endif

9358

9359

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

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

9362#else

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

9364#endif

9365

9366

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

9379template <class T>

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

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

9382}

9394template <class T>

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

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

9397}

9410template <class T>

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

9412 unsigned int flags = hipHostMallocDefault) {

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

9414}

9427template <class T>

9428static inline hipError_t hipHostAlloc(T** ptr, size_t size,

9429 unsigned int flags = hipHostAllocDefault) {

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

9431}

9446template <class T>

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

9448 unsigned int flags = hipMemAttachGlobal) {

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

9450}

9451

9452

9453#endif

9454#endif

9455// doxygen end HIP API

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

9460

9461#if USE_PROF_API

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

9463#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 [Deprecated].

hipCtxPopCurrent

hipError_t hipCtxPopCurrent(hipCtx_t *ctx)

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

hipCtxGetSharedMemConfig

hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig *pConfig)

Get Shared memory bank configuration [Deprecated].

hipDevicePrimaryCtxSetFlags

hipError_t hipDevicePrimaryCtxSetFlags(hipDevice_t dev, unsigned int flags)

Set flags for the primary context [Deprecated].

hipDevicePrimaryCtxGetState

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

Get the state of the primary context [Deprecated].

hipCtxGetCurrent

hipError_t hipCtxGetCurrent(hipCtx_t *ctx)

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

hipDevicePrimaryCtxRelease

hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev)

Release the primary context on the GPU.

hipCtxSetCacheConfig

hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig)

Set L1/Shared cache partition [Deprecated].

hipCtxSetCurrent

hipError_t hipCtxSetCurrent(hipCtx_t ctx)

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

hipCtxEnablePeerAccess

hipError_t hipCtxEnablePeerAccess(hipCtx_t peerCtx, unsigned int flags)

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

hipCtxGetDevice

hipError_t hipCtxGetDevice(hipDevice_t *device)

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

hipCtxDestroy

hipError_t hipCtxDestroy(hipCtx_t ctx)

Destroy a HIP context [Deprecated].

hipCtxPushCurrent

hipError_t hipCtxPushCurrent(hipCtx_t ctx)

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

hipCtxGetCacheConfig

hipError_t hipCtxGetCacheConfig(hipFuncCache_t *cacheConfig)

Get Cache configuration for a specific function [Deprecated].

hipCtxCreate

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

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

hipDevicePrimaryCtxRetain

hipError_t hipDevicePrimaryCtxRetain(hipCtx_t *pctx, hipDevice_t dev)

Retain the primary context on the GPU [Deprecated].

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 [Deprecated].

hipCtxSynchronize

hipError_t hipCtxSynchronize(void)

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

hipCtxSetSharedMemConfig

hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config)

Set Shared memory bank configuration [Deprecated].

hipCtxDisablePeerAccess

hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx)

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

hipGetDeviceFlags

hipError_t hipGetDeviceFlags(unsigned int *flags)

Gets the flags set for current device.

hipIpcGetEventHandle

hipError_t hipIpcGetEventHandle(hipIpcEventHandle_t *handle, hipEvent_t event)

Gets an opaque interprocess handle for an event.

hipDeviceGetDefaultMemPool

hipError_t hipDeviceGetDefaultMemPool(hipMemPool_t *mem_pool, int device)

Returns the default memory pool of the specified device.

hipDeviceGetSharedMemConfig

hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig *pConfig)

Returns bank width of shared memory for current device.

hipDeviceSetMemPool

hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool)

Sets the current memory pool of a device.

hipIpcOpenMemHandle

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

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

hipDeviceGetCacheConfig

hipError_t hipDeviceGetCacheConfig(hipFuncCache_t *cacheConfig)

Get Cache configuration for a specific Device.

hipSetDevice

hipError_t hipSetDevice(int deviceId)

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

hipExtGetLinkTypeAndHopCount

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

Returns the link type and hop count between two devices.

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

hipMemAllocationHandleType

hipMemAllocationHandleType

Definition hip_runtime_api.h:981

hipGraphicsResource_t

hipGraphicsResource * hipGraphicsResource_t

Definition hip_runtime_api.h:1221

hipCtx_t

struct ihipCtx_t * hipCtx_t

Definition hip_runtime_api.h:609

__dparm

#define __dparm(x)

Definition hip_runtime_api.h:590

hipStream_t

struct ihipStream_t * hipStream_t

Definition hip_runtime_api.h:618

hipGraphInstantiateResult

hipGraphInstantiateResult

Definition hip_runtime_api.h:1436

hipDevice_t

int hipDevice_t

Definition hip_runtime_api.h:611

hipAccessProperty

hipAccessProperty

Definition hip_runtime_api.h:1296

hipGraphDependencyType

hipGraphDependencyType

Definition hip_runtime_api.h:1652

hipMemRangeAttribute

hipMemRangeAttribute

Definition hip_runtime_api.h:860

hipMemAttachSingle

#define hipMemAttachSingle

Definition hip_runtime_api.h:744

hipMemoryAdvise

hipMemoryAdvise

Definition hip_runtime_api.h:827

hipArrayDefault

#define hipArrayDefault

Definition hip_runtime_api.h:795

hipSharedMemConfig

hipSharedMemConfig

Definition hip_runtime_api.h:1051

hipKernelNodeAttrValue

#define hipKernelNodeAttrValue

Definition hip_runtime_api.h:1340

hipComputeMode

hipComputeMode

Definition hip_runtime_api.h:551

hipEvent_t

struct ihipEvent_t * hipEvent_t

Definition hip_runtime_api.h:646

hipStreamCaptureMode

hipStreamCaptureMode

Definition hip_runtime_api.h:1372

hipDriverProcAddressQueryResult

hipDriverProcAddressQueryResult

Definition hip_runtime_api.h:545

HIP_DEPRECATED_MSG

#define HIP_DEPRECATED_MSG

Definition hip_runtime_api.h:585

hipLaunchAttributeID

hipLaunchAttributeID

Definition hip_runtime_api.h:1312

hipGraphNodeType

hipGraphNodeType

Definition hip_runtime_api.h:1245

hipExternalMemoryHandleType

hipExternalMemoryHandleType

Definition hip_runtime_api.h:1095

hipMemAttachGlobal

#define hipMemAttachGlobal

Definition hip_runtime_api.h:738

hipFuncAttribute

hipFuncAttribute

Definition hip_runtime_api.h:1034

hipExternalSemaphoreHandleType

hipExternalSemaphoreHandleType

Definition hip_runtime_api.h:1133

hipJitOption

hipJitOption

Definition hip_runtime_api.h:1011

hipDeviceP2PAttr

hipDeviceP2PAttr

Definition hip_runtime_api.h:612

hipGraphDebugDotFlags

hipGraphDebugDotFlags

Definition hip_runtime_api.h:1414

hipUserObjectRetainFlags

hipUserObjectRetainFlags

Definition hip_runtime_api.h:1399

hipError_t

enum __HIP_NODISCARD hipError_t hipError_t

Definition hip_runtime_api.h:290

hipHostAllocDefault

#define hipHostAllocDefault

Definition hip_runtime_api.h:708

hipHostFn_t

void(* hipHostFn_t)(void *userData)

Definition hip_runtime_api.h:1263

hipOccupancyDefault

#define hipOccupancyDefault

Definition hip_runtime_api.h:800

hipStreamUpdateCaptureDependenciesFlags

hipStreamUpdateCaptureDependenciesFlags

Definition hip_runtime_api.h:1384

hipGraph_t

struct ihipGraph * hipGraph_t

Definition hip_runtime_api.h:1226

hipChooseDevice

#define hipChooseDevice

Definition hip_runtime_api.h:93

hipMemHandleType

hipMemHandleType

Definition hip_runtime_api.h:1515

hipFlushGPUDirectRDMAWritesOptions

hipFlushGPUDirectRDMAWritesOptions

Definition hip_runtime_api.h:558

hipFuncCache_t

hipFuncCache_t

Definition hip_runtime_api.h:1042

hipUserObjectFlags

hipUserObjectFlags

Definition hip_runtime_api.h:1395

__HIP_NODISCARD

#define __HIP_NODISCARD

Definition hip_runtime_api.h:280

hipGraphMemAttributeType

hipGraphMemAttributeType

Definition hip_runtime_api.h:1389

hipMemPoolAttr

hipMemPoolAttr

Definition hip_runtime_api.h:876

hipDeviceProp_t

#define hipDeviceProp_t

Definition hip_runtime_api.h:92

hipModule_t

struct ihipModule_t * hipModule_t

Definition hip_runtime_api.h:627

hipUserObject_t

struct hipUserObject * hipUserObject_t

Definition hip_runtime_api.h:1239

hipMemOperationType

hipMemOperationType

Definition hip_runtime_api.h:1522

hipExternalSemaphore_t

void * hipExternalSemaphore_t

Definition hip_runtime_api.h:1158

hipGraphicsRegisterFlags

hipGraphicsRegisterFlags

Definition hip_runtime_api.h:1209

hipMemRangeCoherencyMode

hipMemRangeCoherencyMode

Definition hip_runtime_api.h:848

hipMemAccessFlags

hipMemAccessFlags

Definition hip_runtime_api.h:951

hipMemAllocationGranularity_flags

hipMemAllocationGranularity_flags

Definition hip_runtime_api.h:1507

hipGraphExec_t

struct hipGraphExec * hipGraphExec_t

Definition hip_runtime_api.h:1234

hipGraphExecUpdateResult

hipGraphExecUpdateResult

Definition hip_runtime_api.h:1357

hipFunction_t

struct ihipModuleSymbol_t * hipFunction_t

Definition hip_runtime_api.h:628

hipKernelNodeAttrID

#define hipKernelNodeAttrID

Definition hip_runtime_api.h:1332

hipExternalMemory_t

void * hipExternalMemory_t

Definition hip_runtime_api.h:1132

hipStreamCaptureStatus

hipStreamCaptureStatus

Definition hip_runtime_api.h:1377

hipDeviceAttribute_t

hipDeviceAttribute_t

Definition hip_runtime_api.h:410

hipGPUDirectRDMAWritesOrdering

hipGPUDirectRDMAWritesOrdering

Definition hip_runtime_api.h:563

hipGetDeviceProperties

#define hipGetDeviceProperties

Definition hip_runtime_api.h:91

hipHostMallocDefault

#define hipHostMallocDefault

Definition hip_runtime_api.h:707

HIP_DEPRECATED

#define HIP_DEPRECATED(msg)

Definition hip_runtime_api.h:583

hipGraphicsResource

struct _hipGraphicsResource hipGraphicsResource

Definition hip_runtime_api.h:1219

hipMemAllocationType

hipMemAllocationType

Definition hip_runtime_api.h:969

hipGraphNode_t

struct hipGraphNode * hipGraphNode_t

Definition hip_runtime_api.h:1230

hipMemGenericAllocationHandle_t

struct ihipMemGenericAllocationHandle * hipMemGenericAllocationHandle_t

Definition hip_runtime_api.h:1502

hipMemoryType

hipMemoryType

Definition hip_runtime_api.h:248

hipGraphInstantiateFlags

hipGraphInstantiateFlags

Definition hip_runtime_api.h:1403

hipMemLocationType

hipMemLocationType

Definition hip_runtime_api.h:934

HIP_IPC_HANDLE_SIZE

#define HIP_IPC_HANDLE_SIZE

Definition hip_runtime_api.h:620

hipMemPool_t

struct ihipMemPoolHandle_t * hipMemPool_t

Definition hip_runtime_api.h:632

hipArraySparseSubresourceType

hipArraySparseSubresourceType

Definition hip_runtime_api.h:1530

hipLimitMallocHeapSize

@ hipLimitMallocHeapSize

Definition hip_runtime_api.h:660

hipLimitStackSize

@ hipLimitStackSize

Definition hip_runtime_api.h:655

hipLimitRange

@ hipLimitRange

Supported limit range.

Definition hip_runtime_api.h:662

hipLimitPrintfFifoSize

@ hipLimitPrintfFifoSize

Definition hip_runtime_api.h:658

hipMemHandleTypeWin32

@ hipMemHandleTypeWin32

Allows a Win32 NT handle for exporting. (HANDLE)

Definition hip_runtime_api.h:984

hipMemHandleTypeWin32Kmt

@ hipMemHandleTypeWin32Kmt

Allows a Win32 KMT handle for exporting. (D3DKMT_HANDLE)

Definition hip_runtime_api.h:985

hipMemHandleTypeNone

@ hipMemHandleTypeNone

Does not allow any export mechanism.

Definition hip_runtime_api.h:982

hipMemHandleTypePosixFileDescriptor

@ hipMemHandleTypePosixFileDescriptor

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

Definition hip_runtime_api.h:983

hipGraphInstantiateNodeOperationNotSupported

@ hipGraphInstantiateNodeOperationNotSupported

Definition hip_runtime_api.h:1442

hipGraphInstantiateMultipleDevicesNotSupported

@ hipGraphInstantiateMultipleDevicesNotSupported

Definition hip_runtime_api.h:1444

hipGraphInstantiateError

@ hipGraphInstantiateError

Definition hip_runtime_api.h:1438

hipGraphInstantiateInvalidStructure

@ hipGraphInstantiateInvalidStructure

Definition hip_runtime_api.h:1440

hipGraphInstantiateSuccess

@ hipGraphInstantiateSuccess

Definition hip_runtime_api.h:1437

hipAccessPropertyNormal

@ hipAccessPropertyNormal

Definition hip_runtime_api.h:1297

hipAccessPropertyPersisting

@ hipAccessPropertyPersisting

Definition hip_runtime_api.h:1299

hipAccessPropertyStreaming

@ hipAccessPropertyStreaming

Definition hip_runtime_api.h:1298

hipGraphDependencyTypeDefault

@ hipGraphDependencyTypeDefault

Definition hip_runtime_api.h:1653

hipGraphDependencyTypeProgrammatic

@ hipGraphDependencyTypeProgrammatic

Definition hip_runtime_api.h:1654

hipMemRangeAttributeLastPrefetchLocation

@ hipMemRangeAttributeLastPrefetchLocation

prefetched

Definition hip_runtime_api.h:866

hipMemRangeAttributePreferredLocation

@ hipMemRangeAttributePreferredLocation

The preferred location of the range.

Definition hip_runtime_api.h:863

hipMemRangeAttributeAccessedBy

@ hipMemRangeAttributeAccessedBy

Definition hip_runtime_api.h:864

hipMemRangeAttributeReadMostly

@ hipMemRangeAttributeReadMostly

Definition hip_runtime_api.h:861

hipMemRangeAttributeCoherencyMode

@ hipMemRangeAttributeCoherencyMode

Definition hip_runtime_api.h:868

hipMemAdviseUnsetAccessedBy

@ hipMemAdviseUnsetAccessedBy

Definition hip_runtime_api.h:836

hipMemAdviseUnsetCoarseGrain

@ hipMemAdviseUnsetCoarseGrain

Restores cache coherency policy back to fine-grain.

Definition hip_runtime_api.h:843

hipMemAdviseSetCoarseGrain

@ hipMemAdviseSetCoarseGrain

Definition hip_runtime_api.h:838

hipMemAdviseUnsetPreferredLocation

@ hipMemAdviseUnsetPreferredLocation

Clear the preferred location for the data.

Definition hip_runtime_api.h:833

hipMemAdviseSetAccessedBy

@ hipMemAdviseSetAccessedBy

Definition hip_runtime_api.h:834

hipMemAdviseSetPreferredLocation

@ hipMemAdviseSetPreferredLocation

Definition hip_runtime_api.h:831

hipMemAdviseSetReadMostly

@ hipMemAdviseSetReadMostly

Definition hip_runtime_api.h:828

hipMemAdviseUnsetReadMostly

@ hipMemAdviseUnsetReadMostly

Undo the effect of hipMemAdviseSetReadMostly.

Definition hip_runtime_api.h:830

hipSharedMemBankSizeFourByte

@ hipSharedMemBankSizeFourByte

Definition hip_runtime_api.h:1053

hipSharedMemBankSizeEightByte

@ hipSharedMemBankSizeEightByte

Definition hip_runtime_api.h:1055

hipSharedMemBankSizeDefault

@ hipSharedMemBankSizeDefault

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

Definition hip_runtime_api.h:1052

hipComputeModeProhibited

@ hipComputeModeProhibited

Definition hip_runtime_api.h:554

hipComputeModeExclusive

@ hipComputeModeExclusive

Definition hip_runtime_api.h:553

hipComputeModeDefault

@ hipComputeModeDefault

Definition hip_runtime_api.h:552

hipComputeModeExclusiveProcess

@ hipComputeModeExclusiveProcess

Definition hip_runtime_api.h:555

hipStreamCaptureModeRelaxed

@ hipStreamCaptureModeRelaxed

Definition hip_runtime_api.h:1375

hipStreamCaptureModeThreadLocal

@ hipStreamCaptureModeThreadLocal

Definition hip_runtime_api.h:1374

hipStreamCaptureModeGlobal

@ hipStreamCaptureModeGlobal

Definition hip_runtime_api.h:1373

HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND

@ HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND

Definition hip_runtime_api.h:547

HIP_GET_PROC_ADDRESS_SUCCESS

@ HIP_GET_PROC_ADDRESS_SUCCESS

Definition hip_runtime_api.h:546

HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT

@ HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT

Definition hip_runtime_api.h:548

hipLaunchAttributePriority

@ hipLaunchAttributePriority

Definition hip_runtime_api.h:1315

hipLaunchAttributeAccessPolicyWindow

@ hipLaunchAttributeAccessPolicyWindow

Definition hip_runtime_api.h:1313

hipLaunchAttributeCooperative

@ hipLaunchAttributeCooperative

Definition hip_runtime_api.h:1314

hipGraphNodeTypeGraph

@ hipGraphNodeTypeGraph

Node which executes an embedded graph.

Definition hip_runtime_api.h:1250

hipGraphNodeTypeMemset

@ hipGraphNodeTypeMemset

Memset node.

Definition hip_runtime_api.h:1248

hipGraphNodeTypeEventRecord

@ hipGraphNodeTypeEventRecord

External event record node.

Definition hip_runtime_api.h:1253

hipGraphNodeTypeExtSemaphoreSignal

@ hipGraphNodeTypeExtSemaphoreSignal

External Semaphore signal node.

Definition hip_runtime_api.h:1254

hipGraphNodeTypeMemcpy

@ hipGraphNodeTypeMemcpy

Memcpy node.

Definition hip_runtime_api.h:1247

hipGraphNodeTypeWaitEvent

@ hipGraphNodeTypeWaitEvent

External event wait node.

Definition hip_runtime_api.h:1252

hipGraphNodeTypeCount

@ hipGraphNodeTypeCount

Definition hip_runtime_api.h:1260

hipGraphNodeTypeKernel

@ hipGraphNodeTypeKernel

GPU kernel node.

Definition hip_runtime_api.h:1246

hipGraphNodeTypeHost

@ hipGraphNodeTypeHost

Host (executable) node.

Definition hip_runtime_api.h:1249

hipGraphNodeTypeMemAlloc

@ hipGraphNodeTypeMemAlloc

Memory alloc node.

Definition hip_runtime_api.h:1256

hipGraphNodeTypeMemFree

@ hipGraphNodeTypeMemFree

Memory free node.

Definition hip_runtime_api.h:1257

hipGraphNodeTypeMemcpyFromSymbol

@ hipGraphNodeTypeMemcpyFromSymbol

MemcpyFromSymbol node.

Definition hip_runtime_api.h:1258

hipGraphNodeTypeMemcpyToSymbol

@ hipGraphNodeTypeMemcpyToSymbol

MemcpyToSymbol node.

Definition hip_runtime_api.h:1259

hipGraphNodeTypeEmpty

@ hipGraphNodeTypeEmpty

Empty (no-op) node.

Definition hip_runtime_api.h:1251

hipGraphNodeTypeExtSemaphoreWait

@ hipGraphNodeTypeExtSemaphoreWait

External Semaphore wait node.

Definition hip_runtime_api.h:1255

hipExternalMemoryHandleTypeD3D11Resource

@ hipExternalMemoryHandleTypeD3D11Resource

Definition hip_runtime_api.h:1101

hipExternalMemoryHandleTypeD3D12Resource

@ hipExternalMemoryHandleTypeD3D12Resource

Definition hip_runtime_api.h:1100

hipExternalMemoryHandleTypeNvSciBuf

@ hipExternalMemoryHandleTypeNvSciBuf

Definition hip_runtime_api.h:1103

hipExternalMemoryHandleTypeOpaqueFd

@ hipExternalMemoryHandleTypeOpaqueFd

Definition hip_runtime_api.h:1096

hipExternalMemoryHandleTypeD3D12Heap

@ hipExternalMemoryHandleTypeD3D12Heap

Definition hip_runtime_api.h:1099

hipExternalMemoryHandleTypeOpaqueWin32Kmt

@ hipExternalMemoryHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:1098

hipExternalMemoryHandleTypeOpaqueWin32

@ hipExternalMemoryHandleTypeOpaqueWin32

Definition hip_runtime_api.h:1097

hipExternalMemoryHandleTypeD3D11ResourceKmt

@ hipExternalMemoryHandleTypeD3D11ResourceKmt

Definition hip_runtime_api.h:1102

hipFuncAttributePreferredSharedMemoryCarveout

@ hipFuncAttributePreferredSharedMemoryCarveout

Definition hip_runtime_api.h:1036

hipFuncAttributeMaxDynamicSharedMemorySize

@ hipFuncAttributeMaxDynamicSharedMemorySize

Definition hip_runtime_api.h:1035

hipFuncAttributeMax

@ hipFuncAttributeMax

Definition hip_runtime_api.h:1037

hipExternalSemaphoreHandleTypeNvSciSync

@ hipExternalSemaphoreHandleTypeNvSciSync

Definition hip_runtime_api.h:1139

hipExternalSemaphoreHandleTypeKeyedMutexKmt

@ hipExternalSemaphoreHandleTypeKeyedMutexKmt

Definition hip_runtime_api.h:1141

hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

@ hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:1136

hipExternalSemaphoreHandleTypeKeyedMutex

@ hipExternalSemaphoreHandleTypeKeyedMutex

Definition hip_runtime_api.h:1140

hipExternalSemaphoreHandleTypeD3D11Fence

@ hipExternalSemaphoreHandleTypeD3D11Fence

Definition hip_runtime_api.h:1138

hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

@ hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

Definition hip_runtime_api.h:1143

hipExternalSemaphoreHandleTypeOpaqueFd

@ hipExternalSemaphoreHandleTypeOpaqueFd

Definition hip_runtime_api.h:1134

hipExternalSemaphoreHandleTypeOpaqueWin32

@ hipExternalSemaphoreHandleTypeOpaqueWin32

Definition hip_runtime_api.h:1135

hipExternalSemaphoreHandleTypeTimelineSemaphoreFd

@ hipExternalSemaphoreHandleTypeTimelineSemaphoreFd

Definition hip_runtime_api.h:1142

hipExternalSemaphoreHandleTypeD3D12Fence

@ hipExternalSemaphoreHandleTypeD3D12Fence

Definition hip_runtime_api.h:1137

hipJitOptionCacheMode

@ hipJitOptionCacheMode

Definition hip_runtime_api.h:1026

hipJitOptionFastCompile

@ hipJitOptionFastCompile

Definition hip_runtime_api.h:1028

hipJitOptionInfoLogBuffer

@ hipJitOptionInfoLogBuffer

Definition hip_runtime_api.h:1015

hipJitOptionErrorLogBuffer

@ hipJitOptionErrorLogBuffer

Definition hip_runtime_api.h:1017

hipJitOptionTarget

@ hipJitOptionTarget

Definition hip_runtime_api.h:1021

hipJitOptionThreadsPerBlock

@ hipJitOptionThreadsPerBlock

Definition hip_runtime_api.h:1013

hipJitOptionNumOptions

@ hipJitOptionNumOptions

Definition hip_runtime_api.h:1029

hipJitOptionGenerateLineInfo

@ hipJitOptionGenerateLineInfo

Definition hip_runtime_api.h:1025

hipJitOptionOptimizationLevel

@ hipJitOptionOptimizationLevel

Definition hip_runtime_api.h:1019

hipJitOptionErrorLogBufferSizeBytes

@ hipJitOptionErrorLogBufferSizeBytes

Definition hip_runtime_api.h:1018

hipJitOptionWallTime

@ hipJitOptionWallTime

Definition hip_runtime_api.h:1014

hipJitOptionInfoLogBufferSizeBytes

@ hipJitOptionInfoLogBufferSizeBytes

Definition hip_runtime_api.h:1016

hipJitOptionTargetFromContext

@ hipJitOptionTargetFromContext

Definition hip_runtime_api.h:1020

hipJitOptionGenerateDebugInfo

@ hipJitOptionGenerateDebugInfo

Definition hip_runtime_api.h:1023

hipJitOptionLogVerbose

@ hipJitOptionLogVerbose

Definition hip_runtime_api.h:1024

hipJitOptionMaxRegisters

@ hipJitOptionMaxRegisters

Definition hip_runtime_api.h:1012

hipJitOptionSm3xOpt

@ hipJitOptionSm3xOpt

Definition hip_runtime_api.h:1027

hipJitOptionFallbackStrategy

@ hipJitOptionFallbackStrategy

Definition hip_runtime_api.h:1022

hipDevP2PAttrAccessSupported

@ hipDevP2PAttrAccessSupported

Definition hip_runtime_api.h:614

hipDevP2PAttrHipArrayAccessSupported

@ hipDevP2PAttrHipArrayAccessSupported

Definition hip_runtime_api.h:616

hipDevP2PAttrNativeAtomicSupported

@ hipDevP2PAttrNativeAtomicSupported

Definition hip_runtime_api.h:615

hipDevP2PAttrPerformanceRank

@ hipDevP2PAttrPerformanceRank

Definition hip_runtime_api.h:613

hipGraphDebugDotFlagsKernelNodeAttributes

@ hipGraphDebugDotFlagsKernelNodeAttributes

Definition hip_runtime_api.h:1427

hipGraphDebugDotFlagsMemsetNodeParams

@ hipGraphDebugDotFlagsMemsetNodeParams

Definition hip_runtime_api.h:1419

hipGraphDebugDotFlagsKernelNodeParams

@ hipGraphDebugDotFlagsKernelNodeParams

Definition hip_runtime_api.h:1417

hipGraphDebugDotFlagsExtSemasWaitNodeParams

@ hipGraphDebugDotFlagsExtSemasWaitNodeParams

Definition hip_runtime_api.h:1425

hipGraphDebugDotFlagsHandles

@ hipGraphDebugDotFlagsHandles

Definition hip_runtime_api.h:1429

hipGraphDebugDotFlagsExtSemasSignalNodeParams

@ hipGraphDebugDotFlagsExtSemasSignalNodeParams

Definition hip_runtime_api.h:1423

hipGraphDebugDotFlagsHostNodeParams

@ hipGraphDebugDotFlagsHostNodeParams

Definition hip_runtime_api.h:1420

hipGraphDebugDotFlagsEventNodeParams

@ hipGraphDebugDotFlagsEventNodeParams

Definition hip_runtime_api.h:1421

hipGraphDebugDotFlagsVerbose

@ hipGraphDebugDotFlagsVerbose

Definition hip_runtime_api.h:1415

hipGraphDebugDotFlagsMemcpyNodeParams

@ hipGraphDebugDotFlagsMemcpyNodeParams

Definition hip_runtime_api.h:1418

hipGraphUserObjectMove

@ hipGraphUserObjectMove

Add new reference or retain.

Definition hip_runtime_api.h:1400

hipStreamAddCaptureDependencies

@ hipStreamAddCaptureDependencies

Add new nodes to the dependency set.

Definition hip_runtime_api.h:1385

hipStreamSetCaptureDependencies

@ hipStreamSetCaptureDependencies

Replace the dependency set with the new nodes.

Definition hip_runtime_api.h:1386

hipMemHandleTypeGeneric

@ hipMemHandleTypeGeneric

Generic handle type.

Definition hip_runtime_api.h:1516

hipFlushGPUDirectRDMAWritesOptionHost

@ hipFlushGPUDirectRDMAWritesOptionHost

Definition hip_runtime_api.h:559

hipFlushGPUDirectRDMAWritesOptionMemOps

@ hipFlushGPUDirectRDMAWritesOptionMemOps

Definition hip_runtime_api.h:560

hipFuncCachePreferNone

@ hipFuncCachePreferNone

no preference for shared memory or L1 (default)

Definition hip_runtime_api.h:1043

hipFuncCachePreferEqual

@ hipFuncCachePreferEqual

prefer equal size L1 cache and shared memory

Definition hip_runtime_api.h:1046

hipFuncCachePreferL1

@ hipFuncCachePreferL1

prefer larger L1 cache and smaller shared memory

Definition hip_runtime_api.h:1045

hipFuncCachePreferShared

@ hipFuncCachePreferShared

prefer larger shared memory and smaller L1 cache

Definition hip_runtime_api.h:1044

hipUserObjectNoDestructorSync

@ hipUserObjectNoDestructorSync

Destructor execution is not synchronized.

Definition hip_runtime_api.h:1396

hipGraphMemAttrReservedMemHigh

@ hipGraphMemAttrReservedMemHigh

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

Definition hip_runtime_api.h:1393

hipGraphMemAttrUsedMemCurrent

@ hipGraphMemAttrUsedMemCurrent

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

Definition hip_runtime_api.h:1390

hipGraphMemAttrUsedMemHigh

@ hipGraphMemAttrUsedMemHigh

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

Definition hip_runtime_api.h:1391

hipGraphMemAttrReservedMemCurrent

@ hipGraphMemAttrReservedMemCurrent

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

Definition hip_runtime_api.h:1392

hipMemPoolAttrUsedMemCurrent

@ hipMemPoolAttrUsedMemCurrent

Definition hip_runtime_api.h:923

hipMemPoolAttrReservedMemHigh

@ hipMemPoolAttrReservedMemHigh

Definition hip_runtime_api.h:918

hipMemPoolAttrReservedMemCurrent

@ hipMemPoolAttrReservedMemCurrent

Definition hip_runtime_api.h:912

hipMemPoolAttrReleaseThreshold

@ hipMemPoolAttrReleaseThreshold

Definition hip_runtime_api.h:907

hipMemPoolAttrUsedMemHigh

@ hipMemPoolAttrUsedMemHigh

Definition hip_runtime_api.h:929

hipMemPoolReuseAllowInternalDependencies

@ hipMemPoolReuseAllowInternalDependencies

Definition hip_runtime_api.h:898

hipMemPoolReuseFollowEventDependencies

@ hipMemPoolReuseFollowEventDependencies

Definition hip_runtime_api.h:885

hipMemPoolReuseAllowOpportunistic

@ hipMemPoolReuseAllowOpportunistic

Definition hip_runtime_api.h:891

hipMemOperationTypeMap

@ hipMemOperationTypeMap

Map operation.

Definition hip_runtime_api.h:1523

hipMemOperationTypeUnmap

@ hipMemOperationTypeUnmap

Unmap operation.

Definition hip_runtime_api.h:1524

hipGraphicsRegisterFlagsReadOnly

@ hipGraphicsRegisterFlagsReadOnly

HIP will not write to this registered resource.

Definition hip_runtime_api.h:1211

hipGraphicsRegisterFlagsTextureGather

@ hipGraphicsRegisterFlagsTextureGather

HIP will perform texture gather operations on this registered resource.

Definition hip_runtime_api.h:1215

hipGraphicsRegisterFlagsWriteDiscard

@ hipGraphicsRegisterFlagsWriteDiscard

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

Definition hip_runtime_api.h:1212

hipGraphicsRegisterFlagsNone

@ hipGraphicsRegisterFlagsNone

Definition hip_runtime_api.h:1210

hipGraphicsRegisterFlagsSurfaceLoadStore

@ hipGraphicsRegisterFlagsSurfaceLoadStore

HIP will bind this resource to a surface.

Definition hip_runtime_api.h:1214

hipMemRangeCoherencyModeFineGrain

@ hipMemRangeCoherencyModeFineGrain

Definition hip_runtime_api.h:849

hipMemRangeCoherencyModeIndeterminate

@ hipMemRangeCoherencyModeIndeterminate

Definition hip_runtime_api.h:853

hipMemRangeCoherencyModeCoarseGrain

@ hipMemRangeCoherencyModeCoarseGrain

Definition hip_runtime_api.h:851

hipMemAccessFlagsProtRead

@ hipMemAccessFlagsProtRead

Set the address range read accessible.

Definition hip_runtime_api.h:953

hipMemAccessFlagsProtNone

@ hipMemAccessFlagsProtNone

Default, make the address range not accessible.

Definition hip_runtime_api.h:952

hipMemAccessFlagsProtReadWrite

@ hipMemAccessFlagsProtReadWrite

Set the address range read-write accessible.

Definition hip_runtime_api.h:954

hipMemAllocationGranularityMinimum

@ hipMemAllocationGranularityMinimum

Minimum granularity.

Definition hip_runtime_api.h:1508

hipMemAllocationGranularityRecommended

@ hipMemAllocationGranularityRecommended

Recommended granularity for performance.

Definition hip_runtime_api.h:1509

hipGraphExecUpdateErrorNotSupported

@ hipGraphExecUpdateErrorNotSupported

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

Definition hip_runtime_api.h:1367

hipGraphExecUpdateErrorNodeTypeChanged

@ hipGraphExecUpdateErrorNodeTypeChanged

The update failed because a node type changed.

Definition hip_runtime_api.h:1362

hipGraphExecUpdateErrorTopologyChanged

@ hipGraphExecUpdateErrorTopologyChanged

The update failed because the topology changed.

Definition hip_runtime_api.h:1361

hipGraphExecUpdateErrorUnsupportedFunctionChange

@ hipGraphExecUpdateErrorUnsupportedFunctionChange

Definition hip_runtime_api.h:1369

hipGraphExecUpdateError

@ hipGraphExecUpdateError

Definition hip_runtime_api.h:1359

hipGraphExecUpdateErrorFunctionChanged

@ hipGraphExecUpdateErrorFunctionChanged

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

Definition hip_runtime_api.h:1363

hipGraphExecUpdateSuccess

@ hipGraphExecUpdateSuccess

The update succeeded.

Definition hip_runtime_api.h:1358

hipGraphExecUpdateErrorParametersChanged

@ hipGraphExecUpdateErrorParametersChanged

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

Definition hip_runtime_api.h:1365

hipStreamCaptureStatusInvalidated

@ hipStreamCaptureStatusInvalidated

Definition hip_runtime_api.h:1380

hipStreamCaptureStatusNone

@ hipStreamCaptureStatusNone

Stream is not capturing.

Definition hip_runtime_api.h:1378

hipStreamCaptureStatusActive

@ hipStreamCaptureStatusActive

Stream is actively capturing.

Definition hip_runtime_api.h:1379

hipDeviceAttributeDirectManagedMemAccessFromHost

@ hipDeviceAttributeDirectManagedMemAccessFromHost

Definition hip_runtime_api.h:428

hipDeviceAttributeSurfaceAlignment

@ hipDeviceAttributeSurfaceAlignment

Alignment requirement for surfaces.

Definition hip_runtime_api.h:498

hipDeviceAttributeMaxGridDimX

@ hipDeviceAttributeMaxGridDimX

Max grid size in width.

Definition hip_runtime_api.h:445

hipDeviceAttributeMaxSurfaceCubemapLayered

@ hipDeviceAttributeMaxSurfaceCubemapLayered

Cuda only. Maximum dimension of Cubemap layered surface.

Definition hip_runtime_api.h:454

hipDeviceAttributeMaxSurface3D

@ hipDeviceAttributeMaxSurface3D

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

Definition hip_runtime_api.h:452

hipDeviceAttributeMaxPitch

@ hipDeviceAttributeMaxPitch

Maximum pitch in bytes allowed by memory copies.

Definition hip_runtime_api.h:475

hipDeviceAttributeTccDriver

@ hipDeviceAttributeTccDriver

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

Definition hip_runtime_api.h:499

hipDeviceAttributeHostNativeAtomicSupported

@ hipDeviceAttributeHostNativeAtomicSupported

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

Definition hip_runtime_api.h:431

hipDeviceAttributePageableMemoryAccessUsesHostPageTables

@ hipDeviceAttributePageableMemoryAccessUsesHostPageTables

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

Definition hip_runtime_api.h:484

hipDeviceAttributeUnused5

@ hipDeviceAttributeUnused5

Previously hipDeviceAttributeGcnArchName.

Definition hip_runtime_api.h:519

hipDeviceAttributeMaxBlockDimY

@ hipDeviceAttributeMaxBlockDimY

Max block size in height.

Definition hip_runtime_api.h:443

hipDeviceAttributeMaxSurfaceCubemap

@ hipDeviceAttributeMaxSurfaceCubemap

Cuda only. Maximum dimensions of Cubemap surface.

Definition hip_runtime_api.h:453

hipDeviceAttributePageableMemoryAccess

@ hipDeviceAttributePageableMemoryAccess

Definition hip_runtime_api.h:482

hipDeviceAttributeClockRate

@ hipDeviceAttributeClockRate

Peak clock frequency in kilohertz.

Definition hip_runtime_api.h:419

hipDeviceAttributeCudaCompatibleEnd

@ hipDeviceAttributeCudaCompatibleEnd

Definition hip_runtime_api.h:512

hipDeviceAttributeMaxTexture1DMipmap

@ hipDeviceAttributeMaxTexture1DMipmap

Maximum size of 1D mipmapped texture.

Definition hip_runtime_api.h:459

hipDeviceAttributeComputeCapabilityMajor

@ hipDeviceAttributeComputeCapabilityMajor

Major compute capability version number.

Definition hip_runtime_api.h:439

hipDeviceAttributeGlobalL1CacheSupported

@ hipDeviceAttributeGlobalL1CacheSupported

Device supports caching globals in L1.

Definition hip_runtime_api.h:430

hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

Definition hip_runtime_api.h:528

hipDeviceAttributeAccessPolicyMaxWindowSize

@ hipDeviceAttributeAccessPolicyMaxWindowSize

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

Definition hip_runtime_api.h:414

hipDeviceAttributeMaxTexture3DHeight

@ hipDeviceAttributeMaxTexture3DHeight

Maximum dimension height of 3D texture.

Definition hip_runtime_api.h:467

hipDeviceAttributeComputeCapabilityMinor

@ hipDeviceAttributeComputeCapabilityMinor

Minor compute capability version number.

Definition hip_runtime_api.h:478

hipDeviceAttributeMaxTextureCubemap

@ hipDeviceAttributeMaxTextureCubemap

Maximum dimensions of Cubemap texture.

Definition hip_runtime_api.h:470

hipDeviceAttributeDeviceOverlap

@ hipDeviceAttributeDeviceOverlap

Definition hip_runtime_api.h:426

hipDeviceAttributeMaxTexture2DLinear

@ hipDeviceAttributeMaxTexture2DLinear

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

Definition hip_runtime_api.h:464

hipDeviceAttributeMaxSurface2D

@ hipDeviceAttributeMaxSurface2D

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

Definition hip_runtime_api.h:450

hipDeviceAttributeMaxSurface1DLayered

@ hipDeviceAttributeMaxSurface1DLayered

Cuda only. Maximum dimensions of 1D layered surface.

Definition hip_runtime_api.h:449

hipDeviceAttributeHdpRegFlushCntl

@ hipDeviceAttributeHdpRegFlushCntl

Address of the HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:521

hipDeviceAttributeComputeMode

@ hipDeviceAttributeComputeMode

Compute mode that device is currently in.

Definition hip_runtime_api.h:420

hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

Definition hip_runtime_api.h:522

hipDeviceAttributeAsicRevision

@ hipDeviceAttributeAsicRevision

Revision of the GPU in this device.

Definition hip_runtime_api.h:531

hipDeviceAttributeUnused4

@ hipDeviceAttributeUnused4

Previously hipDeviceAttributeGcnArch.

Definition hip_runtime_api.h:518

hipDeviceAttributeCooperativeMultiDeviceLaunch

@ hipDeviceAttributeCooperativeMultiDeviceLaunch

Support cooperative launch on multiple devices.

Definition hip_runtime_api.h:425

hipDeviceAttributeMaxTexture2DHeight

@ hipDeviceAttributeMaxTexture2DHeight

Maximum dimension hight of 2D texture.

Definition hip_runtime_api.h:461

hipDeviceAttributePersistingL2CacheMaxSize

@ hipDeviceAttributePersistingL2CacheMaxSize

Maximum l2 persisting lines capacity in bytes.

Definition hip_runtime_api.h:488

hipDeviceAttributeEccEnabled

@ hipDeviceAttributeEccEnabled

Whether ECC support is enabled.

Definition hip_runtime_api.h:413

hipDeviceAttributeCanUseHostPointerForRegisteredMem

@ hipDeviceAttributeCanUseHostPointerForRegisteredMem

Definition hip_runtime_api.h:417

hipDeviceAttributePciBusId

@ hipDeviceAttributePciBusId

PCI Bus ID.

Definition hip_runtime_api.h:485

hipDeviceAttributeL2CacheSize

@ hipDeviceAttributeL2CacheSize

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

Definition hip_runtime_api.h:435

hipDeviceAttributeKernelExecTimeout

@ hipDeviceAttributeKernelExecTimeout

Run time limit for kernels executed on the device.

Definition hip_runtime_api.h:434

hipDeviceAttributeMaxThreadsDim

@ hipDeviceAttributeMaxThreadsDim

Maximum dimension of a block.

Definition hip_runtime_api.h:472

hipDeviceAttributeSingleToDoublePrecisionPerfRatio

@ hipDeviceAttributeSingleToDoublePrecisionPerfRatio

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

Definition hip_runtime_api.h:496

hipDeviceAttributeMaxGridDimY

@ hipDeviceAttributeMaxGridDimY

Max grid size in height.

Definition hip_runtime_api.h:446

hipDeviceAttributeMultiprocessorCount

@ hipDeviceAttributeMultiprocessorCount

Number of multiprocessors on the device.

Definition hip_runtime_api.h:480

hipDeviceAttributeAmdSpecificBegin

@ hipDeviceAttributeAmdSpecificBegin

Definition hip_runtime_api.h:513

hipDeviceAttributeMaxRegistersPerMultiprocessor

@ hipDeviceAttributeMaxRegistersPerMultiprocessor

32-bit registers available per block.

Definition hip_runtime_api.h:491

hipDeviceAttributeIsMultiGpuBoard

@ hipDeviceAttributeIsMultiGpuBoard

Multiple GPU devices.

Definition hip_runtime_api.h:433

hipDeviceAttributeSharedMemPerBlockOptin

@ hipDeviceAttributeSharedMemPerBlockOptin

Maximum shared memory per block usable by special opt in.

Definition hip_runtime_api.h:494

hipDeviceAttributeMaxSurface2DLayered

@ hipDeviceAttributeMaxSurface2DLayered

Cuda only. Maximum dimensions of 2D layered surface.

Definition hip_runtime_api.h:451

hipDeviceAttributeAmdSpecificEnd

@ hipDeviceAttributeAmdSpecificEnd

Definition hip_runtime_api.h:540

hipDeviceAttributeMemoryClockRate

@ hipDeviceAttributeMemoryClockRate

Peak memory clock frequency in kilohertz.

Definition hip_runtime_api.h:477

hipDeviceAttributeMaxGridDimZ

@ hipDeviceAttributeMaxGridDimZ

Max grid size in depth.

Definition hip_runtime_api.h:447

hipDeviceAttributeHdpMemFlushCntl

@ hipDeviceAttributeHdpMemFlushCntl

Address of the HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:520

hipDeviceAttributeUnused2

@ hipDeviceAttributeUnused2

Previously hipDeviceAttributeUuid.

Definition hip_runtime_api.h:505

hipDeviceAttributeFineGrainSupport

@ hipDeviceAttributeFineGrainSupport

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

Definition hip_runtime_api.h:537

hipDeviceAttributeCooperativeLaunch

@ hipDeviceAttributeCooperativeLaunch

Support cooperative launch.

Definition hip_runtime_api.h:424

hipDeviceAttributeUnifiedAddressing

@ hipDeviceAttributeUnifiedAddressing

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

Definition hip_runtime_api.h:504

hipDeviceAttributeAsyncEngineCount

@ hipDeviceAttributeAsyncEngineCount

Asynchronous engines number.

Definition hip_runtime_api.h:415

hipDeviceAttributeMultiGpuBoardGroupID

@ hipDeviceAttributeMultiGpuBoardGroupID

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

Definition hip_runtime_api.h:479

hipDeviceAttributeStreamPrioritiesSupported

@ hipDeviceAttributeStreamPrioritiesSupported

Whether to support stream priorities.

Definition hip_runtime_api.h:497

hipDeviceAttributeMaxSharedMemoryPerBlock

@ hipDeviceAttributeMaxSharedMemoryPerBlock

Maximum shared memory available per block in bytes.

Definition hip_runtime_api.h:493

hipDeviceAttributeLocalL1CacheSupported

@ hipDeviceAttributeLocalL1CacheSupported

caching locals in L1 is supported

Definition hip_runtime_api.h:436

hipDeviceAttributeCanUseStreamWaitValue

@ hipDeviceAttributeCanUseStreamWaitValue

Definition hip_runtime_api.h:532

hipDeviceAttributeMaxRegistersPerBlock

@ hipDeviceAttributeMaxRegistersPerBlock

Definition hip_runtime_api.h:489

hipDeviceAttributeMaxThreadsPerBlock

@ hipDeviceAttributeMaxThreadsPerBlock

Maximum number of threads per block.

Definition hip_runtime_api.h:473

hipDeviceAttributeMemoryBusWidth

@ hipDeviceAttributeMemoryBusWidth

Global memory bus width in bits.

Definition hip_runtime_api.h:476

hipDeviceAttributeMemoryPoolSupportedHandleTypes

@ hipDeviceAttributeMemoryPoolSupportedHandleTypes

Supported handle mask for HIP Stream Ordered Memory Allocator.

Definition hip_runtime_api.h:510

hipDeviceAttributeComputePreemptionSupported

@ hipDeviceAttributeComputePreemptionSupported

Device supports Compute Preemption.

Definition hip_runtime_api.h:421

hipDeviceAttributeMaxSurface1D

@ hipDeviceAttributeMaxSurface1D

Maximum size of 1D surface.

Definition hip_runtime_api.h:448

hipDeviceAttributeUnused1

@ hipDeviceAttributeUnused1

Previously hipDeviceAttributeName.

Definition hip_runtime_api.h:481

hipDeviceAttributeMaxTexture3DAlt

@ hipDeviceAttributeMaxTexture3DAlt

Maximum dimensions of alternate 3D texture.

Definition hip_runtime_api.h:469

hipDeviceAttributeMaxTexture1DLinear

@ hipDeviceAttributeMaxTexture1DLinear

Definition hip_runtime_api.h:457

hipDeviceAttributeMaxTexture2DGather

@ hipDeviceAttributeMaxTexture2DGather

Maximum dimensions of 2D texture if gather operations performed.

Definition hip_runtime_api.h:462

hipDeviceAttributeWallClockRate

@ hipDeviceAttributeWallClockRate

Constant frequency of wall clock in kilohertz.

Definition hip_runtime_api.h:538

hipDeviceAttributePciDeviceId

@ hipDeviceAttributePciDeviceId

PCI Device ID.

Definition hip_runtime_api.h:486

hipDeviceAttributeCanMapHostMemory

@ hipDeviceAttributeCanMapHostMemory

Whether host memory can be mapped into device address space.

Definition hip_runtime_api.h:416

hipDeviceAttributeMaxTexture1DWidth

@ hipDeviceAttributeMaxTexture1DWidth

Maximum size of 1D texture.

Definition hip_runtime_api.h:455

hipDeviceAttributeConcurrentManagedAccess

@ hipDeviceAttributeConcurrentManagedAccess

Device can coherently access managed memory concurrently with the CPU.

Definition hip_runtime_api.h:423

hipDeviceAttributeVendorSpecificBegin

@ hipDeviceAttributeVendorSpecificBegin

Definition hip_runtime_api.h:541

hipDeviceAttributeManagedMemory

@ hipDeviceAttributeManagedMemory

Device supports allocating managed memory on this system.

Definition hip_runtime_api.h:440

hipDeviceAttributeIntegrated

@ hipDeviceAttributeIntegrated

Device is integrated GPU.

Definition hip_runtime_api.h:432

hipDeviceAttributeMaxTexture2DLayered

@ hipDeviceAttributeMaxTexture2DLayered

Maximum dimensions of 2D layered texture.

Definition hip_runtime_api.h:463

hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

Definition hip_runtime_api.h:524

hipDeviceAttributeMaxTexture3DDepth

@ hipDeviceAttributeMaxTexture3DDepth

Maximum dimension depth of 3D texture.

Definition hip_runtime_api.h:468

hipDeviceAttributeImageSupport

@ hipDeviceAttributeImageSupport

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

Definition hip_runtime_api.h:534

hipDeviceAttributeTotalGlobalMem

@ hipDeviceAttributeTotalGlobalMem

Global memory available on devicice.

Definition hip_runtime_api.h:503

hipDeviceAttributeMaxBlocksPerMultiProcessor

@ hipDeviceAttributeMaxBlocksPerMultiProcessor

Max block size per multiprocessor.

Definition hip_runtime_api.h:441

hipDeviceAttributeIsLargeBar

@ hipDeviceAttributeIsLargeBar

Whether it is LargeBar.

Definition hip_runtime_api.h:530

hipDeviceAttributeMaxTexture2DWidth

@ hipDeviceAttributeMaxTexture2DWidth

Maximum dimension width of 2D texture.

Definition hip_runtime_api.h:460

hipDeviceAttributeMaxBlockDimX

@ hipDeviceAttributeMaxBlockDimX

Max block size in width.

Definition hip_runtime_api.h:442

hipDeviceAttributeMaxTexture3DWidth

@ hipDeviceAttributeMaxTexture3DWidth

Maximum dimension width of 3D texture.

Definition hip_runtime_api.h:466

hipDeviceAttributeUnused3

@ hipDeviceAttributeUnused3

Previously hipDeviceAttributeArch.

Definition hip_runtime_api.h:516

hipDeviceAttributeTotalConstantMemory

@ hipDeviceAttributeTotalConstantMemory

Constant memory size in bytes.

Definition hip_runtime_api.h:502

hipDeviceAttributeTextureAlignment

@ hipDeviceAttributeTextureAlignment

Alignment requirement for textures.

Definition hip_runtime_api.h:500

hipDeviceAttributeMaxTexture1DLayered

@ hipDeviceAttributeMaxTexture1DLayered

Maximum dimensions of 1D layered texture.

Definition hip_runtime_api.h:456

hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

@ hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

Maximum Shared Memory PerMultiprocessor.

Definition hip_runtime_api.h:517

hipDeviceAttributeReservedSharedMemPerBlock

@ hipDeviceAttributeReservedSharedMemPerBlock

Shared memory reserved by CUDA driver per block.

Definition hip_runtime_api.h:492

hipDeviceAttributeCudaCompatibleBegin

@ hipDeviceAttributeCudaCompatibleBegin

Definition hip_runtime_api.h:411

hipDeviceAttributeConcurrentKernels

@ hipDeviceAttributeConcurrentKernels

Device can possibly execute multiple kernels concurrently.

Definition hip_runtime_api.h:422

hipDeviceAttributeLuid

@ hipDeviceAttributeLuid

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

Definition hip_runtime_api.h:437

hipDeviceAttributePciDomainID

@ hipDeviceAttributePciDomainID

PCI Domain ID.

Definition hip_runtime_api.h:487

hipDeviceAttributeMaxThreadsPerMultiProcessor

@ hipDeviceAttributeMaxThreadsPerMultiProcessor

Maximum resident threads per multiprocessor.

Definition hip_runtime_api.h:474

hipDeviceAttributeTexturePitchAlignment

@ hipDeviceAttributeTexturePitchAlignment

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

Definition hip_runtime_api.h:501

hipDeviceAttributePhysicalMultiProcessorCount

@ hipDeviceAttributePhysicalMultiProcessorCount

Definition hip_runtime_api.h:535

hipDeviceAttributeHostRegisterSupported

@ hipDeviceAttributeHostRegisterSupported

Can device support host memory registration via hipHostRegister.

Definition hip_runtime_api.h:509

hipDeviceAttributeSharedMemPerMultiprocessor

@ hipDeviceAttributeSharedMemPerMultiprocessor

Shared memory available per multiprocessor.

Definition hip_runtime_api.h:495

hipDeviceAttributeLuidDeviceNodeMask

@ hipDeviceAttributeLuidDeviceNodeMask

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

Definition hip_runtime_api.h:438

hipDeviceAttributeMaxTextureCubemapLayered

@ hipDeviceAttributeMaxTextureCubemapLayered

Maximum dimensions of Cubemap layered texture.

Definition hip_runtime_api.h:471

hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

Definition hip_runtime_api.h:526

hipDeviceAttributeVirtualMemoryManagementSupported

@ hipDeviceAttributeVirtualMemoryManagementSupported

Device supports HIP virtual memory management.

Definition hip_runtime_api.h:508

hipDeviceAttributeMemoryPoolsSupported

@ hipDeviceAttributeMemoryPoolsSupported

Device supports HIP Stream Ordered Memory Allocator.

Definition hip_runtime_api.h:507

hipDeviceAttributeClockInstructionRate

@ hipDeviceAttributeClockInstructionRate

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

Definition hip_runtime_api.h:515

hipDeviceAttributeMaxTexture2DMipmap

@ hipDeviceAttributeMaxTexture2DMipmap

Maximum dimensions of 2D mipmapped texture.

Definition hip_runtime_api.h:465

hipDeviceAttributeMaxBlockDimZ

@ hipDeviceAttributeMaxBlockDimZ

Max block size in depth.

Definition hip_runtime_api.h:444

hipDeviceAttributeWarpSize

@ hipDeviceAttributeWarpSize

Warp size in threads.

Definition hip_runtime_api.h:506

hipGPUDirectRDMAWritesOrderingOwner

@ hipGPUDirectRDMAWritesOrderingOwner

Definition hip_runtime_api.h:565

hipGPUDirectRDMAWritesOrderingNone

@ hipGPUDirectRDMAWritesOrderingNone

Definition hip_runtime_api.h:564

hipGPUDirectRDMAWritesOrderingAllDevices

@ hipGPUDirectRDMAWritesOrderingAllDevices

Definition hip_runtime_api.h:566

hipMemAllocationTypeMax

@ hipMemAllocationTypeMax

Definition hip_runtime_api.h:975

hipMemAllocationTypePinned

@ hipMemAllocationTypePinned

Definition hip_runtime_api.h:974

hipMemAllocationTypeInvalid

@ hipMemAllocationTypeInvalid

Definition hip_runtime_api.h:970

hipMemoryTypeDevice

@ hipMemoryTypeDevice

Definition hip_runtime_api.h:251

hipMemoryTypeHost

@ hipMemoryTypeHost

Memory is physically located on host.

Definition hip_runtime_api.h:250

hipMemoryTypeUnregistered

@ hipMemoryTypeUnregistered

Unregistered memory.

Definition hip_runtime_api.h:249

hipMemoryTypeArray

@ hipMemoryTypeArray

Definition hip_runtime_api.h:256

hipMemoryTypeManaged

@ hipMemoryTypeManaged

Definition hip_runtime_api.h:253

hipMemoryTypeUnified

@ hipMemoryTypeUnified

unified address space

Definition hip_runtime_api.h:258

hipGraphInstantiateFlagAutoFreeOnLaunch

@ hipGraphInstantiateFlagAutoFreeOnLaunch

Automatically free memory allocated in a graph before relaunching.

Definition hip_runtime_api.h:1404

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

hipGraphInstantiateFlagUpload

@ hipGraphInstantiateFlagUpload

Automatically upload the graph after instantiation.

Definition hip_runtime_api.h:1406

hipGraphInstantiateFlagDeviceLaunch

@ hipGraphInstantiateFlagDeviceLaunch

Instantiate the graph to be launched from the device.

Definition hip_runtime_api.h:1408

hipMemLocationTypeInvalid

@ hipMemLocationTypeInvalid

Definition hip_runtime_api.h:935

hipMemLocationTypeDevice

@ hipMemLocationTypeDevice

Device location, thus it's HIP device ID.

Definition hip_runtime_api.h:936

hipArraySparseSubresourceTypeSparseLevel

@ hipArraySparseSubresourceTypeSparseLevel

Sparse level.

Definition hip_runtime_api.h:1531

hipArraySparseSubresourceTypeMiptail

@ hipArraySparseSubresourceTypeMiptail

Miptail.

Definition hip_runtime_api.h:1532

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.

hipDrvGraphMemcpyNodeGetParams

hipError_t hipDrvGraphMemcpyNodeGetParams(hipGraphNode_t hNode, HIP_MEMCPY3D *nodeParams)

Gets a memcpy node's parameters.

hipDeviceSetGraphMemAttribute

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

Set the mem attribute for graphs.

hipGraphMemcpyNodeSetParams

hipError_t hipGraphMemcpyNodeSetParams(hipGraphNode_t node, const hipMemcpy3DParms *pNodeParams)

Sets a memcpy node's parameters.

hipUserObjectCreate

hipError_t hipUserObjectCreate(hipUserObject_t *object_out, void *ptr, hipHostFn_t destroy, unsigned int initialRefcount, unsigned int flags)

Create an instance of userObject to manage lifetime of a resource.

hipGraphExecUpdate

hipError_t hipGraphExecUpdate(hipGraphExec_t hGraphExec, hipGraph_t hGraph, hipGraphNode_t *hErrorNode_out, hipGraphExecUpdateResult *updateResult_out)

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

hipGraphNodeFindInClone

hipError_t hipGraphNodeFindInClone(hipGraphNode_t *pNode, hipGraphNode_t originalNode, hipGraph_t clonedGraph)

Finds a cloned version of a node.

hipGraphAddEventWaitNode

hipError_t hipGraphAddEventWaitNode(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, hipEvent_t event)

Creates an event wait node and adds it to a graph.

hipGraphMemcpyNodeSetParamsToSymbol

hipError_t hipGraphMemcpyNodeSetParamsToSymbol(hipGraphNode_t node, const void *symbol, const void *src, size_t count, size_t offset, hipMemcpyKind kind)

Sets a memcpy node's parameters to copy to a symbol on the device.

hipStreamIsCapturing

hipError_t hipStreamIsCapturing(hipStream_t stream, hipStreamCaptureStatus *pCaptureStatus)

Get stream's capture state.

hipGraphNodeGetEnabled

hipError_t hipGraphNodeGetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, unsigned int *isEnabled)

Query whether a node in the given graphExec is enabled.

hipGraphAddChildGraphNode

hipError_t hipGraphAddChildGraphNode(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, hipGraph_t childGraph)

Creates a child graph node and adds it to a graph.

hipGraphExternalSemaphoresSignalNodeSetParams

hipError_t hipGraphExternalSemaphoresSignalNodeSetParams(hipGraphNode_t hNode, const hipExternalSemaphoreSignalNodeParams *nodeParams)

Updates node parameters in the external semaphore signal node.

hipGraphDestroyNode

hipError_t hipGraphDestroyNode(hipGraphNode_t node)

Remove a node from the graph.

hipGraphMemcpyNodeSetParamsFromSymbol

hipError_t hipGraphMemcpyNodeSetParamsFromSymbol(hipGraphNode_t node, void *dst, const void *symbol, size_t count, size_t offset, hipMemcpyKind kind)

Sets a memcpy node's parameters to copy from a symbol on the device.

hipGraphReleaseUserObject

hipError_t hipGraphReleaseUserObject(hipGraph_t graph, hipUserObject_t object, unsigned int count)

Release user object from graphs.

hipDrvGraphAddMemcpyNode

hipError_t hipDrvGraphAddMemcpyNode(hipGraphNode_t *phGraphNode, hipGraph_t hGraph, const hipGraphNode_t *dependencies, size_t numDependencies, const HIP_MEMCPY3D *copyParams, hipCtx_t ctx)

Creates a memcpy node and adds it to a graph.

hipGraphRemoveDependencies

hipError_t hipGraphRemoveDependencies(hipGraph_t graph, const hipGraphNode_t *from, const hipGraphNode_t *to, size_t numDependencies)

Removes dependency edges from a graph.

hipGraphMemcpyNodeSetParams1D

hipError_t hipGraphMemcpyNodeSetParams1D(hipGraphNode_t node, void *dst, const void *src, size_t count, hipMemcpyKind kind)

Sets a memcpy node's parameters to perform a 1-dimensional copy.

hipGraphExecMemcpyNodeSetParams1D

hipError_t hipGraphExecMemcpyNodeSetParams1D(hipGraphExec_t hGraphExec, hipGraphNode_t node, void *dst, const void *src, size_t count, hipMemcpyKind kind)

Sets the parameters for a memcpy node in the given graphExec to perform a 1-dimensional copy.

hipGraphExecDestroy

hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec)

Destroys an executable graph.

hipGraphAddExternalSemaphoresSignalNode

hipError_t hipGraphAddExternalSemaphoresSignalNode(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, const hipExternalSemaphoreSignalNodeParams *nodeParams)

Creates a external semaphor signal node and adds it to a graph.

hipGraphExecExternalSemaphoresWaitNodeSetParams

hipError_t hipGraphExecExternalSemaphoresWaitNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, const hipExternalSemaphoreWaitNodeParams *nodeParams)

Updates node parameters in the external semaphore wait node in the given graphExec.

hipGraphExecHostNodeSetParams

hipError_t hipGraphExecHostNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node, const hipHostNodeParams *pNodeParams)

Sets the parameters for a host node in the given graphExec.

hipGraphExecChildGraphNodeSetParams

hipError_t hipGraphExecChildGraphNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node, hipGraph_t childGraph)

Updates node parameters in the child graph node in the given graphExec.

hipStreamGetCaptureInfo

hipError_t hipStreamGetCaptureInfo(hipStream_t stream, hipStreamCaptureStatus *pCaptureStatus, unsigned long long *pId)

Get capture status of a stream.

hipGraphAddDependencies

hipError_t hipGraphAddDependencies(hipGraph_t graph, const hipGraphNode_t *from, const hipGraphNode_t *to, size_t numDependencies)

Adds dependency edges to a graph.

hipDrvGraphExecMemsetNodeSetParams

hipError_t hipDrvGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, const HIP_MEMSET_NODE_PARAMS *memsetParams, hipCtx_t ctx)

Sets the parameters for a memset node in the given graphExec.

hipDrvGraphAddMemFreeNode

hipError_t hipDrvGraphAddMemFreeNode(hipGraphNode_t *phGraphNode, hipGraph_t hGraph, const hipGraphNode_t *dependencies, size_t numDependencies, hipDeviceptr_t dptr)

Creates a memory free node and adds it to a graph.

hipGraphExecKernelNodeSetParams

hipError_t hipGraphExecKernelNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node, const hipKernelNodeParams *pNodeParams)

Sets the parameters for a kernel node in the given graphExec.

hipGraphNodeGetDependentNodes

hipError_t hipGraphNodeGetDependentNodes(hipGraphNode_t node, hipGraphNode_t *pDependentNodes, size_t *pNumDependentNodes)

Returns a node's dependent nodes.

hipDeviceGetGraphMemAttribute

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

Get the mem attribute for graphs.

hipGraphHostNodeGetParams

hipError_t hipGraphHostNodeGetParams(hipGraphNode_t node, hipHostNodeParams *pNodeParams)

Returns a host node's parameters.

hipGraphInstantiateWithFlags

hipError_t hipGraphInstantiateWithFlags(hipGraphExec_t *pGraphExec, hipGraph_t graph, unsigned long long flags)

Creates an executable graph from a graph.

hipGraphExternalSemaphoresSignalNodeGetParams

hipError_t hipGraphExternalSemaphoresSignalNodeGetParams(hipGraphNode_t hNode, hipExternalSemaphoreSignalNodeParams *params_out)

Returns external semaphore signal node params.

hipGraphUpload

hipError_t hipGraphUpload(hipGraphExec_t graphExec, hipStream_t stream)

Uploads an executable graph to a stream.

hipGraphExecExternalSemaphoresSignalNodeSetParams

hipError_t hipGraphExecExternalSemaphoresSignalNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, const hipExternalSemaphoreSignalNodeParams *nodeParams)

Updates node parameters in the external semaphore signal node in the given graphExec.

hipGraphExecMemcpyNodeSetParamsToSymbol

hipError_t hipGraphExecMemcpyNodeSetParamsToSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node, const void *symbol, const void *src, size_t count, size_t offset, hipMemcpyKind kind)

Sets the parameters for a memcpy node in the given graphExec to copy to a symbol on the device.

hipUserObjectRelease

hipError_t hipUserObjectRelease(hipUserObject_t object, unsigned int count)

Release number of references to resource.

hipGraphKernelNodeGetParams

hipError_t hipGraphKernelNodeGetParams(hipGraphNode_t node, hipKernelNodeParams *pNodeParams)

Gets kernel node's parameters.

hipGraphAddMemcpyNodeFromSymbol

hipError_t hipGraphAddMemcpyNodeFromSymbol(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, void *dst, const void *symbol, size_t count, size_t offset, hipMemcpyKind kind)

Creates a memcpy node to copy from a symbol on the device and adds it to a graph.

hipGraphKernelNodeCopyAttributes

hipError_t hipGraphKernelNodeCopyAttributes(hipGraphNode_t hSrc, hipGraphNode_t hDst)

Copies attributes from source node to destination node.

hipGraphAddMemFreeNode

hipError_t hipGraphAddMemFreeNode(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, void *dev_ptr)

Creates a memory free node and adds it to a graph.

hipDrvGraphMemcpyNodeSetParams

hipError_t hipDrvGraphMemcpyNodeSetParams(hipGraphNode_t hNode, const HIP_MEMCPY3D *nodeParams)

Sets a memcpy node's parameters.

hipGraphMemcpyNodeGetParams

hipError_t hipGraphMemcpyNodeGetParams(hipGraphNode_t node, hipMemcpy3DParms *pNodeParams)

Gets a memcpy node's parameters.

hipGraphNodeSetParams

hipError_t hipGraphNodeSetParams(hipGraphNode_t node, hipGraphNodeParams *nodeParams)

Updates parameters of a graph's node.

hipGraphAddEventRecordNode

hipError_t hipGraphAddEventRecordNode(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, hipEvent_t event)

Creates an event record node and adds it to a graph.

hipDrvGraphExecMemcpyNodeSetParams

hipError_t hipDrvGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, const HIP_MEMCPY3D *copyParams, hipCtx_t ctx)

Sets the parameters for a memcpy node in the given graphExec.

hipStreamBeginCapture

hipError_t hipStreamBeginCapture(hipStream_t stream, hipStreamCaptureMode mode)

Begins graph capture on a stream.

hipStreamEndCapture

hipError_t hipStreamEndCapture(hipStream_t stream, hipGraph_t *pGraph)

Ends capture on a stream, returning the captured graph.

hipGraphExecGetFlags

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

Return the flags of an executable graph.

hipUserObjectRetain

hipError_t hipUserObjectRetain(hipUserObject_t object, unsigned int count)

Retain number of references to resource.

hipGraphNodeGetType

hipError_t hipGraphNodeGetType(hipGraphNode_t node, hipGraphNodeType *pType)

Returns a node's type.

hipGraphNodeSetEnabled

hipError_t hipGraphNodeSetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, unsigned int isEnabled)

Enables or disables the specified node in the given graphExec.

hipGraphExecMemcpyNodeSetParams

hipError_t hipGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node, hipMemcpy3DParms *pNodeParams)

Sets the parameters of a memcpy node in the given graphExec.

hipGraphExecNodeSetParams

hipError_t hipGraphExecNodeSetParams(hipGraphExec_t graphExec, hipGraphNode_t node, hipGraphNodeParams *nodeParams)

Updates parameters of an executable graph's node.

hipGraphHostNodeSetParams

hipError_t hipGraphHostNodeSetParams(hipGraphNode_t node, const hipHostNodeParams *pNodeParams)

Sets a host node's parameters.

hipGraphMemAllocNodeGetParams

hipError_t hipGraphMemAllocNodeGetParams(hipGraphNode_t node, hipMemAllocNodeParams *pNodeParams)

Returns parameters for memory allocation node.

hipGraphInstantiateWithParams

hipError_t hipGraphInstantiateWithParams(hipGraphExec_t *pGraphExec, hipGraph_t graph, hipGraphInstantiateParams *instantiateParams)

Creates an executable graph from a graph.

hipGraphExecEventRecordNodeSetEvent

hipError_t hipGraphExecEventRecordNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, hipEvent_t event)

Sets the event for an event record node in the given graphExec.

hipGraphExternalSemaphoresWaitNodeSetParams

hipError_t hipGraphExternalSemaphoresWaitNodeSetParams(hipGraphNode_t hNode, const hipExternalSemaphoreWaitNodeParams *nodeParams)

Updates node parameters in the external semaphore wait node.

hipGraphMemsetNodeGetParams

hipError_t hipGraphMemsetNodeGetParams(hipGraphNode_t node, hipMemsetParams *pNodeParams)

Gets a memset node's parameters.

hipGraphChildGraphNodeGetGraph

hipError_t hipGraphChildGraphNodeGetGraph(hipGraphNode_t node, hipGraph_t *pGraph)

Gets a handle to the embedded graph of a child graph node.

hipGraphKernelNodeGetAttribute

hipError_t hipGraphKernelNodeGetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr, hipKernelNodeAttrValue *value)

Gets a node's attribute.

hipThreadExchangeStreamCaptureMode

hipError_t hipThreadExchangeStreamCaptureMode(hipStreamCaptureMode *mode)

Swaps the stream capture mode of a thread.

hipGraphLaunch

hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream)

Launches an executable graph in the specified stream.

hipGraphDebugDotPrint

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

Write a DOT file describing graph structure.

hipGraphExecMemsetNodeSetParams

hipError_t hipGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node, const hipMemsetParams *pNodeParams)

Sets the parameters for a memset node in the given graphExec.

hipGraphGetEdges

hipError_t hipGraphGetEdges(hipGraph_t graph, hipGraphNode_t *from, hipGraphNode_t *to, size_t *numEdges)

Returns a graph's dependency edges.

hipGraphAddKernelNode

hipError_t hipGraphAddKernelNode(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, const hipKernelNodeParams *pNodeParams)

Creates a kernel execution node and adds it to a graph.

hipGraphExecEventWaitNodeSetEvent

hipError_t hipGraphExecEventWaitNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, hipEvent_t event)

Sets the event for an event record node in the given graphExec.

hipStreamGetCaptureInfo_v2

hipError_t hipStreamGetCaptureInfo_v2(hipStream_t stream, hipStreamCaptureStatus *captureStatus_out, unsigned long long *id_out, hipGraph_t *graph_out, const hipGraphNode_t **dependencies_out, size_t *numDependencies_out)

Get stream's capture state.

hipStreamBeginCaptureToGraph

hipError_t hipStreamBeginCaptureToGraph(hipStream_t stream, hipGraph_t graph, const hipGraphNode_t *dependencies, const hipGraphEdgeData *dependencyData, size_t numDependencies, hipStreamCaptureMode mode)

Begins graph capture on a stream to an existing graph.

hipGraphAddExternalSemaphoresWaitNode

hipError_t hipGraphAddExternalSemaphoresWaitNode(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, const hipExternalSemaphoreWaitNodeParams *nodeParams)

Creates a external semaphor wait node and adds it to a graph.

hipGraphEventWaitNodeSetEvent

hipError_t hipGraphEventWaitNodeSetEvent(hipGraphNode_t node, hipEvent_t event)

Sets an event wait node's event.

hipGraphEventRecordNodeSetEvent

hipError_t hipGraphEventRecordNodeSetEvent(hipGraphNode_t node, hipEvent_t event)

Sets an event record node's event.

hipGraphEventWaitNodeGetEvent

hipError_t hipGraphEventWaitNodeGetEvent(hipGraphNode_t node, hipEvent_t *event_out)

Returns the event associated with an event wait node.

hipGraphKernelNodeSetAttribute

hipError_t hipGraphKernelNodeSetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr, const hipKernelNodeAttrValue *value)

Sets a node's attribute.

hipGraphMemsetNodeSetParams

hipError_t hipGraphMemsetNodeSetParams(hipGraphNode_t node, const hipMemsetParams *pNodeParams)

Sets a memset node's parameters.

hipGraphEventRecordNodeGetEvent

hipError_t hipGraphEventRecordNodeGetEvent(hipGraphNode_t node, hipEvent_t *event_out)

Returns the event associated with an event record node.

hipGraphAddEmptyNode

hipError_t hipGraphAddEmptyNode(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies)

Creates an empty node and adds it to a graph.

hipGraphAddMemcpyNodeToSymbol

hipError_t hipGraphAddMemcpyNodeToSymbol(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, const void *symbol, const void *src, size_t count, size_t offset, hipMemcpyKind kind)

Creates a memcpy node to copy to a symbol on the device and adds it to a graph.

hipGraphDestroy

hipError_t hipGraphDestroy(hipGraph_t graph)

Destroys a graph.

hipGraphRetainUserObject

hipError_t hipGraphRetainUserObject(hipGraph_t graph, hipUserObject_t object, unsigned int count, unsigned int flags)

Retain user object for graphs.

hipGraphExecMemcpyNodeSetParamsFromSymbol

hipError_t hipGraphExecMemcpyNodeSetParamsFromSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node, void *dst, const void *symbol, size_t count, size_t offset, hipMemcpyKind kind)

Sets the parameters for a memcpy node in the given graphExec to copy from a symbol on the.

hipGraphAddMemAllocNode

hipError_t hipGraphAddMemAllocNode(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, hipMemAllocNodeParams *pNodeParams)

Creates a memory allocation node and adds it to a graph.

hipGraphAddHostNode

hipError_t hipGraphAddHostNode(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, const hipHostNodeParams *pNodeParams)

Creates a host execution node and adds it to a graph.

hipGraphAddNode

hipError_t hipGraphAddNode(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, hipGraphNodeParams *nodeParams)

Creates a kernel execution node and adds it to a graph.

hipGraphGetNodes

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

Returns a graph's nodes.

hipGraphAddMemsetNode

hipError_t hipGraphAddMemsetNode(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, const hipMemsetParams *pMemsetParams)

Creates a memset node and adds it to a graph.

hipStreamUpdateCaptureDependencies

hipError_t hipStreamUpdateCaptureDependencies(hipStream_t stream, hipGraphNode_t *dependencies, size_t numDependencies, unsigned int flags)

Update the set of dependencies in a capturing stream.

hipGraphInstantiate

hipError_t hipGraphInstantiate(hipGraphExec_t *pGraphExec, hipGraph_t graph, hipGraphNode_t *pErrorNode, char *pLogBuffer, size_t bufferSize)

Creates an executable graph from a graph.

hipDeviceGraphMemTrim

hipError_t hipDeviceGraphMemTrim(int device)

Free unused memory reserved for graphs on a specific device and return it back to the OS.

hipGraphExternalSemaphoresWaitNodeGetParams

hipError_t hipGraphExternalSemaphoresWaitNodeGetParams(hipGraphNode_t hNode, hipExternalSemaphoreWaitNodeParams *params_out)

Returns external semaphore wait node params.

hipGraphClone

hipError_t hipGraphClone(hipGraph_t *pGraphClone, hipGraph_t originalGraph)

Clones a graph.

hipDrvGraphAddMemsetNode

hipError_t hipDrvGraphAddMemsetNode(hipGraphNode_t *phGraphNode, hipGraph_t hGraph, const hipGraphNode_t *dependencies, size_t numDependencies, const HIP_MEMSET_NODE_PARAMS *memsetParams, hipCtx_t ctx)

Creates a memset node and adds it to a graph.

hipGraphGetRootNodes

hipError_t hipGraphGetRootNodes(hipGraph_t graph, hipGraphNode_t *pRootNodes, size_t *pNumRootNodes)

Returns a graph's root nodes.

hipGraphAddMemcpyNode

hipError_t hipGraphAddMemcpyNode(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, const hipMemcpy3DParms *pCopyParams)

Creates a memcpy node and adds it to a graph.

hipHostFree

hipError_t hipHostFree(void *ptr)

Free memory allocated by the hcc hip host memory allocation API This API performs an implicit hipDevi...

hipMallocHost

hipError_t hipMallocHost(void **ptr, size_t size)

Allocate pinned host memory [Deprecated].

hipMemcpyToArray

hipError_t hipMemcpyToArray(hipArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t count, hipMemcpyKind kind)

Copies data between host and device [Deprecated].

hipMemcpyFromArray

hipError_t hipMemcpyFromArray(void *dst, hipArray_const_t srcArray, size_t wOffset, size_t hOffset, size_t count, hipMemcpyKind kind)

Copies data between host and device [Deprecated].

hipMemAllocHost

hipError_t hipMemAllocHost(void **ptr, size_t size)

Allocate pinned host memory [Deprecated].

hipMemcpyAtoA

hipError_t hipMemcpyAtoA(hipArray_t dstArray, size_t dstOffset, hipArray_t srcArray, size_t srcOffset, size_t ByteCount)

Copies from one 1D array to another.

hipHostAlloc

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

Allocate device accessible page locked host memory.

hipMemcpy2DArrayToArray

hipError_t hipMemcpy2DArrayToArray(hipArray_t dst, size_t wOffsetDst, size_t hOffsetDst, hipArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, hipMemcpyKind kind)

Copies data between host and device.

hipMemsetD8Async

hipError_t hipMemsetD8Async(hipDeviceptr_t dest, unsigned char value, size_t count, hipStream_t stream)

Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value va...

hipMemcpyAtoHAsync

hipError_t hipMemcpyAtoHAsync(void *dstHost, hipArray_t srcArray, size_t srcOffset, size_t ByteCount, hipStream_t stream)

Copies from one 1D array to host memory.

hipFreeHost

hipError_t hipFreeHost(void *ptr)

Frees page-locked memory This API performs an implicit hipDeviceSynchronize() call....

hipMemset2DAsync

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

Fills asynchronously the memory area pointed to by dst with the constant value.

hipMemGetInfo

hipError_t hipMemGetInfo(size_t *free, size_t *total)

Query memory info.

hipExtMallocWithFlags

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

Allocate memory on the default accelerator.

hipMemcpy3D

hipError_t hipMemcpy3D(const struct hipMemcpy3DParms *p)

Copies data between host and device.

hipMalloc3DArray

hipError_t hipMalloc3DArray(hipArray_t *array, const struct hipChannelFormatDesc *desc, struct hipExtent extent, unsigned int flags)

Allocate an array on the device.

hipArrayCreate

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

Create an array memory pointer on the device.

hipMemset3D

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

Fills synchronously the memory area pointed to by pitchedDevPtr with the constant value.

hipModuleGetGlobal

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

Returns a global pointer from a module. Returns in *dptr and *bytes the pointer and size of the globa...

hipMemsetD16

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

Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant short value v...

hipMemcpyAtoD

hipError_t hipMemcpyAtoD(hipDeviceptr_t dstDevice, hipArray_t srcArray, size_t srcOffset, size_t ByteCount)

Copies from one 1D array to device memory.

hipMalloc

hipError_t hipMalloc(void **ptr, size_t size)

Allocate memory on the default accelerator.

hipHostUnregister

hipError_t hipHostUnregister(void *hostPtr)

Un-register host pointer.

hipHostGetFlags

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

Return flags associated with host pointer.

hipMemcpyFromSymbolAsync

hipError_t hipMemcpyFromSymbolAsync(void *dst, const void *symbol, size_t sizeBytes, size_t offset, hipMemcpyKind kind, hipStream_t stream)

Copies data from the given symbol on the device asynchronously.

hipMemsetD32

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

Fills the memory area pointed to by dest with the constant integer value for specified number of time...

hipMemset3DAsync

hipError_t hipMemset3DAsync(hipPitchedPtr pitchedDevPtr, int value, hipExtent extent, hipStream_t stream)

Fills asynchronously the memory area pointed to by pitchedDevPtr with the constant value.

hipMemcpyFromSymbol

hipError_t hipMemcpyFromSymbol(void *dst, const void *symbol, size_t sizeBytes, size_t offset, hipMemcpyKind kind)

Copies data from the given symbol on the device.

hipDrvMemcpy3DAsync

hipError_t hipDrvMemcpy3DAsync(const HIP_MEMCPY3D *pCopy, hipStream_t stream)

Copies data between host and device asynchronously.

hipArray3DGetDescriptor

hipError_t hipArray3DGetDescriptor(HIP_ARRAY3D_DESCRIPTOR *pArrayDescriptor, hipArray_t array)

Gets a 3D array descriptor.

hipMemcpy2DAsync

hipError_t hipMemcpy2DAsync(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind, hipStream_t stream)

Copies data between host and device.

hipArrayGetDescriptor

hipError_t hipArrayGetDescriptor(HIP_ARRAY_DESCRIPTOR *pArrayDescriptor, hipArray_t array)

Gets a 1D or 2D array descriptor.

hipFree

hipError_t hipFree(void *ptr)

Free memory allocated by the hcc hip memory allocation API. This API performs an implicit hipDeviceSy...

hipMemcpyHtoAAsync

hipError_t hipMemcpyHtoAAsync(hipArray_t dstArray, size_t dstOffset, const void *srcHost, size_t ByteCount, hipStream_t stream)

Copies from host memory to a 1D array.

hipMemsetD16Async

hipError_t hipMemsetD16Async(hipDeviceptr_t dest, unsigned short value, size_t count, hipStream_t stream)

Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant short value v...

hipGetProcAddress

hipError_t hipGetProcAddress(const char *symbol, void **pfn, int hipVersion, uint64_t flags, hipDriverProcAddressQueryResult *symbolStatus)

Gets the pointer of requested HIP driver function.

hipPointerGetAttributes

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

Returns attributes for the specified pointer.

hipMallocPitch

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

hipMemcpyDtoD

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

Copy data from Device to Device.

hipMallocArray

hipError_t hipMallocArray(hipArray_t *array, const hipChannelFormatDesc *desc, size_t width, size_t height, unsigned int flags)

Allocate an array on the device.

hipMemcpy2D

hipError_t hipMemcpy2D(void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind)

Copies data between host and device.

hipHostGetDevicePointer

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

Get Device pointer from Host Pointer allocated through hipHostMalloc.

hipMemcpyDtoA

hipError_t hipMemcpyDtoA(hipArray_t dstArray, size_t dstOffset, hipDeviceptr_t srcDevice, size_t ByteCount)

Copies from device memory to a 1D array.

hipMemcpy2DFromArrayAsync

hipError_t hipMemcpy2DFromArrayAsync(void *dst, size_t dpitch, hipArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, hipMemcpyKind kind, hipStream_t stream)

Copies data between host and device asynchronously.

hipMemcpy2DFromArray

hipError_t hipMemcpy2DFromArray(void *dst, size_t dpitch, hipArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, hipMemcpyKind kind)

Copies data between host and device.

hipMemcpy3DAsync

hipError_t hipMemcpy3DAsync(const struct hipMemcpy3DParms *p, hipStream_t stream)

Copies data between host and device asynchronously.

hipArray3DCreate

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

Create a 3D array memory pointer on the device.

hipArrayGetInfo

hipError_t hipArrayGetInfo(hipChannelFormatDesc *desc, hipExtent *extent, unsigned int *flags, hipArray_t array)

Gets info about the specified array.

hipDrvMemcpy3D

hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D *pCopy)

Copies data between host and device.

hipMemcpyHtoD

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

Copy data from Host to Device.

hipMemcpyParam2D

hipError_t hipMemcpyParam2D(const hip_Memcpy2D *pCopy)

Copies memory for 2D arrays.

hipMemcpyHtoA

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

Copies data between host and device.

hipMemcpyToSymbolAsync

hipError_t hipMemcpyToSymbolAsync(const void *symbol, const void *src, size_t sizeBytes, size_t offset, hipMemcpyKind kind, hipStream_t stream)

Copies data to the given symbol on the device asynchronously.

hipHostMalloc

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

Allocates device accessible page locked (pinned) host memory.

hipMemcpy2DToArrayAsync

hipError_t hipMemcpy2DToArrayAsync(hipArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind, hipStream_t stream)

Copies data between host and device.

hipHostRegister

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

Register host memory so it can be accessed from the current device.

hipMemcpyAtoH

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

Copies data between host and device.

hipMemcpyToSymbol

hipError_t hipMemcpyToSymbol(const void *symbol, const void *src, size_t sizeBytes, size_t offset, hipMemcpyKind kind)

Copies data to the given symbol on the device. Symbol HIP APIs allow a kernel to define a device-side...

hipMemcpy

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

Copy data from src to dst.

hipMemset

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

Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value va...

hipMemcpy2DToArray

hipError_t hipMemcpy2DToArray(hipArray_t dst, size_t wOffset, size_t hOffset, const void *src, size_t spitch, size_t width, size_t height, hipMemcpyKind kind)

Copies data between host and device.

hipMemcpyParam2DAsync

hipError_t hipMemcpyParam2DAsync(const hip_Memcpy2D *pCopy, hipStream_t stream)

Copies memory for 2D arrays.

hipDrvPointerGetAttributes

hipError_t hipDrvPointerGetAttributes(unsigned int numAttributes, hipPointer_attribute *attributes, void **data, hipDeviceptr_t ptr)

Returns information about the specified pointer.[BETA].

hipMalloc3D

hipError_t hipMalloc3D(hipPitchedPtr *pitchedDevPtr, hipExtent extent)

Create a 3D memory pointer on the device.

hipPointerSetAttribute

hipError_t hipPointerSetAttribute(const void *value, hipPointer_attribute attribute, hipDeviceptr_t ptr)

Sets information on the specified pointer.[BETA].

hipMemcpyDtoDAsync

hipError_t hipMemcpyDtoDAsync(hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes, hipStream_t stream)

Copy data from Device to Device asynchronously.

hipMemAllocPitch

hipError_t hipMemAllocPitch(hipDeviceptr_t *dptr, size_t *pitch, size_t widthInBytes, size_t height, unsigned int elementSizeBytes)

hipMemsetD8

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

Fills the first sizeBytes bytes of the memory area pointed to by dest with the constant byte value va...

hipMemcpyAsync

hipError_t hipMemcpyAsync(void *dst, const void *src, size_t sizeBytes, hipMemcpyKind kind, hipStream_t stream)

Copy data from src to dst asynchronously.

hipMemcpyDtoHAsync

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

Copy data from Device to Host asynchronously.

hipFreeArray

hipError_t hipFreeArray(hipArray_t array)

Frees an array on the device.

hipMemsetD32Async

hipError_t hipMemsetD32Async(hipDeviceptr_t dst, int value, size_t count, hipStream_t stream)

Fills the memory area pointed to by dev with the constant integer value for specified number of times...

hipMemset2D

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

Fills the memory area pointed to by dst with the constant value.

hipMemcpyHtoDAsync

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

Copy data from Host to Device asynchronously.

hipGetSymbolSize

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

Gets the size of the given symbol on the device.

hipMemcpyDtoH

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

Copy data from Device to Host.

hipMemsetAsync

hipError_t hipMemsetAsync(void *dst, int value, size_t sizeBytes, hipStream_t stream)

Fills the first sizeBytes bytes of the memory area pointed to by dev with the constant byte value val...

hipMemcpyWithStream

hipError_t hipMemcpyWithStream(void *dst, const void *src, size_t sizeBytes, hipMemcpyKind kind, hipStream_t stream)

Memory copy on the stream. It allows single or multiple devices to do memory copy on single or multip...

hipGetSymbolAddress

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

Gets device pointer associated with symbol on the device.

hipPointerGetAttribute

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

Returns information about the specified pointer.[BETA].

hipMemPtrGetInfo

hipError_t hipMemPtrGetInfo(void *ptr, size_t *size)

Get allocated memory size via memory pointer.

hipArrayDestroy

hipError_t hipArrayDestroy(hipArray_t array)

Destroy an array memory pointer on the device.

hipMemPrefetchAsync

hipError_t hipMemPrefetchAsync(const void *dev_ptr, size_t count, int device, hipStream_t stream)

Prefetches memory to the specified destination device using HIP.

hipMemRangeGetAttributes

hipError_t hipMemRangeGetAttributes(void **data, size_t *data_sizes, hipMemRangeAttribute *attributes, size_t num_attributes, const void *dev_ptr, size_t count)

Query attributes of a given memory range in HIP.

hipMemAdvise

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

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

hipMemRangeGetAttribute

hipError_t hipMemRangeGetAttribute(void *data, size_t data_size, hipMemRangeAttribute attribute, const void *dev_ptr, size_t count)

Query an attribute of a given memory range in HIP.

hipMallocManaged

hipError_t hipMallocManaged(void **dev_ptr, size_t size, unsigned int flags)

Allocates memory that will be automatically managed by HIP.

hipStreamAttachMemAsync

hipError_t hipStreamAttachMemAsync(hipStream_t stream, void *dev_ptr, size_t length, unsigned int flags)

Attach memory to a stream asynchronously in HIP.

hipModuleLaunchCooperativeKernelMultiDevice

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

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

hipLaunchCooperativeKernelMultiDevice

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

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

hipModuleLaunchCooperativeKernel

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

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

hipLaunchCooperativeKernel

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

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

hipFuncGetAttributes

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

Find out attributes for a given function.

hipModuleGetTexRef

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

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

hipExtLaunchMultiKernelMultiDevice

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

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

hipModuleLaunchKernel

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

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

hipModuleLoad

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

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

hipModuleLoadDataEx

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

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

hipFuncGetAttribute

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

Find out a specific attribute for a given function.

hipGetFuncBySymbol

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

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

hipModuleGetFunction

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

Function with kname will be extracted if present in module.

hipModuleLoadData

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

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

hipModuleUnload

hipError_t hipModuleUnload(hipModule_t module)

Frees the module.

hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags

hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, const void *f, int blockSize, size_t dynSharedMemPerBlk, unsigned int flags)

Returns occupancy for a device function.

hipModuleOccupancyMaxPotentialBlockSize

hipError_t hipModuleOccupancyMaxPotentialBlockSize(int *gridSize, int *blockSize, hipFunction_t f, size_t dynSharedMemPerBlk, int blockSizeLimit)

determine the grid and block sizes to achieves maximum occupancy for a kernel

hipOccupancyMaxActiveBlocksPerMultiprocessor

hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, const void *f, int blockSize, size_t dynSharedMemPerBlk)

Returns occupancy for a device function.

hipOccupancyMaxPotentialBlockSize

hipError_t hipOccupancyMaxPotentialBlockSize(int *gridSize, int *blockSize, const void *f, size_t dynSharedMemPerBlk, int blockSizeLimit)

determine the grid and block sizes to achieves maximum occupancy for a kernel

hipModuleOccupancyMaxActiveBlocksPerMultiprocessor

hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(int *numBlocks, hipFunction_t f, int blockSize, size_t dynSharedMemPerBlk)

Returns occupancy for a device function.

hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags

hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int *numBlocks, hipFunction_t f, int blockSize, size_t dynSharedMemPerBlk, unsigned int flags)

Returns occupancy for a device function.

hipModuleOccupancyMaxPotentialBlockSizeWithFlags

hipError_t hipModuleOccupancyMaxPotentialBlockSizeWithFlags(int *gridSize, int *blockSize, hipFunction_t f, size_t dynSharedMemPerBlk, int blockSizeLimit, unsigned int flags)

determine the grid and block sizes to achieves maximum occupancy for a kernel

hipDeviceCanAccessPeer

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

Determine if a device can access a peer's memory.

hipDeviceEnablePeerAccess

hipError_t hipDeviceEnablePeerAccess(int peerDeviceId, unsigned int flags)

Enable direct access from current device's virtual address space to memory allocations physically loc...

hipDeviceDisablePeerAccess

hipError_t hipDeviceDisablePeerAccess(int peerDeviceId)

Disable direct access from current device's virtual address space to memory allocations physically lo...

hipMemGetAddressRange

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

Get information on memory allocations.

hipProfilerStart

hipError_t hipProfilerStart()

Start recording of profiling information [Deprecated] When using this API, start the profiler with pr...

hipProfilerStop

hipError_t hipProfilerStop()

Stop recording of profiling information [Deprecated] When using this API, start the profiler with pro...

hipDeviceGetStreamPriorityRange

hipError_t hipDeviceGetStreamPriorityRange(int *leastPriority, int *greatestPriority)

Returns numerical values that correspond to the least and greatest stream priority.

hipStreamDestroy

hipError_t hipStreamDestroy(hipStream_t stream)

Destroys the specified stream.

hipStreamGetFlags

hipError_t hipStreamGetFlags(hipStream_t stream, unsigned int *flags)

Return flags associated with this stream.

hipStreamAddCallback

hipError_t hipStreamAddCallback(hipStream_t stream, hipStreamCallback_t callback, void *userData, unsigned int flags)

Adds a callback to be called on the host after all currently enqueued items in the stream have comple...

hipStreamCallback_t

void(* hipStreamCallback_t)(hipStream_t stream, hipError_t status, void *userData)

Definition hip_runtime_api.h:2611

hipStreamGetDevice

hipError_t hipStreamGetDevice(hipStream_t stream, hipDevice_t *device)

Get the device assocaited with the stream.

hipStreamQuery

hipError_t hipStreamQuery(hipStream_t stream)

Return hipSuccess if all of the operations in the specified stream have completed,...

hipStreamSynchronize

hipError_t hipStreamSynchronize(hipStream_t stream)

Wait for all commands in stream to complete.

hipStreamWaitEvent

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

Make the specified compute stream wait for an event.

hipStreamCreateWithPriority

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

Create an asynchronous stream with the specified priority.

hipExtStreamCreateWithCUMask

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

Create an asynchronous stream with the specified CU mask.

hipStreamGetPriority

hipError_t hipStreamGetPriority(hipStream_t stream, int *priority)

Query the priority of a stream.

hipExtStreamGetCUMask

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

Get CU mask associated with an asynchronous stream.

hipStreamCreateWithFlags

hipError_t hipStreamCreateWithFlags(hipStream_t *stream, unsigned int flags)

Create an asynchronous stream.

hipStreamCreate

hipError_t hipStreamCreate(hipStream_t *stream)

Create an asynchronous stream.

hipStreamWriteValue64

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

Enqueues a write command to the stream.[BETA].

hipStreamWriteValue32

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

Enqueues a write command to the stream.[BETA].

hipStreamWaitValue64

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

Enqueues a wait command to the stream.[BETA].

hipStreamWaitValue32

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

Enqueues a wait command to the stream.[BETA].

hipMemPoolImportPointer

hipError_t hipMemPoolImportPointer(void **dev_ptr, hipMemPool_t mem_pool, hipMemPoolPtrExportData *export_data)

Import a memory pool allocation from another process.

hipMemPoolImportFromShareableHandle

hipError_t hipMemPoolImportFromShareableHandle(hipMemPool_t *mem_pool, void *shared_handle, hipMemAllocationHandleType handle_type, unsigned int flags)

Imports a memory pool from a shared handle.

hipMallocFromPoolAsync

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

Allocates memory from a specified pool with stream ordered semantics.

hipFreeAsync

hipError_t hipFreeAsync(void *dev_ptr, hipStream_t stream)

Frees memory with stream ordered semantics.

hipMemPoolTrimTo

hipError_t hipMemPoolTrimTo(hipMemPool_t mem_pool, size_t min_bytes_to_hold)

Releases freed memory back to the OS.

hipMemPoolCreate

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

Creates a memory pool.

hipMemPoolSetAccess

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

Controls visibility of the specified pool between devices.

hipMemPoolDestroy

hipError_t hipMemPoolDestroy(hipMemPool_t mem_pool)

Destroys the specified memory pool.

hipMemPoolSetAttribute

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

Sets attributes of a memory pool.

hipMemPoolGetAttribute

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

Gets attributes of a memory pool.

hipMemPoolExportToShareableHandle

hipError_t hipMemPoolExportToShareableHandle(void *shared_handle, hipMemPool_t mem_pool, hipMemAllocationHandleType handle_type, unsigned int flags)

Exports a memory pool to the requested handle type.

hipMemPoolExportPointer

hipError_t hipMemPoolExportPointer(hipMemPoolPtrExportData *export_data, void *dev_ptr)

Export data to share a memory pool allocation between processes.

hipMallocAsync

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

Allocates memory with stream ordered semantics.

hipMemPoolGetAccess

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

Returns the accessibility of a pool from a device.

hipDestroySurfaceObject

hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject)

Destroy a surface object.

hipCreateSurfaceObject

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

Create a surface object.

hipTexRefGetFilterMode

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

Gets filter mode for a texture reference [Deprecated].

hipBindTextureToMipmappedArray

hipError_t hipBindTextureToMipmappedArray(const textureReference *tex, hipMipmappedArray_const_t mipmappedArray, const hipChannelFormatDesc *desc)

Binds a mipmapped array to a texture [Deprecated].

hipTexRefGetMipmapLevelClamp

hipError_t hipTexRefGetMipmapLevelClamp(float *pminMipmapLevelClamp, float *pmaxMipmapLevelClamp, const textureReference *texRef)

Gets the minimum and maximum mipmap level clamps for a texture reference [Deprecated].

hipTexRefGetAddressMode

hipError_t hipTexRefGetAddressMode(enum hipTextureAddressMode *pam, const textureReference *texRef, int dim)

Gets the address mode for a texture reference [Deprecated].

hipTexRefGetFlags

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

Gets flags for a texture reference [Deprecated].

hipTexRefSetAddress

hipError_t hipTexRefSetAddress(size_t *ByteOffset, textureReference *texRef, hipDeviceptr_t dptr, size_t bytes)

Sets an bound address for a texture reference [Deprecated].

hipTexRefSetFilterMode

hipError_t hipTexRefSetFilterMode(textureReference *texRef, enum hipTextureFilterMode fm)

Set filter mode for a texture reference [Deprecated].

hipTexRefSetMipmappedArray

hipError_t hipTexRefSetMipmappedArray(textureReference *texRef, struct hipMipmappedArray *mipmappedArray, unsigned int Flags)

Binds mipmapped array to a texture reference [Deprecated].

hipTexRefGetMipmapFilterMode

hipError_t hipTexRefGetMipmapFilterMode(enum hipTextureFilterMode *pfm, const textureReference *texRef)

Gets the mipmap filter mode for a texture reference [Deprecated].

hipGetTextureAlignmentOffset

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

Get the offset of the alignment in a texture [Deprecated].

hipBindTexture2D

hipError_t hipBindTexture2D(size_t *offset, const textureReference *tex, const void *devPtr, const hipChannelFormatDesc *desc, size_t width, size_t height, size_t pitch)

Binds a 2D memory area to a texture [Deprecated].

hipTexRefGetMaxAnisotropy

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

Gets the maximum anisotropy for a texture reference [Deprecated].

hipBindTexture

hipError_t hipBindTexture(size_t *offset, const textureReference *tex, const void *devPtr, const hipChannelFormatDesc *desc, size_t size)

Binds a memory area to a texture [Deprecated].

hipUnbindTexture

hipError_t hipUnbindTexture(const textureReference *tex)

Unbinds a texture [Deprecated].

hipTexRefGetBorderColor

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

Gets the border color used by a texture reference [Deprecated].

hipTexRefSetFormat

hipError_t hipTexRefSetFormat(textureReference *texRef, hipArray_Format fmt, int NumPackedComponents)

Set format for a texture reference [Deprecated].

hipTexRefGetAddress

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

Gets the address for a texture reference [Deprecated].

hipTexRefGetArray

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

Gets the array bound to a texture reference [Deprecated].

hipTexRefSetFlags

hipError_t hipTexRefSetFlags(textureReference *texRef, unsigned int Flags)

Set flags for a texture reference [Deprecated].

hipTexRefSetAddressMode

hipError_t hipTexRefSetAddressMode(textureReference *texRef, int dim, enum hipTextureAddressMode am)

Sets address mode for a texture reference [Deprecated].

hipTexRefGetMipMappedArray

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

Gets the mipmapped array bound to a texture reference [Deprecated].

hipTexRefSetMaxAnisotropy

hipError_t hipTexRefSetMaxAnisotropy(textureReference *texRef, unsigned int maxAniso)

Sets the maximum anisotropy for a texture reference [Deprecated].

hipTexRefSetMipmapLevelClamp

hipError_t hipTexRefSetMipmapLevelClamp(textureReference *texRef, float minMipMapLevelClamp, float maxMipMapLevelClamp)

Sets mipmap level clamp for a texture reference [Deprecated].

hipTexRefSetBorderColor

hipError_t hipTexRefSetBorderColor(textureReference *texRef, float *pBorderColor)

Sets border color for a texture reference [Deprecated].

hipTexRefSetArray

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

Binds an array as a texture reference [Deprecated].

hipTexRefSetMipmapLevelBias

hipError_t hipTexRefSetMipmapLevelBias(textureReference *texRef, float bias)

Sets mipmap level bias for a texture reference [Deprecated].

hipTexRefGetMipmapLevelBias

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

Gets the mipmap level bias for a texture reference [Deprecated].

hipBindTextureToArray

hipError_t hipBindTextureToArray(const textureReference *tex, hipArray_const_t array, const hipChannelFormatDesc *desc)

Binds a memory area to a texture [Deprecated].

hipGetTextureReference

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

Gets the texture reference related with the symbol [Deprecated].

hipTexRefSetAddress2D

hipError_t hipTexRefSetAddress2D(textureReference *texRef, const HIP_ARRAY_DESCRIPTOR *desc, hipDeviceptr_t dptr, size_t Pitch)

Set a bind an address as a 2D texture reference [Deprecated].

hipTexRefSetMipmapFilterMode

hipError_t hipTexRefSetMipmapFilterMode(textureReference *texRef, enum hipTextureFilterMode fm)

Sets mipmap filter mode for a texture reference [Deprecated].

hipTexRefGetFormat

hipError_t hipTexRefGetFormat(hipArray_Format *pFormat, int *pNumChannels, const textureReference *texRef)

Gets texture format for a texture reference [Deprecated].

hipFreeMipmappedArray

hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray)

Frees a mipmapped array on the device.

hipGetMipmappedArrayLevel

hipError_t hipGetMipmappedArrayLevel(hipArray_t *levelArray, hipMipmappedArray_const_t mipmappedArray, unsigned int level)

Gets a mipmap level of a HIP mipmapped array.

hipMipmappedArrayGetLevel

hipError_t hipMipmappedArrayGetLevel(hipArray_t *pLevelArray, hipMipmappedArray_t hMipMappedArray, unsigned int level)

Get a mipmapped array on a mipmapped level.

hipMipmappedArrayDestroy

hipError_t hipMipmappedArrayDestroy(hipMipmappedArray_t hMipmappedArray)

Destroy a mipmapped array.

hipTexObjectCreate

hipError_t hipTexObjectCreate(hipTextureObject_t *pTexObject, const HIP_RESOURCE_DESC *pResDesc, const HIP_TEXTURE_DESC *pTexDesc, const HIP_RESOURCE_VIEW_DESC *pResViewDesc)

Creates a texture object.

hipGetTextureObjectResourceDesc

hipError_t hipGetTextureObjectResourceDesc(hipResourceDesc *pResDesc, hipTextureObject_t textureObject)

Gets resource descriptor for the texture object.

hipGetTextureObjectResourceViewDesc

hipError_t hipGetTextureObjectResourceViewDesc(struct hipResourceViewDesc *pResViewDesc, hipTextureObject_t textureObject)

Gets resource view descriptor for the texture object.

hipTexObjectGetTextureDesc

hipError_t hipTexObjectGetTextureDesc(HIP_TEXTURE_DESC *pTexDesc, hipTextureObject_t texObject)

Gets texture descriptor of a texture object.

hipCreateTextureObject

hipError_t hipCreateTextureObject(hipTextureObject_t *pTexObject, const hipResourceDesc *pResDesc, const hipTextureDesc *pTexDesc, const struct hipResourceViewDesc *pResViewDesc)

Creates a texture object.

hipTexObjectDestroy

hipError_t hipTexObjectDestroy(hipTextureObject_t texObject)

Destroys a texture object.

hipMipmappedArrayCreate

hipError_t hipMipmappedArrayCreate(hipMipmappedArray_t *pHandle, HIP_ARRAY3D_DESCRIPTOR *pMipmappedArrayDesc, unsigned int numMipmapLevels)

Create a mipmapped array.

hipGetChannelDesc

hipError_t hipGetChannelDesc(hipChannelFormatDesc *desc, hipArray_const_t array)

Gets the channel descriptor in an array.

hipTexObjectGetResourceDesc

hipError_t hipTexObjectGetResourceDesc(HIP_RESOURCE_DESC *pResDesc, hipTextureObject_t texObject)

Gets resource descriptor of a texture object.

hipTexObjectGetResourceViewDesc

hipError_t hipTexObjectGetResourceViewDesc(HIP_RESOURCE_VIEW_DESC *pResViewDesc, hipTextureObject_t texObject)

Gets resource view descriptor of a texture object.

hipMallocMipmappedArray

hipError_t hipMallocMipmappedArray(hipMipmappedArray_t *mipmappedArray, const struct hipChannelFormatDesc *desc, struct hipExtent extent, unsigned int numLevels, unsigned int flags)

Allocate a mipmapped array on the device.

hipDestroyTextureObject

hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject)

Destroys a texture object.

hipGetTextureObjectTextureDesc

hipError_t hipGetTextureObjectTextureDesc(hipTextureDesc *pTexDesc, hipTextureObject_t textureObject)

Gets texture descriptor for the texture object.

hipMemAddressFree

hipError_t hipMemAddressFree(void *devPtr, size_t size)

Frees an address range reservation made via hipMemAddressReserve.

hipMemExportToShareableHandle

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

Exports an allocation to a requested shareable handle type.

hipMemGetAccess

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

Get the access flags set for the given location and ptr.

hipMemSetAccess

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

Set the access flags for each location specified in desc for the given virtual address range.

hipMemRelease

hipError_t hipMemRelease(hipMemGenericAllocationHandle_t handle)

Release a memory handle representing a memory allocation which was previously allocated through hipMe...

hipMemUnmap

hipError_t hipMemUnmap(void *ptr, size_t size)

Unmap memory allocation of a given address range.

hipMemGetAllocationGranularity

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

Calculates either the minimal or recommended granularity.

hipMemRetainAllocationHandle

hipError_t hipMemRetainAllocationHandle(hipMemGenericAllocationHandle_t *handle, void *addr)

Returns the allocation handle of the backing memory allocation given the address.

hipMemCreate

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

Creates a memory allocation described by the properties and size.

hipMemMap

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

Maps an allocation handle to a reserved virtual address range.

hipMemAddressReserve

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

Reserves an address range.

hipMemGetAllocationPropertiesFromHandle

hipError_t hipMemGetAllocationPropertiesFromHandle(hipMemAllocationProp *prop, hipMemGenericAllocationHandle_t handle)

Retrieve the property structure of the given handle.

hipMemMapArrayAsync

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

Maps or unmaps subregions of sparse HIP arrays and sparse HIP mipmapped arrays.

hipMemImportFromShareableHandle

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

Imports an allocation from a requested shareable handle type.

hip_common.h

hipErrorIllegalAddress

hipErrorIllegalAddress

Definition hip_runtime_api.h:350

hipErrorMemoryAllocation

hipErrorMemoryAllocation

Memory allocation error.

Definition hip_runtime_api.h:296

hipErrorNotFound

hipErrorNotFound

Not found.

Definition hip_runtime_api.h:345

hipErrorProfilerDisabled

hipErrorProfilerDisabled

Definition hip_runtime_api.h:301

hipErrorInvalidDevicePointer

hipErrorInvalidDevicePointer

Invalid Device Pointer.

Definition hip_runtime_api.h:308

hipErrorRuntimeMemory

hipErrorRuntimeMemory

Definition hip_runtime_api.h:397

hipErrorInvalidImage

hipErrorInvalidImage

Invalid image.

Definition hip_runtime_api.h:316

hipErrorPeerAccessUnsupported

hipErrorPeerAccessUnsupported

Definition hip_runtime_api.h:333

hipErrorArrayIsMapped

hipErrorArrayIsMapped

Definition hip_runtime_api.h:323

hipErrorStreamCaptureIsolation

hipErrorStreamCaptureIsolation

Definition hip_runtime_api.h:378

hipErrorInvalidKernelFile

hipErrorInvalidKernelFile

In CUDA DRV, it is CUDA_ERROR_INVALID_PTX.

Definition hip_runtime_api.h:334

hipErrorNotMapped

hipErrorNotMapped

Definition hip_runtime_api.h:327

hipErrorGraphExecUpdateFailure

hipErrorGraphExecUpdateFailure

Definition hip_runtime_api.h:391

hipErrorNotInitialized

hipErrorNotInitialized

Invalid not initialized.

Definition hip_runtime_api.h:297

hipErrorInvalidResourceHandle

hipErrorInvalidResourceHandle

Resource handle (hipEvent_t or hipStream_t) invalid.

Definition hip_runtime_api.h:343

hipErrorSharedObjectInitFailed

hipErrorSharedObjectInitFailed

Failed to initialize shared object.

Definition hip_runtime_api.h:339

hipErrorInvalidPitchValue

hipErrorInvalidPitchValue

Invalid pitch value.

Definition hip_runtime_api.h:306

hipErrorNoBinaryForGpu

hipErrorNoBinaryForGpu

Definition hip_runtime_api.h:325

hipErrorInvalidContext

hipErrorInvalidContext

Produced when input context is invalid.

Definition hip_runtime_api.h:317

hipErrorStreamCaptureUnsupported

hipErrorStreamCaptureUnsupported

Definition hip_runtime_api.h:369

hipErrorPeerAccessNotEnabled

hipErrorPeerAccessNotEnabled

Peer access was never enabled from the current device.

Definition hip_runtime_api.h:355

hipErrorOperatingSystem

hipErrorOperatingSystem

Not the correct operating system.

Definition hip_runtime_api.h:340

hipErrorStreamCaptureUnjoined

hipErrorStreamCaptureUnjoined

Definition hip_runtime_api.h:376

hipErrorInitializationError

hipErrorInitializationError

Definition hip_runtime_api.h:299

hipErrorNotMappedAsPointer

hipErrorNotMappedAsPointer

Definition hip_runtime_api.h:329

hipErrorPriorLaunchFailure

hipErrorPriorLaunchFailure

Definition hip_runtime_api.h:312

hipErrorContextIsDestroyed

hipErrorContextIsDestroyed

The context is already destroyed.

Definition hip_runtime_api.h:357

hipErrorInvalidValue

hipErrorInvalidValue

Definition hip_runtime_api.h:292

hipErrorLaunchTimeOut

hipErrorLaunchTimeOut

Timeout for the launch.

Definition hip_runtime_api.h:352

hipErrorUnmapFailed

hipErrorUnmapFailed

Definition hip_runtime_api.h:322

hipErrorSetOnActiveProcess

hipErrorSetOnActiveProcess

The process is active.

Definition hip_runtime_api.h:356

hipErrorFileNotFound

hipErrorFileNotFound

the file is not found.

Definition hip_runtime_api.h:337

hipErrorLaunchFailure

hipErrorLaunchFailure

An exception occurred on the device while executing a kernel.

Definition hip_runtime_api.h:363

hipErrorInvalidDevice

hipErrorInvalidDevice

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

Definition hip_runtime_api.h:315

hipErrorUnsupportedLimit

hipErrorUnsupportedLimit

Unsupported limit.

Definition hip_runtime_api.h:331

hipErrorMapBufferObjectFailed

hipErrorMapBufferObjectFailed

Produced when the IPC memory attach failed from ROCr.

Definition hip_runtime_api.h:321

hipErrorHostMemoryAlreadyRegistered

hipErrorHostMemoryAlreadyRegistered

Definition hip_runtime_api.h:359

hipErrorMissingConfiguration

hipErrorMissingConfiguration

Definition hip_runtime_api.h:311

hipErrorSharedObjectSymbolNotFound

hipErrorSharedObjectSymbolNotFound

Definition hip_runtime_api.h:338

hipErrorECCNotCorrectable

hipErrorECCNotCorrectable

Definition hip_runtime_api.h:330

hipErrorStreamCaptureWrongThread

hipErrorStreamCaptureWrongThread

Definition hip_runtime_api.h:387

hipErrorAssert

hipErrorAssert

Produced when the kernel calls assert.

Definition hip_runtime_api.h:358

hipErrorContextAlreadyInUse

hipErrorContextAlreadyInUse

The context is already in use.

Definition hip_runtime_api.h:332

hipErrorNotReady

hipErrorNotReady

Definition hip_runtime_api.h:346

hipErrorInvalidSource

hipErrorInvalidSource

Invalid source.

Definition hip_runtime_api.h:336

hipErrorLaunchOutOfResources

hipErrorLaunchOutOfResources

Out of resources error.

Definition hip_runtime_api.h:351

hipErrorInvalidDeviceFunction

hipErrorInvalidDeviceFunction

Invalid device function.

Definition hip_runtime_api.h:313

hipErrorCooperativeLaunchTooLarge

hipErrorCooperativeLaunchTooLarge

Definition hip_runtime_api.h:364

hipErrorAlreadyMapped

hipErrorAlreadyMapped

Definition hip_runtime_api.h:324

hipErrorProfilerNotInitialized

hipErrorProfilerNotInitialized

Definition hip_runtime_api.h:302

hipErrorProfilerAlreadyStarted

hipErrorProfilerAlreadyStarted

Definition hip_runtime_api.h:303

hipErrorNoDevice

hipErrorNoDevice

Call to hipGetDeviceCount returned 0 devices.

Definition hip_runtime_api.h:314

HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

@ HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

Definition hip_runtime_api.h:41

HIP_ERROR_INVALID_VALUE

@ HIP_ERROR_INVALID_VALUE

Definition hip_runtime_api.h:39

HIP_SUCCESS

@ HIP_SUCCESS

Definition hip_runtime_api.h:38

HIP_ERROR_NOT_INITIALIZED

@ HIP_ERROR_NOT_INITIALIZED

Definition hip_runtime_api.h:40

hipErrorMapFailed

hipErrorMapFailed

Definition hip_runtime_api.h:319

hipErrorStreamCaptureInvalidated

hipErrorStreamCaptureInvalidated

Definition hip_runtime_api.h:371

hipErrorProfilerAlreadyStopped

hipErrorProfilerAlreadyStopped

Definition hip_runtime_api.h:304

hipErrorDeinitialized

hipErrorDeinitialized

Deinitialized.

Definition hip_runtime_api.h:300

hipErrorPeerAccessAlreadyEnabled

hipErrorPeerAccessAlreadyEnabled

Definition hip_runtime_api.h:353

hipErrorNotMappedAsArray

hipErrorNotMappedAsArray

Definition hip_runtime_api.h:328

hipErrorNotSupported

hipErrorNotSupported

Produced when the hip API is not supported/implemented.

Definition hip_runtime_api.h:368

hipErrorInvalidConfiguration

hipErrorInvalidConfiguration

Invalide configuration.

Definition hip_runtime_api.h:305

hipErrorStreamCaptureImplicit

hipErrorStreamCaptureImplicit

Definition hip_runtime_api.h:382

hipErrorStreamCaptureMerge

hipErrorStreamCaptureMerge

Definition hip_runtime_api.h:373

hipErrorInvalidGraphicsContext

hipErrorInvalidGraphicsContext

Definition hip_runtime_api.h:335

hipErrorIllegalState

hipErrorIllegalState

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

Definition hip_runtime_api.h:344

hipErrorOutOfMemory

hipErrorOutOfMemory

out of memory range.

Definition hip_runtime_api.h:294

hipErrorInvalidSymbol

hipErrorInvalidSymbol

Invalid symbol.

Definition hip_runtime_api.h:307

hipSuccess

hipSuccess

Successful completion.

Definition hip_runtime_api.h:291

hipErrorUnknown

hipErrorUnknown

Unknown error.

Definition hip_runtime_api.h:395

hipErrorInvalidHandle

hipErrorInvalidHandle

Invalide handle.

Definition hip_runtime_api.h:341

hipErrorStreamCaptureUnmatched

hipErrorStreamCaptureUnmatched

The capture was not initiated in this stream.

Definition hip_runtime_api.h:375

hipErrorCapturedEvent

hipErrorCapturedEvent

Definition hip_runtime_api.h:385

hipErrorAlreadyAcquired

hipErrorAlreadyAcquired

Definition hip_runtime_api.h:326

hipErrorInsufficientDriver

hipErrorInsufficientDriver

Definition hip_runtime_api.h:310

hipErrorHostMemoryNotRegistered

hipErrorHostMemoryNotRegistered

Definition hip_runtime_api.h:361

hipErrorRuntimeOther

hipErrorRuntimeOther

Definition hip_runtime_api.h:399

hipErrorContextAlreadyCurrent

hipErrorContextAlreadyCurrent

Definition hip_runtime_api.h:318

hipErrorInvalidMemcpyDirection

hipErrorInvalidMemcpyDirection

Invalid memory copy direction.

Definition hip_runtime_api.h:309

hip_impl

Definition hip_runtime_api.h:599

hip_impl::hip_init

hipError_t hip_init()

HIP_ARRAY3D_DESCRIPTOR

Definition driver_types.h:104

HIP_ARRAY_DESCRIPTOR

Definition driver_types.h:94

HIP_MEMCPY3D

Definition driver_types.h:427

HIP_MEMSET_NODE_PARAMS

Definition hip_runtime_api.h:1345

HIP_MEMSET_NODE_PARAMS::height

size_t height

Number of rows.

Definition hip_runtime_api.h:1351

HIP_MEMSET_NODE_PARAMS::pitch

size_t pitch

Destination device pointer pitch. Unused if height equals 1.

Definition hip_runtime_api.h:1347

HIP_MEMSET_NODE_PARAMS::dst

hipDeviceptr_t dst

Destination pointer on device.

Definition hip_runtime_api.h:1346

HIP_MEMSET_NODE_PARAMS::value

unsigned int value

Value of memset to be set.

Definition hip_runtime_api.h:1348

HIP_MEMSET_NODE_PARAMS::elementSize

unsigned int elementSize

Element in bytes. Must be 1, 2, or 4.

Definition hip_runtime_api.h:1349

HIP_MEMSET_NODE_PARAMS::width

size_t width

Width of a row.

Definition hip_runtime_api.h:1350

HIP_RESOURCE_DESC

Definition driver_types.h:315

HIP_RESOURCE_VIEW_DESC

Definition driver_types.h:361

HIP_TEXTURE_DESC

Definition driver_types.h:191

dim3

Definition hip_runtime_api.h:1061

dim3::y

uint32_t y

y

Definition hip_runtime_api.h:1063

dim3::z

uint32_t z

z

Definition hip_runtime_api.h:1064

dim3::x

uint32_t x

x

Definition hip_runtime_api.h:1062

dim3::dim3

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

Definition hip_runtime_api.h:1066

hip_Memcpy2D

Definition driver_types.h:116

hipAccessPolicyWindow

Definition hip_runtime_api.h:1301

hipAccessPolicyWindow::hitProp

hipAccessProperty hitProp

Definition hip_runtime_api.h:1303

hipAccessPolicyWindow::missProp

hipAccessProperty missProp

Definition hip_runtime_api.h:1305

hipAccessPolicyWindow::hitRatio

float hitRatio

Definition hip_runtime_api.h:1304

hipAccessPolicyWindow::base_ptr

void * base_ptr

Definition hip_runtime_api.h:1302

hipAccessPolicyWindow::num_bytes

size_t num_bytes

Definition hip_runtime_api.h:1306

hipArrayMapInfo

Definition hip_runtime_api.h:1538

hipArrayMapInfo::level

unsigned int level

For mipmapped arrays must be a valid mipmap level. For arrays must be zero.

Definition hip_runtime_api.h:1547

hipArrayMapInfo::sparseLevel

struct hipArrayMapInfo::@26::@28 sparseLevel

hipArrayMapInfo::flags

unsigned int flags

flags for future use, must be zero now.

Definition hip_runtime_api.h:1569

hipArrayMapInfo::resource

union hipArrayMapInfo::@25 resource

hipArrayMapInfo::subresourceType

hipArraySparseSubresourceType subresourceType

Sparse subresource type.

Definition hip_runtime_api.h:1544

hipArrayMapInfo::extentDepth

unsigned int extentDepth

Depth in elements.

Definition hip_runtime_api.h:1554

hipArrayMapInfo::offsetX

unsigned int offsetX

X offset in elements.

Definition hip_runtime_api.h:1549

hipArrayMapInfo::array

hipArray_t array

Definition hip_runtime_api.h:1542

hipArrayMapInfo::resourceType

hipResourceType resourceType

Resource type.

Definition hip_runtime_api.h:1539

hipArrayMapInfo::memOperationType

hipMemOperationType memOperationType

Memory operation type.

Definition hip_runtime_api.h:1562

hipArrayMapInfo::reserved

unsigned int reserved[2]

Reserved for future use, must be zero now.

Definition hip_runtime_api.h:1570

hipArrayMapInfo::extentWidth

unsigned int extentWidth

Width in elements.

Definition hip_runtime_api.h:1552

hipArrayMapInfo::subresource

union hipArrayMapInfo::@26 subresource

hipArrayMapInfo::extentHeight

unsigned int extentHeight

Height in elements.

Definition hip_runtime_api.h:1553

hipArrayMapInfo::offsetY

unsigned int offsetY

Y offset in elements.

Definition hip_runtime_api.h:1550

hipArrayMapInfo::memHandleType

hipMemHandleType memHandleType

Memory handle type.

Definition hip_runtime_api.h:1563

hipArrayMapInfo::miptail

struct hipArrayMapInfo::@26::@29 miptail

hipArrayMapInfo::memHandle

hipMemGenericAllocationHandle_t memHandle

Definition hip_runtime_api.h:1565

hipArrayMapInfo::mipmap

hipMipmappedArray mipmap

Definition hip_runtime_api.h:1541

hipArrayMapInfo::layer

unsigned int layer

For layered arrays must be a valid layer index. Otherwise, must be zero.

Definition hip_runtime_api.h:1548

hipArrayMapInfo::deviceBitMask

unsigned int deviceBitMask

Device ordinal bit mask.

Definition hip_runtime_api.h:1568

hipArrayMapInfo::size

unsigned long long size

Extent in bytes.

Definition hip_runtime_api.h:1559

hipArrayMapInfo::offset

unsigned long long offset

Offset within mip tail.

Definition hip_runtime_api.h:1558

hipArrayMapInfo::offsetZ

unsigned int offsetZ

Z offset in elements.

Definition hip_runtime_api.h:1551

hipChannelFormatDesc

Definition driver_types.h:60

hipChildGraphNodeParams

Definition hip_runtime_api.h:1585

hipChildGraphNodeParams::graph

hipGraph_t graph

Definition hip_runtime_api.h:1586

hipDeviceArch_t

Definition hip_runtime_api.h:53

hipDeviceArch_t::hasSharedInt64Atomics

unsigned hasSharedInt64Atomics

64-bit integer atomics for shared memory.

Definition hip_runtime_api.h:63

hipDeviceArch_t::hasSharedInt32Atomics

unsigned hasSharedInt32Atomics

32-bit integer atomics for shared memory.

Definition hip_runtime_api.h:57

hipDeviceArch_t::hasFloatAtomicAdd

unsigned hasFloatAtomicAdd

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

Definition hip_runtime_api.h:59

hipDeviceArch_t::hasDoubles

unsigned hasDoubles

Double-precision floating point.

Definition hip_runtime_api.h:66

hipDeviceArch_t::hasWarpVote

unsigned hasWarpVote

Warp vote instructions (__any, __all).

Definition hip_runtime_api.h:69

hipDeviceArch_t::hasWarpShuffle

unsigned hasWarpShuffle

Warp shuffle operations. (__shfl_*).

Definition hip_runtime_api.h:71

hipDeviceArch_t::hasGlobalInt32Atomics

unsigned hasGlobalInt32Atomics

32-bit integer atomics for global memory.

Definition hip_runtime_api.h:55

hipDeviceArch_t::hasGlobalFloatAtomicExch

unsigned hasGlobalFloatAtomicExch

32-bit float atomic exch for global memory.

Definition hip_runtime_api.h:56

hipDeviceArch_t::hasDynamicParallelism

unsigned hasDynamicParallelism

Dynamic parallelism.

Definition hip_runtime_api.h:81

hipDeviceArch_t::hasSurfaceFuncs

unsigned hasSurfaceFuncs

Surface functions.

Definition hip_runtime_api.h:79

hipDeviceArch_t::has3dGrid

unsigned has3dGrid

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

Definition hip_runtime_api.h:80

hipDeviceArch_t::hasFunnelShift

unsigned hasFunnelShift

Funnel two words into one with shift&mask caps.

Definition hip_runtime_api.h:72

hipDeviceArch_t::hasThreadFenceSystem

unsigned hasThreadFenceSystem

__threadfence_system.

Definition hip_runtime_api.h:75

hipDeviceArch_t::hasGlobalInt64Atomics

unsigned hasGlobalInt64Atomics

64-bit integer atomics for global memory.

Definition hip_runtime_api.h:62

hipDeviceArch_t::hasSyncThreadsExt

unsigned hasSyncThreadsExt

__syncthreads_count, syncthreads_and, syncthreads_or.

Definition hip_runtime_api.h:76

hipDeviceArch_t::hasWarpBallot

unsigned hasWarpBallot

Warp ballot instructions (__ballot).

Definition hip_runtime_api.h:70

hipDeviceArch_t::hasSharedFloatAtomicExch

unsigned hasSharedFloatAtomicExch

32-bit float atomic exch for shared memory.

Definition hip_runtime_api.h:58

hipDeviceProp_t

Definition hip_runtime_api.h:99

hipDeviceProp_t::ECCEnabled

int ECCEnabled

Device has ECC support enabled.

Definition hip_runtime_api.h:156

hipDeviceProp_t::ipcEventSupported

int ipcEventSupported

Device supports IPC events.

Definition hip_runtime_api.h:211

hipDeviceProp_t::computePreemptionSupported

int computePreemptionSupported

Is compute preemption supported on the device.

Definition hip_runtime_api.h:182

hipDeviceProp_t::maxTexture1DLinear

int maxTexture1DLinear

Maximum size for 1D textures bound to linear memory.

Definition hip_runtime_api.h:135

hipDeviceProp_t::timelineSemaphoreInteropSupported

int timelineSemaphoreInteropSupported

Indicates external timeline semaphore support.

Definition hip_runtime_api.h:201

hipDeviceProp_t::pciBusID

int pciBusID

PCI Bus ID.

Definition hip_runtime_api.h:157

hipDeviceProp_t::maxTexture1D

int maxTexture1D

Maximum number of elements in 1D images.

Definition hip_runtime_api.h:133

hipDeviceProp_t::memoryBusWidth

int memoryBusWidth

Global memory bus width in bits.

Definition hip_runtime_api.h:164

hipDeviceProp_t::maxTexture2DMipmap

int maxTexture2DMipmap[2]

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

Definition hip_runtime_api.h:137

hipDeviceProp_t::clockRate

int clockRate

Max clock frequency of the multiProcessors in khz.

Definition hip_runtime_api.h:113

hipDeviceProp_t::maxThreadsPerMultiProcessor

int maxThreadsPerMultiProcessor

Maximum resident threads per multi-processor.

Definition hip_runtime_api.h:167

hipDeviceProp_t::l2CacheSize

int l2CacheSize

L2 cache size.

Definition hip_runtime_api.h:165

hipDeviceProp_t::deferredMappingHipArraySupported

int deferredMappingHipArraySupported

Definition hip_runtime_api.h:209

hipDeviceProp_t::asyncEngineCount

int asyncEngineCount

Number of async engines.

Definition hip_runtime_api.h:161

hipDeviceProp_t::accessPolicyMaxWindowSize

int accessPolicyMaxWindowSize

Max value of access policy window.

Definition hip_runtime_api.h:195

hipDeviceProp_t::totalConstMem

size_t totalConstMem

Definition hip_runtime_api.h:114

hipDeviceProp_t::memoryPoolsSupported

int memoryPoolsSupported

Indicates if device supports hipMallocAsync and hipMemPool APIs.

Definition hip_runtime_api.h:202

hipDeviceProp_t::unifiedFunctionPointers

int unifiedFunctionPointers

Indicates device supports unified function pointers.

Definition hip_runtime_api.h:213

hipDeviceProp_t::maxTexture2DGather

int maxTexture2DGather[2]

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

Definition hip_runtime_api.h:139

hipDeviceProp_t::memPitch

size_t memPitch

Definition hip_runtime_api.h:108

hipDeviceProp_t::gpuDirectRDMAWritesOrdering

int gpuDirectRDMAWritesOrdering

value of hipGPUDirectRDMAWritesOrdering

Definition hip_runtime_api.h:206

hipDeviceProp_t::uuid

hipUUID uuid

UUID of a device.

Definition hip_runtime_api.h:101

hipDeviceProp_t::sharedMemPerBlock

size_t sharedMemPerBlock

Size of shared memory per block (in bytes).

Definition hip_runtime_api.h:105

hipDeviceProp_t::gpuDirectRDMAFlushWritesOptions

unsigned int gpuDirectRDMAFlushWritesOptions

Definition hip_runtime_api.h:204

hipDeviceProp_t::surfaceAlignment

size_t surfaceAlignment

Alignment requirement for surface.

Definition hip_runtime_api.h:154

hipDeviceProp_t::reserved

int reserved[63]

CUDA Reserved.

Definition hip_runtime_api.h:214

hipDeviceProp_t::maxTexture2DLayered

int maxTexture2DLayered[3]

Maximum number of elements in 2D array images.

Definition hip_runtime_api.h:145

hipDeviceProp_t::streamPrioritiesSupported

int streamPrioritiesSupported

Device supports stream priority.

Definition hip_runtime_api.h:168

hipDeviceProp_t::cooperativeMultiDeviceLaunch

int cooperativeMultiDeviceLaunch

Definition hip_runtime_api.h:186

hipDeviceProp_t::hostRegisterSupported

int hostRegisterSupported

Device supports hipHostRegister.

Definition hip_runtime_api.h:197

hipDeviceProp_t::pageableMemoryAccess

int pageableMemoryAccess

Definition hip_runtime_api.h:178

hipDeviceProp_t::name

char name[256]

Device name.

Definition hip_runtime_api.h:100

hipDeviceProp_t::textureAlignment

size_t textureAlignment

Alignment requirement for textures.

Definition hip_runtime_api.h:125

hipDeviceProp_t::globalL1CacheSupported

int globalL1CacheSupported

Indicates globals are cached in L1.

Definition hip_runtime_api.h:169

hipDeviceProp_t::hostNativeAtomicSupported

int hostNativeAtomicSupported

Link between host and device supports native atomics.

Definition hip_runtime_api.h:176

hipDeviceProp_t::maxSurfaceCubemapLayered

int maxSurfaceCubemapLayered[2]

Maximum cubemap layered surface size.

Definition hip_runtime_api.h:153

hipDeviceProp_t::maxTextureCubemapLayered

int maxTextureCubemapLayered[2]

Maximum cubemaps layered texture dims.

Definition hip_runtime_api.h:146

hipDeviceProp_t::sharedMemPerBlockOptin

size_t sharedMemPerBlockOptin

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

Definition hip_runtime_api.h:189

hipDeviceProp_t::sharedMemPerMultiprocessor

size_t sharedMemPerMultiprocessor

Amount of shared memory available per multiprocessor.

Definition hip_runtime_api.h:171

hipDeviceProp_t::singleToDoublePrecisionPerfRatio

int singleToDoublePrecisionPerfRatio

Deprecated. CUDA only.

Definition hip_runtime_api.h:177

hipDeviceProp_t::maxSurface2D

int maxSurface2D[2]

Maximum 2D surface size.

Definition hip_runtime_api.h:148

hipDeviceProp_t::memoryClockRate

int memoryClockRate

Max global memory clock frequency in khz.

Definition hip_runtime_api.h:163

hipDeviceProp_t::maxTexture2DLinear

int maxTexture2DLinear[3]

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

Definition hip_runtime_api.h:138

hipDeviceProp_t::sparseHipArraySupported

int sparseHipArraySupported

Indicates if device supports sparse hip arrays.

Definition hip_runtime_api.h:198

hipDeviceProp_t::clockInstructionRate

int clockInstructionRate

Definition hip_runtime_api.h:221

hipDeviceProp_t::localL1CacheSupported

int localL1CacheSupported

Locals are cahced in L1.

Definition hip_runtime_api.h:170

hipDeviceProp_t::regsPerMultiprocessor

int regsPerMultiprocessor

registers available per multiprocessor

Definition hip_runtime_api.h:172

hipDeviceProp_t::regsPerBlock

int regsPerBlock

Registers per block.

Definition hip_runtime_api.h:106

hipDeviceProp_t::maxTexture2D

int maxTexture2D[2]

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

Definition hip_runtime_api.h:136

hipDeviceProp_t::cooperativeLaunch

int cooperativeLaunch

HIP device supports cooperative launch.

Definition hip_runtime_api.h:185

hipDeviceProp_t::maxTexture3D

int maxTexture3D[3]

Definition hip_runtime_api.h:140

hipDeviceProp_t::directManagedMemAccessFromHost

int directManagedMemAccessFromHost

Definition hip_runtime_api.h:192

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedFunc

int cooperativeMultiDeviceUnmatchedFunc

Definition hip_runtime_api.h:226

hipDeviceProp_t::deviceOverlap

int deviceOverlap

Deprecated. Use asyncEngineCount instead.

Definition hip_runtime_api.h:127

hipDeviceProp_t::pageableMemoryAccessUsesHostPageTables

int pageableMemoryAccessUsesHostPageTables

Definition hip_runtime_api.h:190

hipDeviceProp_t::hdpRegFlushCntl

unsigned int * hdpRegFlushCntl

Addres of HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:225

hipDeviceProp_t::maxThreadsDim

int maxThreadsDim[3]

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

Definition hip_runtime_api.h:111

hipDeviceProp_t::unifiedAddressing

int unifiedAddressing

Does device and host share unified address space.

Definition hip_runtime_api.h:162

hipDeviceProp_t::multiGpuBoardGroupID

int multiGpuBoardGroupID

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

Definition hip_runtime_api.h:175

hipDeviceProp_t::isMultiGpuBoard

int isMultiGpuBoard

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

Definition hip_runtime_api.h:174

hipDeviceProp_t::canUseHostPointerForRegisteredMem

int canUseHostPointerForRegisteredMem

Definition hip_runtime_api.h:183

hipDeviceProp_t::maxTexture1DLayered

int maxTexture1DLayered[2]

Maximum number of elements in 1D array images.

Definition hip_runtime_api.h:144

hipDeviceProp_t::pciDomainID

int pciDomainID

PCI Domain ID.

Definition hip_runtime_api.h:159

hipDeviceProp_t::maxSharedMemoryPerMultiProcessor

size_t maxSharedMemoryPerMultiProcessor

Maximum Shared Memory Per CU. HIP Only.

Definition hip_runtime_api.h:220

hipDeviceProp_t::maxTextureCubemap

int maxTextureCubemap

Maximum cubemap texture dims.

Definition hip_runtime_api.h:143

hipDeviceProp_t::hipReserved

int hipReserved[32]

Reserved for adding new entries for HIP/CUDA.

Definition hip_runtime_api.h:216

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedGridDim

int cooperativeMultiDeviceUnmatchedGridDim

Definition hip_runtime_api.h:229

hipDeviceProp_t::gpuDirectRDMASupported

int gpuDirectRDMASupported

Indicates device support of RDMA APIs.

Definition hip_runtime_api.h:203

hipDeviceProp_t::minor

int minor

Definition hip_runtime_api.h:120

hipDeviceProp_t::gcnArchName

char gcnArchName[256]

AMD GCN Arch Name. HIP Only.

Definition hip_runtime_api.h:219

hipDeviceProp_t::luid

char luid[8]

8-byte unique identifier. Only valid on windows

Definition hip_runtime_api.h:102

hipDeviceProp_t::kernelExecTimeoutEnabled

int kernelExecTimeoutEnabled

Run time limit for kernels executed on the device.

Definition hip_runtime_api.h:129

hipDeviceProp_t::memoryPoolSupportedHandleTypes

unsigned int memoryPoolSupportedHandleTypes

Bitmask of handle types support with mempool based IPC.

Definition hip_runtime_api.h:208

hipDeviceProp_t::hdpMemFlushCntl

unsigned int * hdpMemFlushCntl

Addres of HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:224

hipDeviceProp_t::concurrentManagedAccess

int concurrentManagedAccess

Definition hip_runtime_api.h:180

hipDeviceProp_t::integrated

int integrated

APU vs dGPU.

Definition hip_runtime_api.h:130

hipDeviceProp_t::canMapHostMemory

int canMapHostMemory

Check whether HIP can map host memory.

Definition hip_runtime_api.h:131

hipDeviceProp_t::reservedSharedMemPerBlock

size_t reservedSharedMemPerBlock

Shared memory reserved by driver per block.

Definition hip_runtime_api.h:196

hipDeviceProp_t::maxSurfaceCubemap

int maxSurfaceCubemap

Maximum cubemap surface size.

Definition hip_runtime_api.h:152

hipDeviceProp_t::maxSurface3D

int maxSurface3D[3]

Maximum 3D surface size.

Definition hip_runtime_api.h:149

hipDeviceProp_t::asicRevision

int asicRevision

Revision of the GPU in this device.

Definition hip_runtime_api.h:239

hipDeviceProp_t::totalGlobalMem

size_t totalGlobalMem

Size of global memory region (in bytes).

Definition hip_runtime_api.h:104

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedBlockDim

int cooperativeMultiDeviceUnmatchedBlockDim

Definition hip_runtime_api.h:232

hipDeviceProp_t::maxSurface1DLayered

int maxSurface1DLayered[2]

Maximum 1D layered surface size.

Definition hip_runtime_api.h:150

hipDeviceProp_t::persistingL2CacheMaxSize

int persistingL2CacheMaxSize

Device's max L2 persisting lines in bytes.

Definition hip_runtime_api.h:166

hipDeviceProp_t::maxSurface1D

int maxSurface1D

Maximum 1D surface size.

Definition hip_runtime_api.h:147

hipDeviceProp_t::concurrentKernels

int concurrentKernels

Device can possibly execute multiple kernels concurrently.

Definition hip_runtime_api.h:155

hipDeviceProp_t::isLargeBar

int isLargeBar

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

Definition hip_runtime_api.h:238

hipDeviceProp_t::clusterLaunch

int clusterLaunch

Device supports cluster launch.

Definition hip_runtime_api.h:212

hipDeviceProp_t::maxTexture1DMipmap

int maxTexture1DMipmap

Maximum 1D mipmap texture size.

Definition hip_runtime_api.h:134

hipDeviceProp_t::multiProcessorCount

int multiProcessorCount

Number of multi-processors (compute units).

Definition hip_runtime_api.h:128

hipDeviceProp_t::maxTexture3DAlt

int maxTexture3DAlt[3]

Maximum alternate 3D texture dims.

Definition hip_runtime_api.h:142

hipDeviceProp_t::maxGridSize

int maxGridSize[3]

Max grid dimensions (XYZ).

Definition hip_runtime_api.h:112

hipDeviceProp_t::pciDeviceID

int pciDeviceID

PCI Device ID.

Definition hip_runtime_api.h:158

hipDeviceProp_t::maxBlocksPerMultiProcessor

int maxBlocksPerMultiProcessor

Max number of blocks on CU.

Definition hip_runtime_api.h:194

hipDeviceProp_t::computeMode

int computeMode

Compute mode.

Definition hip_runtime_api.h:132

hipDeviceProp_t::maxSurface2DLayered

int maxSurface2DLayered[3]

Maximum 2D layared surface size.

Definition hip_runtime_api.h:151

hipDeviceProp_t::major

int major

Definition hip_runtime_api.h:116

hipDeviceProp_t::warpSize

int warpSize

Warp size.

Definition hip_runtime_api.h:107

hipDeviceProp_t::tccDriver

int tccDriver

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

Definition hip_runtime_api.h:160

hipDeviceProp_t::luidDeviceNodeMask

unsigned int luidDeviceNodeMask

LUID node mask.

Definition hip_runtime_api.h:103

hipDeviceProp_t::hostRegisterReadOnlySupported

int hostRegisterReadOnlySupported

Definition hip_runtime_api.h:199

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedSharedMem

int cooperativeMultiDeviceUnmatchedSharedMem

Definition hip_runtime_api.h:235

hipDeviceProp_t::maxThreadsPerBlock

int maxThreadsPerBlock

Max work items per work group or workgroup max size.

Definition hip_runtime_api.h:110

hipDeviceProp_t::arch

hipDeviceArch_t arch

Architectural feature flags. New for HIP.

Definition hip_runtime_api.h:223

hipDeviceProp_t::managedMemory

int managedMemory

Device supports allocating managed memory on this system.

Definition hip_runtime_api.h:173

hipDeviceProp_t::texturePitchAlignment

size_t texturePitchAlignment

Pitch alignment requirement for texture references bound to.

Definition hip_runtime_api.h:126

hipEventRecordNodeParams

Definition hip_runtime_api.h:1600

hipEventRecordNodeParams::event

hipEvent_t event

The event to be recorded when node executes.

Definition hip_runtime_api.h:1601

hipEventWaitNodeParams

Definition hip_runtime_api.h:1593

hipEventWaitNodeParams::event

hipEvent_t event

Event to wait on.

Definition hip_runtime_api.h:1594

hipExtent

Definition driver_types.h:397

hipExternalMemoryBufferDesc

Definition hip_runtime_api.h:1119

hipExternalMemoryBufferDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1122

hipExternalMemoryBufferDesc::offset

unsigned long long offset

Definition hip_runtime_api.h:1120

hipExternalMemoryBufferDesc::size

unsigned long long size

Definition hip_runtime_api.h:1121

hipExternalMemoryHandleDesc

Definition hip_runtime_api.h:1105

hipExternalMemoryHandleDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1116

hipExternalMemoryHandleDesc::name

const void * name

Definition hip_runtime_api.h:1111

hipExternalMemoryHandleDesc::fd

int fd

Definition hip_runtime_api.h:1108

hipExternalMemoryHandleDesc::size

unsigned long long size

Definition hip_runtime_api.h:1115

hipExternalMemoryHandleDesc::type

hipExternalMemoryHandleType type

Definition hip_runtime_api.h:1106

hipExternalMemoryHandleDesc::nvSciBufObject

const void * nvSciBufObject

Definition hip_runtime_api.h:1113

hipExternalMemoryHandleDesc::handle

void * handle

Definition hip_runtime_api.h:1110

hipExternalMemoryMipmappedArrayDesc

Definition hip_runtime_api.h:1125

hipExternalMemoryMipmappedArrayDesc::extent

hipExtent extent

Definition hip_runtime_api.h:1128

hipExternalMemoryMipmappedArrayDesc::numLevels

unsigned int numLevels

Definition hip_runtime_api.h:1130

hipExternalMemoryMipmappedArrayDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1129

hipExternalMemoryMipmappedArrayDesc::offset

unsigned long long offset

Definition hip_runtime_api.h:1126

hipExternalMemoryMipmappedArrayDesc::formatDesc

hipChannelFormatDesc formatDesc

Definition hip_runtime_api.h:1127

hipExternalSemaphoreHandleDesc

Definition hip_runtime_api.h:1145

hipExternalSemaphoreHandleDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1155

hipExternalSemaphoreHandleDesc::name

const void * name

Definition hip_runtime_api.h:1151

hipExternalSemaphoreHandleDesc::NvSciSyncObj

const void * NvSciSyncObj

Definition hip_runtime_api.h:1153

hipExternalSemaphoreHandleDesc::type

hipExternalSemaphoreHandleType type

Definition hip_runtime_api.h:1146

hipExternalSemaphoreHandleDesc::handle

void * handle

Definition hip_runtime_api.h:1150

hipExternalSemaphoreHandleDesc::fd

int fd

Definition hip_runtime_api.h:1148

hipExternalSemaphoreSignalNodeParams

Definition hip_runtime_api.h:1478

hipExternalSemaphoreSignalNodeParams::paramsArray

const hipExternalSemaphoreSignalParams * paramsArray

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

Definition hip_runtime_api.h:1482

hipExternalSemaphoreSignalNodeParams::extSemArray

hipExternalSemaphore_t * extSemArray

< Array containing external semaphore handles.

Definition hip_runtime_api.h:1480

hipExternalSemaphoreSignalNodeParams::numExtSems

unsigned int numExtSems

Definition hip_runtime_api.h:1484

hipExternalSemaphoreSignalParams

Definition hip_runtime_api.h:1159

hipExternalSemaphoreSignalParams::reserved

unsigned long long reserved

Definition hip_runtime_api.h:1166

hipExternalSemaphoreSignalParams::value

unsigned long long value

Definition hip_runtime_api.h:1162

hipExternalSemaphoreSignalParams::fence

void * fence

Definition hip_runtime_api.h:1165

hipExternalSemaphoreSignalParams::flags

unsigned int flags

Definition hip_runtime_api.h:1173

hipExternalSemaphoreSignalParams::key

unsigned long long key

Definition hip_runtime_api.h:1169

hipExternalSemaphoreWaitNodeParams

Definition hip_runtime_api.h:1490

hipExternalSemaphoreWaitNodeParams::numExtSems

unsigned int numExtSems

Definition hip_runtime_api.h:1496

hipExternalSemaphoreWaitNodeParams::paramsArray

const hipExternalSemaphoreWaitParams * paramsArray

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

Definition hip_runtime_api.h:1494

hipExternalSemaphoreWaitNodeParams::extSemArray

hipExternalSemaphore_t * extSemArray

< Array containing external semaphore handles.

Definition hip_runtime_api.h:1492

hipExternalSemaphoreWaitParams

Definition hip_runtime_api.h:1179

hipExternalSemaphoreWaitParams::value

unsigned long long value

Definition hip_runtime_api.h:1182

hipExternalSemaphoreWaitParams::fence

void * fence

Definition hip_runtime_api.h:1185

hipExternalSemaphoreWaitParams::timeoutMs

unsigned int timeoutMs

Definition hip_runtime_api.h:1190

hipExternalSemaphoreWaitParams::key

unsigned long long key

Definition hip_runtime_api.h:1189

hipExternalSemaphoreWaitParams::flags

unsigned int flags

Definition hip_runtime_api.h:1194

hipExternalSemaphoreWaitParams::reserved

unsigned long long reserved

Definition hip_runtime_api.h:1186

hipFuncAttributes

Definition hip_runtime_api.h:634

hipFuncAttributes::cacheModeCA

int cacheModeCA

Definition hip_runtime_api.h:636

hipFuncAttributes::binaryVersion

int binaryVersion

Definition hip_runtime_api.h:635

hipFuncAttributes::constSizeBytes

size_t constSizeBytes

Definition hip_runtime_api.h:637

hipFuncAttributes::preferredShmemCarveout

int preferredShmemCarveout

Definition hip_runtime_api.h:642

hipFuncAttributes::sharedSizeBytes

size_t sharedSizeBytes

Definition hip_runtime_api.h:644

hipFuncAttributes::maxDynamicSharedSizeBytes

int maxDynamicSharedSizeBytes

Definition hip_runtime_api.h:639

hipFuncAttributes::ptxVersion

int ptxVersion

Definition hip_runtime_api.h:643

hipFuncAttributes::numRegs

int numRegs

Definition hip_runtime_api.h:641

hipFuncAttributes::localSizeBytes

size_t localSizeBytes

Definition hip_runtime_api.h:638

hipFuncAttributes::maxThreadsPerBlock

int maxThreadsPerBlock

Definition hip_runtime_api.h:640

hipFunctionLaunchParams

Definition hip_runtime_api.h:1083

hipFunctionLaunchParams::gridDimX

unsigned int gridDimX

Width(X) of grid in blocks.

Definition hip_runtime_api.h:1085

hipFunctionLaunchParams::blockDimX

unsigned int blockDimX

X dimension of each thread block.

Definition hip_runtime_api.h:1088

hipFunctionLaunchParams::function

hipFunction_t function

Kernel to launch.

Definition hip_runtime_api.h:1084

hipFunctionLaunchParams::hStream

hipStream_t hStream

Stream identifier.

Definition hip_runtime_api.h:1092

hipFunctionLaunchParams::blockDimY

unsigned int blockDimY

Y dimension of each thread block.

Definition hip_runtime_api.h:1089

hipFunctionLaunchParams::gridDimY

unsigned int gridDimY

Height(Y) of grid in blocks.

Definition hip_runtime_api.h:1086

hipFunctionLaunchParams::gridDimZ

unsigned int gridDimZ

Depth(Z) of grid in blocks.

Definition hip_runtime_api.h:1087

hipFunctionLaunchParams::sharedMemBytes

unsigned int sharedMemBytes

Shared memory.

Definition hip_runtime_api.h:1091

hipFunctionLaunchParams::blockDimZ

unsigned int blockDimZ

Z dimension of each thread block.

Definition hip_runtime_api.h:1090

hipFunctionLaunchParams::kernelParams

void ** kernelParams

Kernel parameters.

Definition hip_runtime_api.h:1093

hipGraphEdgeData

Definition hip_runtime_api.h:1657

hipGraphEdgeData::to_port

unsigned char to_port

Currently no node types define non-zero ports. This field must be set to zero.

Definition hip_runtime_api.h:1668

hipGraphEdgeData::reserved

unsigned char reserved[5]

These bytes are unused and must be zeroed.

Definition hip_runtime_api.h:1666

hipGraphEdgeData::type

unsigned char type

This should be populated with a value from hipGraphDependencyType.

Definition hip_runtime_api.h:1669

hipGraphEdgeData::from_port

unsigned char from_port

Definition hip_runtime_api.h:1659

hipGraphInstantiateParams

Definition hip_runtime_api.h:1451

hipGraphInstantiateParams::result_out

hipGraphInstantiateResult result_out

Definition hip_runtime_api.h:1454

hipGraphInstantiateParams::uploadStream

hipStream_t uploadStream

Definition hip_runtime_api.h:1456

hipGraphInstantiateParams::errNode_out

hipGraphNode_t errNode_out

Definition hip_runtime_api.h:1452

hipGraphInstantiateParams::flags

unsigned long long flags

Definition hip_runtime_api.h:1453

hipGraphNodeParams

Definition hip_runtime_api.h:1614

hipGraphNodeParams::type

hipGraphNodeType type

Definition hip_runtime_api.h:1615

hipGraphNodeParams::reserved0

int reserved0[3]

Definition hip_runtime_api.h:1616

hipGraphNodeParams::alloc

hipMemAllocNodeParams alloc

Definition hip_runtime_api.h:1628

hipGraphNodeParams::reserved1

long long reserved1[29]

Definition hip_runtime_api.h:1618

hipGraphNodeParams::eventRecord

hipEventRecordNodeParams eventRecord

Definition hip_runtime_api.h:1625

hipGraphNodeParams::extSemSignal

hipExternalSemaphoreSignalNodeParams extSemSignal

Definition hip_runtime_api.h:1626

hipGraphNodeParams::free

hipMemFreeNodeParams free

Definition hip_runtime_api.h:1629

hipGraphNodeParams::graph

hipChildGraphNodeParams graph

Definition hip_runtime_api.h:1623

hipGraphNodeParams::extSemWait

hipExternalSemaphoreWaitNodeParams extSemWait

Definition hip_runtime_api.h:1627

hipGraphNodeParams::memset

hipMemsetParams memset

Definition hip_runtime_api.h:1621

hipGraphNodeParams::host

hipHostNodeParams host

Definition hip_runtime_api.h:1622

hipGraphNodeParams::reserved2

long long reserved2

Definition hip_runtime_api.h:1632

hipGraphNodeParams::kernel

hipKernelNodeParams kernel

Definition hip_runtime_api.h:1619

hipGraphNodeParams::eventWait

hipEventWaitNodeParams eventWait

Definition hip_runtime_api.h:1624

hipGraphNodeParams::memcpy

hipMemcpyNodeParams memcpy

Definition hip_runtime_api.h:1620

hipHostNodeParams

Definition hip_runtime_api.h:1264

hipHostNodeParams::fn

hipHostFn_t fn

Definition hip_runtime_api.h:1265

hipHostNodeParams::userData

void * userData

Definition hip_runtime_api.h:1266

hipIpcEventHandle_t

Definition hip_runtime_api.h:624

hipIpcMemHandle_t

Definition hip_runtime_api.h:621

hipKernelNodeParams

Definition hip_runtime_api.h:1268

hipKernelNodeParams::gridDim

dim3 gridDim

Definition hip_runtime_api.h:1272

hipKernelNodeParams::sharedMemBytes

unsigned int sharedMemBytes

Definition hip_runtime_api.h:1274

hipKernelNodeParams::blockDim

dim3 blockDim

Definition hip_runtime_api.h:1269

hipKernelNodeParams::kernelParams

void ** kernelParams

Definition hip_runtime_api.h:1273

hipKernelNodeParams::extra

void ** extra

Definition hip_runtime_api.h:1270

hipKernelNodeParams::func

void * func

Definition hip_runtime_api.h:1271

hipLaunchParams

Definition hip_runtime_api.h:1072

hipLaunchParams::sharedMem

size_t sharedMem

Shared memory.

Definition hip_runtime_api.h:1077

hipLaunchParams::args

void ** args

Arguments.

Definition hip_runtime_api.h:1076

hipLaunchParams::blockDim

dim3 blockDim

Block dimensions.

Definition hip_runtime_api.h:1075

hipLaunchParams::gridDim

dim3 gridDim

Grid dimensions.

Definition hip_runtime_api.h:1074

hipLaunchParams::func

void * func

Device function symbol.

Definition hip_runtime_api.h:1073

hipLaunchParams::stream

hipStream_t stream

Stream identifier.

Definition hip_runtime_api.h:1078

hipMemAccessDesc

Definition hip_runtime_api.h:962

hipMemAccessDesc::flags

hipMemAccessFlags flags

Accessibility flags to set.

Definition hip_runtime_api.h:964

hipMemAccessDesc::location

hipMemLocation location

Location on which the accessibility has to change.

Definition hip_runtime_api.h:963

hipMemAllocNodeParams

Definition hip_runtime_api.h:1285

hipMemAllocNodeParams::accessDescs

const hipMemAccessDesc * accessDescs

The number of memory access descriptors.

Definition hip_runtime_api.h:1288

hipMemAllocNodeParams::bytesize

size_t bytesize

The size of the requested allocation in bytes.

Definition hip_runtime_api.h:1291

hipMemAllocNodeParams::poolProps

hipMemPoolProps poolProps

Definition hip_runtime_api.h:1286

hipMemAllocNodeParams::accessDescCount

size_t accessDescCount

Definition hip_runtime_api.h:1289

hipMemAllocNodeParams::dptr

void * dptr

Returned device address of the allocation.

Definition hip_runtime_api.h:1292

hipMemAllocationProp

Definition hip_runtime_api.h:1463

hipMemAllocationProp::win32HandleMetaData

void * win32HandleMetaData

Metadata for Win32 handles.

Definition hip_runtime_api.h:1467

hipMemAllocationProp::type

hipMemAllocationType type

Memory allocation type.

Definition hip_runtime_api.h:1464

hipMemAllocationProp::gpuDirectRDMACapable

unsigned char gpuDirectRDMACapable

RDMA capable.

Definition hip_runtime_api.h:1470

hipMemAllocationProp::allocFlags

struct hipMemAllocationProp::@24 allocFlags

hipMemAllocationProp::usage

unsigned short usage

Usage.

Definition hip_runtime_api.h:1471

hipMemAllocationProp::requestedHandleType

hipMemAllocationHandleType requestedHandleType

Requested handle type.

Definition hip_runtime_api.h:1465

hipMemAllocationProp::location

hipMemLocation location

Memory location.

Definition hip_runtime_api.h:1466

hipMemAllocationProp::compressionType

unsigned char compressionType

Compression type.

Definition hip_runtime_api.h:1469

hipMemFreeNodeParams

Definition hip_runtime_api.h:1607

hipMemFreeNodeParams::dptr

void * dptr

the pointer to be freed

Definition hip_runtime_api.h:1608

hipMemLocation

Definition hip_runtime_api.h:943

hipMemLocation::id

int id

Identifier for the provided location type hipMemLocationType.

Definition hip_runtime_api.h:945

hipMemLocation::type

hipMemLocationType type

Specifies the location type, which describes the meaning of id.

Definition hip_runtime_api.h:944

hipMemPoolProps

Definition hip_runtime_api.h:990

hipMemPoolProps::maxSize

size_t maxSize

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

Definition hip_runtime_api.h:998

hipMemPoolProps::reserved

unsigned char reserved[56]

Reserved for future use, must be 0.

Definition hip_runtime_api.h:999

hipMemPoolProps::location

hipMemLocation location

Location where allocations should reside.

Definition hip_runtime_api.h:993

hipMemPoolProps::handleTypes

hipMemAllocationHandleType handleTypes

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

Definition hip_runtime_api.h:992

hipMemPoolProps::allocType

hipMemAllocationType allocType

Allocation type. Currently must be specified as hipMemAllocationTypePinned.

Definition hip_runtime_api.h:991

hipMemPoolProps::win32SecurityAttributes

void * win32SecurityAttributes

Definition hip_runtime_api.h:997

hipMemPoolPtrExportData

Definition hip_runtime_api.h:1004

hipMemPoolPtrExportData::reserved

unsigned char reserved[64]

Definition hip_runtime_api.h:1005

hipMemcpy3DParms

Definition driver_types.h:414

hipMemcpyNodeParams

Definition hip_runtime_api.h:1576

hipMemcpyNodeParams::reserved

int reserved[3]

Must be zero.

Definition hip_runtime_api.h:1578

hipMemcpyNodeParams::flags

int flags

Must be zero.

Definition hip_runtime_api.h:1577

hipMemcpyNodeParams::copyParams

hipMemcpy3DParms copyParams

Params set for the memory copy.

Definition hip_runtime_api.h:1579

hipMemsetParams

Definition hip_runtime_api.h:1276

hipMemsetParams::dst

void * dst

Definition hip_runtime_api.h:1277

hipMemsetParams::value

unsigned int value

Definition hip_runtime_api.h:1281

hipMemsetParams::elementSize

unsigned int elementSize

Definition hip_runtime_api.h:1278

hipMemsetParams::width

size_t width

Definition hip_runtime_api.h:1282

hipMemsetParams::pitch

size_t pitch

Definition hip_runtime_api.h:1280

hipMemsetParams::height

size_t height

Definition hip_runtime_api.h:1279

hipMipmappedArray

Definition driver_types.h:138

hipPitchedPtr

Definition driver_types.h:388

hipPointerAttribute_t

Definition hip_runtime_api.h:265

hipPointerAttribute_t::device

int device

Definition hip_runtime_api.h:267

hipPointerAttribute_t::hostPointer

void * hostPointer

Definition hip_runtime_api.h:269

hipPointerAttribute_t::type

enum hipMemoryType type

Definition hip_runtime_api.h:266

hipPointerAttribute_t::isManaged

int isManaged

Definition hip_runtime_api.h:270

hipPointerAttribute_t::devicePointer

void * devicePointer

Definition hip_runtime_api.h:268

hipPointerAttribute_t::allocationFlags

unsigned allocationFlags

Definition hip_runtime_api.h:271

hipResourceDesc

Definition driver_types.h:287

hipResourceViewDesc

Definition driver_types.h:347

hipTextureDesc

Definition texture_types.h:117

hipUUID

Definition hip_runtime_api.h:84

texture

Definition texture_types.h:148

textureReference

Definition texture_types.h:96

textureReference::channelDesc

struct hipChannelFormatDesc channelDesc

Definition texture_types.h:101

surface_types.h

Defines surface types for HIP runtime.

hipSurfaceObject_t

struct __hip_surface * hipSurfaceObject_t

Definition surface_types.h:41

texture_types.h

hipTextureObject_t

struct __hip_texture * hipTextureObject_t

Definition texture_types.h:71

hipTextureAddressMode

hipTextureAddressMode

Definition texture_types.h:76

hipTextureFilterMode

hipTextureFilterMode

Definition texture_types.h:86

hipLaunchAttributeValue

Definition hip_runtime_api.h:1321

hipLaunchAttributeValue::priority

int priority

Definition hip_runtime_api.h:1325

hipLaunchAttributeValue::cooperative

int cooperative

Definition hip_runtime_api.h:1324

hipLaunchAttributeValue::accessPolicyWindow

hipAccessPolicyWindow accessPolicyWindow

Definition hip_runtime_api.h:1322