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#include <hip/linker_types.h>

37

38enum {

39 HIP_SUCCESS = 0,

40 HIP_ERROR_INVALID_VALUE,

41 HIP_ERROR_NOT_INITIALIZED,

42 HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

43};

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

54typedef struct {

55 // 32-bit Atomics

56 unsigned hasGlobalInt32Atomics : 1;

57 unsigned hasGlobalFloatAtomicExch : 1;

58 unsigned hasSharedInt32Atomics : 1;

59 unsigned hasSharedFloatAtomicExch : 1;

60 unsigned hasFloatAtomicAdd : 1;

61

62 // 64-bit Atomics

63 unsigned hasGlobalInt64Atomics : 1;

64 unsigned hasSharedInt64Atomics : 1;

65

66 // Doubles

67 unsigned hasDoubles : 1;

68

69 // Warp cross-lane operations

70 unsigned hasWarpVote : 1;

71 unsigned hasWarpBallot : 1;

72 unsigned hasWarpShuffle : 1;

73 unsigned hasFunnelShift : 1;

74

75 // Sync

76 unsigned hasThreadFenceSystem : 1;

77 unsigned hasSyncThreadsExt : 1;

78

79 // Misc

80 unsigned hasSurfaceFuncs : 1;

81 unsigned has3dGrid : 1;

82 unsigned hasDynamicParallelism : 1;

83} hipDeviceArch_t;

84

85typedef struct hipUUID_t {

86 char bytes[16];

87} hipUUID;

88

89//---

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

91

92#define hipGetDeviceProperties hipGetDevicePropertiesR0600

93#define hipDeviceProp_t hipDeviceProp_tR0600

94#define hipChooseDevice hipChooseDeviceR0600

95

100typedef struct hipDeviceProp_t {

101 char name[256];

102 hipUUID uuid;

103 char luid[8];

104 unsigned int luidDeviceNodeMask;

105 size_t totalGlobalMem;

106 size_t sharedMemPerBlock;

107 int regsPerBlock;

108 int warpSize;

109 size_t memPitch;

111 int maxThreadsPerBlock;

112 int maxThreadsDim[3];

113 int maxGridSize[3];

114 int clockRate;

115 size_t totalConstMem;

117 int major;

121 int minor;

126 size_t textureAlignment;

127 size_t texturePitchAlignment;

128 int deviceOverlap;

129 int multiProcessorCount;

130 int kernelExecTimeoutEnabled;

131 int integrated;

132 int canMapHostMemory;

133 int computeMode;

134 int maxTexture1D;

135 int maxTexture1DMipmap;

136 int maxTexture1DLinear;

137 int maxTexture2D[2];

138 int maxTexture2DMipmap[2];

139 int maxTexture2DLinear[3];

140 int maxTexture2DGather[2];

141 int maxTexture3D[3];

143 int maxTexture3DAlt[3];

144 int maxTextureCubemap;

145 int maxTexture1DLayered[2];

146 int maxTexture2DLayered[3];

147 int maxTextureCubemapLayered[2];

148 int maxSurface1D;

149 int maxSurface2D[2];

150 int maxSurface3D[3];

151 int maxSurface1DLayered[2];

152 int maxSurface2DLayered[3];

153 int maxSurfaceCubemap;

154 int maxSurfaceCubemapLayered[2];

155 size_t surfaceAlignment;

156 int concurrentKernels;

157 int ECCEnabled;

158 int pciBusID;

159 int pciDeviceID;

160 int pciDomainID;

161 int tccDriver;

162 int asyncEngineCount;

163 int unifiedAddressing;

164 int memoryClockRate;

165 int memoryBusWidth;

166 int l2CacheSize;

167 int persistingL2CacheMaxSize;

168 int maxThreadsPerMultiProcessor;

169 int streamPrioritiesSupported;

170 int globalL1CacheSupported;

171 int localL1CacheSupported;

172 size_t sharedMemPerMultiprocessor;

173 int regsPerMultiprocessor;

174 int managedMemory;

175 int isMultiGpuBoard;

176 int multiGpuBoardGroupID;

177 int hostNativeAtomicSupported;

178 int singleToDoublePrecisionPerfRatio;

179 int pageableMemoryAccess;

181 int concurrentManagedAccess;

183 int computePreemptionSupported;

184 int canUseHostPointerForRegisteredMem;

186 int cooperativeLaunch;

187 int cooperativeMultiDeviceLaunch;

189 size_t

190 sharedMemPerBlockOptin;

191 int pageableMemoryAccessUsesHostPageTables;

193 int directManagedMemAccessFromHost;

195 int maxBlocksPerMultiProcessor;

196 int accessPolicyMaxWindowSize;

197 size_t reservedSharedMemPerBlock;

198 int hostRegisterSupported;

199 int sparseHipArraySupported;

200 int hostRegisterReadOnlySupported;

202 int timelineSemaphoreInteropSupported;

203 int memoryPoolsSupported;

204 int gpuDirectRDMASupported;

205 unsigned int gpuDirectRDMAFlushWritesOptions;

207 int gpuDirectRDMAWritesOrdering;

208 unsigned int

209 memoryPoolSupportedHandleTypes;

210 int deferredMappingHipArraySupported;

212 int ipcEventSupported;

213 int clusterLaunch;

214 int unifiedFunctionPointers;

215 int reserved[63];

216

217 int hipReserved[32];

218

219 /* HIP Only struct members */

220 char gcnArchName[256];

221 size_t maxSharedMemoryPerMultiProcessor;

222 int clockInstructionRate;

224 hipDeviceArch_t arch;

225 unsigned int* hdpMemFlushCntl;

226 unsigned int* hdpRegFlushCntl;

227 int cooperativeMultiDeviceUnmatchedFunc;

230 int cooperativeMultiDeviceUnmatchedGridDim;

233 int cooperativeMultiDeviceUnmatchedBlockDim;

236 int cooperativeMultiDeviceUnmatchedSharedMem;

239 int isLargeBar;

240 int asicRevision;

241} hipDeviceProp_t;

242

249typedef enum hipMemoryType {

250 hipMemoryTypeUnregistered = 0,

251 hipMemoryTypeHost = 1,

252 hipMemoryTypeDevice = 2,

254 hipMemoryTypeManaged = 3,

257 hipMemoryTypeArray = 10,

259 hipMemoryTypeUnified = 11

260

261} hipMemoryType;

262

266typedef struct hipPointerAttribute_t {

267 enum hipMemoryType type;

268 int device;

269 void* devicePointer;

270 void* hostPointer;

271 int isManaged;

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

273 /* peers? */

274} hipPointerAttribute_t;

275

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

277// we can make that yield a warning

278#if __cplusplus >= 201703L

279#define __HIP_NODISCARD [[nodiscard]]

280#else

281#define __HIP_NODISCARD

282#endif

283

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

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

290

291typedef enum __HIP_NODISCARD hipError_t {

292 hipSuccess = 0,

293 hipErrorInvalidValue = 1,

295 hipErrorOutOfMemory = 2,

296 // Deprecated

297 hipErrorMemoryAllocation = 2,

298 hipErrorNotInitialized = 3,

299 // Deprecated

300 hipErrorInitializationError = 3,

301 hipErrorDeinitialized = 4,

302 hipErrorProfilerDisabled = 5,

303 hipErrorProfilerNotInitialized = 6,

304 hipErrorProfilerAlreadyStarted = 7,

305 hipErrorProfilerAlreadyStopped = 8,

306 hipErrorInvalidConfiguration = 9,

307 hipErrorInvalidPitchValue = 12,

308 hipErrorInvalidSymbol = 13,

309 hipErrorInvalidDevicePointer = 17,

310 hipErrorInvalidMemcpyDirection = 21,

311 hipErrorInsufficientDriver = 35,

312 hipErrorMissingConfiguration = 52,

313 hipErrorPriorLaunchFailure = 53,

314 hipErrorInvalidDeviceFunction = 98,

315 hipErrorNoDevice = 100,

316 hipErrorInvalidDevice = 101,

317 hipErrorInvalidImage = 200,

318 hipErrorInvalidContext = 201,

319 hipErrorContextAlreadyCurrent = 202,

320 hipErrorMapFailed = 205,

321 // Deprecated

322 hipErrorMapBufferObjectFailed = 205,

323 hipErrorUnmapFailed = 206,

324 hipErrorArrayIsMapped = 207,

325 hipErrorAlreadyMapped = 208,

326 hipErrorNoBinaryForGpu = 209,

327 hipErrorAlreadyAcquired = 210,

328 hipErrorNotMapped = 211,

329 hipErrorNotMappedAsArray = 212,

330 hipErrorNotMappedAsPointer = 213,

331 hipErrorECCNotCorrectable = 214,

332 hipErrorUnsupportedLimit = 215,

333 hipErrorContextAlreadyInUse = 216,

334 hipErrorPeerAccessUnsupported = 217,

335 hipErrorInvalidKernelFile = 218,

336 hipErrorInvalidGraphicsContext = 219,

337 hipErrorInvalidSource = 300,

338 hipErrorFileNotFound = 301,

339 hipErrorSharedObjectSymbolNotFound = 302,

340 hipErrorSharedObjectInitFailed = 303,

341 hipErrorOperatingSystem = 304,

342 hipErrorInvalidHandle = 400,

343 // Deprecated

344 hipErrorInvalidResourceHandle = 400,

345 hipErrorIllegalState = 401,

346 hipErrorNotFound = 500,

347 hipErrorNotReady = 600,

351 hipErrorIllegalAddress = 700,

352 hipErrorLaunchOutOfResources = 701,

353 hipErrorLaunchTimeOut = 702,

354 hipErrorPeerAccessAlreadyEnabled = 704,

356 hipErrorPeerAccessNotEnabled = 705,

357 hipErrorSetOnActiveProcess = 708,

358 hipErrorContextIsDestroyed = 709,

359 hipErrorAssert = 710,

360 hipErrorHostMemoryAlreadyRegistered = 712,

362 hipErrorHostMemoryNotRegistered = 713,

364 hipErrorLaunchFailure = 719,

365 hipErrorCooperativeLaunchTooLarge = 720,

369 hipErrorNotSupported = 801,

370 hipErrorStreamCaptureUnsupported = 900,

372 hipErrorStreamCaptureInvalidated = 901,

374 hipErrorStreamCaptureMerge = 902,

376 hipErrorStreamCaptureUnmatched = 903,

377 hipErrorStreamCaptureUnjoined = 904,

379 hipErrorStreamCaptureIsolation = 905,

383 hipErrorStreamCaptureImplicit = 906,

386 hipErrorCapturedEvent = 907,

388 hipErrorStreamCaptureWrongThread = 908,

392 hipErrorGraphExecUpdateFailure = 910,

396 hipErrorInvalidChannelDescriptor = 911,

397 hipErrorInvalidTexture = 912,

398 hipErrorUnknown = 999,

399 // HSA Runtime Error Codes start here.

400 hipErrorRuntimeMemory = 1052,

402 hipErrorRuntimeOther = 1053,

404 hipErrorTbd

405} hipError_t;

406

407#undef __HIP_NODISCARD

408

413typedef enum hipDeviceAttribute_t {

414 hipDeviceAttributeCudaCompatibleBegin = 0,

415

416 hipDeviceAttributeEccEnabled = hipDeviceAttributeCudaCompatibleBegin,

417 hipDeviceAttributeAccessPolicyMaxWindowSize,

418 hipDeviceAttributeAsyncEngineCount,

419 hipDeviceAttributeCanMapHostMemory,

420 hipDeviceAttributeCanUseHostPointerForRegisteredMem,

422 hipDeviceAttributeClockRate,

423 hipDeviceAttributeComputeMode,

424 hipDeviceAttributeComputePreemptionSupported,

425 hipDeviceAttributeConcurrentKernels,

426 hipDeviceAttributeConcurrentManagedAccess,

427 hipDeviceAttributeCooperativeLaunch,

428 hipDeviceAttributeCooperativeMultiDeviceLaunch,

429 hipDeviceAttributeDeviceOverlap,

431 hipDeviceAttributeDirectManagedMemAccessFromHost,

433 hipDeviceAttributeGlobalL1CacheSupported,

434 hipDeviceAttributeHostNativeAtomicSupported,

435 hipDeviceAttributeIntegrated,

436 hipDeviceAttributeIsMultiGpuBoard,

437 hipDeviceAttributeKernelExecTimeout,

438 hipDeviceAttributeL2CacheSize,

439 hipDeviceAttributeLocalL1CacheSupported,

440 hipDeviceAttributeLuid,

441 hipDeviceAttributeLuidDeviceNodeMask,

442 hipDeviceAttributeComputeCapabilityMajor,

443 hipDeviceAttributeManagedMemory,

444 hipDeviceAttributeMaxBlocksPerMultiProcessor,

445 hipDeviceAttributeMaxBlockDimX,

446 hipDeviceAttributeMaxBlockDimY,

447 hipDeviceAttributeMaxBlockDimZ,

448 hipDeviceAttributeMaxGridDimX,

449 hipDeviceAttributeMaxGridDimY,

450 hipDeviceAttributeMaxGridDimZ,

451 hipDeviceAttributeMaxSurface1D,

452 hipDeviceAttributeMaxSurface1DLayered,

453 hipDeviceAttributeMaxSurface2D,

454 hipDeviceAttributeMaxSurface2DLayered,

455 hipDeviceAttributeMaxSurface3D,

456 hipDeviceAttributeMaxSurfaceCubemap,

457 hipDeviceAttributeMaxSurfaceCubemapLayered,

458 hipDeviceAttributeMaxTexture1DWidth,

459 hipDeviceAttributeMaxTexture1DLayered,

460 hipDeviceAttributeMaxTexture1DLinear,

462 hipDeviceAttributeMaxTexture1DMipmap,

463 hipDeviceAttributeMaxTexture2DWidth,

464 hipDeviceAttributeMaxTexture2DHeight,

465 hipDeviceAttributeMaxTexture2DGather,

466 hipDeviceAttributeMaxTexture2DLayered,

467 hipDeviceAttributeMaxTexture2DLinear,

468 hipDeviceAttributeMaxTexture2DMipmap,

469 hipDeviceAttributeMaxTexture3DWidth,

470 hipDeviceAttributeMaxTexture3DHeight,

471 hipDeviceAttributeMaxTexture3DDepth,

472 hipDeviceAttributeMaxTexture3DAlt,

473 hipDeviceAttributeMaxTextureCubemap,

474 hipDeviceAttributeMaxTextureCubemapLayered,

475 hipDeviceAttributeMaxThreadsDim,

476 hipDeviceAttributeMaxThreadsPerBlock,

477 hipDeviceAttributeMaxThreadsPerMultiProcessor,

478 hipDeviceAttributeMaxPitch,

479 hipDeviceAttributeMemoryBusWidth,

480 hipDeviceAttributeMemoryClockRate,

481 hipDeviceAttributeComputeCapabilityMinor,

482 hipDeviceAttributeMultiGpuBoardGroupID,

483 hipDeviceAttributeMultiprocessorCount,

484 hipDeviceAttributeUnused1,

485 hipDeviceAttributePageableMemoryAccess,

487 hipDeviceAttributePageableMemoryAccessUsesHostPageTables,

488 hipDeviceAttributePciBusId,

489 hipDeviceAttributePciDeviceId,

490 hipDeviceAttributePciDomainID,

491 hipDeviceAttributePersistingL2CacheMaxSize,

492 hipDeviceAttributeMaxRegistersPerBlock,

494 hipDeviceAttributeMaxRegistersPerMultiprocessor,

495 hipDeviceAttributeReservedSharedMemPerBlock,

496 hipDeviceAttributeMaxSharedMemoryPerBlock,

497 hipDeviceAttributeSharedMemPerBlockOptin,

498 hipDeviceAttributeSharedMemPerMultiprocessor,

499 hipDeviceAttributeSingleToDoublePrecisionPerfRatio,

500 hipDeviceAttributeStreamPrioritiesSupported,

501 hipDeviceAttributeSurfaceAlignment,

502 hipDeviceAttributeTccDriver,

503 hipDeviceAttributeTextureAlignment,

504 hipDeviceAttributeTexturePitchAlignment,

505 hipDeviceAttributeTotalConstantMemory,

506 hipDeviceAttributeTotalGlobalMem,

507 hipDeviceAttributeUnifiedAddressing,

508 hipDeviceAttributeUnused2,

509 hipDeviceAttributeWarpSize,

510 hipDeviceAttributeMemoryPoolsSupported,

511 hipDeviceAttributeVirtualMemoryManagementSupported,

512 hipDeviceAttributeHostRegisterSupported,

513 hipDeviceAttributeMemoryPoolSupportedHandleTypes,

514

515 hipDeviceAttributeCudaCompatibleEnd = 9999,

516 hipDeviceAttributeAmdSpecificBegin = 10000,

517

518 hipDeviceAttributeClockInstructionRate = hipDeviceAttributeAmdSpecificBegin,

519 hipDeviceAttributeUnused3,

520 hipDeviceAttributeMaxSharedMemoryPerMultiprocessor,

521 hipDeviceAttributeUnused4,

522 hipDeviceAttributeUnused5,

523 hipDeviceAttributeHdpMemFlushCntl,

524 hipDeviceAttributeHdpRegFlushCntl,

525 hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc,

527 hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim,

529 hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim,

531 hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem,

533 hipDeviceAttributeIsLargeBar,

534 hipDeviceAttributeAsicRevision,

535 hipDeviceAttributeCanUseStreamWaitValue,

537 hipDeviceAttributeImageSupport,

538 hipDeviceAttributePhysicalMultiProcessorCount,

540 hipDeviceAttributeFineGrainSupport,

541 hipDeviceAttributeWallClockRate,

542

543 hipDeviceAttributeAmdSpecificEnd = 19999,

544 hipDeviceAttributeVendorSpecificBegin = 20000,

545 // Extended attributes for vendors

546} hipDeviceAttribute_t;

547

548typedef enum hipDriverProcAddressQueryResult {

549 HIP_GET_PROC_ADDRESS_SUCCESS = 0,

550 HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND = 1,

551 HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT = 2

552} hipDriverProcAddressQueryResult;

553

554enum hipComputeMode {

555 hipComputeModeDefault = 0,

556 hipComputeModeExclusive = 1,

557 hipComputeModeProhibited = 2,

558 hipComputeModeExclusiveProcess = 3

559};

560

561enum hipFlushGPUDirectRDMAWritesOptions {

562 hipFlushGPUDirectRDMAWritesOptionHost = 1 << 0,

563 hipFlushGPUDirectRDMAWritesOptionMemOps = 1 << 1

564};

565

566enum hipGPUDirectRDMAWritesOrdering {

567 hipGPUDirectRDMAWritesOrderingNone = 0,

568 hipGPUDirectRDMAWritesOrderingOwner = 100,

569 hipGPUDirectRDMAWritesOrderingAllDevices = 200

570};

571

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

573

574#include <stdint.h>

575#include <stddef.h>

576#ifndef GENERIC_GRID_LAUNCH

577#define GENERIC_GRID_LAUNCH 1

578#endif

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

580#include <hip/driver_types.h>

581#include <hip/texture_types.h>

582#include <hip/surface_types.h>

583#if defined(_MSC_VER)

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

585#else // !defined(_MSC_VER)

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

587#endif // !defined(_MSC_VER)

588#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"

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

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

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

592#ifdef __cplusplus

593 #define __dparm(x) \

594 = x

595#else

596 #define __dparm(x)

597#endif

598#ifdef __GNUC__

599#pragma GCC visibility push (default)

600#endif

601#ifdef __cplusplus

602namespace hip_impl {

603hipError_t hip_init();

604} // namespace hip_impl

605#endif

606// Structure definitions:

607#ifdef __cplusplus

608extern "C" {

609#endif

610//---

611// API-visible structures

612typedef struct ihipCtx_t* hipCtx_t;

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

614typedef int hipDevice_t;

615typedef enum hipDeviceP2PAttr {

616 hipDevP2PAttrPerformanceRank = 0,

617 hipDevP2PAttrAccessSupported,

618 hipDevP2PAttrNativeAtomicSupported,

619 hipDevP2PAttrHipArrayAccessSupported

620} hipDeviceP2PAttr;

621typedef struct ihipStream_t* hipStream_t;

622#define hipIpcMemLazyEnablePeerAccess 0x01

623#define HIP_IPC_HANDLE_SIZE 64

624typedef struct hipIpcMemHandle_st {

625 char reserved[HIP_IPC_HANDLE_SIZE];

626} hipIpcMemHandle_t;

627typedef struct hipIpcEventHandle_st {

628 char reserved[HIP_IPC_HANDLE_SIZE];

629} hipIpcEventHandle_t;

630typedef struct ihipModule_t* hipModule_t;

631typedef struct ihipModuleSymbol_t* hipFunction_t;

632typedef struct ihipLinkState_t* hipLinkState_t;

636typedef struct ihipMemPoolHandle_t* hipMemPool_t;

637

638typedef struct hipFuncAttributes {

639 int binaryVersion;

640 int cacheModeCA;

641 size_t constSizeBytes;

642 size_t localSizeBytes;

643 int maxDynamicSharedSizeBytes;

644 int maxThreadsPerBlock;

645 int numRegs;

646 int preferredShmemCarveout;

647 int ptxVersion;

648 size_t sharedSizeBytes;

649} hipFuncAttributes;

650typedef struct ihipEvent_t* hipEvent_t;

651

658enum hipLimit_t {

659 hipLimitStackSize = 0x0,

662 hipLimitPrintfFifoSize = 0x01,

664 hipLimitMallocHeapSize = 0x02,

666 hipLimitRange

667};

671//Flags that can be used with hipStreamCreateWithFlags.

673#define hipStreamDefault 0x00

674

676#define hipStreamNonBlocking 0x01

677

678//Flags that can be used with hipEventCreateWithFlags.

680#define hipEventDefault 0x0

681

683#define hipEventBlockingSync 0x1

684

686#define hipEventDisableTiming 0x2

687

689#define hipEventInterprocess 0x4

690

691//Flags that can be used with hipEventRecordWithFlags.

693#define hipEventRecordDefault 0x00

694

696#define hipEventRecordExternal 0x01

697

698//Flags that can be used with hipStreamWaitEvent.

700#define hipEventWaitDefault 0x00

701

703#define hipEventWaitExternal 0x01

704

713#define hipEventDisableSystemFence 0x20000000

714

717#define hipEventReleaseToDevice 0x40000000

718

721#define hipEventReleaseToSystem 0x80000000

722

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

725#define hipHostAllocDefault 0x0

726

729#define hipHostMallocDefault 0x0

730

732#define hipHostAllocPortable 0x1

733

736#define hipHostMallocPortable 0x1

737

740#define hipHostAllocMapped 0x2

741

745#define hipHostMallocMapped 0x2

746

750#define hipHostAllocWriteCombined 0x4

751

757#define hipHostMallocWriteCombined 0x4

762#define hipHostMallocNumaUser 0x20000000

763

765#define hipHostMallocCoherent 0x40000000

766

768#define hipHostMallocNonCoherent 0x80000000

769

771#define hipMemAttachGlobal 0x01

772

774#define hipMemAttachHost 0x02

775

777#define hipMemAttachSingle 0x04

778

779#define hipDeviceMallocDefault 0x0

780

782#define hipDeviceMallocFinegrained 0x1

783

785#define hipMallocSignalMemory 0x2

786

788#define hipDeviceMallocUncached 0x3

789

791#define hipDeviceMallocContiguous 0x4

792

793//Flags that can be used with hipHostRegister.

795#define hipHostRegisterDefault 0x0

796

798#define hipHostRegisterPortable 0x1

799

802#define hipHostRegisterMapped 0x2

803

805#define hipHostRegisterIoMemory 0x4

806

808#define hipHostRegisterReadOnly 0x08

809

811#define hipExtHostRegisterCoarseGrained 0x8

812

814#define hipDeviceScheduleAuto 0x0

815

818#define hipDeviceScheduleSpin 0x1

819

822#define hipDeviceScheduleYield 0x2

823#define hipDeviceScheduleBlockingSync 0x4

824#define hipDeviceScheduleMask 0x7

825#define hipDeviceMapHost 0x8

826#define hipDeviceLmemResizeToMax 0x10

828#define hipArrayDefault 0x00

829#define hipArrayLayered 0x01

830#define hipArraySurfaceLoadStore 0x02

831#define hipArrayCubemap 0x04

832#define hipArrayTextureGather 0x08

833#define hipOccupancyDefault 0x00

834#define hipOccupancyDisableCachingOverride 0x01

835#define hipCooperativeLaunchMultiDeviceNoPreSync 0x01

836#define hipCooperativeLaunchMultiDeviceNoPostSync 0x02

837#define hipCpuDeviceId ((int)-1)

838#define hipInvalidDeviceId ((int)-2)

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

841#define hipExtAnyOrderLaunch 0x01

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

843#define hipStreamWaitValueGte 0x0

844#define hipStreamWaitValueEq 0x1

845#define hipStreamWaitValueAnd 0x2

846#define hipStreamWaitValueNor 0x3

847

849typedef enum hipStreamBatchMemOpType {

850 hipStreamMemOpWaitValue32 = 0x1,

851 hipStreamMemOpWriteValue32 = 0x2,

852 hipStreamMemOpWaitValue64 = 0x4,

853 hipStreamMemOpWriteValue64 = 0x5,

854 hipStreamMemOpBarrier = 0x6,

855 hipStreamMemOpFlushRemoteWrites = 0x3

856} hipStreamBatchMemOpType;

857

894typedef union hipStreamBatchMemOpParams_union {

895 hipStreamBatchMemOpType operation;

896 struct hipStreamMemOpWaitValueParams_t{

897 hipStreamBatchMemOpType operation;

898 hipDeviceptr_t address;

899 union {

900 uint32_t value;

901 uint64_t value64;

902 };

903 unsigned int flags;

904 hipDeviceptr_t alias;

905 } waitValue;

906 struct hipStreamMemOpWriteValueParams_t{

907 hipStreamBatchMemOpType operation;

908 hipDeviceptr_t address;

909 union {

910 uint32_t value;

911 uint64_t value64;

912 };

913 unsigned int flags;

914 hipDeviceptr_t alias;

915 } writeValue;

916 struct hipStreamMemOpFlushRemoteWritesParams_t{

917 hipStreamBatchMemOpType operation;

918 unsigned int flags;

919 } flushRemoteWrites;

920 struct hipStreamMemOpMemoryBarrierParams_t{

921 hipStreamBatchMemOpType operation;

922 unsigned int flags;

923 } memoryBarrier;

924 uint64_t pad[6];

925} hipStreamBatchMemOpParams;

926

954typedef struct hipBatchMemOpNodeParams {

955 hipCtx_t ctx;

956 unsigned int count;

957 hipStreamBatchMemOpParams *paramArray;

958 unsigned int flags;

959} hipBatchMemOpNodeParams;

960

961// Stream per thread

963#define hipStreamPerThread ((hipStream_t)2)

964

965#define hipStreamLegacy ((hipStream_t)1)

966

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

968#define hipExternalMemoryDedicated 0x1

974typedef enum hipMemoryAdvise {

975 hipMemAdviseSetReadMostly = 1,

977 hipMemAdviseUnsetReadMostly = 2,

978 hipMemAdviseSetPreferredLocation = 3,

980 hipMemAdviseUnsetPreferredLocation = 4,

981 hipMemAdviseSetAccessedBy = 5,

983 hipMemAdviseUnsetAccessedBy = 6,

985 hipMemAdviseSetCoarseGrain = 100,

990 hipMemAdviseUnsetCoarseGrain = 101

991} hipMemoryAdvise;

995typedef enum hipMemRangeCoherencyMode {

996 hipMemRangeCoherencyModeFineGrain = 0,

998 hipMemRangeCoherencyModeCoarseGrain = 1,

1000 hipMemRangeCoherencyModeIndeterminate = 2

1003} hipMemRangeCoherencyMode;

1007typedef enum hipMemRangeAttribute {

1008 hipMemRangeAttributeReadMostly = 1,

1010 hipMemRangeAttributePreferredLocation = 2,

1011 hipMemRangeAttributeAccessedBy = 3,

1013 hipMemRangeAttributeLastPrefetchLocation = 4,

1015 hipMemRangeAttributeCoherencyMode = 100,

1017} hipMemRangeAttribute;

1018

1022typedef enum hipMemPoolAttr

1023{

1032 hipMemPoolReuseFollowEventDependencies = 0x1,

1038 hipMemPoolReuseAllowOpportunistic = 0x2,

1045 hipMemPoolReuseAllowInternalDependencies = 0x3,

1054 hipMemPoolAttrReleaseThreshold = 0x4,

1059 hipMemPoolAttrReservedMemCurrent = 0x5,

1065 hipMemPoolAttrReservedMemHigh = 0x6,

1070 hipMemPoolAttrUsedMemCurrent = 0x7,

1076 hipMemPoolAttrUsedMemHigh = 0x8

1077} hipMemPoolAttr;

1081 typedef enum hipMemLocationType {

1082 hipMemLocationTypeInvalid = 0,

1083 hipMemLocationTypeDevice = 1

1084} hipMemLocationType;

1090typedef struct hipMemLocation {

1091 hipMemLocationType type;

1092 int id;

1093} hipMemLocation;

1098typedef enum hipMemAccessFlags {

1099 hipMemAccessFlagsProtNone = 0,

1100 hipMemAccessFlagsProtRead = 1,

1101 hipMemAccessFlagsProtReadWrite = 3

1102} hipMemAccessFlags;

1109typedef struct hipMemAccessDesc {

1110 hipMemLocation location;

1111 hipMemAccessFlags flags;

1112} hipMemAccessDesc;

1116typedef enum hipMemAllocationType {

1117 hipMemAllocationTypeInvalid = 0x0,

1121 hipMemAllocationTypePinned = 0x1,

1122 hipMemAllocationTypeMax = 0x7FFFFFFF

1123} hipMemAllocationType;

1128typedef enum hipMemAllocationHandleType {

1129 hipMemHandleTypeNone = 0x0,

1130 hipMemHandleTypePosixFileDescriptor = 0x1,

1131 hipMemHandleTypeWin32 = 0x2,

1132 hipMemHandleTypeWin32Kmt = 0x4

1133} hipMemAllocationHandleType;

1137typedef struct hipMemPoolProps {

1138 hipMemAllocationType allocType;

1139 hipMemAllocationHandleType handleTypes;

1140 hipMemLocation location;

1144 void* win32SecurityAttributes;

1145 size_t maxSize;

1146 unsigned char reserved[56];

1147} hipMemPoolProps;

1151typedef struct hipMemPoolPtrExportData {

1152 unsigned char reserved[64];

1153} hipMemPoolPtrExportData;

1154

1158typedef enum hipFuncAttribute {

1159 hipFuncAttributeMaxDynamicSharedMemorySize = 8,

1160 hipFuncAttributePreferredSharedMemoryCarveout = 9,

1161 hipFuncAttributeMax

1162} hipFuncAttribute;

1166typedef enum hipFuncCache_t {

1167 hipFuncCachePreferNone,

1168 hipFuncCachePreferShared,

1169 hipFuncCachePreferL1,

1170 hipFuncCachePreferEqual,

1171} hipFuncCache_t;

1175typedef enum hipSharedMemConfig {

1176 hipSharedMemBankSizeDefault,

1177 hipSharedMemBankSizeFourByte,

1179 hipSharedMemBankSizeEightByte

1181} hipSharedMemConfig;

1185typedef struct dim3 {

1186 uint32_t x;

1187 uint32_t y;

1188 uint32_t z;

1189#ifdef __cplusplus

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

1191#endif

1192} dim3;

1196typedef struct hipLaunchParams_t {

1197 void* func;

1198 dim3 gridDim;

1199 dim3 blockDim;

1200 void **args;

1201 size_t sharedMem;

1202 hipStream_t stream;

1203} hipLaunchParams;

1207typedef struct hipFunctionLaunchParams_t {

1208 hipFunction_t function;

1209 unsigned int gridDimX;

1210 unsigned int gridDimY;

1211 unsigned int gridDimZ;

1212 unsigned int blockDimX;

1213 unsigned int blockDimY;

1214 unsigned int blockDimZ;

1215 unsigned int sharedMemBytes;

1216 hipStream_t hStream;

1217 void **kernelParams;

1218} hipFunctionLaunchParams;

1219typedef enum hipExternalMemoryHandleType_enum {

1220 hipExternalMemoryHandleTypeOpaqueFd = 1,

1221 hipExternalMemoryHandleTypeOpaqueWin32 = 2,

1222 hipExternalMemoryHandleTypeOpaqueWin32Kmt = 3,

1223 hipExternalMemoryHandleTypeD3D12Heap = 4,

1224 hipExternalMemoryHandleTypeD3D12Resource = 5,

1225 hipExternalMemoryHandleTypeD3D11Resource = 6,

1226 hipExternalMemoryHandleTypeD3D11ResourceKmt = 7,

1227 hipExternalMemoryHandleTypeNvSciBuf = 8

1228} hipExternalMemoryHandleType;

1229typedef struct hipExternalMemoryHandleDesc_st {

1230 hipExternalMemoryHandleType type;

1231 union {

1232 int fd;

1233 struct {

1234 void *handle;

1235 const void *name;

1236 } win32;

1237 const void *nvSciBufObject;

1238 } handle;

1239 unsigned long long size;

1240 unsigned int flags;

1241 unsigned int reserved[16];

1242} hipExternalMemoryHandleDesc;

1243typedef struct hipExternalMemoryBufferDesc_st {

1244 unsigned long long offset;

1245 unsigned long long size;

1246 unsigned int flags;

1247 unsigned int reserved[16];

1248} hipExternalMemoryBufferDesc;

1249typedef struct hipExternalMemoryMipmappedArrayDesc_st {

1250 unsigned long long offset;

1251 hipChannelFormatDesc formatDesc;

1252 hipExtent extent;

1253 unsigned int flags;

1254 unsigned int numLevels;

1255} hipExternalMemoryMipmappedArrayDesc;

1256typedef void* hipExternalMemory_t;

1257typedef enum hipExternalSemaphoreHandleType_enum {

1258 hipExternalSemaphoreHandleTypeOpaqueFd = 1,

1259 hipExternalSemaphoreHandleTypeOpaqueWin32 = 2,

1260 hipExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3,

1261 hipExternalSemaphoreHandleTypeD3D12Fence = 4,

1262 hipExternalSemaphoreHandleTypeD3D11Fence = 5,

1263 hipExternalSemaphoreHandleTypeNvSciSync = 6,

1264 hipExternalSemaphoreHandleTypeKeyedMutex = 7,

1265 hipExternalSemaphoreHandleTypeKeyedMutexKmt = 8,

1266 hipExternalSemaphoreHandleTypeTimelineSemaphoreFd = 9,

1267 hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = 10

1268} hipExternalSemaphoreHandleType;

1269typedef struct hipExternalSemaphoreHandleDesc_st {

1270 hipExternalSemaphoreHandleType type;

1271 union {

1272 int fd;

1273 struct {

1274 void* handle;

1275 const void* name;

1276 } win32;

1277 const void* NvSciSyncObj;

1278 } handle;

1279 unsigned int flags;

1280 unsigned int reserved[16];

1281} hipExternalSemaphoreHandleDesc;

1282typedef void* hipExternalSemaphore_t;

1283typedef struct hipExternalSemaphoreSignalParams_st {

1284 struct {

1285 struct {

1286 unsigned long long value;

1287 } fence;

1288 union {

1289 void *fence;

1290 unsigned long long reserved;

1291 } nvSciSync;

1292 struct {

1293 unsigned long long key;

1294 } keyedMutex;

1295 unsigned int reserved[12];

1296 } params;

1297 unsigned int flags;

1298 unsigned int reserved[16];

1299} hipExternalSemaphoreSignalParams;

1303typedef struct hipExternalSemaphoreWaitParams_st {

1304 struct {

1305 struct {

1306 unsigned long long value;

1307 } fence;

1308 union {

1309 void *fence;

1310 unsigned long long reserved;

1311 } nvSciSync;

1312 struct {

1313 unsigned long long key;

1314 unsigned int timeoutMs;

1315 } keyedMutex;

1316 unsigned int reserved[10];

1317 } params;

1318 unsigned int flags;

1319 unsigned int reserved[16];

1320} hipExternalSemaphoreWaitParams;

1321

1322#if __HIP_HAS_GET_PCH

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

1328#endif

1329

1333typedef enum hipGraphicsRegisterFlags {

1334 hipGraphicsRegisterFlagsNone = 0,

1335 hipGraphicsRegisterFlagsReadOnly = 1,

1336 hipGraphicsRegisterFlagsWriteDiscard =

1337 2,

1338 hipGraphicsRegisterFlagsSurfaceLoadStore = 4,

1339 hipGraphicsRegisterFlagsTextureGather =

1340 8

1341} hipGraphicsRegisterFlags;

1342

1343typedef struct _hipGraphicsResource hipGraphicsResource;

1344

1345typedef hipGraphicsResource* hipGraphicsResource_t;

1346

1350typedef struct ihipGraph* hipGraph_t;

1354typedef struct hipGraphNode* hipGraphNode_t;

1358typedef struct hipGraphExec* hipGraphExec_t;

1359

1363typedef struct hipUserObject* hipUserObject_t;

1364

1365

1369typedef enum hipGraphNodeType {

1370 hipGraphNodeTypeKernel = 0,

1371 hipGraphNodeTypeMemcpy = 1,

1372 hipGraphNodeTypeMemset = 2,

1373 hipGraphNodeTypeHost = 3,

1374 hipGraphNodeTypeGraph = 4,

1375 hipGraphNodeTypeEmpty = 5,

1376 hipGraphNodeTypeWaitEvent = 6,

1377 hipGraphNodeTypeEventRecord = 7,

1378 hipGraphNodeTypeExtSemaphoreSignal = 8,

1379 hipGraphNodeTypeExtSemaphoreWait = 9,

1380 hipGraphNodeTypeMemAlloc = 10,

1381 hipGraphNodeTypeMemFree = 11,

1382 hipGraphNodeTypeMemcpyFromSymbol = 12,

1383 hipGraphNodeTypeMemcpyToSymbol = 13,

1384 hipGraphNodeTypeBatchMemOp = 14,

1385 hipGraphNodeTypeCount

1386} hipGraphNodeType;

1387

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

1389typedef struct hipHostNodeParams {

1390 hipHostFn_t fn;

1391 void* userData;

1392} hipHostNodeParams;

1393typedef struct hipKernelNodeParams {

1394 dim3 blockDim;

1395 void** extra;

1396 void* func;

1397 dim3 gridDim;

1398 void** kernelParams;

1399 unsigned int sharedMemBytes;

1400} hipKernelNodeParams;

1401typedef struct hipMemsetParams {

1402 void* dst;

1403 unsigned int elementSize;

1404 size_t height;

1405 size_t pitch;

1406 unsigned int value;

1407 size_t width;

1408} hipMemsetParams;

1409

1410typedef struct hipMemAllocNodeParams {

1411 hipMemPoolProps poolProps;

1413 const hipMemAccessDesc* accessDescs;

1414 size_t accessDescCount;

1416 size_t bytesize;

1417 void* dptr;

1418} hipMemAllocNodeParams;

1419

1420

1421typedef enum hipAccessProperty {

1422 hipAccessPropertyNormal = 0,

1423 hipAccessPropertyStreaming = 1,

1424 hipAccessPropertyPersisting = 2,

1425} hipAccessProperty;

1426typedef struct hipAccessPolicyWindow {

1427 void* base_ptr;

1428 hipAccessProperty hitProp;

1429 float hitRatio;

1430 hipAccessProperty missProp;

1431 size_t num_bytes;

1432} hipAccessPolicyWindow;

1433

1437typedef enum hipLaunchAttributeID {

1438 hipLaunchAttributeAccessPolicyWindow = 1,

1439 hipLaunchAttributeCooperative = 2,

1440 hipLaunchAttributePriority = 8,

1441} hipLaunchAttributeID;

1442

1446typedef union hipLaunchAttributeValue {

1447 hipAccessPolicyWindow accessPolicyWindow;

1449 int cooperative;

1450 int priority;

1452} hipLaunchAttributeValue;

1453

1457#define hipKernelNodeAttrID hipLaunchAttributeID

1458#define hipKernelNodeAttributeAccessPolicyWindow hipLaunchAttributeAccessPolicyWindow

1459#define hipKernelNodeAttributeCooperative hipLaunchAttributeCooperative

1460#define hipKernelNodeAttributePriority hipLaunchAttributePriority

1461

1465#define hipKernelNodeAttrValue hipLaunchAttributeValue

1466

1470typedef struct HIP_MEMSET_NODE_PARAMS {

1471 hipDeviceptr_t dst;

1472 size_t pitch;

1473 unsigned int value;

1474 unsigned int elementSize;

1475 size_t width;

1476 size_t height;

1477} HIP_MEMSET_NODE_PARAMS;

1478

1482typedef enum hipGraphExecUpdateResult {

1483 hipGraphExecUpdateSuccess = 0x0,

1484 hipGraphExecUpdateError = 0x1,

1486 hipGraphExecUpdateErrorTopologyChanged = 0x2,

1487 hipGraphExecUpdateErrorNodeTypeChanged = 0x3,

1488 hipGraphExecUpdateErrorFunctionChanged =

1489 0x4,

1490 hipGraphExecUpdateErrorParametersChanged =

1491 0x5,

1492 hipGraphExecUpdateErrorNotSupported =

1493 0x6,

1494 hipGraphExecUpdateErrorUnsupportedFunctionChange = 0x7

1495} hipGraphExecUpdateResult;

1496

1497typedef enum hipStreamCaptureMode {

1498 hipStreamCaptureModeGlobal = 0,

1499 hipStreamCaptureModeThreadLocal,

1500 hipStreamCaptureModeRelaxed

1501} hipStreamCaptureMode;

1502typedef enum hipStreamCaptureStatus {

1503 hipStreamCaptureStatusNone = 0,

1504 hipStreamCaptureStatusActive,

1505 hipStreamCaptureStatusInvalidated

1507} hipStreamCaptureStatus;

1508

1509typedef enum hipStreamUpdateCaptureDependenciesFlags {

1510 hipStreamAddCaptureDependencies = 0,

1511 hipStreamSetCaptureDependencies,

1512} hipStreamUpdateCaptureDependenciesFlags;

1513

1514typedef enum hipGraphMemAttributeType {

1515 hipGraphMemAttrUsedMemCurrent = 0,

1516 hipGraphMemAttrUsedMemHigh,

1517 hipGraphMemAttrReservedMemCurrent,

1518 hipGraphMemAttrReservedMemHigh,

1519}hipGraphMemAttributeType;

1520typedef enum hipUserObjectFlags {

1521 hipUserObjectNoDestructorSync = 0x1,

1522} hipUserObjectFlags;

1523

1524typedef enum hipUserObjectRetainFlags {

1525 hipGraphUserObjectMove = 0x1,

1526} hipUserObjectRetainFlags;

1527

1528typedef enum hipGraphInstantiateFlags {

1529 hipGraphInstantiateFlagAutoFreeOnLaunch =

1530 1,

1531 hipGraphInstantiateFlagUpload =

1532 2,

1533 hipGraphInstantiateFlagDeviceLaunch =

1534 4,

1535 hipGraphInstantiateFlagUseNodePriority =

1536 8,

1537} hipGraphInstantiateFlags;

1538

1539enum hipGraphDebugDotFlags {

1540 hipGraphDebugDotFlagsVerbose = 1

1541 << 0,

1542 hipGraphDebugDotFlagsKernelNodeParams = 1 << 2,

1543 hipGraphDebugDotFlagsMemcpyNodeParams = 1 << 3,

1544 hipGraphDebugDotFlagsMemsetNodeParams = 1 << 4,

1545 hipGraphDebugDotFlagsHostNodeParams = 1 << 5,

1546 hipGraphDebugDotFlagsEventNodeParams = 1

1547 << 6,

1548 hipGraphDebugDotFlagsExtSemasSignalNodeParams = 1

1549 << 7,

1550 hipGraphDebugDotFlagsExtSemasWaitNodeParams = 1

1551 << 8,

1552 hipGraphDebugDotFlagsKernelNodeAttributes = 1

1553 << 9,

1554 hipGraphDebugDotFlagsHandles = 1

1555 << 10

1556};

1557

1561typedef enum hipGraphInstantiateResult {

1562 hipGraphInstantiateSuccess = 0,

1563 hipGraphInstantiateError = 1,

1565 hipGraphInstantiateInvalidStructure = 2,

1567 hipGraphInstantiateNodeOperationNotSupported = 3,

1569 hipGraphInstantiateMultipleDevicesNotSupported = 4,

1571}hipGraphInstantiateResult;

1572

1576typedef struct hipGraphInstantiateParams {

1577 hipGraphNode_t errNode_out;

1578 unsigned long long flags;

1579 hipGraphInstantiateResult result_out;

1581 hipStream_t uploadStream;

1582} hipGraphInstantiateParams;

1583

1584

1588typedef struct hipMemAllocationProp {

1589 hipMemAllocationType type;

1590 hipMemAllocationHandleType requestedHandleType;

1591 hipMemLocation location;

1592 void* win32HandleMetaData;

1593 struct {

1594 unsigned char compressionType;

1595 unsigned char gpuDirectRDMACapable;

1596 unsigned short usage;

1597 } allocFlags;

1598} hipMemAllocationProp;

1599

1603typedef struct hipExternalSemaphoreSignalNodeParams {

1605 hipExternalSemaphore_t* extSemArray;

1607 const hipExternalSemaphoreSignalParams* paramsArray;

1609 unsigned int numExtSems;

1610} hipExternalSemaphoreSignalNodeParams;

1611

1615typedef struct hipExternalSemaphoreWaitNodeParams {

1617 hipExternalSemaphore_t* extSemArray;

1619 const hipExternalSemaphoreWaitParams* paramsArray;

1621 unsigned int numExtSems;

1622} hipExternalSemaphoreWaitNodeParams;

1623

1627typedef struct ihipMemGenericAllocationHandle* hipMemGenericAllocationHandle_t;

1628

1632typedef enum hipMemAllocationGranularity_flags {

1633 hipMemAllocationGranularityMinimum = 0x0,

1634 hipMemAllocationGranularityRecommended = 0x1

1635} hipMemAllocationGranularity_flags;

1636

1640typedef enum hipMemHandleType {

1641 hipMemHandleTypeGeneric = 0x0

1642} hipMemHandleType;

1643

1647typedef enum hipMemOperationType {

1648 hipMemOperationTypeMap = 0x1,

1649 hipMemOperationTypeUnmap = 0x2

1650} hipMemOperationType;

1651

1655typedef enum hipArraySparseSubresourceType {

1656 hipArraySparseSubresourceTypeSparseLevel = 0x0,

1657 hipArraySparseSubresourceTypeMiptail = 0x1

1658} hipArraySparseSubresourceType;

1659

1663typedef struct hipArrayMapInfo {

1664 hipResourceType resourceType;

1665 union {

1666 hipMipmappedArray mipmap;

1667 hipArray_t array;

1668 } resource;

1669 hipArraySparseSubresourceType subresourceType;

1670 union {

1671 struct {

1672 unsigned int level;

1673 unsigned int layer;

1674 unsigned int offsetX;

1675 unsigned int offsetY;

1676 unsigned int offsetZ;

1677 unsigned int extentWidth;

1678 unsigned int extentHeight;

1679 unsigned int extentDepth;

1680 } sparseLevel;

1681 struct {

1682 unsigned int layer;

1683 unsigned long long offset;

1684 unsigned long long size;

1685 } miptail;

1686 } subresource;

1687 hipMemOperationType memOperationType;

1688 hipMemHandleType memHandleType;

1689 union {

1690 hipMemGenericAllocationHandle_t memHandle;

1691 } memHandle;

1692 unsigned long long offset;

1693 unsigned int deviceBitMask;

1694 unsigned int flags;

1695 unsigned int reserved[2];

1696} hipArrayMapInfo;

1697

1701typedef struct hipMemcpyNodeParams {

1702 int flags;

1703 int reserved[3];

1704 hipMemcpy3DParms copyParams;

1705} hipMemcpyNodeParams;

1706

1710typedef struct hipChildGraphNodeParams {

1711 hipGraph_t graph;

1713} hipChildGraphNodeParams;

1714

1718typedef struct hipEventWaitNodeParams {

1719 hipEvent_t event;

1720} hipEventWaitNodeParams;

1721

1725typedef struct hipEventRecordNodeParams {

1726 hipEvent_t event;

1727} hipEventRecordNodeParams;

1728

1732typedef struct hipMemFreeNodeParams {

1733 void *dptr;

1734} hipMemFreeNodeParams;

1735

1739typedef struct hipGraphNodeParams {

1740 hipGraphNodeType type;

1741 int reserved0[3];

1742 union {

1743 long long reserved1[29];

1744 hipKernelNodeParams kernel;

1745 hipMemcpyNodeParams memcpy;

1746 hipMemsetParams memset;

1747 hipHostNodeParams host;

1748 hipChildGraphNodeParams graph;

1749 hipEventWaitNodeParams eventWait;

1750 hipEventRecordNodeParams eventRecord;

1751 hipExternalSemaphoreSignalNodeParams extSemSignal;

1752 hipExternalSemaphoreWaitNodeParams extSemWait;

1753 hipMemAllocNodeParams alloc;

1754 hipMemFreeNodeParams free;

1755 };

1756

1757 long long reserved2;

1758} hipGraphNodeParams;

1759

1763#define hipGraphKernelNodePortDefault 0

1764

1768#define hipGraphKernelNodePortLaunchCompletion 2

1769

1775#define hipGraphKernelNodePortProgrammatic 1

1776

1777typedef enum hipGraphDependencyType {

1778 hipGraphDependencyTypeDefault = 0,

1779 hipGraphDependencyTypeProgrammatic = 1

1780}hipGraphDependencyType;

1781

1782typedef struct hipGraphEdgeData {

1783 unsigned char

1784 from_port;

1791 unsigned char reserved[5];

1792 unsigned char

1793 to_port;

1794 unsigned char type;

1795} hipGraphEdgeData;

1796

1797// Doxygen end group GlobalDefs

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

1824hipError_t hipInit(unsigned int flags);

1825

1843hipError_t hipDriverGetVersion(int* driverVersion);

1858hipError_t hipRuntimeGetVersion(int* runtimeVersion);

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

1867

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

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

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

1907hipError_t hipDeviceGetP2PAttribute(int* value, hipDeviceP2PAttr attr,

1908 int srcDevice, int dstDevice);

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

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

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

1934// doxygen end initialization

1953hipError_t hipDeviceSynchronize(void);

1965hipError_t hipDeviceReset(void);

1997hipError_t hipSetDevice(int deviceId);

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

2023hipError_t hipGetDevice(int* deviceId);

2036hipError_t hipGetDeviceCount(int* count);

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

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

2083hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool);

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

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

2132hipError_t hipDeviceGetTexture1DLinearMaxWidth(hipMemPool_t* mem_pool, int device);

2144hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig);

2155hipError_t hipDeviceGetCacheConfig(hipFuncCache_t* cacheConfig);

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

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

2201hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig* pConfig);

2209hipError_t hipGetDeviceFlags(unsigned int* flags);

2221hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config);

2253hipError_t hipSetDeviceFlags(unsigned flags);

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

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

2276// TODO: implement IPC apis

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

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

2345hipError_t hipIpcCloseMemHandle(void* devPtr);

2346

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

2365

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

2385

2386// end doxygen Device

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

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

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

2436//doxygen end execution

2458hipError_t hipGetLastError(void);

2459

2471hipError_t hipExtGetLastError(void);

2472

2483hipError_t hipPeekAtLastError(void);

2492const char* hipGetErrorName(hipError_t hip_error);

2501const char* hipGetErrorString(hipError_t hipError);

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

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

2522// end doxygen Error

2552hipError_t hipStreamCreate(hipStream_t* stream);

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

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

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

2620hipError_t hipStreamDestroy(hipStream_t stream);

2636hipError_t hipStreamQuery(hipStream_t stream);

2657hipError_t hipStreamSynchronize(hipStream_t stream);

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

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

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

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

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

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

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

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

2776 unsigned int flags);

2777// end doxygen Stream

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

2826 uint32_t mask __dparm(0xFFFFFFFF));

2827

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

2865 uint64_t mask __dparm(0xFFFFFFFFFFFFFFFF));

2866

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

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

2909

2929hipError_t hipStreamBatchMemOp(hipStream_t stream, unsigned int count,

2930 hipStreamBatchMemOpParams* paramArray, unsigned int flags);

2931

2949hipError_t hipGraphAddBatchMemOpNode(hipGraphNode_t *phGraphNode, hipGraph_t hGraph,

2950 const hipGraphNode_t *dependencies, size_t numDependencies,

2951 const hipBatchMemOpNodeParams* nodeParams);

2952

2973hipError_t hipGraphBatchMemOpNodeGetParams(hipGraphNode_t hNode,

2974 hipBatchMemOpNodeParams* nodeParams_out);

2975

2993hipError_t hipGraphBatchMemOpNodeSetParams(hipGraphNode_t hNode,

2994 hipBatchMemOpNodeParams* nodeParams);

2995

3015hipError_t hipGraphExecBatchMemOpNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

3016 const hipBatchMemOpNodeParams* nodeParams);

3017

3018// end doxygen Stream Memory Operations

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

3066hipError_t hipEventCreate(hipEvent_t* event);

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

3104 unsigned int flags __dparm(0));

3135#ifdef __cplusplus

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

3137#else

3138hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream);

3139#endif

3156hipError_t hipEventDestroy(hipEvent_t event);

3175hipError_t hipEventSynchronize(hipEvent_t event);

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

3221hipError_t hipEventQuery(hipEvent_t event);

3222// end doxygen Events

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

3254 hipDeviceptr_t ptr);

3255

3256

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

3291hipError_t hipPointerGetAttribute(void* data, hipPointer_attribute attribute,

3292 hipDeviceptr_t ptr);

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

3310 void** data, hipDeviceptr_t ptr);

3334hipError_t hipImportExternalSemaphore(hipExternalSemaphore_t* extSem_out,

3335 const hipExternalSemaphoreHandleDesc* semHandleDesc);

3351hipError_t hipSignalExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

3352 const hipExternalSemaphoreSignalParams* paramsArray,

3353 unsigned int numExtSems, hipStream_t stream);

3369hipError_t hipWaitExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

3370 const hipExternalSemaphoreWaitParams* paramsArray,

3371 unsigned int numExtSems, hipStream_t stream);

3384hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem);

3385

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

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

3419hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem);

3433hipError_t hipExternalMemoryGetMappedMipmappedArray(hipMipmappedArray_t* mipmap, hipExternalMemory_t extMem,

3434 const hipExternalMemoryMipmappedArrayDesc* mipmapDesc);

3435 // end of external resource

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

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

3473

3474

3497HIP_DEPRECATED("use hipHostMalloc instead")

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

3511HIP_DEPRECATED("use hipHostMalloc instead")

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

3513// end doxygen deprecated management memory

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

3584hipError_t hipMallocManaged(void** dev_ptr,

3585 size_t size,

3586 unsigned int flags __dparm(hipMemAttachGlobal));

3599hipError_t hipMemPrefetchAsync(const void* dev_ptr,

3600 size_t count,

3601 int device,

3602 hipStream_t stream __dparm(0));

3622hipError_t hipMemAdvise(const void* dev_ptr,

3623 size_t count,

3624 hipMemoryAdvise advice,

3625 int device);

3640hipError_t hipMemRangeGetAttribute(void* data,

3641 size_t data_size,

3642 hipMemRangeAttribute attribute,

3643 const void* dev_ptr,

3644 size_t count);

3661hipError_t hipMemRangeGetAttributes(void** data,

3662 size_t* data_sizes,

3663 hipMemRangeAttribute* attributes,

3664 size_t num_attributes,

3665 const void* dev_ptr,

3666 size_t count);

3682hipError_t hipStreamAttachMemAsync(hipStream_t stream,

3683 void* dev_ptr,

3684 size_t length __dparm(0),

3685 unsigned int flags __dparm(hipMemAttachSingle));

3686// end doxygen Managed Memory

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

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

3799hipError_t hipMemPoolTrimTo(hipMemPool_t mem_pool, size_t min_bytes_to_hold);

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

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

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

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

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

3966hipError_t hipMemPoolDestroy(hipMemPool_t mem_pool);

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

4027hipError_t hipMemPoolExportToShareableHandle(

4028 void* shared_handle,

4029 hipMemPool_t mem_pool,

4030 hipMemAllocationHandleType handle_type,

4031 unsigned int flags);

4055hipError_t hipMemPoolImportFromShareableHandle(

4056 hipMemPool_t* mem_pool,

4057 void* shared_handle,

4058 hipMemAllocationHandleType handle_type,

4059 unsigned int flags);

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

4108hipError_t hipMemPoolImportPointer(

4109 void** dev_ptr,

4110 hipMemPool_t mem_pool,

4111 hipMemPoolPtrExportData* export_data);

4112// Doxygen end of ordered memory allocator

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

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

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

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

4202hipError_t hipHostUnregister(void* hostPtr);

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

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

4245 unsigned int elementSizeBytes);

4259hipError_t hipFree(void* ptr);

4271hipError_t hipFreeHost(void* ptr);

4288hipError_t hipHostFree(void* ptr);

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

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

4334 hipMemcpyKind kind, hipStream_t stream);

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

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

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

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

4408 size_t ByteCount);

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

4428 size_t ByteCount);

4429

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

4450 size_t srcOffset, size_t ByteCount);

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

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

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

4508 hipStream_t stream);

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

4529 size_t ByteCount, hipStream_t stream);

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

4550 size_t ByteCount, hipStream_t stream);

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

4568 hipModule_t hmod, const char* name);

4569

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

4580

4581

4582

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

4593

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

4614 hipDriverProcAddressQueryResult* symbolStatus);

4615

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

4637 size_t sizeBytes, size_t offset __dparm(0),

4638 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice));

4639

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

4654 size_t sizeBytes, size_t offset,

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

4656

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

4670 size_t sizeBytes, size_t offset __dparm(0),

4671 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost));

4672

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

4687 size_t sizeBytes, size_t offset,

4688 hipMemcpyKind kind,

4689 hipStream_t stream __dparm(0));

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

4720 hipStream_t stream __dparm(0));

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

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

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

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

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

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

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

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

4825 hipStream_t stream __dparm(0));

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

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

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

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

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

4885

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

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

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

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

4932hipError_t hipArrayDestroy(hipArray_t array);

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

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

4963hipError_t hipFreeArray(hipArray_t array);

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

4976 struct hipExtent extent, unsigned int flags);

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

4990 hipArray_t array);

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

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

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

5044 size_t height, hipMemcpyKind kind);

5054hipError_t hipMemcpyParam2D(const hip_Memcpy2D* pCopy);

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

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

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

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

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

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

5123 size_t spitch, size_t width, size_t height, hipMemcpyKind kind,

5124 hipStream_t stream __dparm(0));

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

5144 hipArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc,

5145 size_t width, size_t height, hipMemcpyKind kind);

5164HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5166 size_t count, hipMemcpyKind kind);

5185HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5187 size_t count, hipMemcpyKind kind);

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

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

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

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

5263hipError_t hipMemcpy3D(const struct hipMemcpy3DParms* p);

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

5286hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D* pCopy);

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

5299// doxygen end Memory

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

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

5356hipError_t hipDeviceDisablePeerAccess(int peerDeviceId);

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

5370#ifndef USE_PEER_NON_UNIFIED

5371#define USE_PEER_NON_UNIFIED 1

5372#endif

5373#if USE_PEER_NON_UNIFIED == 1

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

5386 size_t sizeBytes);

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

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

5401#endif

5402// doxygen end PeerToPeer

5443HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5458HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5459hipError_t hipCtxDestroy(hipCtx_t ctx);

5473HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5474hipError_t hipCtxPopCurrent(hipCtx_t* ctx);

5488HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5489hipError_t hipCtxPushCurrent(hipCtx_t ctx);

5503HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5504hipError_t hipCtxSetCurrent(hipCtx_t ctx);

5518HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5519hipError_t hipCtxGetCurrent(hipCtx_t* ctx);

5533HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5534hipError_t hipCtxGetDevice(hipDevice_t* device);

5555HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5573HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5574hipError_t hipCtxGetCacheConfig(hipFuncCache_t* cacheConfig);

5591HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5592hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig);

5609HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5610hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config);

5627HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5628hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig* pConfig);

5643HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5644hipError_t hipCtxSynchronize(void);

5658HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5659hipError_t hipCtxGetFlags(unsigned int* flags);

5682HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5703HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5704hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx);

5705

5721HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5738HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5739hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev);

5754HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5769HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5770hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev);

5785HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5787// doxygen end Context Management

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

5824hipError_t hipModuleUnload(hipModule_t module);

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

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

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

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

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

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

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

5898 hipJitOption* options, void** optionValues);

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

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

5919 void** optionValues);

5920

5937hipError_t hipLinkAddFile(hipLinkState_t state, hipJitInputType type, const char* path, unsigned int numOptions,

5938 hipJitOption* options, void** optionValues);

5939

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

5955

5967hipError_t hipLinkCreate(unsigned int numOptions, hipJitOption* options,

5968 void** optionValues, hipLinkState_t* stateOut);

5977hipError_t hipLinkDestroy(hipLinkState_t state);

5978

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

6008 unsigned int gridDimZ, unsigned int blockDimX,

6009 unsigned int blockDimY, unsigned int blockDimZ,

6010 unsigned int sharedMemBytes, hipStream_t stream,

6011 void** kernelParams, void** extra);

6040hipError_t hipModuleLaunchCooperativeKernel(hipFunction_t f, unsigned int gridDimX,

6041 unsigned int gridDimY, unsigned int gridDimZ,

6042 unsigned int blockDimX, unsigned int blockDimY,

6043 unsigned int blockDimZ, unsigned int sharedMemBytes,

6044 hipStream_t stream, void** kernelParams);

6059hipError_t hipModuleLaunchCooperativeKernelMultiDevice(hipFunctionLaunchParams* launchParamsList,

6060 unsigned int numDevices,

6061 unsigned int flags);

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

6083 void** kernelParams, unsigned int sharedMemBytes,

6084 hipStream_t stream);

6096hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

6097 int numDevices, unsigned int flags);

6098

6099// Doxygen end group ModuleCooperativeG

6112hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

6113 int numDevices, unsigned int flags);

6114// doxygen end Module

6141//TODO - Match CUoccupancyB2DSize

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

6143 hipFunction_t f, size_t dynSharedMemPerBlk,

6144 int blockSizeLimit);

6160//TODO - Match CUoccupancyB2DSize

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

6162 hipFunction_t f, size_t dynSharedMemPerBlk,

6163 int blockSizeLimit, unsigned int flags);

6173hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(

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

6185hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

6196hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(

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

6208hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

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

6225 const void* f, size_t dynSharedMemPerBlk,

6226 int blockSizeLimit);

6227// doxygen end Occupancy

6241// TODO - expand descriptions:

6248HIP_DEPRECATED("use roctracer/rocTX instead")

6249hipError_t hipProfilerStart();

6256HIP_DEPRECATED("use roctracer/rocTX instead")

6257hipError_t hipProfilerStop();

6258// doxygen end profiler

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

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

6305hipError_t hipLaunchByPtr(const void* func);

6322hipError_t __hipPushCallConfiguration(dim3 gridDim,

6323 dim3 blockDim,

6324 size_t sharedMem __dparm(0),

6325 hipStream_t stream __dparm(0));

6345hipError_t __hipPopCallConfiguration(dim3 *gridDim,

6346 dim3 *blockDim,

6347 size_t *sharedMem,

6348 hipStream_t *stream);

6365hipError_t hipLaunchKernel(const void* function_address,

6366 dim3 numBlocks,

6367 dim3 dimBlocks,

6368 void** args,

6369 size_t sharedMemBytes __dparm(0),

6370 hipStream_t stream __dparm(0));

6371

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

6398

6406hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D* pCopy);

6407//TODO: Move this to hip_ext.h

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

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

6431 hipEvent_t startEvent, hipEvent_t stopEvent, int flags);

6432// doxygen end Clang launch

6458hipError_t hipCreateTextureObject(

6459 hipTextureObject_t* pTexObject,

6460 const hipResourceDesc* pResDesc,

6461 const hipTextureDesc* pTexDesc,

6462 const struct hipResourceViewDesc* pResViewDesc);

6463

6472hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject);

6473

6483hipError_t hipGetChannelDesc(

6484 hipChannelFormatDesc* desc,

6485 hipArray_const_t array);

6486

6496hipError_t hipGetTextureObjectResourceDesc(

6497 hipResourceDesc* pResDesc,

6498 hipTextureObject_t textureObject);

6499

6509hipError_t hipGetTextureObjectResourceViewDesc(

6510 struct hipResourceViewDesc* pResViewDesc,

6511 hipTextureObject_t textureObject);

6512

6522hipError_t hipGetTextureObjectTextureDesc(

6523 hipTextureDesc* pTexDesc,

6524 hipTextureObject_t textureObject);

6525

6537hipError_t hipTexObjectCreate(

6538 hipTextureObject_t* pTexObject,

6539 const HIP_RESOURCE_DESC* pResDesc,

6540 const HIP_TEXTURE_DESC* pTexDesc,

6541 const HIP_RESOURCE_VIEW_DESC* pResViewDesc);

6542

6551hipError_t hipTexObjectDestroy(

6552 hipTextureObject_t texObject);

6553

6563hipError_t hipTexObjectGetResourceDesc(

6564 HIP_RESOURCE_DESC* pResDesc,

6565 hipTextureObject_t texObject);

6566

6576hipError_t hipTexObjectGetResourceViewDesc(

6577 HIP_RESOURCE_VIEW_DESC* pResViewDesc,

6578 hipTextureObject_t texObject);

6579

6589hipError_t hipTexObjectGetTextureDesc(

6590 HIP_TEXTURE_DESC* pTexDesc,

6591 hipTextureObject_t texObject);

6592

6607hipError_t hipMallocMipmappedArray(

6608 hipMipmappedArray_t *mipmappedArray,

6609 const struct hipChannelFormatDesc* desc,

6610 struct hipExtent extent,

6611 unsigned int numLevels,

6612 unsigned int flags __dparm(0));

6613

6624hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray);

6625

6638hipError_t hipGetMipmappedArrayLevel(

6639 hipArray_t *levelArray,

6640 hipMipmappedArray_const_t mipmappedArray,

6641 unsigned int level);

6642

6654hipError_t hipMipmappedArrayCreate(

6655 hipMipmappedArray_t* pHandle,

6656 HIP_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc,

6657 unsigned int numMipmapLevels);

6658

6669hipError_t hipMipmappedArrayDestroy(hipMipmappedArray_t hMipmappedArray);

6670

6683hipError_t hipMipmappedArrayGetLevel(

6684 hipArray_t* pLevelArray,

6685 hipMipmappedArray_t hMipMappedArray,

6686 unsigned int level);

6687

6706HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6707hipError_t hipBindTextureToMipmappedArray(

6708 const textureReference* tex,

6709 hipMipmappedArray_const_t mipmappedArray,

6710 const hipChannelFormatDesc* desc);

6711

6722HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6723hipError_t hipGetTextureReference(

6724 const textureReference** texref,

6725 const void* symbol);

6726

6737HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6739

6751HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6753

6765HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6766hipError_t hipTexRefSetAddressMode(

6767 textureReference* texRef,

6768 int dim,

6769 enum hipTextureAddressMode am);

6782HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6783hipError_t hipTexRefSetArray(

6784 textureReference* tex,

6785 hipArray_const_t array,

6786 unsigned int flags);

6798HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6799hipError_t hipTexRefSetFilterMode(

6800 textureReference* texRef,

6801 enum hipTextureFilterMode fm);

6813HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6814hipError_t hipTexRefSetFlags(

6815 textureReference* texRef,

6816 unsigned int Flags);

6829HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6830hipError_t hipTexRefSetFormat(

6831 textureReference* texRef,

6832 hipArray_Format fmt,

6833 int NumPackedComponents);

6848HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6849hipError_t hipBindTexture(

6850 size_t* offset,

6851 const textureReference* tex,

6852 const void* devPtr,

6853 const hipChannelFormatDesc* desc,

6854 size_t size __dparm(UINT_MAX));

6871HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6872hipError_t hipBindTexture2D(

6873 size_t* offset,

6874 const textureReference* tex,

6875 const void* devPtr,

6876 const hipChannelFormatDesc* desc,

6877 size_t width,

6878 size_t height,

6879 size_t pitch);

6892HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6893hipError_t hipBindTextureToArray(

6894 const textureReference* tex,

6895 hipArray_const_t array,

6896 const hipChannelFormatDesc* desc);

6908HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6909hipError_t hipGetTextureAlignmentOffset(

6910 size_t* offset,

6911 const textureReference* texref);

6922HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6923hipError_t hipUnbindTexture(const textureReference* tex);

6935HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6936hipError_t hipTexRefGetAddress(

6937 hipDeviceptr_t* dev_ptr,

6938 const textureReference* texRef);

6951HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6952hipError_t hipTexRefGetAddressMode(

6953 enum hipTextureAddressMode* pam,

6954 const textureReference* texRef,

6955 int dim);

6967HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6968hipError_t hipTexRefGetFilterMode(

6969 enum hipTextureFilterMode* pfm,

6970 const textureReference* texRef);

6982HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6983hipError_t hipTexRefGetFlags(

6984 unsigned int* pFlags,

6985 const textureReference* texRef);

6998HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6999hipError_t hipTexRefGetFormat(

7000 hipArray_Format* pFormat,

7001 int* pNumChannels,

7002 const textureReference* texRef);

7014HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7015hipError_t hipTexRefGetMaxAnisotropy(

7016 int* pmaxAnsio,

7017 const textureReference* texRef);

7029HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7030hipError_t hipTexRefGetMipmapFilterMode(

7031 enum hipTextureFilterMode* pfm,

7032 const textureReference* texRef);

7044HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7045hipError_t hipTexRefGetMipmapLevelBias(

7046 float* pbias,

7047 const textureReference* texRef);

7060HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7061hipError_t hipTexRefGetMipmapLevelClamp(

7062 float* pminMipmapLevelClamp,

7063 float* pmaxMipmapLevelClamp,

7064 const textureReference* texRef);

7076HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7077hipError_t hipTexRefGetMipMappedArray(

7078 hipMipmappedArray_t* pArray,

7079 const textureReference* texRef);

7093HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7094hipError_t hipTexRefSetAddress(

7095 size_t* ByteOffset,

7096 textureReference* texRef,

7097 hipDeviceptr_t dptr,

7098 size_t bytes);

7112HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7113hipError_t hipTexRefSetAddress2D(

7114 textureReference* texRef,

7115 const HIP_ARRAY_DESCRIPTOR* desc,

7116 hipDeviceptr_t dptr,

7117 size_t Pitch);

7129HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7130hipError_t hipTexRefSetMaxAnisotropy(

7131 textureReference* texRef,

7132 unsigned int maxAniso);

7144HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7145hipError_t hipTexRefSetBorderColor(

7146 textureReference* texRef,

7147 float* pBorderColor);

7159HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7160hipError_t hipTexRefSetMipmapFilterMode(

7161 textureReference* texRef,

7162 enum hipTextureFilterMode fm);

7174HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7175hipError_t hipTexRefSetMipmapLevelBias(

7176 textureReference* texRef,

7177 float bias);

7190HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7191hipError_t hipTexRefSetMipmapLevelClamp(

7192 textureReference* texRef,

7193 float minMipMapLevelClamp,

7194 float maxMipMapLevelClamp);

7207HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7208hipError_t hipTexRefSetMipmappedArray(

7209 textureReference* texRef,

7210 struct hipMipmappedArray* mipmappedArray,

7211 unsigned int Flags);

7212

7213// doxygen end deprecated texture management

7218// doxygen end Texture management

7230// This group is for HIPrtc

7231

7232// doxygen end Runtime

7251const char* hipApiName(uint32_t id);

7260const char* hipKernelNameRef(const hipFunction_t f);

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

7279int hipGetStreamDeviceId(hipStream_t stream);

7280

7281// doxygen end Callback

7306hipError_t hipStreamBeginCapture(hipStream_t stream, hipStreamCaptureMode mode);

7307

7327hipError_t hipStreamBeginCaptureToGraph(hipStream_t stream, hipGraph_t graph,

7328 const hipGraphNode_t* dependencies,

7329 const hipGraphEdgeData* dependencyData,

7330 size_t numDependencies, hipStreamCaptureMode mode);

7331

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

7345

7359hipError_t hipStreamGetCaptureInfo(hipStream_t stream, hipStreamCaptureStatus* pCaptureStatus,

7360 unsigned long long* pId);

7361

7378hipError_t hipStreamGetCaptureInfo_v2(hipStream_t stream, hipStreamCaptureStatus* captureStatus_out,

7379 unsigned long long* id_out __dparm(0),

7380 hipGraph_t* graph_out __dparm(0),

7381 const hipGraphNode_t** dependencies_out __dparm(0),

7382 size_t* numDependencies_out __dparm(0));

7383

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

7397

7412hipError_t hipStreamUpdateCaptureDependencies(hipStream_t stream, hipGraphNode_t* dependencies,

7413 size_t numDependencies,

7414 unsigned int flags __dparm(0));

7415

7426hipError_t hipThreadExchangeStreamCaptureMode(hipStreamCaptureMode* mode);

7427

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

7441

7453hipError_t hipGraphDestroy(hipGraph_t graph);

7454

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

7469 const hipGraphNode_t* to, size_t numDependencies);

7470

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

7485 const hipGraphNode_t* to, size_t numDependencies);

7486

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

7505 size_t* numEdges);

7506

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

7524

7541hipError_t hipGraphGetRootNodes(hipGraph_t graph, hipGraphNode_t* pRootNodes,

7542 size_t* pNumRootNodes);

7543

7560hipError_t hipGraphNodeGetDependencies(hipGraphNode_t node, hipGraphNode_t* pDependencies,

7561 size_t* pNumDependencies);

7562

7580hipError_t hipGraphNodeGetDependentNodes(hipGraphNode_t node, hipGraphNode_t* pDependentNodes,

7581 size_t* pNumDependentNodes);

7582

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

7595

7606hipError_t hipGraphDestroyNode(hipGraphNode_t node);

7607

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

7620

7633hipError_t hipGraphNodeFindInClone(hipGraphNode_t* pNode, hipGraphNode_t originalNode,

7634 hipGraph_t clonedGraph);

7635

7652hipError_t hipGraphInstantiate(hipGraphExec_t* pGraphExec, hipGraph_t graph,

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

7654

7667hipError_t hipGraphInstantiateWithFlags(hipGraphExec_t* pGraphExec, hipGraph_t graph,

7668 unsigned long long flags);

7669

7681hipError_t hipGraphInstantiateWithParams(hipGraphExec_t* pGraphExec, hipGraph_t graph,

7682 hipGraphInstantiateParams *instantiateParams);

7693hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream);

7694

7705hipError_t hipGraphUpload(hipGraphExec_t graphExec, hipStream_t stream);

7706

7719hipError_t hipGraphAddNode(hipGraphNode_t *pGraphNode, hipGraph_t graph,

7720 const hipGraphNode_t *pDependencies, size_t numDependencies,

7721 hipGraphNodeParams *nodeParams);

7722

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

7733

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

7744

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

7756

7767hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec);

7768

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

7783hipError_t hipGraphExecUpdate(hipGraphExec_t hGraphExec, hipGraph_t hGraph,

7784 hipGraphNode_t* hErrorNode_out,

7785 hipGraphExecUpdateResult* updateResult_out);

7786

7799hipError_t hipGraphAddKernelNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7800 const hipGraphNode_t* pDependencies, size_t numDependencies,

7801 const hipKernelNodeParams* pNodeParams);

7802

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

7813

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

7824

7835hipError_t hipGraphExecKernelNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7836 const hipKernelNodeParams* pNodeParams);

7837

7851hipError_t hipDrvGraphAddMemcpyNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

7852 const hipGraphNode_t* dependencies,

7853 size_t numDependencies,

7854 const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);

7867hipError_t hipGraphAddMemcpyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7868 const hipGraphNode_t* pDependencies, size_t numDependencies,

7869 const hipMemcpy3DParms* pCopyParams);

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

7880

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

7891

7902hipError_t hipGraphKernelNodeSetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

7903 const hipKernelNodeAttrValue* value);

7914hipError_t hipGraphKernelNodeGetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

7915 hipKernelNodeAttrValue* value);

7926hipError_t hipGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7927 hipMemcpy3DParms* pNodeParams);

7928

7944hipError_t hipGraphAddMemcpyNode1D(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7945 const hipGraphNode_t* pDependencies, size_t numDependencies,

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

7947

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

7961 size_t count, hipMemcpyKind kind);

7962

7977hipError_t hipGraphExecMemcpyNodeSetParams1D(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

7979 hipMemcpyKind kind);

7980

7997hipError_t hipGraphAddMemcpyNodeFromSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7998 const hipGraphNode_t* pDependencies,

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

8000 size_t count, size_t offset, hipMemcpyKind kind);

8001

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

8016 size_t count, size_t offset, hipMemcpyKind kind);

8017

8033hipError_t hipGraphExecMemcpyNodeSetParamsFromSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

8035 size_t offset, hipMemcpyKind kind);

8036

8053hipError_t hipGraphAddMemcpyNodeToSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8054 const hipGraphNode_t* pDependencies,

8055 size_t numDependencies, const void* symbol,

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

8057 hipMemcpyKind kind);

8058

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

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

8074 hipMemcpyKind kind);

8075

8076

8091hipError_t hipGraphExecMemcpyNodeSetParamsToSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8092 const void* symbol, const void* src,

8093 size_t count, size_t offset, hipMemcpyKind kind);

8094

8107hipError_t hipGraphAddMemsetNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8108 const hipGraphNode_t* pDependencies, size_t numDependencies,

8109 const hipMemsetParams* pMemsetParams);

8110

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

8121

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

8132

8143hipError_t hipGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8144 const hipMemsetParams* pNodeParams);

8145

8158hipError_t hipGraphAddHostNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8159 const hipGraphNode_t* pDependencies, size_t numDependencies,

8160 const hipHostNodeParams* pNodeParams);

8161

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

8172

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

8183

8194hipError_t hipGraphExecHostNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8195 const hipHostNodeParams* pNodeParams);

8196

8209hipError_t hipGraphAddChildGraphNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8210 const hipGraphNode_t* pDependencies, size_t numDependencies,

8211 hipGraph_t childGraph);

8212

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

8223

8234hipError_t hipGraphExecChildGraphNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8235 hipGraph_t childGraph);

8236

8248hipError_t hipGraphAddEmptyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8249 const hipGraphNode_t* pDependencies, size_t numDependencies);

8250

8251

8264hipError_t hipGraphAddEventRecordNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8265 const hipGraphNode_t* pDependencies, size_t numDependencies,

8266 hipEvent_t event);

8267

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

8278

8288hipError_t hipGraphEventRecordNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

8289

8300hipError_t hipGraphExecEventRecordNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8301 hipEvent_t event);

8302

8315hipError_t hipGraphAddEventWaitNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8316 const hipGraphNode_t* pDependencies, size_t numDependencies,

8317 hipEvent_t event);

8318

8319

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

8330

8340hipError_t hipGraphEventWaitNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

8341

8352hipError_t hipGraphExecEventWaitNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8353 hipEvent_t event);

8354

8367hipError_t hipGraphAddMemAllocNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

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

8369

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

8380

8393hipError_t hipGraphAddMemFreeNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

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

8395

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

8406

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

8418

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

8430

8440hipError_t hipDeviceGraphMemTrim(int device);

8441

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

8455 unsigned int initialRefcount, unsigned int flags);

8456

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

8467

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

8478

8490hipError_t hipGraphRetainUserObject(hipGraph_t graph, hipUserObject_t object,

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

8492

8503hipError_t hipGraphReleaseUserObject(hipGraph_t graph, hipUserObject_t object,

8504 unsigned int count __dparm(1));

8505

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

8517

8532hipError_t hipGraphKernelNodeCopyAttributes(hipGraphNode_t hSrc, hipGraphNode_t hDst);

8533

8556hipError_t hipGraphNodeSetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8557 unsigned int isEnabled);

8578hipError_t hipGraphNodeGetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8579 unsigned int* isEnabled);

8580

8593hipError_t hipGraphAddExternalSemaphoresWaitNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8594 const hipGraphNode_t* pDependencies, size_t numDependencies,

8595 const hipExternalSemaphoreWaitNodeParams* nodeParams);

8596

8609hipError_t hipGraphAddExternalSemaphoresSignalNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8610 const hipGraphNode_t* pDependencies, size_t numDependencies,

8611 const hipExternalSemaphoreSignalNodeParams* nodeParams);

8621hipError_t hipGraphExternalSemaphoresSignalNodeSetParams(hipGraphNode_t hNode,

8622 const hipExternalSemaphoreSignalNodeParams* nodeParams);

8632hipError_t hipGraphExternalSemaphoresWaitNodeSetParams(hipGraphNode_t hNode,

8633 const hipExternalSemaphoreWaitNodeParams* nodeParams);

8643hipError_t hipGraphExternalSemaphoresSignalNodeGetParams(hipGraphNode_t hNode,

8644 hipExternalSemaphoreSignalNodeParams* params_out);

8654hipError_t hipGraphExternalSemaphoresWaitNodeGetParams(hipGraphNode_t hNode,

8655 hipExternalSemaphoreWaitNodeParams* params_out);

8666hipError_t hipGraphExecExternalSemaphoresSignalNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8667 const hipExternalSemaphoreSignalNodeParams* nodeParams);

8678hipError_t hipGraphExecExternalSemaphoresWaitNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8679 const hipExternalSemaphoreWaitNodeParams* nodeParams);

8680

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

8691

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

8702

8716hipError_t hipDrvGraphAddMemsetNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

8717 const hipGraphNode_t* dependencies, size_t numDependencies,

8718 const HIP_MEMSET_NODE_PARAMS* memsetParams, hipCtx_t ctx);

8719

8732hipError_t hipDrvGraphAddMemFreeNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

8733 const hipGraphNode_t* dependencies, size_t numDependencies,

8734 hipDeviceptr_t dptr);

8735

8747hipError_t hipDrvGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8748 const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);

8749

8761hipError_t hipDrvGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8762 const HIP_MEMSET_NODE_PARAMS* memsetParams, hipCtx_t ctx);

8763

8764// doxygen end graph API

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

8796

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

8812

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

8827

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

8842

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

8856

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

8871

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

8884

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

8898

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

8914

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

8926

8937hipError_t hipMemRelease(hipMemGenericAllocationHandle_t handle);

8938

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

8951

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

8966

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

8979

8980// doxygen end virtual memory management API

9002hipError_t hipGraphicsMapResources(int count, hipGraphicsResource_t* resources,

9003 hipStream_t stream __dparm(0) );

9017hipError_t hipGraphicsSubResourceGetMappedArray(hipArray_t* array, hipGraphicsResource_t resource,

9018 unsigned int arrayIndex, unsigned int mipLevel);

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

9030 hipGraphicsResource_t resource);

9041hipError_t hipGraphicsUnmapResources(int count, hipGraphicsResource_t* resources,

9042 hipStream_t stream __dparm(0));

9051hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource);

9052// doxygen end GraphicsInterop

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

9086hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject);

9087// end of surface

9091#ifdef __cplusplus

9092} /* extern "c" */

9093#endif

9094#ifdef __cplusplus

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

9096template <typename T>

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

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

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

9100}

9101template <typename T>

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

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

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

9105}

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

9107

9117template <typename T>

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

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

9120}

9131template <typename T>

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

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

9134}

9135

9144template <typename T>

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

9146 size_t offset __dparm(0),

9147 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice)) {

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

9149}

9158template <typename T>

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

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

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

9162}

9170template <typename T>

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

9172 size_t sizeBytes, size_t offset __dparm(0),

9173 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost)) {

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

9175}

9183template <typename T>

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

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

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

9187}

9188

9200template <class T>

9201inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(

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

9203 return hipOccupancyMaxActiveBlocksPerMultiprocessor(

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

9205}

9219template <class T>

9220inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

9222 return hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

9224}

9245template<typename UnaryFunction, class T>

9246static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(

9247 int* min_grid_size,

9248 int* block_size,

9249 T func,

9250 UnaryFunction block_size_to_dynamic_smem_size,

9251 int block_size_limit = 0,

9252 unsigned int flags = 0) {

9253 if (min_grid_size == nullptr || block_size == nullptr ||

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

9255 return hipErrorInvalidValue;

9256 }

9257

9258 int dev;

9259 hipError_t status;

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

9261 return status;

9262 }

9263

9264 int max_threads_per_cu;

9265 if ((status = hipDeviceGetAttribute(&max_threads_per_cu,

9266 hipDeviceAttributeMaxThreadsPerMultiProcessor, dev)) != hipSuccess) {

9267 return status;

9268 }

9269

9270 int warp_size;

9271 if ((status = hipDeviceGetAttribute(&warp_size,

9272 hipDeviceAttributeWarpSize, dev)) != hipSuccess) {

9273 return status;

9274 }

9275

9276 int max_cu_count;

9277 if ((status = hipDeviceGetAttribute(&max_cu_count,

9278 hipDeviceAttributeMultiprocessorCount, dev)) != hipSuccess) {

9279 return status;

9280 }

9281

9282 struct hipFuncAttributes attr;

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

9284 return status;

9285 }

9286

9287 // Initial limits for the execution

9288 const int func_max_threads_per_block = attr.maxThreadsPerBlock;

9289 if (block_size_limit == 0) {

9290 block_size_limit = func_max_threads_per_block;

9291 }

9292

9293 if (func_max_threads_per_block < block_size_limit) {

9294 block_size_limit = func_max_threads_per_block;

9295 }

9296

9297 const int block_size_limit_aligned =

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

9299

9300 // For maximum search

9301 int max_threads = 0;

9302 int max_block_size{};

9303 int max_num_blocks{};

9304 for (int block_size_check_aligned = block_size_limit_aligned;

9305 block_size_check_aligned > 0;

9306 block_size_check_aligned -= warp_size) {

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

9308 int block_size_check = (block_size_limit < block_size_check_aligned) ?

9309 block_size_limit : block_size_check_aligned;

9310

9311 size_t dyn_smem_size = block_size_to_dynamic_smem_size(block_size_check);

9312 int optimal_blocks;

9313 if ((status = hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

9315 return status;

9316 }

9317

9318 int total_threads = block_size_check * optimal_blocks;

9319 if (total_threads > max_threads) {

9320 max_block_size = block_size_check;

9321 max_num_blocks = optimal_blocks;

9322 max_threads = total_threads;

9323 }

9324

9325 // Break if the logic reached possible maximum

9326 if (max_threads_per_cu == max_threads) {

9327 break;

9328 }

9329 }

9330

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

9332 *min_grid_size = max_num_blocks * max_cu_count;

9333 *block_size = max_block_size;

9334

9335 return status;

9336}

9337

9357template<typename UnaryFunction, class T>

9358static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMem(

9359 int* min_grid_size,

9360 int* block_size,

9361 T func,

9362 UnaryFunction block_size_to_dynamic_smem_size,

9363 int block_size_limit = 0)

9364{

9365 return hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(min_grid_size, block_size, func,

9366 block_size_to_dynamic_smem_size, block_size_limit);

9367}

9382template <typename F>

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

9384 F kernel, size_t dynSharedMemPerBlk, uint32_t blockSizeLimit) {

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

9386}

9408template <class T>

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

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

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

9412 blockDim, kernelParams, sharedMemBytes, stream);

9413}

9429template <class T>

9430inline hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

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

9432 return hipLaunchCooperativeKernelMultiDevice(launchParamsList, numDevices, flags);

9433}

9445template <class T>

9446inline hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

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

9448 return hipExtLaunchMultiKernelMultiDevice(launchParamsList, numDevices, flags);

9449}

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

9464HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

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

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

9468}

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

9484HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9485static inline hipError_t

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

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

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

9489}

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

9506HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9507static inline hipError_t hipBindTexture2D(

9508 size_t *offset,

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

9510 const void *devPtr,

9511 size_t width,

9512 size_t height,

9513 size_t pitch)

9514{

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

9516}

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

9534HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9535static inline hipError_t hipBindTexture2D(

9536 size_t *offset,

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

9538 const void *devPtr,

9539 const struct hipChannelFormatDesc &desc,

9540 size_t width,

9541 size_t height,

9542 size_t pitch)

9543{

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

9545}

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

9558HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9559static inline hipError_t hipBindTextureToArray(

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

9561 hipArray_const_t array)

9562{

9563 struct hipChannelFormatDesc desc;

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

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

9566}

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

9580HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9581static inline hipError_t hipBindTextureToArray(

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

9583 hipArray_const_t array,

9584 const struct hipChannelFormatDesc &desc)

9585{

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

9587}

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

9600HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9601static inline hipError_t hipBindTextureToMipmappedArray(

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

9603 hipMipmappedArray_const_t mipmappedArray)

9604{

9605 struct hipChannelFormatDesc desc;

9606 hipArray_t levelArray;

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

9608 if (err != hipSuccess) {

9609 return err;

9610 }

9611 err = hipGetChannelDesc(&desc, levelArray);

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

9613}

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

9627HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9628static inline hipError_t hipBindTextureToMipmappedArray(

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

9630 hipMipmappedArray_const_t mipmappedArray,

9631 const struct hipChannelFormatDesc &desc)

9632{

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

9634}

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

9646HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9647static inline hipError_t hipUnbindTexture(

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

9649{

9650 return hipUnbindTexture(&tex);

9651}

9675static inline hipError_t hipMallocAsync(

9676 void** dev_ptr,

9677 size_t size,

9678 hipMemPool_t mem_pool,

9679 hipStream_t stream) {

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

9681}

9692template<class T>

9693static inline hipError_t hipMallocAsync(

9694 T** dev_ptr,

9695 size_t size,

9696 hipMemPool_t mem_pool,

9697 hipStream_t stream) {

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

9699}

9710template<class T>

9711static inline hipError_t hipMallocAsync(

9712 T** dev_ptr,

9713 size_t size,

9714 hipStream_t stream) {

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

9716}

9727template<class T>

9728static inline hipError_t hipMallocFromPoolAsync(

9729 T** dev_ptr,

9730 size_t size,

9731 hipMemPool_t mem_pool,

9732 hipStream_t stream) {

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

9734}

9740#endif // __cplusplus

9741

9742#ifdef __GNUC__

9743#pragma GCC visibility pop

9744#endif

9745

9746

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

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

9749#else

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

9751#endif

9752

9753

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

9766template <class T>

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

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

9769}

9781template <class T>

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

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

9784}

9797template <class T>

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

9799 unsigned int flags = hipHostMallocDefault) {

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

9801}

9814template <class T>

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

9816 unsigned int flags = hipHostAllocDefault) {

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

9818}

9833template <class T>

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

9835 unsigned int flags = hipMemAttachGlobal) {

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

9837}

9838

9839

9840#endif

9841#endif

9842// doxygen end HIP API

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

9847

9848#if USE_PROF_API

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

9850#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 to the flags passed.

hipDeviceGetAttribute

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

Query for a specific device attribute.

hipGetDevice

hipError_t hipGetDevice(int *deviceId)

Return the default device id for the calling host thread.

hipGetDeviceCount

hipError_t hipGetDeviceCount(int *count)

Return number of compute-capable devices.

hipDeviceGetMemPool

hipError_t hipDeviceGetMemPool(hipMemPool_t *mem_pool, int device)

Gets the current memory pool for the specified device.

hipDeviceReset

hipError_t hipDeviceReset(void)

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

hipDeviceGetLimit

hipError_t hipDeviceGetLimit(size_t *pValue, enum hipLimit_t limit)

Gets resource limits of current device.

hipDeviceSetSharedMemConfig

hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config)

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

hipDeviceSetLimit

hipError_t hipDeviceSetLimit(enum hipLimit_t limit, size_t value)

Sets resource limits of current device.

hipDeviceSetCacheConfig

hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig)

Set L1/Shared cache partition.

hipIpcCloseMemHandle

hipError_t hipIpcCloseMemHandle(void *devPtr)

Close memory mapped with hipIpcOpenMemHandle.

hipSetValidDevices

hipError_t hipSetValidDevices(int *device_arr, int len)

Set a list of devices that can be used.

hipIpcOpenEventHandle

hipError_t hipIpcOpenEventHandle(hipEvent_t *event, hipIpcEventHandle_t handle)

Opens an interprocess event handle.

hipDeviceSynchronize

hipError_t hipDeviceSynchronize(void)

Waits on all active streams on current device.

hipDeviceGetTexture1DLinearMaxWidth

hipError_t hipDeviceGetTexture1DLinearMaxWidth(hipMemPool_t *mem_pool, int device)

Gets the maximum width for 1D linear textures on the specified 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.

hipEventRecordWithFlags

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

Record an event in the specified stream.

hipEventRecord

hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream=NULL)

Record an event in the specified stream.

hipEventElapsedTime

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

Return the elapsed time between two events.

hipEventCreateWithFlags

hipError_t hipEventCreateWithFlags(hipEvent_t *event, unsigned flags)

Create an event with the specified flags.

hipFuncGetAttributes

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

Find out attributes for a given function.

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

hipFuncSetSharedMemConfig

hipError_t hipFuncSetSharedMemConfig(const void *func, hipSharedMemConfig config)

Set shared memory configuation for a specific function.

hipFuncGetAttribute

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

Find out a specific attribute for a given function.

hipFuncSetAttribute

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

Set attribute for a specific function.

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.

hipLimit_t

hipLimit_t

Definition hip_runtime_api.h:658

hipMemAllocationHandleType

hipMemAllocationHandleType

Definition hip_runtime_api.h:1128

hipGraphicsResource_t

hipGraphicsResource * hipGraphicsResource_t

Definition hip_runtime_api.h:1345

hipCtx_t

struct ihipCtx_t * hipCtx_t

Definition hip_runtime_api.h:612

__dparm

#define __dparm(x)

Definition hip_runtime_api.h:593

hipStream_t

struct ihipStream_t * hipStream_t

Definition hip_runtime_api.h:621

hipGraphInstantiateResult

hipGraphInstantiateResult

Definition hip_runtime_api.h:1561

hipDevice_t

int hipDevice_t

Definition hip_runtime_api.h:614

hipAccessProperty

hipAccessProperty

Definition hip_runtime_api.h:1421

hipLinkState_t

struct ihipLinkState_t * hipLinkState_t

Definition hip_runtime_api.h:632

hipGraphDependencyType

hipGraphDependencyType

Definition hip_runtime_api.h:1777

hipMemRangeAttribute

hipMemRangeAttribute

Definition hip_runtime_api.h:1007

hipMemAttachSingle

#define hipMemAttachSingle

Definition hip_runtime_api.h:777

hipMemoryAdvise

hipMemoryAdvise

Definition hip_runtime_api.h:974

hipArrayDefault

#define hipArrayDefault

Definition hip_runtime_api.h:828

hipSharedMemConfig

hipSharedMemConfig

Definition hip_runtime_api.h:1175

hipKernelNodeAttrValue

#define hipKernelNodeAttrValue

Definition hip_runtime_api.h:1465

hipComputeMode

hipComputeMode

Definition hip_runtime_api.h:554

hipEvent_t

struct ihipEvent_t * hipEvent_t

Definition hip_runtime_api.h:650

hipStreamCaptureMode

hipStreamCaptureMode

Definition hip_runtime_api.h:1497

hipStreamBatchMemOpType

hipStreamBatchMemOpType

Definition hip_runtime_api.h:849

hipDriverProcAddressQueryResult

hipDriverProcAddressQueryResult

Definition hip_runtime_api.h:548

HIP_DEPRECATED_MSG

#define HIP_DEPRECATED_MSG

Definition hip_runtime_api.h:588

hipLaunchAttributeID

hipLaunchAttributeID

Definition hip_runtime_api.h:1437

hipGraphNodeType

hipGraphNodeType

Definition hip_runtime_api.h:1369

hipExternalMemoryHandleType

hipExternalMemoryHandleType

Definition hip_runtime_api.h:1219

hipMemAttachGlobal

#define hipMemAttachGlobal

Definition hip_runtime_api.h:771

hipFuncAttribute

hipFuncAttribute

Definition hip_runtime_api.h:1158

hipExternalSemaphoreHandleType

hipExternalSemaphoreHandleType

Definition hip_runtime_api.h:1257

hipDeviceP2PAttr

hipDeviceP2PAttr

Definition hip_runtime_api.h:615

hipGraphDebugDotFlags

hipGraphDebugDotFlags

Definition hip_runtime_api.h:1539

hipUserObjectRetainFlags

hipUserObjectRetainFlags

Definition hip_runtime_api.h:1524

hipError_t

enum __HIP_NODISCARD hipError_t hipError_t

Definition hip_runtime_api.h:291

hipHostAllocDefault

#define hipHostAllocDefault

Definition hip_runtime_api.h:725

hipHostFn_t

void(* hipHostFn_t)(void *userData)

Definition hip_runtime_api.h:1388

hipOccupancyDefault

#define hipOccupancyDefault

Definition hip_runtime_api.h:833

hipStreamUpdateCaptureDependenciesFlags

hipStreamUpdateCaptureDependenciesFlags

Definition hip_runtime_api.h:1509

hipGraph_t

struct ihipGraph * hipGraph_t

Definition hip_runtime_api.h:1350

hipChooseDevice

#define hipChooseDevice

Definition hip_runtime_api.h:94

hipMemHandleType

hipMemHandleType

Definition hip_runtime_api.h:1640

hipFlushGPUDirectRDMAWritesOptions

hipFlushGPUDirectRDMAWritesOptions

Definition hip_runtime_api.h:561

hipFuncCache_t

hipFuncCache_t

Definition hip_runtime_api.h:1166

hipUserObjectFlags

hipUserObjectFlags

Definition hip_runtime_api.h:1520

__HIP_NODISCARD

#define __HIP_NODISCARD

Definition hip_runtime_api.h:281

hipGraphMemAttributeType

hipGraphMemAttributeType

Definition hip_runtime_api.h:1514

hipMemPoolAttr

hipMemPoolAttr

Definition hip_runtime_api.h:1023

hipDeviceProp_t

#define hipDeviceProp_t

Definition hip_runtime_api.h:93

hipModule_t

struct ihipModule_t * hipModule_t

Definition hip_runtime_api.h:630

hipUserObject_t

struct hipUserObject * hipUserObject_t

Definition hip_runtime_api.h:1363

hipMemOperationType

hipMemOperationType

Definition hip_runtime_api.h:1647

hipExternalSemaphore_t

void * hipExternalSemaphore_t

Definition hip_runtime_api.h:1282

hipGraphicsRegisterFlags

hipGraphicsRegisterFlags

Definition hip_runtime_api.h:1333

hipMemRangeCoherencyMode

hipMemRangeCoherencyMode

Definition hip_runtime_api.h:995

hipMemAccessFlags

hipMemAccessFlags

Definition hip_runtime_api.h:1098

hipMemAllocationGranularity_flags

hipMemAllocationGranularity_flags

Definition hip_runtime_api.h:1632

hipGraphExec_t

struct hipGraphExec * hipGraphExec_t

Definition hip_runtime_api.h:1358

hipGraphExecUpdateResult

hipGraphExecUpdateResult

Definition hip_runtime_api.h:1482

hipFunction_t

struct ihipModuleSymbol_t * hipFunction_t

Definition hip_runtime_api.h:631

hipKernelNodeAttrID

#define hipKernelNodeAttrID

Definition hip_runtime_api.h:1457

hipExternalMemory_t

void * hipExternalMemory_t

Definition hip_runtime_api.h:1256

hipStreamCaptureStatus

hipStreamCaptureStatus

Definition hip_runtime_api.h:1502

hipDeviceAttribute_t

hipDeviceAttribute_t

Definition hip_runtime_api.h:413

hipGPUDirectRDMAWritesOrdering

hipGPUDirectRDMAWritesOrdering

Definition hip_runtime_api.h:566

hipGetDeviceProperties

#define hipGetDeviceProperties

Definition hip_runtime_api.h:92

hipHostMallocDefault

#define hipHostMallocDefault

Definition hip_runtime_api.h:729

HIP_DEPRECATED

#define HIP_DEPRECATED(msg)

Definition hip_runtime_api.h:586

hipGraphicsResource

struct _hipGraphicsResource hipGraphicsResource

Definition hip_runtime_api.h:1343

hipMemAllocationType

hipMemAllocationType

Definition hip_runtime_api.h:1116

hipGraphNode_t

struct hipGraphNode * hipGraphNode_t

Definition hip_runtime_api.h:1354

hipMemGenericAllocationHandle_t

struct ihipMemGenericAllocationHandle * hipMemGenericAllocationHandle_t

Definition hip_runtime_api.h:1627

hipMemoryType

hipMemoryType

Definition hip_runtime_api.h:249

hipGraphInstantiateFlags

hipGraphInstantiateFlags

Definition hip_runtime_api.h:1528

hipMemLocationType

hipMemLocationType

Definition hip_runtime_api.h:1081

HIP_IPC_HANDLE_SIZE

#define HIP_IPC_HANDLE_SIZE

Definition hip_runtime_api.h:623

hipMemPool_t

struct ihipMemPoolHandle_t * hipMemPool_t

Definition hip_runtime_api.h:636

hipArraySparseSubresourceType

hipArraySparseSubresourceType

Definition hip_runtime_api.h:1655

hipLimitMallocHeapSize

@ hipLimitMallocHeapSize

Definition hip_runtime_api.h:664

hipLimitStackSize

@ hipLimitStackSize

Definition hip_runtime_api.h:659

hipLimitRange

@ hipLimitRange

Supported limit range.

Definition hip_runtime_api.h:666

hipLimitPrintfFifoSize

@ hipLimitPrintfFifoSize

Definition hip_runtime_api.h:662

hipMemHandleTypeWin32

@ hipMemHandleTypeWin32

Allows a Win32 NT handle for exporting. (HANDLE)

Definition hip_runtime_api.h:1131

hipMemHandleTypeWin32Kmt

@ hipMemHandleTypeWin32Kmt

Allows a Win32 KMT handle for exporting. (D3DKMT_HANDLE)

Definition hip_runtime_api.h:1132

hipMemHandleTypeNone

@ hipMemHandleTypeNone

Does not allow any export mechanism.

Definition hip_runtime_api.h:1129

hipMemHandleTypePosixFileDescriptor

@ hipMemHandleTypePosixFileDescriptor

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

Definition hip_runtime_api.h:1130

hipGraphInstantiateNodeOperationNotSupported

@ hipGraphInstantiateNodeOperationNotSupported

Definition hip_runtime_api.h:1567

hipGraphInstantiateMultipleDevicesNotSupported

@ hipGraphInstantiateMultipleDevicesNotSupported

Definition hip_runtime_api.h:1569

hipGraphInstantiateError

@ hipGraphInstantiateError

Definition hip_runtime_api.h:1563

hipGraphInstantiateInvalidStructure

@ hipGraphInstantiateInvalidStructure

Definition hip_runtime_api.h:1565

hipGraphInstantiateSuccess

@ hipGraphInstantiateSuccess

Definition hip_runtime_api.h:1562

hipAccessPropertyNormal

@ hipAccessPropertyNormal

Definition hip_runtime_api.h:1422

hipAccessPropertyPersisting

@ hipAccessPropertyPersisting

Definition hip_runtime_api.h:1424

hipAccessPropertyStreaming

@ hipAccessPropertyStreaming

Definition hip_runtime_api.h:1423

hipGraphDependencyTypeDefault

@ hipGraphDependencyTypeDefault

Definition hip_runtime_api.h:1778

hipGraphDependencyTypeProgrammatic

@ hipGraphDependencyTypeProgrammatic

Definition hip_runtime_api.h:1779

hipMemRangeAttributeLastPrefetchLocation

@ hipMemRangeAttributeLastPrefetchLocation

prefetched

Definition hip_runtime_api.h:1013

hipMemRangeAttributePreferredLocation

@ hipMemRangeAttributePreferredLocation

The preferred location of the range.

Definition hip_runtime_api.h:1010

hipMemRangeAttributeAccessedBy

@ hipMemRangeAttributeAccessedBy

Definition hip_runtime_api.h:1011

hipMemRangeAttributeReadMostly

@ hipMemRangeAttributeReadMostly

Definition hip_runtime_api.h:1008

hipMemRangeAttributeCoherencyMode

@ hipMemRangeAttributeCoherencyMode

Definition hip_runtime_api.h:1015

hipMemAdviseUnsetAccessedBy

@ hipMemAdviseUnsetAccessedBy

Definition hip_runtime_api.h:983

hipMemAdviseUnsetCoarseGrain

@ hipMemAdviseUnsetCoarseGrain

Restores cache coherency policy back to fine-grain.

Definition hip_runtime_api.h:990

hipMemAdviseSetCoarseGrain

@ hipMemAdviseSetCoarseGrain

Definition hip_runtime_api.h:985

hipMemAdviseUnsetPreferredLocation

@ hipMemAdviseUnsetPreferredLocation

Clear the preferred location for the data.

Definition hip_runtime_api.h:980

hipMemAdviseSetAccessedBy

@ hipMemAdviseSetAccessedBy

Definition hip_runtime_api.h:981

hipMemAdviseSetPreferredLocation

@ hipMemAdviseSetPreferredLocation

Definition hip_runtime_api.h:978

hipMemAdviseSetReadMostly

@ hipMemAdviseSetReadMostly

Definition hip_runtime_api.h:975

hipMemAdviseUnsetReadMostly

@ hipMemAdviseUnsetReadMostly

Undo the effect of hipMemAdviseSetReadMostly.

Definition hip_runtime_api.h:977

hipSharedMemBankSizeFourByte

@ hipSharedMemBankSizeFourByte

Definition hip_runtime_api.h:1177

hipSharedMemBankSizeEightByte

@ hipSharedMemBankSizeEightByte

Definition hip_runtime_api.h:1179

hipSharedMemBankSizeDefault

@ hipSharedMemBankSizeDefault

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

Definition hip_runtime_api.h:1176

hipComputeModeProhibited

@ hipComputeModeProhibited

Definition hip_runtime_api.h:557

hipComputeModeExclusive

@ hipComputeModeExclusive

Definition hip_runtime_api.h:556

hipComputeModeDefault

@ hipComputeModeDefault

Definition hip_runtime_api.h:555

hipComputeModeExclusiveProcess

@ hipComputeModeExclusiveProcess

Definition hip_runtime_api.h:558

hipStreamCaptureModeRelaxed

@ hipStreamCaptureModeRelaxed

Definition hip_runtime_api.h:1500

hipStreamCaptureModeThreadLocal

@ hipStreamCaptureModeThreadLocal

Definition hip_runtime_api.h:1499

hipStreamCaptureModeGlobal

@ hipStreamCaptureModeGlobal

Definition hip_runtime_api.h:1498

hipStreamMemOpWriteValue64

@ hipStreamMemOpWriteValue64

Definition hip_runtime_api.h:853

hipStreamMemOpBarrier

@ hipStreamMemOpBarrier

Currently not supported.

Definition hip_runtime_api.h:854

hipStreamMemOpWriteValue32

@ hipStreamMemOpWriteValue32

Definition hip_runtime_api.h:851

hipStreamMemOpWaitValue32

@ hipStreamMemOpWaitValue32

Definition hip_runtime_api.h:850

hipStreamMemOpWaitValue64

@ hipStreamMemOpWaitValue64

Definition hip_runtime_api.h:852

hipStreamMemOpFlushRemoteWrites

@ hipStreamMemOpFlushRemoteWrites

Currently not supported.

Definition hip_runtime_api.h:855

HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND

@ HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND

Definition hip_runtime_api.h:550

HIP_GET_PROC_ADDRESS_SUCCESS

@ HIP_GET_PROC_ADDRESS_SUCCESS

Definition hip_runtime_api.h:549

HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT

@ HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT

Definition hip_runtime_api.h:551

hipLaunchAttributePriority

@ hipLaunchAttributePriority

Definition hip_runtime_api.h:1440

hipLaunchAttributeAccessPolicyWindow

@ hipLaunchAttributeAccessPolicyWindow

Definition hip_runtime_api.h:1438

hipLaunchAttributeCooperative

@ hipLaunchAttributeCooperative

Definition hip_runtime_api.h:1439

hipGraphNodeTypeBatchMemOp

@ hipGraphNodeTypeBatchMemOp

BatchMemOp node.

Definition hip_runtime_api.h:1384

hipGraphNodeTypeGraph

@ hipGraphNodeTypeGraph

Node which executes an embedded graph.

Definition hip_runtime_api.h:1374

hipGraphNodeTypeMemset

@ hipGraphNodeTypeMemset

Memset node.

Definition hip_runtime_api.h:1372

hipGraphNodeTypeEventRecord

@ hipGraphNodeTypeEventRecord

External event record node.

Definition hip_runtime_api.h:1377

hipGraphNodeTypeExtSemaphoreSignal

@ hipGraphNodeTypeExtSemaphoreSignal

External Semaphore signal node.

Definition hip_runtime_api.h:1378

hipGraphNodeTypeMemcpy

@ hipGraphNodeTypeMemcpy

Memcpy node.

Definition hip_runtime_api.h:1371

hipGraphNodeTypeWaitEvent

@ hipGraphNodeTypeWaitEvent

External event wait node.

Definition hip_runtime_api.h:1376

hipGraphNodeTypeCount

@ hipGraphNodeTypeCount

Definition hip_runtime_api.h:1385

hipGraphNodeTypeKernel

@ hipGraphNodeTypeKernel

GPU kernel node.

Definition hip_runtime_api.h:1370

hipGraphNodeTypeHost

@ hipGraphNodeTypeHost

Host (executable) node.

Definition hip_runtime_api.h:1373

hipGraphNodeTypeMemAlloc

@ hipGraphNodeTypeMemAlloc

Memory alloc node.

Definition hip_runtime_api.h:1380

hipGraphNodeTypeMemFree

@ hipGraphNodeTypeMemFree

Memory free node.

Definition hip_runtime_api.h:1381

hipGraphNodeTypeMemcpyFromSymbol

@ hipGraphNodeTypeMemcpyFromSymbol

MemcpyFromSymbol node.

Definition hip_runtime_api.h:1382

hipGraphNodeTypeMemcpyToSymbol

@ hipGraphNodeTypeMemcpyToSymbol

MemcpyToSymbol node.

Definition hip_runtime_api.h:1383

hipGraphNodeTypeEmpty

@ hipGraphNodeTypeEmpty

Empty (no-op) node.

Definition hip_runtime_api.h:1375

hipGraphNodeTypeExtSemaphoreWait

@ hipGraphNodeTypeExtSemaphoreWait

External Semaphore wait node.

Definition hip_runtime_api.h:1379

hipExternalMemoryHandleTypeD3D11Resource

@ hipExternalMemoryHandleTypeD3D11Resource

Definition hip_runtime_api.h:1225

hipExternalMemoryHandleTypeD3D12Resource

@ hipExternalMemoryHandleTypeD3D12Resource

Definition hip_runtime_api.h:1224

hipExternalMemoryHandleTypeNvSciBuf

@ hipExternalMemoryHandleTypeNvSciBuf

Definition hip_runtime_api.h:1227

hipExternalMemoryHandleTypeOpaqueFd

@ hipExternalMemoryHandleTypeOpaqueFd

Definition hip_runtime_api.h:1220

hipExternalMemoryHandleTypeD3D12Heap

@ hipExternalMemoryHandleTypeD3D12Heap

Definition hip_runtime_api.h:1223

hipExternalMemoryHandleTypeOpaqueWin32Kmt

@ hipExternalMemoryHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:1222

hipExternalMemoryHandleTypeOpaqueWin32

@ hipExternalMemoryHandleTypeOpaqueWin32

Definition hip_runtime_api.h:1221

hipExternalMemoryHandleTypeD3D11ResourceKmt

@ hipExternalMemoryHandleTypeD3D11ResourceKmt

Definition hip_runtime_api.h:1226

hipFuncAttributePreferredSharedMemoryCarveout

@ hipFuncAttributePreferredSharedMemoryCarveout

Definition hip_runtime_api.h:1160

hipFuncAttributeMaxDynamicSharedMemorySize

@ hipFuncAttributeMaxDynamicSharedMemorySize

Definition hip_runtime_api.h:1159

hipFuncAttributeMax

@ hipFuncAttributeMax

Definition hip_runtime_api.h:1161

hipExternalSemaphoreHandleTypeNvSciSync

@ hipExternalSemaphoreHandleTypeNvSciSync

Definition hip_runtime_api.h:1263

hipExternalSemaphoreHandleTypeKeyedMutexKmt

@ hipExternalSemaphoreHandleTypeKeyedMutexKmt

Definition hip_runtime_api.h:1265

hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

@ hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:1260

hipExternalSemaphoreHandleTypeKeyedMutex

@ hipExternalSemaphoreHandleTypeKeyedMutex

Definition hip_runtime_api.h:1264

hipExternalSemaphoreHandleTypeD3D11Fence

@ hipExternalSemaphoreHandleTypeD3D11Fence

Definition hip_runtime_api.h:1262

hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

@ hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

Definition hip_runtime_api.h:1267

hipExternalSemaphoreHandleTypeOpaqueFd

@ hipExternalSemaphoreHandleTypeOpaqueFd

Definition hip_runtime_api.h:1258

hipExternalSemaphoreHandleTypeOpaqueWin32

@ hipExternalSemaphoreHandleTypeOpaqueWin32

Definition hip_runtime_api.h:1259

hipExternalSemaphoreHandleTypeTimelineSemaphoreFd

@ hipExternalSemaphoreHandleTypeTimelineSemaphoreFd

Definition hip_runtime_api.h:1266

hipExternalSemaphoreHandleTypeD3D12Fence

@ hipExternalSemaphoreHandleTypeD3D12Fence

Definition hip_runtime_api.h:1261

hipDevP2PAttrAccessSupported

@ hipDevP2PAttrAccessSupported

Definition hip_runtime_api.h:617

hipDevP2PAttrHipArrayAccessSupported

@ hipDevP2PAttrHipArrayAccessSupported

Definition hip_runtime_api.h:619

hipDevP2PAttrNativeAtomicSupported

@ hipDevP2PAttrNativeAtomicSupported

Definition hip_runtime_api.h:618

hipDevP2PAttrPerformanceRank

@ hipDevP2PAttrPerformanceRank

Definition hip_runtime_api.h:616

hipGraphDebugDotFlagsKernelNodeAttributes

@ hipGraphDebugDotFlagsKernelNodeAttributes

Definition hip_runtime_api.h:1552

hipGraphDebugDotFlagsMemsetNodeParams

@ hipGraphDebugDotFlagsMemsetNodeParams

Definition hip_runtime_api.h:1544

hipGraphDebugDotFlagsKernelNodeParams

@ hipGraphDebugDotFlagsKernelNodeParams

Definition hip_runtime_api.h:1542

hipGraphDebugDotFlagsExtSemasWaitNodeParams

@ hipGraphDebugDotFlagsExtSemasWaitNodeParams

Definition hip_runtime_api.h:1550

hipGraphDebugDotFlagsHandles

@ hipGraphDebugDotFlagsHandles

Definition hip_runtime_api.h:1554

hipGraphDebugDotFlagsExtSemasSignalNodeParams

@ hipGraphDebugDotFlagsExtSemasSignalNodeParams

Definition hip_runtime_api.h:1548

hipGraphDebugDotFlagsHostNodeParams

@ hipGraphDebugDotFlagsHostNodeParams

Definition hip_runtime_api.h:1545

hipGraphDebugDotFlagsEventNodeParams

@ hipGraphDebugDotFlagsEventNodeParams

Definition hip_runtime_api.h:1546

hipGraphDebugDotFlagsVerbose

@ hipGraphDebugDotFlagsVerbose

Definition hip_runtime_api.h:1540

hipGraphDebugDotFlagsMemcpyNodeParams

@ hipGraphDebugDotFlagsMemcpyNodeParams

Definition hip_runtime_api.h:1543

hipGraphUserObjectMove

@ hipGraphUserObjectMove

Add new reference or retain.

Definition hip_runtime_api.h:1525

hipStreamAddCaptureDependencies

@ hipStreamAddCaptureDependencies

Add new nodes to the dependency set.

Definition hip_runtime_api.h:1510

hipStreamSetCaptureDependencies

@ hipStreamSetCaptureDependencies

Replace the dependency set with the new nodes.

Definition hip_runtime_api.h:1511

hipMemHandleTypeGeneric

@ hipMemHandleTypeGeneric

Generic handle type.

Definition hip_runtime_api.h:1641

hipFlushGPUDirectRDMAWritesOptionHost

@ hipFlushGPUDirectRDMAWritesOptionHost

Definition hip_runtime_api.h:562

hipFlushGPUDirectRDMAWritesOptionMemOps

@ hipFlushGPUDirectRDMAWritesOptionMemOps

Definition hip_runtime_api.h:563

hipFuncCachePreferNone

@ hipFuncCachePreferNone

no preference for shared memory or L1 (default)

Definition hip_runtime_api.h:1167

hipFuncCachePreferEqual

@ hipFuncCachePreferEqual

prefer equal size L1 cache and shared memory

Definition hip_runtime_api.h:1170

hipFuncCachePreferL1

@ hipFuncCachePreferL1

prefer larger L1 cache and smaller shared memory

Definition hip_runtime_api.h:1169

hipFuncCachePreferShared

@ hipFuncCachePreferShared

prefer larger shared memory and smaller L1 cache

Definition hip_runtime_api.h:1168

hipUserObjectNoDestructorSync

@ hipUserObjectNoDestructorSync

Destructor execution is not synchronized.

Definition hip_runtime_api.h:1521

hipGraphMemAttrReservedMemHigh

@ hipGraphMemAttrReservedMemHigh

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

Definition hip_runtime_api.h:1518

hipGraphMemAttrUsedMemCurrent

@ hipGraphMemAttrUsedMemCurrent

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

Definition hip_runtime_api.h:1515

hipGraphMemAttrUsedMemHigh

@ hipGraphMemAttrUsedMemHigh

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

Definition hip_runtime_api.h:1516

hipGraphMemAttrReservedMemCurrent

@ hipGraphMemAttrReservedMemCurrent

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

Definition hip_runtime_api.h:1517

hipMemPoolAttrUsedMemCurrent

@ hipMemPoolAttrUsedMemCurrent

Definition hip_runtime_api.h:1070

hipMemPoolAttrReservedMemHigh

@ hipMemPoolAttrReservedMemHigh

Definition hip_runtime_api.h:1065

hipMemPoolAttrReservedMemCurrent

@ hipMemPoolAttrReservedMemCurrent

Definition hip_runtime_api.h:1059

hipMemPoolAttrReleaseThreshold

@ hipMemPoolAttrReleaseThreshold

Definition hip_runtime_api.h:1054

hipMemPoolAttrUsedMemHigh

@ hipMemPoolAttrUsedMemHigh

Definition hip_runtime_api.h:1076

hipMemPoolReuseAllowInternalDependencies

@ hipMemPoolReuseAllowInternalDependencies

Definition hip_runtime_api.h:1045

hipMemPoolReuseFollowEventDependencies

@ hipMemPoolReuseFollowEventDependencies

Definition hip_runtime_api.h:1032

hipMemPoolReuseAllowOpportunistic

@ hipMemPoolReuseAllowOpportunistic

Definition hip_runtime_api.h:1038

hipMemOperationTypeMap

@ hipMemOperationTypeMap

Map operation.

Definition hip_runtime_api.h:1648

hipMemOperationTypeUnmap

@ hipMemOperationTypeUnmap

Unmap operation.

Definition hip_runtime_api.h:1649

hipGraphicsRegisterFlagsReadOnly

@ hipGraphicsRegisterFlagsReadOnly

HIP will not write to this registered resource.

Definition hip_runtime_api.h:1335

hipGraphicsRegisterFlagsTextureGather

@ hipGraphicsRegisterFlagsTextureGather

HIP will perform texture gather operations on this registered resource.

Definition hip_runtime_api.h:1339

hipGraphicsRegisterFlagsWriteDiscard

@ hipGraphicsRegisterFlagsWriteDiscard

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

Definition hip_runtime_api.h:1336

hipGraphicsRegisterFlagsNone

@ hipGraphicsRegisterFlagsNone

Definition hip_runtime_api.h:1334

hipGraphicsRegisterFlagsSurfaceLoadStore

@ hipGraphicsRegisterFlagsSurfaceLoadStore

HIP will bind this resource to a surface.

Definition hip_runtime_api.h:1338

hipMemRangeCoherencyModeFineGrain

@ hipMemRangeCoherencyModeFineGrain

Definition hip_runtime_api.h:996

hipMemRangeCoherencyModeIndeterminate

@ hipMemRangeCoherencyModeIndeterminate

Definition hip_runtime_api.h:1000

hipMemRangeCoherencyModeCoarseGrain

@ hipMemRangeCoherencyModeCoarseGrain

Definition hip_runtime_api.h:998

hipMemAccessFlagsProtRead

@ hipMemAccessFlagsProtRead

Set the address range read accessible.

Definition hip_runtime_api.h:1100

hipMemAccessFlagsProtNone

@ hipMemAccessFlagsProtNone

Default, make the address range not accessible.

Definition hip_runtime_api.h:1099

hipMemAccessFlagsProtReadWrite

@ hipMemAccessFlagsProtReadWrite

Set the address range read-write accessible.

Definition hip_runtime_api.h:1101

hipMemAllocationGranularityMinimum

@ hipMemAllocationGranularityMinimum

Minimum granularity.

Definition hip_runtime_api.h:1633

hipMemAllocationGranularityRecommended

@ hipMemAllocationGranularityRecommended

Recommended granularity for performance.

Definition hip_runtime_api.h:1634

hipGraphExecUpdateErrorNotSupported

@ hipGraphExecUpdateErrorNotSupported

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

Definition hip_runtime_api.h:1492

hipGraphExecUpdateErrorNodeTypeChanged

@ hipGraphExecUpdateErrorNodeTypeChanged

The update failed because a node type changed.

Definition hip_runtime_api.h:1487

hipGraphExecUpdateErrorTopologyChanged

@ hipGraphExecUpdateErrorTopologyChanged

The update failed because the topology changed.

Definition hip_runtime_api.h:1486

hipGraphExecUpdateErrorUnsupportedFunctionChange

@ hipGraphExecUpdateErrorUnsupportedFunctionChange

Definition hip_runtime_api.h:1494

hipGraphExecUpdateError

@ hipGraphExecUpdateError

Definition hip_runtime_api.h:1484

hipGraphExecUpdateErrorFunctionChanged

@ hipGraphExecUpdateErrorFunctionChanged

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

Definition hip_runtime_api.h:1488

hipGraphExecUpdateSuccess

@ hipGraphExecUpdateSuccess

The update succeeded.

Definition hip_runtime_api.h:1483

hipGraphExecUpdateErrorParametersChanged

@ hipGraphExecUpdateErrorParametersChanged

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

Definition hip_runtime_api.h:1490

hipStreamCaptureStatusInvalidated

@ hipStreamCaptureStatusInvalidated

Definition hip_runtime_api.h:1505

hipStreamCaptureStatusNone

@ hipStreamCaptureStatusNone

Stream is not capturing.

Definition hip_runtime_api.h:1503

hipStreamCaptureStatusActive

@ hipStreamCaptureStatusActive

Stream is actively capturing.

Definition hip_runtime_api.h:1504

hipDeviceAttributeDirectManagedMemAccessFromHost

@ hipDeviceAttributeDirectManagedMemAccessFromHost

Definition hip_runtime_api.h:431

hipDeviceAttributeSurfaceAlignment

@ hipDeviceAttributeSurfaceAlignment

Alignment requirement for surfaces.

Definition hip_runtime_api.h:501

hipDeviceAttributeMaxGridDimX

@ hipDeviceAttributeMaxGridDimX

Max grid size in width.

Definition hip_runtime_api.h:448

hipDeviceAttributeMaxSurfaceCubemapLayered

@ hipDeviceAttributeMaxSurfaceCubemapLayered

Cuda only. Maximum dimension of Cubemap layered surface.

Definition hip_runtime_api.h:457

hipDeviceAttributeMaxSurface3D

@ hipDeviceAttributeMaxSurface3D

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

Definition hip_runtime_api.h:455

hipDeviceAttributeMaxPitch

@ hipDeviceAttributeMaxPitch

Maximum pitch in bytes allowed by memory copies.

Definition hip_runtime_api.h:478

hipDeviceAttributeTccDriver

@ hipDeviceAttributeTccDriver

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

Definition hip_runtime_api.h:502

hipDeviceAttributeHostNativeAtomicSupported

@ hipDeviceAttributeHostNativeAtomicSupported

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

Definition hip_runtime_api.h:434

hipDeviceAttributePageableMemoryAccessUsesHostPageTables

@ hipDeviceAttributePageableMemoryAccessUsesHostPageTables

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

Definition hip_runtime_api.h:487

hipDeviceAttributeUnused5

@ hipDeviceAttributeUnused5

Previously hipDeviceAttributeGcnArchName.

Definition hip_runtime_api.h:522

hipDeviceAttributeMaxBlockDimY

@ hipDeviceAttributeMaxBlockDimY

Max block size in height.

Definition hip_runtime_api.h:446

hipDeviceAttributeMaxSurfaceCubemap

@ hipDeviceAttributeMaxSurfaceCubemap

Cuda only. Maximum dimensions of Cubemap surface.

Definition hip_runtime_api.h:456

hipDeviceAttributePageableMemoryAccess

@ hipDeviceAttributePageableMemoryAccess

Definition hip_runtime_api.h:485

hipDeviceAttributeClockRate

@ hipDeviceAttributeClockRate

Peak clock frequency in kilohertz.

Definition hip_runtime_api.h:422

hipDeviceAttributeCudaCompatibleEnd

@ hipDeviceAttributeCudaCompatibleEnd

Definition hip_runtime_api.h:515

hipDeviceAttributeMaxTexture1DMipmap

@ hipDeviceAttributeMaxTexture1DMipmap

Maximum size of 1D mipmapped texture.

Definition hip_runtime_api.h:462

hipDeviceAttributeComputeCapabilityMajor

@ hipDeviceAttributeComputeCapabilityMajor

Major compute capability version number.

Definition hip_runtime_api.h:442

hipDeviceAttributeGlobalL1CacheSupported

@ hipDeviceAttributeGlobalL1CacheSupported

Device supports caching globals in L1.

Definition hip_runtime_api.h:433

hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

Definition hip_runtime_api.h:531

hipDeviceAttributeAccessPolicyMaxWindowSize

@ hipDeviceAttributeAccessPolicyMaxWindowSize

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

Definition hip_runtime_api.h:417

hipDeviceAttributeMaxTexture3DHeight

@ hipDeviceAttributeMaxTexture3DHeight

Maximum dimension height of 3D texture.

Definition hip_runtime_api.h:470

hipDeviceAttributeComputeCapabilityMinor

@ hipDeviceAttributeComputeCapabilityMinor

Minor compute capability version number.

Definition hip_runtime_api.h:481

hipDeviceAttributeMaxTextureCubemap

@ hipDeviceAttributeMaxTextureCubemap

Maximum dimensions of Cubemap texture.

Definition hip_runtime_api.h:473

hipDeviceAttributeDeviceOverlap

@ hipDeviceAttributeDeviceOverlap

Definition hip_runtime_api.h:429

hipDeviceAttributeMaxTexture2DLinear

@ hipDeviceAttributeMaxTexture2DLinear

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

Definition hip_runtime_api.h:467

hipDeviceAttributeMaxSurface2D

@ hipDeviceAttributeMaxSurface2D

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

Definition hip_runtime_api.h:453

hipDeviceAttributeMaxSurface1DLayered

@ hipDeviceAttributeMaxSurface1DLayered

Cuda only. Maximum dimensions of 1D layered surface.

Definition hip_runtime_api.h:452

hipDeviceAttributeHdpRegFlushCntl

@ hipDeviceAttributeHdpRegFlushCntl

Address of the HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:524

hipDeviceAttributeComputeMode

@ hipDeviceAttributeComputeMode

Compute mode that device is currently in.

Definition hip_runtime_api.h:423

hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

Definition hip_runtime_api.h:525

hipDeviceAttributeAsicRevision

@ hipDeviceAttributeAsicRevision

Revision of the GPU in this device.

Definition hip_runtime_api.h:534

hipDeviceAttributeUnused4

@ hipDeviceAttributeUnused4

Previously hipDeviceAttributeGcnArch.

Definition hip_runtime_api.h:521

hipDeviceAttributeCooperativeMultiDeviceLaunch

@ hipDeviceAttributeCooperativeMultiDeviceLaunch

Support cooperative launch on multiple devices.

Definition hip_runtime_api.h:428

hipDeviceAttributeMaxTexture2DHeight

@ hipDeviceAttributeMaxTexture2DHeight

Maximum dimension hight of 2D texture.

Definition hip_runtime_api.h:464

hipDeviceAttributePersistingL2CacheMaxSize

@ hipDeviceAttributePersistingL2CacheMaxSize

Maximum l2 persisting lines capacity in bytes.

Definition hip_runtime_api.h:491

hipDeviceAttributeEccEnabled

@ hipDeviceAttributeEccEnabled

Whether ECC support is enabled.

Definition hip_runtime_api.h:416

hipDeviceAttributeCanUseHostPointerForRegisteredMem

@ hipDeviceAttributeCanUseHostPointerForRegisteredMem

Definition hip_runtime_api.h:420

hipDeviceAttributePciBusId

@ hipDeviceAttributePciBusId

PCI Bus ID.

Definition hip_runtime_api.h:488

hipDeviceAttributeL2CacheSize

@ hipDeviceAttributeL2CacheSize

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

Definition hip_runtime_api.h:438

hipDeviceAttributeKernelExecTimeout

@ hipDeviceAttributeKernelExecTimeout

Run time limit for kernels executed on the device.

Definition hip_runtime_api.h:437

hipDeviceAttributeMaxThreadsDim

@ hipDeviceAttributeMaxThreadsDim

Maximum dimension of a block.

Definition hip_runtime_api.h:475

hipDeviceAttributeSingleToDoublePrecisionPerfRatio

@ hipDeviceAttributeSingleToDoublePrecisionPerfRatio

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

Definition hip_runtime_api.h:499

hipDeviceAttributeMaxGridDimY

@ hipDeviceAttributeMaxGridDimY

Max grid size in height.

Definition hip_runtime_api.h:449

hipDeviceAttributeMultiprocessorCount

@ hipDeviceAttributeMultiprocessorCount

Number of multiprocessors on the device.

Definition hip_runtime_api.h:483

hipDeviceAttributeAmdSpecificBegin

@ hipDeviceAttributeAmdSpecificBegin

Definition hip_runtime_api.h:516

hipDeviceAttributeMaxRegistersPerMultiprocessor

@ hipDeviceAttributeMaxRegistersPerMultiprocessor

32-bit registers available per block.

Definition hip_runtime_api.h:494

hipDeviceAttributeIsMultiGpuBoard

@ hipDeviceAttributeIsMultiGpuBoard

Multiple GPU devices.

Definition hip_runtime_api.h:436

hipDeviceAttributeSharedMemPerBlockOptin

@ hipDeviceAttributeSharedMemPerBlockOptin

Maximum shared memory per block usable by special opt in.

Definition hip_runtime_api.h:497

hipDeviceAttributeMaxSurface2DLayered

@ hipDeviceAttributeMaxSurface2DLayered

Cuda only. Maximum dimensions of 2D layered surface.

Definition hip_runtime_api.h:454

hipDeviceAttributeAmdSpecificEnd

@ hipDeviceAttributeAmdSpecificEnd

Definition hip_runtime_api.h:543

hipDeviceAttributeMemoryClockRate

@ hipDeviceAttributeMemoryClockRate

Peak memory clock frequency in kilohertz.

Definition hip_runtime_api.h:480

hipDeviceAttributeMaxGridDimZ

@ hipDeviceAttributeMaxGridDimZ

Max grid size in depth.

Definition hip_runtime_api.h:450

hipDeviceAttributeHdpMemFlushCntl

@ hipDeviceAttributeHdpMemFlushCntl

Address of the HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:523

hipDeviceAttributeUnused2

@ hipDeviceAttributeUnused2

Previously hipDeviceAttributeUuid.

Definition hip_runtime_api.h:508

hipDeviceAttributeFineGrainSupport

@ hipDeviceAttributeFineGrainSupport

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

Definition hip_runtime_api.h:540

hipDeviceAttributeCooperativeLaunch

@ hipDeviceAttributeCooperativeLaunch

Support cooperative launch.

Definition hip_runtime_api.h:427

hipDeviceAttributeUnifiedAddressing

@ hipDeviceAttributeUnifiedAddressing

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

Definition hip_runtime_api.h:507

hipDeviceAttributeAsyncEngineCount

@ hipDeviceAttributeAsyncEngineCount

Asynchronous engines number.

Definition hip_runtime_api.h:418

hipDeviceAttributeMultiGpuBoardGroupID

@ hipDeviceAttributeMultiGpuBoardGroupID

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

Definition hip_runtime_api.h:482

hipDeviceAttributeStreamPrioritiesSupported

@ hipDeviceAttributeStreamPrioritiesSupported

Whether to support stream priorities.

Definition hip_runtime_api.h:500

hipDeviceAttributeMaxSharedMemoryPerBlock

@ hipDeviceAttributeMaxSharedMemoryPerBlock

Maximum shared memory available per block in bytes.

Definition hip_runtime_api.h:496

hipDeviceAttributeLocalL1CacheSupported

@ hipDeviceAttributeLocalL1CacheSupported

caching locals in L1 is supported

Definition hip_runtime_api.h:439

hipDeviceAttributeCanUseStreamWaitValue

@ hipDeviceAttributeCanUseStreamWaitValue

Definition hip_runtime_api.h:535

hipDeviceAttributeMaxRegistersPerBlock

@ hipDeviceAttributeMaxRegistersPerBlock

Definition hip_runtime_api.h:492

hipDeviceAttributeMaxThreadsPerBlock

@ hipDeviceAttributeMaxThreadsPerBlock

Maximum number of threads per block.

Definition hip_runtime_api.h:476

hipDeviceAttributeMemoryBusWidth

@ hipDeviceAttributeMemoryBusWidth

Global memory bus width in bits.

Definition hip_runtime_api.h:479

hipDeviceAttributeMemoryPoolSupportedHandleTypes

@ hipDeviceAttributeMemoryPoolSupportedHandleTypes

Supported handle mask for HIP Stream Ordered Memory Allocator.

Definition hip_runtime_api.h:513

hipDeviceAttributeComputePreemptionSupported

@ hipDeviceAttributeComputePreemptionSupported

Device supports Compute Preemption.

Definition hip_runtime_api.h:424

hipDeviceAttributeMaxSurface1D

@ hipDeviceAttributeMaxSurface1D

Maximum size of 1D surface.

Definition hip_runtime_api.h:451

hipDeviceAttributeUnused1

@ hipDeviceAttributeUnused1

Previously hipDeviceAttributeName.

Definition hip_runtime_api.h:484

hipDeviceAttributeMaxTexture3DAlt

@ hipDeviceAttributeMaxTexture3DAlt

Maximum dimensions of alternate 3D texture.

Definition hip_runtime_api.h:472

hipDeviceAttributeMaxTexture1DLinear

@ hipDeviceAttributeMaxTexture1DLinear

Definition hip_runtime_api.h:460

hipDeviceAttributeMaxTexture2DGather

@ hipDeviceAttributeMaxTexture2DGather

Maximum dimensions of 2D texture if gather operations performed.

Definition hip_runtime_api.h:465

hipDeviceAttributeWallClockRate

@ hipDeviceAttributeWallClockRate

Constant frequency of wall clock in kilohertz.

Definition hip_runtime_api.h:541

hipDeviceAttributePciDeviceId

@ hipDeviceAttributePciDeviceId

PCI Device ID.

Definition hip_runtime_api.h:489

hipDeviceAttributeCanMapHostMemory

@ hipDeviceAttributeCanMapHostMemory

Whether host memory can be mapped into device address space.

Definition hip_runtime_api.h:419

hipDeviceAttributeMaxTexture1DWidth

@ hipDeviceAttributeMaxTexture1DWidth

Maximum size of 1D texture.

Definition hip_runtime_api.h:458

hipDeviceAttributeConcurrentManagedAccess

@ hipDeviceAttributeConcurrentManagedAccess

Device can coherently access managed memory concurrently with the CPU.

Definition hip_runtime_api.h:426

hipDeviceAttributeVendorSpecificBegin

@ hipDeviceAttributeVendorSpecificBegin

Definition hip_runtime_api.h:544

hipDeviceAttributeManagedMemory

@ hipDeviceAttributeManagedMemory

Device supports allocating managed memory on this system.

Definition hip_runtime_api.h:443

hipDeviceAttributeIntegrated

@ hipDeviceAttributeIntegrated

Device is integrated GPU.

Definition hip_runtime_api.h:435

hipDeviceAttributeMaxTexture2DLayered

@ hipDeviceAttributeMaxTexture2DLayered

Maximum dimensions of 2D layered texture.

Definition hip_runtime_api.h:466

hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

Definition hip_runtime_api.h:527

hipDeviceAttributeMaxTexture3DDepth

@ hipDeviceAttributeMaxTexture3DDepth

Maximum dimension depth of 3D texture.

Definition hip_runtime_api.h:471

hipDeviceAttributeImageSupport

@ hipDeviceAttributeImageSupport

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

Definition hip_runtime_api.h:537

hipDeviceAttributeTotalGlobalMem

@ hipDeviceAttributeTotalGlobalMem

Global memory available on devicice.

Definition hip_runtime_api.h:506

hipDeviceAttributeMaxBlocksPerMultiProcessor

@ hipDeviceAttributeMaxBlocksPerMultiProcessor

Max block size per multiprocessor.

Definition hip_runtime_api.h:444

hipDeviceAttributeIsLargeBar

@ hipDeviceAttributeIsLargeBar

Whether it is LargeBar.

Definition hip_runtime_api.h:533

hipDeviceAttributeMaxTexture2DWidth

@ hipDeviceAttributeMaxTexture2DWidth

Maximum dimension width of 2D texture.

Definition hip_runtime_api.h:463

hipDeviceAttributeMaxBlockDimX

@ hipDeviceAttributeMaxBlockDimX

Max block size in width.

Definition hip_runtime_api.h:445

hipDeviceAttributeMaxTexture3DWidth

@ hipDeviceAttributeMaxTexture3DWidth

Maximum dimension width of 3D texture.

Definition hip_runtime_api.h:469

hipDeviceAttributeUnused3

@ hipDeviceAttributeUnused3

Previously hipDeviceAttributeArch.

Definition hip_runtime_api.h:519

hipDeviceAttributeTotalConstantMemory

@ hipDeviceAttributeTotalConstantMemory

Constant memory size in bytes.

Definition hip_runtime_api.h:505

hipDeviceAttributeTextureAlignment

@ hipDeviceAttributeTextureAlignment

Alignment requirement for textures.

Definition hip_runtime_api.h:503

hipDeviceAttributeMaxTexture1DLayered

@ hipDeviceAttributeMaxTexture1DLayered

Maximum dimensions of 1D layered texture.

Definition hip_runtime_api.h:459

hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

@ hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

Maximum Shared Memory PerMultiprocessor.

Definition hip_runtime_api.h:520

hipDeviceAttributeReservedSharedMemPerBlock

@ hipDeviceAttributeReservedSharedMemPerBlock

Shared memory reserved by CUDA driver per block.

Definition hip_runtime_api.h:495

hipDeviceAttributeCudaCompatibleBegin

@ hipDeviceAttributeCudaCompatibleBegin

Definition hip_runtime_api.h:414

hipDeviceAttributeConcurrentKernels

@ hipDeviceAttributeConcurrentKernels

Device can possibly execute multiple kernels concurrently.

Definition hip_runtime_api.h:425

hipDeviceAttributeLuid

@ hipDeviceAttributeLuid

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

Definition hip_runtime_api.h:440

hipDeviceAttributePciDomainID

@ hipDeviceAttributePciDomainID

PCI Domain ID.

Definition hip_runtime_api.h:490

hipDeviceAttributeMaxThreadsPerMultiProcessor

@ hipDeviceAttributeMaxThreadsPerMultiProcessor

Maximum resident threads per multiprocessor.

Definition hip_runtime_api.h:477

hipDeviceAttributeTexturePitchAlignment

@ hipDeviceAttributeTexturePitchAlignment

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

Definition hip_runtime_api.h:504

hipDeviceAttributePhysicalMultiProcessorCount

@ hipDeviceAttributePhysicalMultiProcessorCount

Definition hip_runtime_api.h:538

hipDeviceAttributeHostRegisterSupported

@ hipDeviceAttributeHostRegisterSupported

Can device support host memory registration via hipHostRegister.

Definition hip_runtime_api.h:512

hipDeviceAttributeSharedMemPerMultiprocessor

@ hipDeviceAttributeSharedMemPerMultiprocessor

Shared memory available per multiprocessor.

Definition hip_runtime_api.h:498

hipDeviceAttributeLuidDeviceNodeMask

@ hipDeviceAttributeLuidDeviceNodeMask

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

Definition hip_runtime_api.h:441

hipDeviceAttributeMaxTextureCubemapLayered

@ hipDeviceAttributeMaxTextureCubemapLayered

Maximum dimensions of Cubemap layered texture.

Definition hip_runtime_api.h:474

hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

Definition hip_runtime_api.h:529

hipDeviceAttributeVirtualMemoryManagementSupported

@ hipDeviceAttributeVirtualMemoryManagementSupported

Device supports HIP virtual memory management.

Definition hip_runtime_api.h:511

hipDeviceAttributeMemoryPoolsSupported

@ hipDeviceAttributeMemoryPoolsSupported

Device supports HIP Stream Ordered Memory Allocator.

Definition hip_runtime_api.h:510

hipDeviceAttributeClockInstructionRate

@ hipDeviceAttributeClockInstructionRate

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

Definition hip_runtime_api.h:518

hipDeviceAttributeMaxTexture2DMipmap

@ hipDeviceAttributeMaxTexture2DMipmap

Maximum dimensions of 2D mipmapped texture.

Definition hip_runtime_api.h:468

hipDeviceAttributeMaxBlockDimZ

@ hipDeviceAttributeMaxBlockDimZ

Max block size in depth.

Definition hip_runtime_api.h:447

hipDeviceAttributeWarpSize

@ hipDeviceAttributeWarpSize

Warp size in threads.

Definition hip_runtime_api.h:509

hipGPUDirectRDMAWritesOrderingOwner

@ hipGPUDirectRDMAWritesOrderingOwner

Definition hip_runtime_api.h:568

hipGPUDirectRDMAWritesOrderingNone

@ hipGPUDirectRDMAWritesOrderingNone

Definition hip_runtime_api.h:567

hipGPUDirectRDMAWritesOrderingAllDevices

@ hipGPUDirectRDMAWritesOrderingAllDevices

Definition hip_runtime_api.h:569

hipMemAllocationTypeMax

@ hipMemAllocationTypeMax

Definition hip_runtime_api.h:1122

hipMemAllocationTypePinned

@ hipMemAllocationTypePinned

Definition hip_runtime_api.h:1121

hipMemAllocationTypeInvalid

@ hipMemAllocationTypeInvalid

Definition hip_runtime_api.h:1117

hipMemoryTypeDevice

@ hipMemoryTypeDevice

Definition hip_runtime_api.h:252

hipMemoryTypeHost

@ hipMemoryTypeHost

Memory is physically located on host.

Definition hip_runtime_api.h:251

hipMemoryTypeUnregistered

@ hipMemoryTypeUnregistered

Unregistered memory.

Definition hip_runtime_api.h:250

hipMemoryTypeArray

@ hipMemoryTypeArray

Definition hip_runtime_api.h:257

hipMemoryTypeManaged

@ hipMemoryTypeManaged

Definition hip_runtime_api.h:254

hipMemoryTypeUnified

@ hipMemoryTypeUnified

unified address space

Definition hip_runtime_api.h:259

hipGraphInstantiateFlagAutoFreeOnLaunch

@ hipGraphInstantiateFlagAutoFreeOnLaunch

Automatically free memory allocated in a graph before relaunching.

Definition hip_runtime_api.h:1529

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

hipGraphInstantiateFlagUpload

@ hipGraphInstantiateFlagUpload

Automatically upload the graph after instantiation.

Definition hip_runtime_api.h:1531

hipGraphInstantiateFlagDeviceLaunch

@ hipGraphInstantiateFlagDeviceLaunch

Instantiate the graph to be launched from the device.

Definition hip_runtime_api.h:1533

hipMemLocationTypeInvalid

@ hipMemLocationTypeInvalid

Definition hip_runtime_api.h:1082

hipMemLocationTypeDevice

@ hipMemLocationTypeDevice

Device location, thus it's HIP device ID.

Definition hip_runtime_api.h:1083

hipArraySparseSubresourceTypeSparseLevel

@ hipArraySparseSubresourceTypeSparseLevel

Sparse level.

Definition hip_runtime_api.h:1656

hipArraySparseSubresourceTypeMiptail

@ hipArraySparseSubresourceTypeMiptail

Miptail.

Definition hip_runtime_api.h:1657

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.

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.

hipJitOption

hipJitOption

Definition linker_types.h:47

hipJitInputType

hipJitInputType

Definition linker_types.h:89

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.

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

hipModuleGetTexRef

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

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

hipLinkComplete

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

Completes the linking of the given program.

hipModuleLoad

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

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

hipModuleGetGlobal

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

Returns a global pointer from a module.

hipModuleLoadDataEx

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

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

hipLinkAddFile

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

Adds a file with bit code to be linked with options.

hipGetFuncBySymbol

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

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

hipLinkDestroy

hipError_t hipLinkDestroy(hipLinkState_t state)

Deletes the link instance via hip APIs.

hipModuleGetFunction

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

Function with kname will be extracted if present in module.

hipLinkCreate

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

Creates the link instance via hip APIs.

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.

hipLinkAddData

hipError_t hipLinkAddData(hipLinkState_t state, hipJitInputType type, void *data, size_t size, const char *name, unsigned int numOptions, hipJitOption *options, void **optionValues)

Completes the linking of the given program.

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

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

hipGraphExecBatchMemOpNodeSetParams

hipError_t hipGraphExecBatchMemOpNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode, const hipBatchMemOpNodeParams *nodeParams)

Sets the parameters for a batch mem op node in the given graphExec.[BETA].

hipGraphAddBatchMemOpNode

hipError_t hipGraphAddBatchMemOpNode(hipGraphNode_t *phGraphNode, hipGraph_t hGraph, const hipGraphNode_t *dependencies, size_t numDependencies, const hipBatchMemOpNodeParams *nodeParams)

Creates a batch memory operation node and adds it to a graph.[BETA].

hipStreamWaitValue64

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

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

hipGraphBatchMemOpNodeGetParams

hipError_t hipGraphBatchMemOpNodeGetParams(hipGraphNode_t hNode, hipBatchMemOpNodeParams *nodeParams_out)

Returns a batch mem op node's parameters.[BETA].

hipStreamBatchMemOp

hipError_t hipStreamBatchMemOp(hipStream_t stream, unsigned int count, hipStreamBatchMemOpParams *paramArray, unsigned int flags)

Enqueues an array of stream memory operations in the stream.[BETA].

hipGraphBatchMemOpNodeSetParams

hipError_t hipGraphBatchMemOpNodeSetParams(hipGraphNode_t hNode, hipBatchMemOpNodeParams *nodeParams)

Sets the batch mem op node's parameters.[BETA].

hipStreamWaitValue32

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

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

hipMemPoolImportPointer

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

Import a memory pool allocation from another process.

hipMemPoolImportFromShareableHandle

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

Imports a memory pool from a shared handle.

hipMallocFromPoolAsync

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

Allocates memory from a specified pool with stream ordered semantics.

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

hipErrorMemoryAllocation

hipErrorMemoryAllocation

Memory allocation error.

Definition hip_runtime_api.h:297

hipErrorNotFound

hipErrorNotFound

Not found.

Definition hip_runtime_api.h:346

hipErrorProfilerDisabled

hipErrorProfilerDisabled

Definition hip_runtime_api.h:302

hipErrorInvalidDevicePointer

hipErrorInvalidDevicePointer

Invalid Device Pointer.

Definition hip_runtime_api.h:309

hipErrorRuntimeMemory

hipErrorRuntimeMemory

Definition hip_runtime_api.h:400

hipErrorInvalidImage

hipErrorInvalidImage

Invalid image.

Definition hip_runtime_api.h:317

hipErrorPeerAccessUnsupported

hipErrorPeerAccessUnsupported

Definition hip_runtime_api.h:334

hipErrorArrayIsMapped

hipErrorArrayIsMapped

Definition hip_runtime_api.h:324

hipErrorStreamCaptureIsolation

hipErrorStreamCaptureIsolation

Definition hip_runtime_api.h:379

hipErrorInvalidKernelFile

hipErrorInvalidKernelFile

In CUDA DRV, it is CUDA_ERROR_INVALID_PTX.

Definition hip_runtime_api.h:335

hipErrorNotMapped

hipErrorNotMapped

Definition hip_runtime_api.h:328

hipErrorGraphExecUpdateFailure

hipErrorGraphExecUpdateFailure

Definition hip_runtime_api.h:392

hipErrorNotInitialized

hipErrorNotInitialized

Invalid not initialized.

Definition hip_runtime_api.h:298

hipErrorInvalidResourceHandle

hipErrorInvalidResourceHandle

Resource handle (hipEvent_t or hipStream_t) invalid.

Definition hip_runtime_api.h:344

hipErrorSharedObjectInitFailed

hipErrorSharedObjectInitFailed

Failed to initialize shared object.

Definition hip_runtime_api.h:340

hipErrorInvalidPitchValue

hipErrorInvalidPitchValue

Invalid pitch value.

Definition hip_runtime_api.h:307

hipErrorNoBinaryForGpu

hipErrorNoBinaryForGpu

Definition hip_runtime_api.h:326

hipErrorInvalidContext

hipErrorInvalidContext

Produced when input context is invalid.

Definition hip_runtime_api.h:318

hipErrorStreamCaptureUnsupported

hipErrorStreamCaptureUnsupported

Definition hip_runtime_api.h:370

hipErrorPeerAccessNotEnabled

hipErrorPeerAccessNotEnabled

Peer access was never enabled from the current device.

Definition hip_runtime_api.h:356

hipErrorOperatingSystem

hipErrorOperatingSystem

Not the correct operating system.

Definition hip_runtime_api.h:341

hipErrorStreamCaptureUnjoined

hipErrorStreamCaptureUnjoined

Definition hip_runtime_api.h:377

hipErrorInitializationError

hipErrorInitializationError

Definition hip_runtime_api.h:300

hipErrorNotMappedAsPointer

hipErrorNotMappedAsPointer

Definition hip_runtime_api.h:330

hipErrorPriorLaunchFailure

hipErrorPriorLaunchFailure

Definition hip_runtime_api.h:313

hipErrorContextIsDestroyed

hipErrorContextIsDestroyed

The context is already destroyed.

Definition hip_runtime_api.h:358

hipErrorInvalidValue

hipErrorInvalidValue

Definition hip_runtime_api.h:293

hipErrorLaunchTimeOut

hipErrorLaunchTimeOut

Timeout for the launch.

Definition hip_runtime_api.h:353

hipErrorUnmapFailed

hipErrorUnmapFailed

Definition hip_runtime_api.h:323

hipErrorSetOnActiveProcess

hipErrorSetOnActiveProcess

The process is active.

Definition hip_runtime_api.h:357

hipErrorFileNotFound

hipErrorFileNotFound

the file is not found.

Definition hip_runtime_api.h:338

hipErrorLaunchFailure

hipErrorLaunchFailure

An exception occurred on the device while executing a kernel.

Definition hip_runtime_api.h:364

hipErrorInvalidDevice

hipErrorInvalidDevice

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

Definition hip_runtime_api.h:316

hipErrorUnsupportedLimit

hipErrorUnsupportedLimit

Unsupported limit.

Definition hip_runtime_api.h:332

hipErrorMapBufferObjectFailed

hipErrorMapBufferObjectFailed

Produced when the IPC memory attach failed from ROCr.

Definition hip_runtime_api.h:322

hipErrorHostMemoryAlreadyRegistered

hipErrorHostMemoryAlreadyRegistered

Definition hip_runtime_api.h:360

hipErrorMissingConfiguration

hipErrorMissingConfiguration

Definition hip_runtime_api.h:312

hipErrorSharedObjectSymbolNotFound

hipErrorSharedObjectSymbolNotFound

Definition hip_runtime_api.h:339

hipErrorECCNotCorrectable

hipErrorECCNotCorrectable

Definition hip_runtime_api.h:331

hipErrorStreamCaptureWrongThread

hipErrorStreamCaptureWrongThread

Definition hip_runtime_api.h:388

hipErrorAssert

hipErrorAssert

Produced when the kernel calls assert.

Definition hip_runtime_api.h:359

hipErrorContextAlreadyInUse

hipErrorContextAlreadyInUse

The context is already in use.

Definition hip_runtime_api.h:333

hipErrorNotReady

hipErrorNotReady

Definition hip_runtime_api.h:347

hipErrorInvalidSource

hipErrorInvalidSource

Invalid source.

Definition hip_runtime_api.h:337

hipErrorLaunchOutOfResources

hipErrorLaunchOutOfResources

Out of resources error.

Definition hip_runtime_api.h:352

hipErrorInvalidDeviceFunction

hipErrorInvalidDeviceFunction

Invalid device function.

Definition hip_runtime_api.h:314

hipErrorCooperativeLaunchTooLarge

hipErrorCooperativeLaunchTooLarge

Definition hip_runtime_api.h:365

hipErrorAlreadyMapped

hipErrorAlreadyMapped

Definition hip_runtime_api.h:325

hipErrorProfilerNotInitialized

hipErrorProfilerNotInitialized

Definition hip_runtime_api.h:303

hipErrorProfilerAlreadyStarted

hipErrorProfilerAlreadyStarted

Definition hip_runtime_api.h:304

hipErrorInvalidChannelDescriptor

hipErrorInvalidChannelDescriptor

Invalid channel descriptor.

Definition hip_runtime_api.h:396

hipErrorNoDevice

hipErrorNoDevice

Call to hipGetDeviceCount returned 0 devices.

Definition hip_runtime_api.h:315

HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

@ HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

Definition hip_runtime_api.h:42

HIP_ERROR_INVALID_VALUE

@ HIP_ERROR_INVALID_VALUE

Definition hip_runtime_api.h:40

HIP_SUCCESS

@ HIP_SUCCESS

Definition hip_runtime_api.h:39

HIP_ERROR_NOT_INITIALIZED

@ HIP_ERROR_NOT_INITIALIZED

Definition hip_runtime_api.h:41

hipErrorMapFailed

hipErrorMapFailed

Definition hip_runtime_api.h:320

hipErrorStreamCaptureInvalidated

hipErrorStreamCaptureInvalidated

Definition hip_runtime_api.h:372

hipErrorProfilerAlreadyStopped

hipErrorProfilerAlreadyStopped

Definition hip_runtime_api.h:305

hipErrorDeinitialized

hipErrorDeinitialized

Deinitialized.

Definition hip_runtime_api.h:301

hipErrorPeerAccessAlreadyEnabled

hipErrorPeerAccessAlreadyEnabled

Definition hip_runtime_api.h:354

hipErrorNotMappedAsArray

hipErrorNotMappedAsArray

Definition hip_runtime_api.h:329

hipErrorNotSupported

hipErrorNotSupported

Produced when the hip API is not supported/implemented.

Definition hip_runtime_api.h:369

hipErrorInvalidConfiguration

hipErrorInvalidConfiguration

Invalide configuration.

Definition hip_runtime_api.h:306

hipErrorStreamCaptureImplicit

hipErrorStreamCaptureImplicit

Definition hip_runtime_api.h:383

hipErrorStreamCaptureMerge

hipErrorStreamCaptureMerge

Definition hip_runtime_api.h:374

hipErrorInvalidGraphicsContext

hipErrorInvalidGraphicsContext

Definition hip_runtime_api.h:336

hipErrorIllegalState

hipErrorIllegalState

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

Definition hip_runtime_api.h:345

hipErrorOutOfMemory

hipErrorOutOfMemory

out of memory range.

Definition hip_runtime_api.h:295

hipErrorInvalidSymbol

hipErrorInvalidSymbol

Invalid symbol.

Definition hip_runtime_api.h:308

hipSuccess

hipSuccess

Successful completion.

Definition hip_runtime_api.h:292

hipErrorUnknown

hipErrorUnknown

Unknown error.

Definition hip_runtime_api.h:398

hipErrorInvalidHandle

hipErrorInvalidHandle

Invalide handle.

Definition hip_runtime_api.h:342

hipErrorStreamCaptureUnmatched

hipErrorStreamCaptureUnmatched

The capture was not initiated in this stream.

Definition hip_runtime_api.h:376

hipErrorCapturedEvent

hipErrorCapturedEvent

Definition hip_runtime_api.h:386

hipErrorAlreadyAcquired

hipErrorAlreadyAcquired

Definition hip_runtime_api.h:327

hipErrorInsufficientDriver

hipErrorInsufficientDriver

Definition hip_runtime_api.h:311

hipErrorHostMemoryNotRegistered

hipErrorHostMemoryNotRegistered

Definition hip_runtime_api.h:362

hipErrorInvalidTexture

hipErrorInvalidTexture

Invalid texture.

Definition hip_runtime_api.h:397

hipErrorRuntimeOther

hipErrorRuntimeOther

Definition hip_runtime_api.h:402

hipErrorContextAlreadyCurrent

hipErrorContextAlreadyCurrent

Definition hip_runtime_api.h:319

hipErrorInvalidMemcpyDirection

hipErrorInvalidMemcpyDirection

Invalid memory copy direction.

Definition hip_runtime_api.h:310

linker_types.h

hip_impl

Definition hip_runtime_api.h:602

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

HIP_MEMSET_NODE_PARAMS::height

size_t height

Number of rows.

Definition hip_runtime_api.h:1476

HIP_MEMSET_NODE_PARAMS::pitch

size_t pitch

Destination device pointer pitch. Unused if height equals 1.

Definition hip_runtime_api.h:1472

HIP_MEMSET_NODE_PARAMS::dst

hipDeviceptr_t dst

Destination pointer on device.

Definition hip_runtime_api.h:1471

HIP_MEMSET_NODE_PARAMS::value

unsigned int value

Value of memset to be set.

Definition hip_runtime_api.h:1473

HIP_MEMSET_NODE_PARAMS::elementSize

unsigned int elementSize

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

Definition hip_runtime_api.h:1474

HIP_MEMSET_NODE_PARAMS::width

size_t width

Width of a row.

Definition hip_runtime_api.h:1475

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

dim3::y

uint32_t y

y

Definition hip_runtime_api.h:1187

dim3::z

uint32_t z

z

Definition hip_runtime_api.h:1188

dim3::x

uint32_t x

x

Definition hip_runtime_api.h:1186

dim3::dim3

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

Definition hip_runtime_api.h:1190

hip_Memcpy2D

Definition driver_types.h:116

hipAccessPolicyWindow

Definition hip_runtime_api.h:1426

hipAccessPolicyWindow::hitProp

hipAccessProperty hitProp

Definition hip_runtime_api.h:1428

hipAccessPolicyWindow::missProp

hipAccessProperty missProp

Definition hip_runtime_api.h:1430

hipAccessPolicyWindow::hitRatio

float hitRatio

Definition hip_runtime_api.h:1429

hipAccessPolicyWindow::base_ptr

void * base_ptr

Definition hip_runtime_api.h:1427

hipAccessPolicyWindow::num_bytes

size_t num_bytes

Definition hip_runtime_api.h:1431

hipArrayMapInfo

Definition hip_runtime_api.h:1663

hipArrayMapInfo::level

unsigned int level

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

Definition hip_runtime_api.h:1672

hipArrayMapInfo::flags

unsigned int flags

flags for future use, must be zero now.

Definition hip_runtime_api.h:1694

hipArrayMapInfo::subresourceType

hipArraySparseSubresourceType subresourceType

Sparse subresource type.

Definition hip_runtime_api.h:1669

hipArrayMapInfo::extentDepth

unsigned int extentDepth

Depth in elements.

Definition hip_runtime_api.h:1679

hipArrayMapInfo::offsetX

unsigned int offsetX

X offset in elements.

Definition hip_runtime_api.h:1674

hipArrayMapInfo::array

hipArray_t array

Definition hip_runtime_api.h:1667

hipArrayMapInfo::resourceType

hipResourceType resourceType

Resource type.

Definition hip_runtime_api.h:1664

hipArrayMapInfo::memOperationType

hipMemOperationType memOperationType

Memory operation type.

Definition hip_runtime_api.h:1687

hipArrayMapInfo::reserved

unsigned int reserved[2]

Reserved for future use, must be zero now.

Definition hip_runtime_api.h:1695

hipArrayMapInfo::extentWidth

unsigned int extentWidth

Width in elements.

Definition hip_runtime_api.h:1677

hipArrayMapInfo::extentHeight

unsigned int extentHeight

Height in elements.

Definition hip_runtime_api.h:1678

hipArrayMapInfo::offsetY

unsigned int offsetY

Y offset in elements.

Definition hip_runtime_api.h:1675

hipArrayMapInfo::memHandleType

hipMemHandleType memHandleType

Memory handle type.

Definition hip_runtime_api.h:1688

hipArrayMapInfo::sparseLevel

struct hipArrayMapInfo::@30::@32 sparseLevel

hipArrayMapInfo::resource

union hipArrayMapInfo::@29 resource

hipArrayMapInfo::memHandle

hipMemGenericAllocationHandle_t memHandle

Definition hip_runtime_api.h:1690

hipArrayMapInfo::mipmap

hipMipmappedArray mipmap

Definition hip_runtime_api.h:1666

hipArrayMapInfo::layer

unsigned int layer

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

Definition hip_runtime_api.h:1673

hipArrayMapInfo::deviceBitMask

unsigned int deviceBitMask

Device ordinal bit mask.

Definition hip_runtime_api.h:1693

hipArrayMapInfo::size

unsigned long long size

Extent in bytes.

Definition hip_runtime_api.h:1684

hipArrayMapInfo::miptail

struct hipArrayMapInfo::@30::@33 miptail

hipArrayMapInfo::subresource

union hipArrayMapInfo::@30 subresource

hipArrayMapInfo::offset

unsigned long long offset

Offset within mip tail.

Definition hip_runtime_api.h:1683

hipArrayMapInfo::offsetZ

unsigned int offsetZ

Z offset in elements.

Definition hip_runtime_api.h:1676

hipBatchMemOpNodeParams

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

Definition hip_runtime_api.h:954

hipBatchMemOpNodeParams::paramArray

hipStreamBatchMemOpParams * paramArray

Definition hip_runtime_api.h:957

hipBatchMemOpNodeParams::count

unsigned int count

Definition hip_runtime_api.h:956

hipBatchMemOpNodeParams::flags

unsigned int flags

Definition hip_runtime_api.h:958

hipBatchMemOpNodeParams::ctx

hipCtx_t ctx

Definition hip_runtime_api.h:955

hipChannelFormatDesc

Definition driver_types.h:60

hipChildGraphNodeParams

Definition hip_runtime_api.h:1710

hipChildGraphNodeParams::graph

hipGraph_t graph

Definition hip_runtime_api.h:1711

hipDeviceArch_t

Definition hip_runtime_api.h:54

hipDeviceArch_t::hasSharedInt64Atomics

unsigned hasSharedInt64Atomics

64-bit integer atomics for shared memory.

Definition hip_runtime_api.h:64

hipDeviceArch_t::hasSharedInt32Atomics

unsigned hasSharedInt32Atomics

32-bit integer atomics for shared memory.

Definition hip_runtime_api.h:58

hipDeviceArch_t::hasFloatAtomicAdd

unsigned hasFloatAtomicAdd

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

Definition hip_runtime_api.h:60

hipDeviceArch_t::hasDoubles

unsigned hasDoubles

Double-precision floating point.

Definition hip_runtime_api.h:67

hipDeviceArch_t::hasWarpVote

unsigned hasWarpVote

Warp vote instructions (__any, __all).

Definition hip_runtime_api.h:70

hipDeviceArch_t::hasWarpShuffle

unsigned hasWarpShuffle

Warp shuffle operations. (__shfl_*).

Definition hip_runtime_api.h:72

hipDeviceArch_t::hasGlobalInt32Atomics

unsigned hasGlobalInt32Atomics

32-bit integer atomics for global memory.

Definition hip_runtime_api.h:56

hipDeviceArch_t::hasGlobalFloatAtomicExch

unsigned hasGlobalFloatAtomicExch

32-bit float atomic exch for global memory.

Definition hip_runtime_api.h:57

hipDeviceArch_t::hasDynamicParallelism

unsigned hasDynamicParallelism

Dynamic parallelism.

Definition hip_runtime_api.h:82

hipDeviceArch_t::hasSurfaceFuncs

unsigned hasSurfaceFuncs

Surface functions.

Definition hip_runtime_api.h:80

hipDeviceArch_t::has3dGrid

unsigned has3dGrid

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

Definition hip_runtime_api.h:81

hipDeviceArch_t::hasFunnelShift

unsigned hasFunnelShift

Funnel two words into one with shift&mask caps.

Definition hip_runtime_api.h:73

hipDeviceArch_t::hasThreadFenceSystem

unsigned hasThreadFenceSystem

__threadfence_system.

Definition hip_runtime_api.h:76

hipDeviceArch_t::hasGlobalInt64Atomics

unsigned hasGlobalInt64Atomics

64-bit integer atomics for global memory.

Definition hip_runtime_api.h:63

hipDeviceArch_t::hasSyncThreadsExt

unsigned hasSyncThreadsExt

__syncthreads_count, syncthreads_and, syncthreads_or.

Definition hip_runtime_api.h:77

hipDeviceArch_t::hasWarpBallot

unsigned hasWarpBallot

Warp ballot instructions (__ballot).

Definition hip_runtime_api.h:71

hipDeviceArch_t::hasSharedFloatAtomicExch

unsigned hasSharedFloatAtomicExch

32-bit float atomic exch for shared memory.

Definition hip_runtime_api.h:59

hipDeviceProp_t

Definition hip_runtime_api.h:100

hipDeviceProp_t::ECCEnabled

int ECCEnabled

Device has ECC support enabled.

Definition hip_runtime_api.h:157

hipDeviceProp_t::ipcEventSupported

int ipcEventSupported

Device supports IPC events.

Definition hip_runtime_api.h:212

hipDeviceProp_t::computePreemptionSupported

int computePreemptionSupported

Is compute preemption supported on the device.

Definition hip_runtime_api.h:183

hipDeviceProp_t::maxTexture1DLinear

int maxTexture1DLinear

Maximum size for 1D textures bound to linear memory.

Definition hip_runtime_api.h:136

hipDeviceProp_t::timelineSemaphoreInteropSupported

int timelineSemaphoreInteropSupported

Indicates external timeline semaphore support.

Definition hip_runtime_api.h:202

hipDeviceProp_t::pciBusID

int pciBusID

PCI Bus ID.

Definition hip_runtime_api.h:158

hipDeviceProp_t::maxTexture1D

int maxTexture1D

Maximum number of elements in 1D images.

Definition hip_runtime_api.h:134

hipDeviceProp_t::memoryBusWidth

int memoryBusWidth

Global memory bus width in bits.

Definition hip_runtime_api.h:165

hipDeviceProp_t::maxTexture2DMipmap

int maxTexture2DMipmap[2]

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

Definition hip_runtime_api.h:138

hipDeviceProp_t::clockRate

int clockRate

Max clock frequency of the multiProcessors in khz.

Definition hip_runtime_api.h:114

hipDeviceProp_t::maxThreadsPerMultiProcessor

int maxThreadsPerMultiProcessor

Maximum resident threads per multi-processor.

Definition hip_runtime_api.h:168

hipDeviceProp_t::l2CacheSize

int l2CacheSize

L2 cache size.

Definition hip_runtime_api.h:166

hipDeviceProp_t::deferredMappingHipArraySupported

int deferredMappingHipArraySupported

Definition hip_runtime_api.h:210

hipDeviceProp_t::asyncEngineCount

int asyncEngineCount

Number of async engines.

Definition hip_runtime_api.h:162

hipDeviceProp_t::accessPolicyMaxWindowSize

int accessPolicyMaxWindowSize

Max value of access policy window.

Definition hip_runtime_api.h:196

hipDeviceProp_t::totalConstMem

size_t totalConstMem

Definition hip_runtime_api.h:115

hipDeviceProp_t::memoryPoolsSupported

int memoryPoolsSupported

Indicates if device supports hipMallocAsync and hipMemPool APIs.

Definition hip_runtime_api.h:203

hipDeviceProp_t::unifiedFunctionPointers

int unifiedFunctionPointers

Indicates device supports unified function pointers.

Definition hip_runtime_api.h:214

hipDeviceProp_t::maxTexture2DGather

int maxTexture2DGather[2]

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

Definition hip_runtime_api.h:140

hipDeviceProp_t::memPitch

size_t memPitch

Definition hip_runtime_api.h:109

hipDeviceProp_t::gpuDirectRDMAWritesOrdering

int gpuDirectRDMAWritesOrdering

value of hipGPUDirectRDMAWritesOrdering

Definition hip_runtime_api.h:207

hipDeviceProp_t::uuid

hipUUID uuid

UUID of a device.

Definition hip_runtime_api.h:102

hipDeviceProp_t::sharedMemPerBlock

size_t sharedMemPerBlock

Size of shared memory per block (in bytes).

Definition hip_runtime_api.h:106

hipDeviceProp_t::gpuDirectRDMAFlushWritesOptions

unsigned int gpuDirectRDMAFlushWritesOptions

Definition hip_runtime_api.h:205

hipDeviceProp_t::surfaceAlignment

size_t surfaceAlignment

Alignment requirement for surface.

Definition hip_runtime_api.h:155

hipDeviceProp_t::reserved

int reserved[63]

CUDA Reserved.

Definition hip_runtime_api.h:215

hipDeviceProp_t::maxTexture2DLayered

int maxTexture2DLayered[3]

Maximum number of elements in 2D array images.

Definition hip_runtime_api.h:146

hipDeviceProp_t::streamPrioritiesSupported

int streamPrioritiesSupported

Device supports stream priority.

Definition hip_runtime_api.h:169

hipDeviceProp_t::cooperativeMultiDeviceLaunch

int cooperativeMultiDeviceLaunch

Definition hip_runtime_api.h:187

hipDeviceProp_t::hostRegisterSupported

int hostRegisterSupported

Device supports hipHostRegister.

Definition hip_runtime_api.h:198

hipDeviceProp_t::pageableMemoryAccess

int pageableMemoryAccess

Definition hip_runtime_api.h:179

hipDeviceProp_t::name

char name[256]

Device name.

Definition hip_runtime_api.h:101

hipDeviceProp_t::textureAlignment

size_t textureAlignment

Alignment requirement for textures.

Definition hip_runtime_api.h:126

hipDeviceProp_t::globalL1CacheSupported

int globalL1CacheSupported

Indicates globals are cached in L1.

Definition hip_runtime_api.h:170

hipDeviceProp_t::hostNativeAtomicSupported

int hostNativeAtomicSupported

Link between host and device supports native atomics.

Definition hip_runtime_api.h:177

hipDeviceProp_t::maxSurfaceCubemapLayered

int maxSurfaceCubemapLayered[2]

Maximum cubemap layered surface size.

Definition hip_runtime_api.h:154

hipDeviceProp_t::maxTextureCubemapLayered

int maxTextureCubemapLayered[2]

Maximum cubemaps layered texture dims.

Definition hip_runtime_api.h:147

hipDeviceProp_t::sharedMemPerBlockOptin

size_t sharedMemPerBlockOptin

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

Definition hip_runtime_api.h:190

hipDeviceProp_t::sharedMemPerMultiprocessor

size_t sharedMemPerMultiprocessor

Amount of shared memory available per multiprocessor.

Definition hip_runtime_api.h:172

hipDeviceProp_t::singleToDoublePrecisionPerfRatio

int singleToDoublePrecisionPerfRatio

Deprecated. CUDA only.

Definition hip_runtime_api.h:178

hipDeviceProp_t::maxSurface2D

int maxSurface2D[2]

Maximum 2D surface size.

Definition hip_runtime_api.h:149

hipDeviceProp_t::memoryClockRate

int memoryClockRate

Max global memory clock frequency in khz.

Definition hip_runtime_api.h:164

hipDeviceProp_t::maxTexture2DLinear

int maxTexture2DLinear[3]

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

Definition hip_runtime_api.h:139

hipDeviceProp_t::sparseHipArraySupported

int sparseHipArraySupported

Indicates if device supports sparse hip arrays.

Definition hip_runtime_api.h:199

hipDeviceProp_t::clockInstructionRate

int clockInstructionRate

Definition hip_runtime_api.h:222

hipDeviceProp_t::localL1CacheSupported

int localL1CacheSupported

Locals are cahced in L1.

Definition hip_runtime_api.h:171

hipDeviceProp_t::regsPerMultiprocessor

int regsPerMultiprocessor

registers available per multiprocessor

Definition hip_runtime_api.h:173

hipDeviceProp_t::regsPerBlock

int regsPerBlock

Registers per block.

Definition hip_runtime_api.h:107

hipDeviceProp_t::maxTexture2D

int maxTexture2D[2]

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

Definition hip_runtime_api.h:137

hipDeviceProp_t::cooperativeLaunch

int cooperativeLaunch

HIP device supports cooperative launch.

Definition hip_runtime_api.h:186

hipDeviceProp_t::maxTexture3D

int maxTexture3D[3]

Definition hip_runtime_api.h:141

hipDeviceProp_t::directManagedMemAccessFromHost

int directManagedMemAccessFromHost

Definition hip_runtime_api.h:193

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedFunc

int cooperativeMultiDeviceUnmatchedFunc

Definition hip_runtime_api.h:227

hipDeviceProp_t::deviceOverlap

int deviceOverlap

Deprecated. Use asyncEngineCount instead.

Definition hip_runtime_api.h:128

hipDeviceProp_t::pageableMemoryAccessUsesHostPageTables

int pageableMemoryAccessUsesHostPageTables

Definition hip_runtime_api.h:191

hipDeviceProp_t::hdpRegFlushCntl

unsigned int * hdpRegFlushCntl

Addres of HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:226

hipDeviceProp_t::maxThreadsDim

int maxThreadsDim[3]

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

Definition hip_runtime_api.h:112

hipDeviceProp_t::unifiedAddressing

int unifiedAddressing

Does device and host share unified address space.

Definition hip_runtime_api.h:163

hipDeviceProp_t::multiGpuBoardGroupID

int multiGpuBoardGroupID

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

Definition hip_runtime_api.h:176

hipDeviceProp_t::isMultiGpuBoard

int isMultiGpuBoard

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

Definition hip_runtime_api.h:175

hipDeviceProp_t::canUseHostPointerForRegisteredMem

int canUseHostPointerForRegisteredMem

Definition hip_runtime_api.h:184

hipDeviceProp_t::maxTexture1DLayered

int maxTexture1DLayered[2]

Maximum number of elements in 1D array images.

Definition hip_runtime_api.h:145

hipDeviceProp_t::pciDomainID

int pciDomainID

PCI Domain ID.

Definition hip_runtime_api.h:160

hipDeviceProp_t::maxSharedMemoryPerMultiProcessor

size_t maxSharedMemoryPerMultiProcessor

Maximum Shared Memory Per CU. HIP Only.

Definition hip_runtime_api.h:221

hipDeviceProp_t::maxTextureCubemap

int maxTextureCubemap

Maximum cubemap texture dims.

Definition hip_runtime_api.h:144

hipDeviceProp_t::hipReserved

int hipReserved[32]

Reserved for adding new entries for HIP/CUDA.

Definition hip_runtime_api.h:217

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedGridDim

int cooperativeMultiDeviceUnmatchedGridDim

Definition hip_runtime_api.h:230

hipDeviceProp_t::gpuDirectRDMASupported

int gpuDirectRDMASupported

Indicates device support of RDMA APIs.

Definition hip_runtime_api.h:204

hipDeviceProp_t::minor

int minor

Definition hip_runtime_api.h:121

hipDeviceProp_t::gcnArchName

char gcnArchName[256]

AMD GCN Arch Name. HIP Only.

Definition hip_runtime_api.h:220

hipDeviceProp_t::luid

char luid[8]

8-byte unique identifier. Only valid on windows

Definition hip_runtime_api.h:103

hipDeviceProp_t::kernelExecTimeoutEnabled

int kernelExecTimeoutEnabled

Run time limit for kernels executed on the device.

Definition hip_runtime_api.h:130

hipDeviceProp_t::memoryPoolSupportedHandleTypes

unsigned int memoryPoolSupportedHandleTypes

Bitmask of handle types support with mempool based IPC.

Definition hip_runtime_api.h:209

hipDeviceProp_t::hdpMemFlushCntl

unsigned int * hdpMemFlushCntl

Addres of HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:225

hipDeviceProp_t::concurrentManagedAccess

int concurrentManagedAccess

Definition hip_runtime_api.h:181

hipDeviceProp_t::integrated

int integrated

APU vs dGPU.

Definition hip_runtime_api.h:131

hipDeviceProp_t::canMapHostMemory

int canMapHostMemory

Check whether HIP can map host memory.

Definition hip_runtime_api.h:132

hipDeviceProp_t::reservedSharedMemPerBlock

size_t reservedSharedMemPerBlock

Shared memory reserved by driver per block.

Definition hip_runtime_api.h:197

hipDeviceProp_t::maxSurfaceCubemap

int maxSurfaceCubemap

Maximum cubemap surface size.

Definition hip_runtime_api.h:153

hipDeviceProp_t::maxSurface3D

int maxSurface3D[3]

Maximum 3D surface size.

Definition hip_runtime_api.h:150

hipDeviceProp_t::asicRevision

int asicRevision

Revision of the GPU in this device.

Definition hip_runtime_api.h:240

hipDeviceProp_t::totalGlobalMem

size_t totalGlobalMem

Size of global memory region (in bytes).

Definition hip_runtime_api.h:105

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedBlockDim

int cooperativeMultiDeviceUnmatchedBlockDim

Definition hip_runtime_api.h:233

hipDeviceProp_t::maxSurface1DLayered

int maxSurface1DLayered[2]

Maximum 1D layered surface size.

Definition hip_runtime_api.h:151

hipDeviceProp_t::persistingL2CacheMaxSize

int persistingL2CacheMaxSize

Device's max L2 persisting lines in bytes.

Definition hip_runtime_api.h:167

hipDeviceProp_t::maxSurface1D

int maxSurface1D

Maximum 1D surface size.

Definition hip_runtime_api.h:148

hipDeviceProp_t::concurrentKernels

int concurrentKernels

Device can possibly execute multiple kernels concurrently.

Definition hip_runtime_api.h:156

hipDeviceProp_t::isLargeBar

int isLargeBar

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

Definition hip_runtime_api.h:239

hipDeviceProp_t::clusterLaunch

int clusterLaunch

Device supports cluster launch.

Definition hip_runtime_api.h:213

hipDeviceProp_t::maxTexture1DMipmap

int maxTexture1DMipmap

Maximum 1D mipmap texture size.

Definition hip_runtime_api.h:135

hipDeviceProp_t::multiProcessorCount

int multiProcessorCount

Number of multi-processors (compute units).

Definition hip_runtime_api.h:129

hipDeviceProp_t::maxTexture3DAlt

int maxTexture3DAlt[3]

Maximum alternate 3D texture dims.

Definition hip_runtime_api.h:143

hipDeviceProp_t::maxGridSize

int maxGridSize[3]

Max grid dimensions (XYZ).

Definition hip_runtime_api.h:113

hipDeviceProp_t::pciDeviceID

int pciDeviceID

PCI Device ID.

Definition hip_runtime_api.h:159

hipDeviceProp_t::maxBlocksPerMultiProcessor

int maxBlocksPerMultiProcessor

Max number of blocks on CU.

Definition hip_runtime_api.h:195

hipDeviceProp_t::computeMode

int computeMode

Compute mode.

Definition hip_runtime_api.h:133

hipDeviceProp_t::maxSurface2DLayered

int maxSurface2DLayered[3]

Maximum 2D layared surface size.

Definition hip_runtime_api.h:152

hipDeviceProp_t::major

int major

Definition hip_runtime_api.h:117

hipDeviceProp_t::warpSize

int warpSize

Warp size.

Definition hip_runtime_api.h:108

hipDeviceProp_t::tccDriver

int tccDriver

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

Definition hip_runtime_api.h:161

hipDeviceProp_t::luidDeviceNodeMask

unsigned int luidDeviceNodeMask

LUID node mask.

Definition hip_runtime_api.h:104

hipDeviceProp_t::hostRegisterReadOnlySupported

int hostRegisterReadOnlySupported

Definition hip_runtime_api.h:200

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedSharedMem

int cooperativeMultiDeviceUnmatchedSharedMem

Definition hip_runtime_api.h:236

hipDeviceProp_t::maxThreadsPerBlock

int maxThreadsPerBlock

Max work items per work group or workgroup max size.

Definition hip_runtime_api.h:111

hipDeviceProp_t::arch

hipDeviceArch_t arch

Architectural feature flags. New for HIP.

Definition hip_runtime_api.h:224

hipDeviceProp_t::managedMemory

int managedMemory

Device supports allocating managed memory on this system.

Definition hip_runtime_api.h:174

hipDeviceProp_t::texturePitchAlignment

size_t texturePitchAlignment

Pitch alignment requirement for texture references bound to.

Definition hip_runtime_api.h:127

hipEventRecordNodeParams

Definition hip_runtime_api.h:1725

hipEventRecordNodeParams::event

hipEvent_t event

The event to be recorded when node executes.

Definition hip_runtime_api.h:1726

hipEventWaitNodeParams

Definition hip_runtime_api.h:1718

hipEventWaitNodeParams::event

hipEvent_t event

Event to wait on.

Definition hip_runtime_api.h:1719

hipExtent

Definition driver_types.h:397

hipExternalMemoryBufferDesc

Definition hip_runtime_api.h:1243

hipExternalMemoryBufferDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1246

hipExternalMemoryBufferDesc::offset

unsigned long long offset

Definition hip_runtime_api.h:1244

hipExternalMemoryBufferDesc::size

unsigned long long size

Definition hip_runtime_api.h:1245

hipExternalMemoryHandleDesc

Definition hip_runtime_api.h:1229

hipExternalMemoryHandleDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1240

hipExternalMemoryHandleDesc::name

const void * name

Definition hip_runtime_api.h:1235

hipExternalMemoryHandleDesc::fd

int fd

Definition hip_runtime_api.h:1232

hipExternalMemoryHandleDesc::size

unsigned long long size

Definition hip_runtime_api.h:1239

hipExternalMemoryHandleDesc::type

hipExternalMemoryHandleType type

Definition hip_runtime_api.h:1230

hipExternalMemoryHandleDesc::nvSciBufObject

const void * nvSciBufObject

Definition hip_runtime_api.h:1237

hipExternalMemoryHandleDesc::handle

void * handle

Definition hip_runtime_api.h:1234

hipExternalMemoryMipmappedArrayDesc

Definition hip_runtime_api.h:1249

hipExternalMemoryMipmappedArrayDesc::extent

hipExtent extent

Definition hip_runtime_api.h:1252

hipExternalMemoryMipmappedArrayDesc::numLevels

unsigned int numLevels

Definition hip_runtime_api.h:1254

hipExternalMemoryMipmappedArrayDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1253

hipExternalMemoryMipmappedArrayDesc::offset

unsigned long long offset

Definition hip_runtime_api.h:1250

hipExternalMemoryMipmappedArrayDesc::formatDesc

hipChannelFormatDesc formatDesc

Definition hip_runtime_api.h:1251

hipExternalSemaphoreHandleDesc

Definition hip_runtime_api.h:1269

hipExternalSemaphoreHandleDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1279

hipExternalSemaphoreHandleDesc::name

const void * name

Definition hip_runtime_api.h:1275

hipExternalSemaphoreHandleDesc::NvSciSyncObj

const void * NvSciSyncObj

Definition hip_runtime_api.h:1277

hipExternalSemaphoreHandleDesc::type

hipExternalSemaphoreHandleType type

Definition hip_runtime_api.h:1270

hipExternalSemaphoreHandleDesc::handle

void * handle

Definition hip_runtime_api.h:1274

hipExternalSemaphoreHandleDesc::fd

int fd

Definition hip_runtime_api.h:1272

hipExternalSemaphoreSignalNodeParams

Definition hip_runtime_api.h:1603

hipExternalSemaphoreSignalNodeParams::paramsArray

const hipExternalSemaphoreSignalParams * paramsArray

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

Definition hip_runtime_api.h:1607

hipExternalSemaphoreSignalNodeParams::extSemArray

hipExternalSemaphore_t * extSemArray

< Array containing external semaphore handles.

Definition hip_runtime_api.h:1605

hipExternalSemaphoreSignalNodeParams::numExtSems

unsigned int numExtSems

Definition hip_runtime_api.h:1609

hipExternalSemaphoreSignalParams

Definition hip_runtime_api.h:1283

hipExternalSemaphoreSignalParams::reserved

unsigned long long reserved

Definition hip_runtime_api.h:1290

hipExternalSemaphoreSignalParams::value

unsigned long long value

Definition hip_runtime_api.h:1286

hipExternalSemaphoreSignalParams::fence

void * fence

Definition hip_runtime_api.h:1289

hipExternalSemaphoreSignalParams::flags

unsigned int flags

Definition hip_runtime_api.h:1297

hipExternalSemaphoreSignalParams::key

unsigned long long key

Definition hip_runtime_api.h:1293

hipExternalSemaphoreWaitNodeParams

Definition hip_runtime_api.h:1615

hipExternalSemaphoreWaitNodeParams::numExtSems

unsigned int numExtSems

Definition hip_runtime_api.h:1621

hipExternalSemaphoreWaitNodeParams::paramsArray

const hipExternalSemaphoreWaitParams * paramsArray

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

Definition hip_runtime_api.h:1619

hipExternalSemaphoreWaitNodeParams::extSemArray

hipExternalSemaphore_t * extSemArray

< Array containing external semaphore handles.

Definition hip_runtime_api.h:1617

hipExternalSemaphoreWaitParams

Definition hip_runtime_api.h:1303

hipExternalSemaphoreWaitParams::value

unsigned long long value

Definition hip_runtime_api.h:1306

hipExternalSemaphoreWaitParams::fence

void * fence

Definition hip_runtime_api.h:1309

hipExternalSemaphoreWaitParams::timeoutMs

unsigned int timeoutMs

Definition hip_runtime_api.h:1314

hipExternalSemaphoreWaitParams::key

unsigned long long key

Definition hip_runtime_api.h:1313

hipExternalSemaphoreWaitParams::flags

unsigned int flags

Definition hip_runtime_api.h:1318

hipExternalSemaphoreWaitParams::reserved

unsigned long long reserved

Definition hip_runtime_api.h:1310

hipFuncAttributes

Definition hip_runtime_api.h:638

hipFuncAttributes::cacheModeCA

int cacheModeCA

Definition hip_runtime_api.h:640

hipFuncAttributes::binaryVersion

int binaryVersion

Definition hip_runtime_api.h:639

hipFuncAttributes::constSizeBytes

size_t constSizeBytes

Definition hip_runtime_api.h:641

hipFuncAttributes::preferredShmemCarveout

int preferredShmemCarveout

Definition hip_runtime_api.h:646

hipFuncAttributes::sharedSizeBytes

size_t sharedSizeBytes

Definition hip_runtime_api.h:648

hipFuncAttributes::maxDynamicSharedSizeBytes

int maxDynamicSharedSizeBytes

Definition hip_runtime_api.h:643

hipFuncAttributes::ptxVersion

int ptxVersion

Definition hip_runtime_api.h:647

hipFuncAttributes::numRegs

int numRegs

Definition hip_runtime_api.h:645

hipFuncAttributes::localSizeBytes

size_t localSizeBytes

Definition hip_runtime_api.h:642

hipFuncAttributes::maxThreadsPerBlock

int maxThreadsPerBlock

Definition hip_runtime_api.h:644

hipFunctionLaunchParams

Definition hip_runtime_api.h:1207

hipFunctionLaunchParams::gridDimX

unsigned int gridDimX

Width(X) of grid in blocks.

Definition hip_runtime_api.h:1209

hipFunctionLaunchParams::blockDimX

unsigned int blockDimX

X dimension of each thread block.

Definition hip_runtime_api.h:1212

hipFunctionLaunchParams::function

hipFunction_t function

Kernel to launch.

Definition hip_runtime_api.h:1208

hipFunctionLaunchParams::hStream

hipStream_t hStream

Stream identifier.

Definition hip_runtime_api.h:1216

hipFunctionLaunchParams::blockDimY

unsigned int blockDimY

Y dimension of each thread block.

Definition hip_runtime_api.h:1213

hipFunctionLaunchParams::gridDimY

unsigned int gridDimY

Height(Y) of grid in blocks.

Definition hip_runtime_api.h:1210

hipFunctionLaunchParams::gridDimZ

unsigned int gridDimZ

Depth(Z) of grid in blocks.

Definition hip_runtime_api.h:1211

hipFunctionLaunchParams::sharedMemBytes

unsigned int sharedMemBytes

Shared memory.

Definition hip_runtime_api.h:1215

hipFunctionLaunchParams::blockDimZ

unsigned int blockDimZ

Z dimension of each thread block.

Definition hip_runtime_api.h:1214

hipFunctionLaunchParams::kernelParams

void ** kernelParams

Kernel parameters.

Definition hip_runtime_api.h:1217

hipGraphEdgeData

Definition hip_runtime_api.h:1782

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

hipGraphEdgeData::reserved

unsigned char reserved[5]

These bytes are unused and must be zeroed.

Definition hip_runtime_api.h:1791

hipGraphEdgeData::type

unsigned char type

This should be populated with a value from hipGraphDependencyType.

Definition hip_runtime_api.h:1794

hipGraphEdgeData::from_port

unsigned char from_port

Definition hip_runtime_api.h:1784

hipGraphInstantiateParams

Definition hip_runtime_api.h:1576

hipGraphInstantiateParams::result_out

hipGraphInstantiateResult result_out

Definition hip_runtime_api.h:1579

hipGraphInstantiateParams::uploadStream

hipStream_t uploadStream

Definition hip_runtime_api.h:1581

hipGraphInstantiateParams::errNode_out

hipGraphNode_t errNode_out

Definition hip_runtime_api.h:1577

hipGraphInstantiateParams::flags

unsigned long long flags

Definition hip_runtime_api.h:1578

hipGraphNodeParams

Definition hip_runtime_api.h:1739

hipGraphNodeParams::type

hipGraphNodeType type

Definition hip_runtime_api.h:1740

hipGraphNodeParams::reserved0

int reserved0[3]

Definition hip_runtime_api.h:1741

hipGraphNodeParams::alloc

hipMemAllocNodeParams alloc

Definition hip_runtime_api.h:1753

hipGraphNodeParams::reserved1

long long reserved1[29]

Definition hip_runtime_api.h:1743

hipGraphNodeParams::eventRecord

hipEventRecordNodeParams eventRecord

Definition hip_runtime_api.h:1750

hipGraphNodeParams::extSemSignal

hipExternalSemaphoreSignalNodeParams extSemSignal

Definition hip_runtime_api.h:1751

hipGraphNodeParams::free

hipMemFreeNodeParams free

Definition hip_runtime_api.h:1754

hipGraphNodeParams::graph

hipChildGraphNodeParams graph

Definition hip_runtime_api.h:1748

hipGraphNodeParams::extSemWait

hipExternalSemaphoreWaitNodeParams extSemWait

Definition hip_runtime_api.h:1752

hipGraphNodeParams::memset

hipMemsetParams memset

Definition hip_runtime_api.h:1746

hipGraphNodeParams::host

hipHostNodeParams host

Definition hip_runtime_api.h:1747

hipGraphNodeParams::reserved2

long long reserved2

Definition hip_runtime_api.h:1757

hipGraphNodeParams::kernel

hipKernelNodeParams kernel

Definition hip_runtime_api.h:1744

hipGraphNodeParams::eventWait

hipEventWaitNodeParams eventWait

Definition hip_runtime_api.h:1749

hipGraphNodeParams::memcpy

hipMemcpyNodeParams memcpy

Definition hip_runtime_api.h:1745

hipHostNodeParams

Definition hip_runtime_api.h:1389

hipHostNodeParams::fn

hipHostFn_t fn

Definition hip_runtime_api.h:1390

hipHostNodeParams::userData

void * userData

Definition hip_runtime_api.h:1391

hipIpcEventHandle_t

Definition hip_runtime_api.h:627

hipIpcMemHandle_t

Definition hip_runtime_api.h:624

hipKernelNodeParams

Definition hip_runtime_api.h:1393

hipKernelNodeParams::gridDim

dim3 gridDim

Definition hip_runtime_api.h:1397

hipKernelNodeParams::sharedMemBytes

unsigned int sharedMemBytes

Definition hip_runtime_api.h:1399

hipKernelNodeParams::blockDim

dim3 blockDim

Definition hip_runtime_api.h:1394

hipKernelNodeParams::kernelParams

void ** kernelParams

Definition hip_runtime_api.h:1398

hipKernelNodeParams::extra

void ** extra

Definition hip_runtime_api.h:1395

hipKernelNodeParams::func

void * func

Definition hip_runtime_api.h:1396

hipLaunchParams

Definition hip_runtime_api.h:1196

hipLaunchParams::sharedMem

size_t sharedMem

Shared memory.

Definition hip_runtime_api.h:1201

hipLaunchParams::args

void ** args

Arguments.

Definition hip_runtime_api.h:1200

hipLaunchParams::blockDim

dim3 blockDim

Block dimensions.

Definition hip_runtime_api.h:1199

hipLaunchParams::gridDim

dim3 gridDim

Grid dimensions.

Definition hip_runtime_api.h:1198

hipLaunchParams::func

void * func

Device function symbol.

Definition hip_runtime_api.h:1197

hipLaunchParams::stream

hipStream_t stream

Stream identifier.

Definition hip_runtime_api.h:1202

hipMemAccessDesc

Definition hip_runtime_api.h:1109

hipMemAccessDesc::flags

hipMemAccessFlags flags

Accessibility flags to set.

Definition hip_runtime_api.h:1111

hipMemAccessDesc::location

hipMemLocation location

Location on which the accessibility has to change.

Definition hip_runtime_api.h:1110

hipMemAllocNodeParams

Definition hip_runtime_api.h:1410

hipMemAllocNodeParams::accessDescs

const hipMemAccessDesc * accessDescs

The number of memory access descriptors.

Definition hip_runtime_api.h:1413

hipMemAllocNodeParams::bytesize

size_t bytesize

The size of the requested allocation in bytes.

Definition hip_runtime_api.h:1416

hipMemAllocNodeParams::poolProps

hipMemPoolProps poolProps

Definition hip_runtime_api.h:1411

hipMemAllocNodeParams::accessDescCount

size_t accessDescCount

Definition hip_runtime_api.h:1414

hipMemAllocNodeParams::dptr

void * dptr

Returned device address of the allocation.

Definition hip_runtime_api.h:1417

hipMemAllocationProp

Definition hip_runtime_api.h:1588

hipMemAllocationProp::win32HandleMetaData

void * win32HandleMetaData

Metadata for Win32 handles.

Definition hip_runtime_api.h:1592

hipMemAllocationProp::type

hipMemAllocationType type

Memory allocation type.

Definition hip_runtime_api.h:1589

hipMemAllocationProp::gpuDirectRDMACapable

unsigned char gpuDirectRDMACapable

RDMA capable.

Definition hip_runtime_api.h:1595

hipMemAllocationProp::allocFlags

struct hipMemAllocationProp::@28 allocFlags

hipMemAllocationProp::usage

unsigned short usage

Usage.

Definition hip_runtime_api.h:1596

hipMemAllocationProp::requestedHandleType

hipMemAllocationHandleType requestedHandleType

Requested handle type.

Definition hip_runtime_api.h:1590

hipMemAllocationProp::location

hipMemLocation location

Memory location.

Definition hip_runtime_api.h:1591

hipMemAllocationProp::compressionType

unsigned char compressionType

Compression type.

Definition hip_runtime_api.h:1594

hipMemFreeNodeParams

Definition hip_runtime_api.h:1732

hipMemFreeNodeParams::dptr

void * dptr

the pointer to be freed

Definition hip_runtime_api.h:1733

hipMemLocation

Definition hip_runtime_api.h:1090

hipMemLocation::id

int id

Identifier for the provided location type hipMemLocationType.

Definition hip_runtime_api.h:1092

hipMemLocation::type

hipMemLocationType type

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

Definition hip_runtime_api.h:1091

hipMemPoolProps

Definition hip_runtime_api.h:1137

hipMemPoolProps::maxSize

size_t maxSize

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

Definition hip_runtime_api.h:1145

hipMemPoolProps::reserved

unsigned char reserved[56]

Reserved for future use, must be 0.

Definition hip_runtime_api.h:1146

hipMemPoolProps::location

hipMemLocation location

Location where allocations should reside.

Definition hip_runtime_api.h:1140

hipMemPoolProps::handleTypes

hipMemAllocationHandleType handleTypes

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

Definition hip_runtime_api.h:1139

hipMemPoolProps::allocType

hipMemAllocationType allocType

Allocation type. Currently must be specified as hipMemAllocationTypePinned.

Definition hip_runtime_api.h:1138

hipMemPoolProps::win32SecurityAttributes

void * win32SecurityAttributes

Definition hip_runtime_api.h:1144

hipMemPoolPtrExportData

Definition hip_runtime_api.h:1151

hipMemPoolPtrExportData::reserved

unsigned char reserved[64]

Definition hip_runtime_api.h:1152

hipMemcpy3DParms

Definition driver_types.h:414

hipMemcpyNodeParams

Definition hip_runtime_api.h:1701

hipMemcpyNodeParams::reserved

int reserved[3]

Must be zero.

Definition hip_runtime_api.h:1703

hipMemcpyNodeParams::flags

int flags

Must be zero.

Definition hip_runtime_api.h:1702

hipMemcpyNodeParams::copyParams

hipMemcpy3DParms copyParams

Params set for the memory copy.

Definition hip_runtime_api.h:1704

hipMemsetParams

Definition hip_runtime_api.h:1401

hipMemsetParams::dst

void * dst

Definition hip_runtime_api.h:1402

hipMemsetParams::value

unsigned int value

Definition hip_runtime_api.h:1406

hipMemsetParams::elementSize

unsigned int elementSize

Definition hip_runtime_api.h:1403

hipMemsetParams::width

size_t width

Definition hip_runtime_api.h:1407

hipMemsetParams::pitch

size_t pitch

Definition hip_runtime_api.h:1405

hipMemsetParams::height

size_t height

Definition hip_runtime_api.h:1404

hipMipmappedArray

Definition driver_types.h:138

hipPitchedPtr

Definition driver_types.h:388

hipPointerAttribute_t

Definition hip_runtime_api.h:266

hipPointerAttribute_t::device

int device

Definition hip_runtime_api.h:268

hipPointerAttribute_t::hostPointer

void * hostPointer

Definition hip_runtime_api.h:270

hipPointerAttribute_t::type

enum hipMemoryType type

Definition hip_runtime_api.h:267

hipPointerAttribute_t::isManaged

int isManaged

Definition hip_runtime_api.h:271

hipPointerAttribute_t::devicePointer

void * devicePointer

Definition hip_runtime_api.h:269

hipPointerAttribute_t::allocationFlags

unsigned allocationFlags

Definition hip_runtime_api.h:272

hipResourceDesc

Definition driver_types.h:287

hipResourceViewDesc

Definition driver_types.h:347

hipStreamBatchMemOpParams::hipStreamMemOpFlushRemoteWritesParams_t

Definition hip_runtime_api.h:916

hipStreamBatchMemOpParams::hipStreamMemOpFlushRemoteWritesParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:918

hipStreamBatchMemOpParams::hipStreamMemOpFlushRemoteWritesParams_t::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:917

hipStreamBatchMemOpParams::hipStreamMemOpMemoryBarrierParams_t

Definition hip_runtime_api.h:920

hipStreamBatchMemOpParams::hipStreamMemOpMemoryBarrierParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:922

hipStreamBatchMemOpParams::hipStreamMemOpMemoryBarrierParams_t::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:921

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t

Definition hip_runtime_api.h:896

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:897

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::value64

uint64_t value64

Definition hip_runtime_api.h:901

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::address

hipDeviceptr_t address

Definition hip_runtime_api.h:898

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::alias

hipDeviceptr_t alias

Not valid for AMD backend. Initial value is unimportant.

Definition hip_runtime_api.h:904

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::value

uint32_t value

Definition hip_runtime_api.h:900

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:903

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t

Definition hip_runtime_api.h:906

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::address

hipDeviceptr_t address

Definition hip_runtime_api.h:908

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::alias

hipDeviceptr_t alias

Not valid for AMD backend. Initial value is unimportant.

Definition hip_runtime_api.h:914

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::value

uint32_t value

Definition hip_runtime_api.h:910

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:907

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:913

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::value64

uint64_t value64

Definition hip_runtime_api.h:911

hipTextureDesc

Definition texture_types.h:117

hipUUID

Definition hip_runtime_api.h:85

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

hipLaunchAttributeValue::priority

int priority

Definition hip_runtime_api.h:1450

hipLaunchAttributeValue::cooperative

int cooperative

Definition hip_runtime_api.h:1449

hipLaunchAttributeValue::accessPolicyWindow

hipAccessPolicyWindow accessPolicyWindow

Definition hip_runtime_api.h:1447

hipStreamBatchMemOpParams

Union representing batch memory operation parameters for HIP streams.

Definition hip_runtime_api.h:894

hipStreamBatchMemOpParams::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:895