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

31#ifndef HIP_INCLUDE_HIP_HIP_RUNTIME_API_H

32#define HIP_INCLUDE_HIP_HIP_RUNTIME_API_H

33

34#if __cplusplus

35#include <climits>

36#include <cstdint>

37#include <cstdlib>

38#include <utility>

39#else

40#include <limits.h>

41#include <stdint.h>

42#include <stdlib.h>

43#endif

44

45#include <hip/hip_version.h>

46#include <hip/hip_common.h>

47#include <hip/linker_types.h>

48

49enum {

50 HIP_SUCCESS = 0,

51 HIP_ERROR_INVALID_VALUE,

52 HIP_ERROR_NOT_INITIALIZED,

53 HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

54};

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

65typedef struct {

66 // 32-bit Atomics

67 unsigned hasGlobalInt32Atomics : 1;

68 unsigned hasGlobalFloatAtomicExch : 1;

69 unsigned hasSharedInt32Atomics : 1;

70 unsigned hasSharedFloatAtomicExch : 1;

71 unsigned hasFloatAtomicAdd : 1;

72

73 // 64-bit Atomics

74 unsigned hasGlobalInt64Atomics : 1;

75 unsigned hasSharedInt64Atomics : 1;

76

77 // Doubles

78 unsigned hasDoubles : 1;

79

80 // Warp cross-lane operations

81 unsigned hasWarpVote : 1;

82 unsigned hasWarpBallot : 1;

83 unsigned hasWarpShuffle : 1;

84 unsigned hasFunnelShift : 1;

85

86 // Sync

87 unsigned hasThreadFenceSystem : 1;

88 unsigned hasSyncThreadsExt : 1;

89

90 // Misc

91 unsigned hasSurfaceFuncs : 1;

92 unsigned has3dGrid : 1;

93 unsigned hasDynamicParallelism : 1;

94} hipDeviceArch_t;

95

96typedef struct hipUUID_t {

97 char bytes[16];

98} hipUUID;

99

100//---

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

102

103#define hipGetDeviceProperties hipGetDevicePropertiesR0600

104#define hipDeviceProp_t hipDeviceProp_tR0600

105#define hipChooseDevice hipChooseDeviceR0600

106

111typedef struct hipDeviceProp_t {

112 char name[256];

113 hipUUID uuid;

114 char luid[8];

115 unsigned int luidDeviceNodeMask;

116 size_t totalGlobalMem;

117 size_t sharedMemPerBlock;

118 int regsPerBlock;

119 int warpSize;

120 size_t memPitch;

122 int maxThreadsPerBlock;

123 int maxThreadsDim[3];

124 int maxGridSize[3];

125 int clockRate;

126 size_t totalConstMem;

128 int major;

132 int minor;

137 size_t textureAlignment;

138 size_t texturePitchAlignment;

139 int deviceOverlap;

140 int multiProcessorCount;

141 int kernelExecTimeoutEnabled;

142 int integrated;

143 int canMapHostMemory;

144 int computeMode;

145 int maxTexture1D;

146 int maxTexture1DMipmap;

147 int maxTexture1DLinear;

148 int maxTexture2D[2];

149 int maxTexture2DMipmap[2];

150 int maxTexture2DLinear[3];

151 int maxTexture2DGather[2];

152 int maxTexture3D[3];

154 int maxTexture3DAlt[3];

155 int maxTextureCubemap;

156 int maxTexture1DLayered[2];

157 int maxTexture2DLayered[3];

158 int maxTextureCubemapLayered[2];

159 int maxSurface1D;

160 int maxSurface2D[2];

161 int maxSurface3D[3];

162 int maxSurface1DLayered[2];

163 int maxSurface2DLayered[3];

164 int maxSurfaceCubemap;

165 int maxSurfaceCubemapLayered[2];

166 size_t surfaceAlignment;

167 int concurrentKernels;

168 int ECCEnabled;

169 int pciBusID;

170 int pciDeviceID;

171 int pciDomainID;

172 int tccDriver;

173 int asyncEngineCount;

174 int unifiedAddressing;

175 int memoryClockRate;

176 int memoryBusWidth;

177 int l2CacheSize;

178 int persistingL2CacheMaxSize;

179 int maxThreadsPerMultiProcessor;

180 int streamPrioritiesSupported;

181 int globalL1CacheSupported;

182 int localL1CacheSupported;

183 size_t sharedMemPerMultiprocessor;

184 int regsPerMultiprocessor;

185 int managedMemory;

186 int isMultiGpuBoard;

187 int multiGpuBoardGroupID;

188 int hostNativeAtomicSupported;

189 int singleToDoublePrecisionPerfRatio;

190 int pageableMemoryAccess;

192 int concurrentManagedAccess;

194 int computePreemptionSupported;

195 int canUseHostPointerForRegisteredMem;

197 int cooperativeLaunch;

198 int cooperativeMultiDeviceLaunch;

200 size_t

201 sharedMemPerBlockOptin;

202 int pageableMemoryAccessUsesHostPageTables;

204 int directManagedMemAccessFromHost;

206 int maxBlocksPerMultiProcessor;

207 int accessPolicyMaxWindowSize;

208 size_t reservedSharedMemPerBlock;

209 int hostRegisterSupported;

210 int sparseHipArraySupported;

211 int hostRegisterReadOnlySupported;

213 int timelineSemaphoreInteropSupported;

214 int memoryPoolsSupported;

215 int gpuDirectRDMASupported;

216 unsigned int gpuDirectRDMAFlushWritesOptions;

218 int gpuDirectRDMAWritesOrdering;

219 unsigned int

220 memoryPoolSupportedHandleTypes;

221 int deferredMappingHipArraySupported;

223 int ipcEventSupported;

224 int clusterLaunch;

225 int unifiedFunctionPointers;

226 int reserved[63];

227

228 int hipReserved[32];

229

230 /* HIP Only struct members */

231 char gcnArchName[256];

232 size_t maxSharedMemoryPerMultiProcessor;

233 int clockInstructionRate;

235 hipDeviceArch_t arch;

236 unsigned int* hdpMemFlushCntl;

237 unsigned int* hdpRegFlushCntl;

238 int cooperativeMultiDeviceUnmatchedFunc;

241 int cooperativeMultiDeviceUnmatchedGridDim;

244 int cooperativeMultiDeviceUnmatchedBlockDim;

247 int cooperativeMultiDeviceUnmatchedSharedMem;

250 int isLargeBar;

251 int asicRevision;

252} hipDeviceProp_t;

253

260typedef enum hipMemoryType {

261 hipMemoryTypeUnregistered = 0,

262 hipMemoryTypeHost = 1,

263 hipMemoryTypeDevice = 2,

265 hipMemoryTypeManaged = 3,

268 hipMemoryTypeArray = 10,

270 hipMemoryTypeUnified = 11

271

272} hipMemoryType;

273

277typedef struct hipPointerAttribute_t {

278 enum hipMemoryType type;

279 int device;

280 void* devicePointer;

281 void* hostPointer;

282 int isManaged;

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

284 /* peers? */

285} hipPointerAttribute_t;

286

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

288// we can make that yield a warning

289#if __cplusplus >= 201703L

290#define __HIP_NODISCARD [[nodiscard]]

291#else

292#define __HIP_NODISCARD

293#endif

294

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

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

301

302typedef enum __HIP_NODISCARD hipError_t {

303 hipSuccess = 0,

304 hipErrorInvalidValue = 1,

306 hipErrorOutOfMemory = 2,

307 // Deprecated

308 hipErrorMemoryAllocation = 2,

309 hipErrorNotInitialized = 3,

310 // Deprecated

311 hipErrorInitializationError = 3,

312 hipErrorDeinitialized = 4,

313 hipErrorProfilerDisabled = 5,

314 hipErrorProfilerNotInitialized = 6,

315 hipErrorProfilerAlreadyStarted = 7,

316 hipErrorProfilerAlreadyStopped = 8,

317 hipErrorInvalidConfiguration = 9,

318 hipErrorInvalidPitchValue = 12,

319 hipErrorInvalidSymbol = 13,

320 hipErrorInvalidDevicePointer = 17,

321 hipErrorInvalidMemcpyDirection = 21,

322 hipErrorInsufficientDriver = 35,

323 hipErrorMissingConfiguration = 52,

324 hipErrorPriorLaunchFailure = 53,

325 hipErrorInvalidDeviceFunction = 98,

326 hipErrorNoDevice = 100,

327 hipErrorInvalidDevice = 101,

328 hipErrorInvalidImage = 200,

329 hipErrorInvalidContext = 201,

330 hipErrorContextAlreadyCurrent = 202,

331 hipErrorMapFailed = 205,

332 // Deprecated

333 hipErrorMapBufferObjectFailed = 205,

334 hipErrorUnmapFailed = 206,

335 hipErrorArrayIsMapped = 207,

336 hipErrorAlreadyMapped = 208,

337 hipErrorNoBinaryForGpu = 209,

338 hipErrorAlreadyAcquired = 210,

339 hipErrorNotMapped = 211,

340 hipErrorNotMappedAsArray = 212,

341 hipErrorNotMappedAsPointer = 213,

342 hipErrorECCNotCorrectable = 214,

343 hipErrorUnsupportedLimit = 215,

344 hipErrorContextAlreadyInUse = 216,

345 hipErrorPeerAccessUnsupported = 217,

346 hipErrorInvalidKernelFile = 218,

347 hipErrorInvalidGraphicsContext = 219,

348 hipErrorInvalidSource = 300,

349 hipErrorFileNotFound = 301,

350 hipErrorSharedObjectSymbolNotFound = 302,

351 hipErrorSharedObjectInitFailed = 303,

352 hipErrorOperatingSystem = 304,

353 hipErrorInvalidHandle = 400,

354 // Deprecated

355 hipErrorInvalidResourceHandle = 400,

356 hipErrorIllegalState = 401,

357 hipErrorNotFound = 500,

358 hipErrorNotReady = 600,

362 hipErrorIllegalAddress = 700,

363 hipErrorLaunchOutOfResources = 701,

364 hipErrorLaunchTimeOut = 702,

365 hipErrorPeerAccessAlreadyEnabled = 704,

367 hipErrorPeerAccessNotEnabled = 705,

368 hipErrorSetOnActiveProcess = 708,

369 hipErrorContextIsDestroyed = 709,

370 hipErrorAssert = 710,

371 hipErrorHostMemoryAlreadyRegistered = 712,

373 hipErrorHostMemoryNotRegistered = 713,

375 hipErrorLaunchFailure = 719,

376 hipErrorCooperativeLaunchTooLarge = 720,

380 hipErrorNotSupported = 801,

381 hipErrorStreamCaptureUnsupported = 900,

383 hipErrorStreamCaptureInvalidated = 901,

385 hipErrorStreamCaptureMerge = 902,

387 hipErrorStreamCaptureUnmatched = 903,

388 hipErrorStreamCaptureUnjoined = 904,

390 hipErrorStreamCaptureIsolation = 905,

394 hipErrorStreamCaptureImplicit = 906,

397 hipErrorCapturedEvent = 907,

399 hipErrorStreamCaptureWrongThread = 908,

403 hipErrorGraphExecUpdateFailure = 910,

407 hipErrorInvalidChannelDescriptor = 911,

408 hipErrorInvalidTexture = 912,

409 hipErrorUnknown = 999,

410 // HSA Runtime Error Codes start here.

411 hipErrorRuntimeMemory = 1052,

413 hipErrorRuntimeOther = 1053,

415 hipErrorTbd

416} hipError_t;

417

418#undef __HIP_NODISCARD

419

424typedef enum hipDeviceAttribute_t {

425 hipDeviceAttributeCudaCompatibleBegin = 0,

426

427 hipDeviceAttributeEccEnabled =

428 hipDeviceAttributeCudaCompatibleBegin,

429 hipDeviceAttributeAccessPolicyMaxWindowSize,

431 hipDeviceAttributeAsyncEngineCount,

432 hipDeviceAttributeCanMapHostMemory,

434 hipDeviceAttributeCanUseHostPointerForRegisteredMem,

437 hipDeviceAttributeClockRate,

438 hipDeviceAttributeComputeMode,

439 hipDeviceAttributeComputePreemptionSupported,

440 hipDeviceAttributeConcurrentKernels,

442 hipDeviceAttributeConcurrentManagedAccess,

444 hipDeviceAttributeCooperativeLaunch,

445 hipDeviceAttributeCooperativeMultiDeviceLaunch,

447 hipDeviceAttributeDeviceOverlap,

449 hipDeviceAttributeDirectManagedMemAccessFromHost,

451 hipDeviceAttributeGlobalL1CacheSupported,

452 hipDeviceAttributeHostNativeAtomicSupported,

454 hipDeviceAttributeIntegrated,

455 hipDeviceAttributeIsMultiGpuBoard,

456 hipDeviceAttributeKernelExecTimeout,

457 hipDeviceAttributeL2CacheSize,

459 hipDeviceAttributeLocalL1CacheSupported,

460 hipDeviceAttributeLuid,

462 hipDeviceAttributeLuidDeviceNodeMask,

464 hipDeviceAttributeComputeCapabilityMajor,

465 hipDeviceAttributeManagedMemory,

466 hipDeviceAttributeMaxBlocksPerMultiProcessor,

467 hipDeviceAttributeMaxBlockDimX,

468 hipDeviceAttributeMaxBlockDimY,

469 hipDeviceAttributeMaxBlockDimZ,

470 hipDeviceAttributeMaxGridDimX,

471 hipDeviceAttributeMaxGridDimY,

472 hipDeviceAttributeMaxGridDimZ,

473 hipDeviceAttributeMaxSurface1D,

474 hipDeviceAttributeMaxSurface1DLayered,

475 hipDeviceAttributeMaxSurface2D,

476 hipDeviceAttributeMaxSurface2DLayered,

477 hipDeviceAttributeMaxSurface3D,

478 hipDeviceAttributeMaxSurfaceCubemap,

479 hipDeviceAttributeMaxSurfaceCubemapLayered,

481 hipDeviceAttributeMaxTexture1DWidth,

482 hipDeviceAttributeMaxTexture1DLayered,

483 hipDeviceAttributeMaxTexture1DLinear,

486 hipDeviceAttributeMaxTexture1DMipmap,

487 hipDeviceAttributeMaxTexture2DWidth,

488 hipDeviceAttributeMaxTexture2DHeight,

489 hipDeviceAttributeMaxTexture2DGather,

491 hipDeviceAttributeMaxTexture2DLayered,

492 hipDeviceAttributeMaxTexture2DLinear,

494 hipDeviceAttributeMaxTexture2DMipmap,

495 hipDeviceAttributeMaxTexture3DWidth,

496 hipDeviceAttributeMaxTexture3DHeight,

497 hipDeviceAttributeMaxTexture3DDepth,

498 hipDeviceAttributeMaxTexture3DAlt,

499 hipDeviceAttributeMaxTextureCubemap,

500 hipDeviceAttributeMaxTextureCubemapLayered,

501 hipDeviceAttributeMaxThreadsDim,

502 hipDeviceAttributeMaxThreadsPerBlock,

503 hipDeviceAttributeMaxThreadsPerMultiProcessor,

504 hipDeviceAttributeMaxPitch,

505 hipDeviceAttributeMemoryBusWidth,

506 hipDeviceAttributeMemoryClockRate,

507 hipDeviceAttributeComputeCapabilityMinor,

508 hipDeviceAttributeMultiGpuBoardGroupID,

510 hipDeviceAttributeMultiprocessorCount,

511 hipDeviceAttributeUnused1,

512 hipDeviceAttributePageableMemoryAccess,

514 hipDeviceAttributePageableMemoryAccessUsesHostPageTables,

516 hipDeviceAttributePciBusId,

517 hipDeviceAttributePciDeviceId,

518 hipDeviceAttributePciDomainId,

519 hipDeviceAttributePciDomainID =

520 hipDeviceAttributePciDomainId,

521 hipDeviceAttributePersistingL2CacheMaxSize,

522 hipDeviceAttributeMaxRegistersPerBlock,

525 hipDeviceAttributeMaxRegistersPerMultiprocessor,

526 hipDeviceAttributeReservedSharedMemPerBlock,

528 hipDeviceAttributeMaxSharedMemoryPerBlock,

530 hipDeviceAttributeSharedMemPerBlockOptin,

532 hipDeviceAttributeSharedMemPerMultiprocessor,

533 hipDeviceAttributeSingleToDoublePrecisionPerfRatio,

535 hipDeviceAttributeStreamPrioritiesSupported,

536 hipDeviceAttributeSurfaceAlignment,

537 hipDeviceAttributeTccDriver,

538 hipDeviceAttributeTextureAlignment,

539 hipDeviceAttributeTexturePitchAlignment,

541 hipDeviceAttributeTotalConstantMemory,

542 hipDeviceAttributeTotalGlobalMem,

543 hipDeviceAttributeUnifiedAddressing,

545 hipDeviceAttributeUnused2,

546 hipDeviceAttributeWarpSize,

547 hipDeviceAttributeMemoryPoolsSupported,

548 hipDeviceAttributeVirtualMemoryManagementSupported,

550 hipDeviceAttributeHostRegisterSupported,

552 hipDeviceAttributeMemoryPoolSupportedHandleTypes,

554

555 hipDeviceAttributeCudaCompatibleEnd = 9999,

556 hipDeviceAttributeAmdSpecificBegin = 10000,

557

558 hipDeviceAttributeClockInstructionRate =

559 hipDeviceAttributeAmdSpecificBegin,

561 hipDeviceAttributeUnused3,

562 hipDeviceAttributeMaxSharedMemoryPerMultiprocessor,

563 hipDeviceAttributeUnused4,

564 hipDeviceAttributeUnused5,

565 hipDeviceAttributeHdpMemFlushCntl,

566 hipDeviceAttributeHdpRegFlushCntl,

567 hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc,

570 hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim,

573 hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim,

576 hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem,

579 hipDeviceAttributeIsLargeBar,

580 hipDeviceAttributeAsicRevision,

581 hipDeviceAttributeCanUseStreamWaitValue,

583 hipDeviceAttributeImageSupport,

584 hipDeviceAttributePhysicalMultiProcessorCount,

586 hipDeviceAttributeFineGrainSupport,

587 hipDeviceAttributeWallClockRate,

588 hipDeviceAttributeNumberOfXccs,

589 hipDeviceAttributeMaxAvailableVgprsPerThread,

592 hipDeviceAttributePciChipId,

593

594 hipDeviceAttributeAmdSpecificEnd = 19999,

595 hipDeviceAttributeVendorSpecificBegin = 20000,

596 // Extended attributes for vendors

597} hipDeviceAttribute_t;

598

599typedef enum hipDriverProcAddressQueryResult {

600 HIP_GET_PROC_ADDRESS_SUCCESS = 0,

601 HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND = 1,

602 HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT = 2

603} hipDriverProcAddressQueryResult;

604

605enum hipComputeMode {

606 hipComputeModeDefault = 0,

607 hipComputeModeExclusive = 1,

608 hipComputeModeProhibited = 2,

609 hipComputeModeExclusiveProcess = 3

610};

611

612enum hipFlushGPUDirectRDMAWritesOptions {

613 hipFlushGPUDirectRDMAWritesOptionHost = 1 << 0,

614 hipFlushGPUDirectRDMAWritesOptionMemOps = 1 << 1

615};

616

617enum hipGPUDirectRDMAWritesOrdering {

618 hipGPUDirectRDMAWritesOrderingNone = 0,

619 hipGPUDirectRDMAWritesOrderingOwner = 100,

620 hipGPUDirectRDMAWritesOrderingAllDevices = 200

621};

622

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

624

625#ifndef GENERIC_GRID_LAUNCH

626#define GENERIC_GRID_LAUNCH 1

627#endif

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

629#include <hip/driver_types.h>

630#include <hip/texture_types.h>

631#include <hip/surface_types.h>

632#if defined(_MSC_VER)

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

634#else // !defined(_MSC_VER)

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

636#endif // !defined(_MSC_VER)

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

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

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

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

641#ifdef __cplusplus

642 #define __dparm(x) \

643 = x

644#else

645 #define __dparm(x)

646#endif

647#ifdef __GNUC__

648#pragma GCC visibility push (default)

649#endif

650#ifdef __cplusplus

651namespace hip_impl {

652hipError_t hip_init();

653} // namespace hip_impl

654#endif

655// Structure definitions:

656#ifdef __cplusplus

657extern "C" {

658#endif

659//---

660// API-visible structures

661typedef struct ihipCtx_t* hipCtx_t;

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

663typedef int hipDevice_t;

664typedef enum hipDeviceP2PAttr {

665 hipDevP2PAttrPerformanceRank = 0,

666 hipDevP2PAttrAccessSupported,

667 hipDevP2PAttrNativeAtomicSupported,

668 hipDevP2PAttrHipArrayAccessSupported

669} hipDeviceP2PAttr;

670typedef enum hipDriverEntryPointQueryResult {

671 hipDriverEntryPointSuccess = 0,

672 hipDriverEntryPointSymbolNotFound = 1,

673 hipDriverEntryPointVersionNotSufficent = 2

674} hipDriverEntryPointQueryResult;

675typedef struct ihipStream_t* hipStream_t;

676#define hipIpcMemLazyEnablePeerAccess 0x01

677#define HIP_IPC_HANDLE_SIZE 64

678typedef struct hipIpcMemHandle_st {

679 char reserved[HIP_IPC_HANDLE_SIZE];

680} hipIpcMemHandle_t;

681typedef struct hipIpcEventHandle_st {

682 char reserved[HIP_IPC_HANDLE_SIZE];

683} hipIpcEventHandle_t;

684typedef struct ihipModule_t* hipModule_t;

685typedef struct ihipModuleSymbol_t* hipFunction_t;

686typedef struct ihipLinkState_t* hipLinkState_t;

690typedef struct ihipMemPoolHandle_t* hipMemPool_t;

691

692typedef struct hipFuncAttributes {

693 int binaryVersion;

694 int cacheModeCA;

695 size_t constSizeBytes;

696 size_t localSizeBytes;

697 int maxDynamicSharedSizeBytes;

698 int maxThreadsPerBlock;

699 int numRegs;

700 int preferredShmemCarveout;

701 int ptxVersion;

702 size_t sharedSizeBytes;

703} hipFuncAttributes;

704typedef struct ihipEvent_t* hipEvent_t;

705

712enum hipLimit_t {

713 hipLimitStackSize = 0x0,

716 hipLimitPrintfFifoSize = 0x01,

718 hipLimitMallocHeapSize = 0x02,

720 hipExtLimitScratchMin = 0x1000,

722 hipExtLimitScratchMax = 0x1001,

724 hipExtLimitScratchCurrent = 0x1002,

728 hipLimitRange

729};

730

734//Flags that can be used with hipStreamCreateWithFlags.

736#define hipStreamDefault 0x00

737

739#define hipStreamNonBlocking 0x01

740

741//Flags that can be used with hipEventCreateWithFlags.

743#define hipEventDefault 0x0

744

746#define hipEventBlockingSync 0x1

747

749#define hipEventDisableTiming 0x2

750

752#define hipEventInterprocess 0x4

753

754//Flags that can be used with hipEventRecordWithFlags.

756#define hipEventRecordDefault 0x00

757

759#define hipEventRecordExternal 0x01

760

769#define hipEventDisableSystemFence 0x20000000

770

773#define hipEventReleaseToDevice 0x40000000

774

777#define hipEventReleaseToSystem 0x80000000

778

779// Flags that can be used with hipGetDriverEntryPoint.

783#define hipEnableDefault 0x0

784

786#define hipEnableLegacyStream 0x1

787

790#define hipEnablePerThreadDefaultStream 0x2

791

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

794#define hipHostAllocDefault 0x0

795

798#define hipHostMallocDefault 0x0

799

801#define hipHostAllocPortable 0x1

802

805#define hipHostMallocPortable 0x1

806

809#define hipHostAllocMapped 0x2

810

814#define hipHostMallocMapped 0x2

815

819#define hipHostAllocWriteCombined 0x4

820

826#define hipHostMallocWriteCombined 0x4

827

833#define hipHostMallocUncached 0x10000000

834#define hipHostAllocUncached hipHostMallocUncached

835

840#define hipHostMallocNumaUser 0x20000000

841

843#define hipHostMallocCoherent 0x40000000

844

846#define hipHostMallocNonCoherent 0x80000000

847

849#define hipMemAttachGlobal 0x01

850

852#define hipMemAttachHost 0x02

853

855#define hipMemAttachSingle 0x04

856

857#define hipDeviceMallocDefault 0x0

858

860#define hipDeviceMallocFinegrained 0x1

861

863#define hipMallocSignalMemory 0x2

864

866#define hipDeviceMallocUncached 0x3

867

869#define hipDeviceMallocContiguous 0x4

870

871//Flags that can be used with hipHostRegister.

873#define hipHostRegisterDefault 0x0

874

876#define hipHostRegisterPortable 0x1

877

880#define hipHostRegisterMapped 0x2

881

883#define hipHostRegisterIoMemory 0x4

884

886#define hipHostRegisterReadOnly 0x08

887

889#define hipExtHostRegisterCoarseGrained 0x8

890

894#define hipExtHostRegisterUncached 0x80000000

895

897#define hipDeviceScheduleAuto 0x0

898

901#define hipDeviceScheduleSpin 0x1

902

905#define hipDeviceScheduleYield 0x2

906#define hipDeviceScheduleBlockingSync 0x4

907#define hipDeviceScheduleMask 0x7

908#define hipDeviceMapHost 0x8

909#define hipDeviceLmemResizeToMax 0x10

911#define hipArrayDefault 0x00

912#define hipArrayLayered 0x01

913#define hipArraySurfaceLoadStore 0x02

914#define hipArrayCubemap 0x04

915#define hipArrayTextureGather 0x08

916#define hipOccupancyDefault 0x00

917#define hipOccupancyDisableCachingOverride 0x01

918#define hipCooperativeLaunchMultiDeviceNoPreSync 0x01

919#define hipCooperativeLaunchMultiDeviceNoPostSync 0x02

920#define hipCpuDeviceId ((int)-1)

921#define hipInvalidDeviceId ((int)-2)

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

924#define hipExtAnyOrderLaunch 0x01

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

926#define hipStreamWaitValueGte 0x0

927#define hipStreamWaitValueEq 0x1

928#define hipStreamWaitValueAnd 0x2

929#define hipStreamWaitValueNor 0x3

930

932typedef enum hipStreamBatchMemOpType {

933 hipStreamMemOpWaitValue32 = 0x1,

934 hipStreamMemOpWriteValue32 = 0x2,

935 hipStreamMemOpWaitValue64 = 0x4,

936 hipStreamMemOpWriteValue64 = 0x5,

937 hipStreamMemOpBarrier = 0x6,

938 hipStreamMemOpFlushRemoteWrites = 0x3

939} hipStreamBatchMemOpType;

940

977typedef union hipStreamBatchMemOpParams_union {

978 hipStreamBatchMemOpType operation;

979 struct hipStreamMemOpWaitValueParams_t{

980 hipStreamBatchMemOpType operation;

981 hipDeviceptr_t address;

982 union {

983 uint32_t value;

984 uint64_t value64;

985 };

986 unsigned int flags;

987 hipDeviceptr_t alias;

988 } waitValue;

989 struct hipStreamMemOpWriteValueParams_t{

990 hipStreamBatchMemOpType operation;

991 hipDeviceptr_t address;

992 union {

993 uint32_t value;

994 uint64_t value64;

995 };

996 unsigned int flags;

997 hipDeviceptr_t alias;

998 } writeValue;

999 struct hipStreamMemOpFlushRemoteWritesParams_t{

1000 hipStreamBatchMemOpType operation;

1001 unsigned int flags;

1002 } flushRemoteWrites;

1003 struct hipStreamMemOpMemoryBarrierParams_t{

1004 hipStreamBatchMemOpType operation;

1005 unsigned int flags;

1006 } memoryBarrier;

1007 uint64_t pad[6];

1008} hipStreamBatchMemOpParams;

1009

1037typedef struct hipBatchMemOpNodeParams {

1038 hipCtx_t ctx;

1039 unsigned int count;

1040 hipStreamBatchMemOpParams *paramArray;

1041 unsigned int flags;

1042} hipBatchMemOpNodeParams;

1043

1044// Stream per thread

1046#define hipStreamPerThread ((hipStream_t)2)

1047

1048#define hipStreamLegacy ((hipStream_t)1)

1049

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

1051#define hipExternalMemoryDedicated 0x1

1057typedef enum hipMemoryAdvise {

1058 hipMemAdviseSetReadMostly = 1,

1060 hipMemAdviseUnsetReadMostly = 2,

1061 hipMemAdviseSetPreferredLocation = 3,

1063 hipMemAdviseUnsetPreferredLocation = 4,

1064 hipMemAdviseSetAccessedBy = 5,

1066 hipMemAdviseUnsetAccessedBy = 6,

1068 hipMemAdviseSetCoarseGrain = 100,

1073 hipMemAdviseUnsetCoarseGrain = 101

1074} hipMemoryAdvise;

1078typedef enum hipMemRangeCoherencyMode {

1079 hipMemRangeCoherencyModeFineGrain = 0,

1081 hipMemRangeCoherencyModeCoarseGrain = 1,

1083 hipMemRangeCoherencyModeIndeterminate = 2

1086} hipMemRangeCoherencyMode;

1090typedef enum hipMemRangeAttribute {

1091 hipMemRangeAttributeReadMostly = 1,

1093 hipMemRangeAttributePreferredLocation = 2,

1094 hipMemRangeAttributeAccessedBy = 3,

1096 hipMemRangeAttributeLastPrefetchLocation = 4,

1098 hipMemRangeAttributeCoherencyMode = 100,

1100} hipMemRangeAttribute;

1101

1105typedef enum hipMemPoolAttr

1106{

1115 hipMemPoolReuseFollowEventDependencies = 0x1,

1121 hipMemPoolReuseAllowOpportunistic = 0x2,

1128 hipMemPoolReuseAllowInternalDependencies = 0x3,

1137 hipMemPoolAttrReleaseThreshold = 0x4,

1142 hipMemPoolAttrReservedMemCurrent = 0x5,

1148 hipMemPoolAttrReservedMemHigh = 0x6,

1153 hipMemPoolAttrUsedMemCurrent = 0x7,

1159 hipMemPoolAttrUsedMemHigh = 0x8

1160} hipMemPoolAttr;

1161

1166typedef enum hipMemAccessFlags {

1167 hipMemAccessFlagsProtNone = 0,

1168 hipMemAccessFlagsProtRead = 1,

1169 hipMemAccessFlagsProtReadWrite = 3

1170} hipMemAccessFlags;

1177typedef struct hipMemAccessDesc {

1178 hipMemLocation location;

1179 hipMemAccessFlags flags;

1180} hipMemAccessDesc;

1184typedef enum hipMemAllocationType {

1185 hipMemAllocationTypeInvalid = 0x0,

1189 hipMemAllocationTypePinned = 0x1,

1190 hipMemAllocationTypeMax = 0x7FFFFFFF

1191} hipMemAllocationType;

1196typedef enum hipMemAllocationHandleType {

1197 hipMemHandleTypeNone = 0x0,

1198 hipMemHandleTypePosixFileDescriptor = 0x1,

1199 hipMemHandleTypeWin32 = 0x2,

1200 hipMemHandleTypeWin32Kmt = 0x4

1201} hipMemAllocationHandleType;

1205typedef struct hipMemPoolProps {

1206 hipMemAllocationType allocType;

1207 hipMemAllocationHandleType handleTypes;

1208 hipMemLocation location;

1212 void* win32SecurityAttributes;

1213 size_t maxSize;

1214 unsigned char reserved[56];

1215} hipMemPoolProps;

1219typedef struct hipMemPoolPtrExportData {

1220 unsigned char reserved[64];

1221} hipMemPoolPtrExportData;

1222

1226typedef enum hipFuncAttribute {

1227 hipFuncAttributeMaxDynamicSharedMemorySize = 8,

1228 hipFuncAttributePreferredSharedMemoryCarveout = 9,

1229 hipFuncAttributeMax

1230} hipFuncAttribute;

1234typedef enum hipFuncCache_t {

1235 hipFuncCachePreferNone,

1236 hipFuncCachePreferShared,

1237 hipFuncCachePreferL1,

1238 hipFuncCachePreferEqual,

1239} hipFuncCache_t;

1243typedef enum hipSharedMemConfig {

1244 hipSharedMemBankSizeDefault,

1245 hipSharedMemBankSizeFourByte,

1247 hipSharedMemBankSizeEightByte

1249} hipSharedMemConfig;

1253typedef struct dim3 {

1254 uint32_t x;

1255 uint32_t y;

1256 uint32_t z;

1257#ifdef __cplusplus

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

1259#endif

1260} dim3;

1264typedef struct hipLaunchParams_t {

1265 void* func;

1266 dim3 gridDim;

1267 dim3 blockDim;

1268 void **args;

1269 size_t sharedMem;

1270 hipStream_t stream;

1271} hipLaunchParams;

1275typedef struct hipFunctionLaunchParams_t {

1276 hipFunction_t function;

1277 unsigned int gridDimX;

1278 unsigned int gridDimY;

1279 unsigned int gridDimZ;

1280 unsigned int blockDimX;

1281 unsigned int blockDimY;

1282 unsigned int blockDimZ;

1283 unsigned int sharedMemBytes;

1284 hipStream_t hStream;

1285 void **kernelParams;

1286} hipFunctionLaunchParams;

1287typedef enum hipExternalMemoryHandleType_enum {

1288 hipExternalMemoryHandleTypeOpaqueFd = 1,

1289 hipExternalMemoryHandleTypeOpaqueWin32 = 2,

1290 hipExternalMemoryHandleTypeOpaqueWin32Kmt = 3,

1291 hipExternalMemoryHandleTypeD3D12Heap = 4,

1292 hipExternalMemoryHandleTypeD3D12Resource = 5,

1293 hipExternalMemoryHandleTypeD3D11Resource = 6,

1294 hipExternalMemoryHandleTypeD3D11ResourceKmt = 7,

1295 hipExternalMemoryHandleTypeNvSciBuf = 8

1296} hipExternalMemoryHandleType;

1297typedef struct hipExternalMemoryHandleDesc_st {

1298 hipExternalMemoryHandleType type;

1299 union {

1300 int fd;

1301 struct {

1302 void *handle;

1303 const void *name;

1304 } win32;

1305 const void *nvSciBufObject;

1306 } handle;

1307 unsigned long long size;

1308 unsigned int flags;

1309 unsigned int reserved[16];

1310} hipExternalMemoryHandleDesc;

1311typedef struct hipExternalMemoryBufferDesc_st {

1312 unsigned long long offset;

1313 unsigned long long size;

1314 unsigned int flags;

1315 unsigned int reserved[16];

1316} hipExternalMemoryBufferDesc;

1317typedef struct hipExternalMemoryMipmappedArrayDesc_st {

1318 unsigned long long offset;

1319 hipChannelFormatDesc formatDesc;

1320 hipExtent extent;

1321 unsigned int flags;

1322 unsigned int numLevels;

1323} hipExternalMemoryMipmappedArrayDesc;

1324typedef void* hipExternalMemory_t;

1325typedef enum hipExternalSemaphoreHandleType_enum {

1326 hipExternalSemaphoreHandleTypeOpaqueFd = 1,

1327 hipExternalSemaphoreHandleTypeOpaqueWin32 = 2,

1328 hipExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3,

1329 hipExternalSemaphoreHandleTypeD3D12Fence = 4,

1330 hipExternalSemaphoreHandleTypeD3D11Fence = 5,

1331 hipExternalSemaphoreHandleTypeNvSciSync = 6,

1332 hipExternalSemaphoreHandleTypeKeyedMutex = 7,

1333 hipExternalSemaphoreHandleTypeKeyedMutexKmt = 8,

1334 hipExternalSemaphoreHandleTypeTimelineSemaphoreFd = 9,

1335 hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = 10

1336} hipExternalSemaphoreHandleType;

1337typedef struct hipExternalSemaphoreHandleDesc_st {

1338 hipExternalSemaphoreHandleType type;

1339 union {

1340 int fd;

1341 struct {

1342 void* handle;

1343 const void* name;

1344 } win32;

1345 const void* NvSciSyncObj;

1346 } handle;

1347 unsigned int flags;

1348 unsigned int reserved[16];

1349} hipExternalSemaphoreHandleDesc;

1350typedef void* hipExternalSemaphore_t;

1351typedef struct hipExternalSemaphoreSignalParams_st {

1352 struct {

1353 struct {

1354 unsigned long long value;

1355 } fence;

1356 union {

1357 void *fence;

1358 unsigned long long reserved;

1359 } nvSciSync;

1360 struct {

1361 unsigned long long key;

1362 } keyedMutex;

1363 unsigned int reserved[12];

1364 } params;

1365 unsigned int flags;

1366 unsigned int reserved[16];

1367} hipExternalSemaphoreSignalParams;

1371typedef struct hipExternalSemaphoreWaitParams_st {

1372 struct {

1373 struct {

1374 unsigned long long value;

1375 } fence;

1376 union {

1377 void *fence;

1378 unsigned long long reserved;

1379 } nvSciSync;

1380 struct {

1381 unsigned long long key;

1382 unsigned int timeoutMs;

1383 } keyedMutex;

1384 unsigned int reserved[10];

1385 } params;

1386 unsigned int flags;

1387 unsigned int reserved[16];

1388} hipExternalSemaphoreWaitParams;

1389

1390#if __HIP_HAS_GET_PCH

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

1396#endif

1397

1401typedef enum hipGraphicsRegisterFlags {

1402 hipGraphicsRegisterFlagsNone = 0,

1403 hipGraphicsRegisterFlagsReadOnly = 1,

1404 hipGraphicsRegisterFlagsWriteDiscard =

1405 2,

1406 hipGraphicsRegisterFlagsSurfaceLoadStore = 4,

1407 hipGraphicsRegisterFlagsTextureGather =

1408 8

1409} hipGraphicsRegisterFlags;

1410

1411typedef struct _hipGraphicsResource hipGraphicsResource;

1412

1413typedef hipGraphicsResource* hipGraphicsResource_t;

1414

1418typedef struct ihipGraph* hipGraph_t;

1422typedef struct hipGraphNode* hipGraphNode_t;

1426typedef struct hipGraphExec* hipGraphExec_t;

1427

1431typedef struct hipUserObject* hipUserObject_t;

1432

1433

1437typedef enum hipGraphNodeType {

1438 hipGraphNodeTypeKernel = 0,

1439 hipGraphNodeTypeMemcpy = 1,

1440 hipGraphNodeTypeMemset = 2,

1441 hipGraphNodeTypeHost = 3,

1442 hipGraphNodeTypeGraph = 4,

1443 hipGraphNodeTypeEmpty = 5,

1444 hipGraphNodeTypeWaitEvent = 6,

1445 hipGraphNodeTypeEventRecord = 7,

1446 hipGraphNodeTypeExtSemaphoreSignal = 8,

1447 hipGraphNodeTypeExtSemaphoreWait = 9,

1448 hipGraphNodeTypeMemAlloc = 10,

1449 hipGraphNodeTypeMemFree = 11,

1450 hipGraphNodeTypeMemcpyFromSymbol = 12,

1451 hipGraphNodeTypeMemcpyToSymbol = 13,

1452 hipGraphNodeTypeBatchMemOp = 14,

1453 hipGraphNodeTypeCount

1454} hipGraphNodeType;

1455

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

1457typedef struct hipHostNodeParams {

1458 hipHostFn_t fn;

1459 void* userData;

1460} hipHostNodeParams;

1461typedef struct hipKernelNodeParams {

1462 dim3 blockDim;

1463 void** extra;

1464 void* func;

1465 dim3 gridDim;

1466 void** kernelParams;

1467 unsigned int sharedMemBytes;

1468} hipKernelNodeParams;

1469typedef struct hipMemsetParams {

1470 void* dst;

1471 unsigned int elementSize;

1472 size_t height;

1473 size_t pitch;

1474 unsigned int value;

1475 size_t width;

1476} hipMemsetParams;

1477

1478typedef struct hipMemAllocNodeParams {

1479 hipMemPoolProps poolProps;

1481 const hipMemAccessDesc* accessDescs;

1482 size_t accessDescCount;

1484 size_t bytesize;

1485 void* dptr;

1486} hipMemAllocNodeParams;

1487

1491typedef enum hipAccessProperty {

1492 hipAccessPropertyNormal = 0,

1493 hipAccessPropertyStreaming = 1,

1494 hipAccessPropertyPersisting = 2,

1495} hipAccessProperty;

1496

1497/***

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

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

1500 */

1501typedef struct hipAccessPolicyWindow {

1502 void* base_ptr;

1503 hipAccessProperty hitProp;

1504 float hitRatio;

1505 hipAccessProperty missProp;

1506 size_t num_bytes;

1507} hipAccessPolicyWindow;

1508

1512typedef struct hipLaunchMemSyncDomainMap {

1513 unsigned char default_;

1514 unsigned char remote;

1515} hipLaunchMemSyncDomainMap;

1516

1520typedef enum hipLaunchMemSyncDomain {

1521 hipLaunchMemSyncDomainDefault = 0,

1522 hipLaunchMemSyncDomainRemote = 1

1523} hipLaunchMemSyncDomain;

1524

1529typedef enum hipSynchronizationPolicy {

1530 hipSyncPolicyAuto = 1,

1531 hipSyncPolicySpin = 2,

1532 hipSyncPolicyYield = 3,

1533 hipSyncPolicyBlockingSync = 4

1534} hipSynchronizationPolicy;

1535

1539typedef enum hipLaunchAttributeID {

1540 hipLaunchAttributeAccessPolicyWindow = 1,

1541 hipLaunchAttributeCooperative = 2,

1542 hipLaunchAttributeSynchronizationPolicy = 3,

1543 hipLaunchAttributePriority = 8,

1544 hipLaunchAttributeMemSyncDomainMap = 9,

1545 hipLaunchAttributeMemSyncDomain = 10,

1546 hipLaunchAttributeMax

1547} hipLaunchAttributeID;

1548

1549

1553typedef union hipLaunchAttributeValue {

1554 char pad[64];

1555 hipAccessPolicyWindow accessPolicyWindow;

1556 int cooperative;

1557 int priority;

1558 hipSynchronizationPolicy syncPolicy;

1559 hipLaunchMemSyncDomainMap memSyncDomainMap;

1560 hipLaunchMemSyncDomain memSyncDomain;

1561} hipLaunchAttributeValue;

1562

1566#define hipStreamAttrID hipLaunchAttributeID

1567#define hipStreamAttributeAccessPolicyWindow hipLaunchAttributeAccessPolicyWindow

1568#define hipStreamAttributeSynchronizationPolicy hipLaunchAttributeSynchronizationPolicy

1569#define hipStreamAttributeMemSyncDomainMap hipLaunchAttributeMemSyncDomainMap

1570#define hipStreamAttributeMemSyncDomain hipLaunchAttributeMemSyncDomain

1571#define hipStreamAttributePriority hipLaunchAttributePriority

1572

1573#define hipStreamAttrValue hipLaunchAttributeValue

1574

1578#define hipKernelNodeAttrID hipLaunchAttributeID

1579#define hipKernelNodeAttributeAccessPolicyWindow hipLaunchAttributeAccessPolicyWindow

1580#define hipKernelNodeAttributeCooperative hipLaunchAttributeCooperative

1581#define hipKernelNodeAttributePriority hipLaunchAttributePriority

1582

1586#define hipKernelNodeAttrValue hipLaunchAttributeValue

1587

1591#define hipDrvLaunchAttributeCooperative hipLaunchAttributeCooperative

1592

1593#define hipDrvLaunchAttributeID hipLaunchAttributeID

1594#define hipDrvLaunchAttributeValue hipLaunchAttributeValue

1595#define hipDrvLaunchAttribute hipLaunchAttribute

1596

1600typedef enum hipGraphExecUpdateResult {

1601 hipGraphExecUpdateSuccess = 0x0,

1602 hipGraphExecUpdateError = 0x1,

1604 hipGraphExecUpdateErrorTopologyChanged = 0x2,

1605 hipGraphExecUpdateErrorNodeTypeChanged = 0x3,

1606 hipGraphExecUpdateErrorFunctionChanged =

1607 0x4,

1608 hipGraphExecUpdateErrorParametersChanged =

1609 0x5,

1610 hipGraphExecUpdateErrorNotSupported =

1611 0x6,

1612 hipGraphExecUpdateErrorUnsupportedFunctionChange = 0x7

1613} hipGraphExecUpdateResult;

1614

1615typedef enum hipStreamCaptureMode {

1616 hipStreamCaptureModeGlobal = 0,

1617 hipStreamCaptureModeThreadLocal,

1618 hipStreamCaptureModeRelaxed

1619} hipStreamCaptureMode;

1620typedef enum hipStreamCaptureStatus {

1621 hipStreamCaptureStatusNone = 0,

1622 hipStreamCaptureStatusActive,

1623 hipStreamCaptureStatusInvalidated

1625} hipStreamCaptureStatus;

1626

1627typedef enum hipStreamUpdateCaptureDependenciesFlags {

1628 hipStreamAddCaptureDependencies = 0,

1629 hipStreamSetCaptureDependencies,

1630} hipStreamUpdateCaptureDependenciesFlags;

1631

1632typedef enum hipGraphMemAttributeType {

1633 hipGraphMemAttrUsedMemCurrent = 0,

1634 hipGraphMemAttrUsedMemHigh,

1635 hipGraphMemAttrReservedMemCurrent,

1636 hipGraphMemAttrReservedMemHigh,

1637}hipGraphMemAttributeType;

1638typedef enum hipUserObjectFlags {

1639 hipUserObjectNoDestructorSync = 0x1,

1640} hipUserObjectFlags;

1641

1642typedef enum hipUserObjectRetainFlags {

1643 hipGraphUserObjectMove = 0x1,

1644} hipUserObjectRetainFlags;

1645

1646typedef enum hipGraphInstantiateFlags {

1647 hipGraphInstantiateFlagAutoFreeOnLaunch =

1648 1,

1649 hipGraphInstantiateFlagUpload =

1650 2,

1651 hipGraphInstantiateFlagDeviceLaunch =

1652 4,

1653 hipGraphInstantiateFlagUseNodePriority =

1654 8,

1655} hipGraphInstantiateFlags;

1656

1657enum hipGraphDebugDotFlags {

1658 hipGraphDebugDotFlagsVerbose = 1

1659 << 0,

1660 hipGraphDebugDotFlagsKernelNodeParams = 1 << 2,

1661 hipGraphDebugDotFlagsMemcpyNodeParams = 1 << 3,

1662 hipGraphDebugDotFlagsMemsetNodeParams = 1 << 4,

1663 hipGraphDebugDotFlagsHostNodeParams = 1 << 5,

1664 hipGraphDebugDotFlagsEventNodeParams = 1

1665 << 6,

1666 hipGraphDebugDotFlagsExtSemasSignalNodeParams = 1

1667 << 7,

1668 hipGraphDebugDotFlagsExtSemasWaitNodeParams = 1

1669 << 8,

1670 hipGraphDebugDotFlagsKernelNodeAttributes = 1

1671 << 9,

1672 hipGraphDebugDotFlagsHandles = 1

1673 << 10

1674};

1675

1679typedef enum hipGraphInstantiateResult {

1680 hipGraphInstantiateSuccess = 0,

1681 hipGraphInstantiateError = 1,

1683 hipGraphInstantiateInvalidStructure = 2,

1685 hipGraphInstantiateNodeOperationNotSupported = 3,

1687 hipGraphInstantiateMultipleDevicesNotSupported = 4,

1689}hipGraphInstantiateResult;

1690

1694typedef struct hipGraphInstantiateParams {

1695 hipGraphNode_t errNode_out;

1696 unsigned long long flags;

1697 hipGraphInstantiateResult result_out;

1699 hipStream_t uploadStream;

1700} hipGraphInstantiateParams;

1701

1702

1706typedef struct hipMemAllocationProp {

1707 hipMemAllocationType type;

1708 union {

1709 hipMemAllocationHandleType requestedHandleType;

1710 hipMemAllocationHandleType requestedHandleTypes;

1711 };

1712 hipMemLocation location;

1713 void* win32HandleMetaData;

1714 struct {

1715 unsigned char compressionType;

1716 unsigned char gpuDirectRDMACapable;

1717 unsigned short usage;

1718 } allocFlags;

1719} hipMemAllocationProp;

1720

1724typedef struct hipExternalSemaphoreSignalNodeParams {

1726 hipExternalSemaphore_t* extSemArray;

1728 const hipExternalSemaphoreSignalParams* paramsArray;

1730 unsigned int numExtSems;

1731} hipExternalSemaphoreSignalNodeParams;

1732

1736typedef struct hipExternalSemaphoreWaitNodeParams {

1738 hipExternalSemaphore_t* extSemArray;

1740 const hipExternalSemaphoreWaitParams* paramsArray;

1742 unsigned int numExtSems;

1743} hipExternalSemaphoreWaitNodeParams;

1744

1748typedef struct ihipMemGenericAllocationHandle* hipMemGenericAllocationHandle_t;

1749

1753typedef enum hipMemAllocationGranularity_flags {

1754 hipMemAllocationGranularityMinimum = 0x0,

1755 hipMemAllocationGranularityRecommended = 0x1

1756} hipMemAllocationGranularity_flags;

1757

1761typedef enum hipMemHandleType {

1762 hipMemHandleTypeGeneric = 0x0

1763} hipMemHandleType;

1764

1768typedef enum hipMemOperationType {

1769 hipMemOperationTypeMap = 0x1,

1770 hipMemOperationTypeUnmap = 0x2

1771} hipMemOperationType;

1772

1776typedef enum hipArraySparseSubresourceType {

1777 hipArraySparseSubresourceTypeSparseLevel = 0x0,

1778 hipArraySparseSubresourceTypeMiptail = 0x1

1779} hipArraySparseSubresourceType;

1780

1784typedef struct hipArrayMapInfo {

1785 hipResourceType resourceType;

1786 union {

1787 hipMipmappedArray mipmap;

1788 hipArray_t array;

1789 } resource;

1790 hipArraySparseSubresourceType subresourceType;

1791 union {

1792 struct {

1793 unsigned int level;

1794 unsigned int layer;

1795 unsigned int offsetX;

1796 unsigned int offsetY;

1797 unsigned int offsetZ;

1798 unsigned int extentWidth;

1799 unsigned int extentHeight;

1800 unsigned int extentDepth;

1801 } sparseLevel;

1802 struct {

1803 unsigned int layer;

1804 unsigned long long offset;

1805 unsigned long long size;

1806 } miptail;

1807 } subresource;

1808 hipMemOperationType memOperationType;

1809 hipMemHandleType memHandleType;

1810 union {

1811 hipMemGenericAllocationHandle_t memHandle;

1812 } memHandle;

1813 unsigned long long offset;

1814 unsigned int deviceBitMask;

1815 unsigned int flags;

1816 unsigned int reserved[2];

1817} hipArrayMapInfo;

1818

1822typedef struct hipMemcpyNodeParams {

1823 int flags;

1824 int reserved[3];

1825 hipMemcpy3DParms copyParams;

1826} hipMemcpyNodeParams;

1827

1831typedef struct hipChildGraphNodeParams {

1832 hipGraph_t graph;

1834} hipChildGraphNodeParams;

1835

1839typedef struct hipEventWaitNodeParams {

1840 hipEvent_t event;

1841} hipEventWaitNodeParams;

1842

1846typedef struct hipEventRecordNodeParams {

1847 hipEvent_t event;

1848} hipEventRecordNodeParams;

1849

1853typedef struct hipMemFreeNodeParams {

1854 void *dptr;

1855} hipMemFreeNodeParams;

1856

1860typedef struct hipGraphNodeParams {

1861 hipGraphNodeType type;

1862 int reserved0[3];

1863 union {

1864 long long reserved1[29];

1865 hipKernelNodeParams kernel;

1866 hipMemcpyNodeParams memcpy;

1867 hipMemsetParams memset;

1868 hipHostNodeParams host;

1869 hipChildGraphNodeParams graph;

1870 hipEventWaitNodeParams eventWait;

1871 hipEventRecordNodeParams eventRecord;

1872 hipExternalSemaphoreSignalNodeParams extSemSignal;

1873 hipExternalSemaphoreWaitNodeParams extSemWait;

1874 hipMemAllocNodeParams alloc;

1875 hipMemFreeNodeParams free;

1876 };

1877

1878 long long reserved2;

1879} hipGraphNodeParams;

1880

1884#define hipGraphKernelNodePortDefault 0

1885

1889#define hipGraphKernelNodePortLaunchCompletion 2

1890

1896#define hipGraphKernelNodePortProgrammatic 1

1897

1898typedef enum hipGraphDependencyType {

1899 hipGraphDependencyTypeDefault = 0,

1900 hipGraphDependencyTypeProgrammatic = 1

1901}hipGraphDependencyType;

1902

1903typedef struct hipGraphEdgeData {

1904 unsigned char

1905 from_port;

1912 unsigned char reserved[5];

1913 unsigned char

1914 to_port;

1915 unsigned char type;

1916} hipGraphEdgeData;

1917

1918

1922typedef struct hipLaunchAttribute_st {

1923 hipLaunchAttributeID id;

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

1925 union {

1926 hipLaunchAttributeValue val;

1927 hipLaunchAttributeValue value;

1928 };

1929} hipLaunchAttribute;

1930

1934typedef struct hipLaunchConfig_st {

1935 dim3 gridDim;

1936 dim3 blockDim;

1937 size_t dynamicSmemBytes;

1938 hipStream_t stream;

1939 hipLaunchAttribute* attrs;

1940 unsigned int numAttrs;

1941} hipLaunchConfig_t;

1942

1946typedef struct HIP_LAUNCH_CONFIG_st {

1947 unsigned int gridDimX;

1948 unsigned int gridDimY;

1949 unsigned int gridDimZ;

1950 unsigned int blockDimX;

1951 unsigned int blockDimY;

1952 unsigned int blockDimZ;

1953 unsigned int sharedMemBytes;

1954 hipStream_t hStream;

1955 hipLaunchAttribute* attrs;

1956 unsigned int numAttrs;

1957} HIP_LAUNCH_CONFIG;

1958

1962typedef enum hipMemRangeHandleType {

1963 hipMemRangeHandleTypeDmaBufFd = 0x1,

1964 hipMemRangeHandleTypeMax = 0x7fffffff

1965} hipMemRangeHandleType;

1966

1970typedef enum hipMemRangeFlags {

1971 hipMemRangeFlagDmaBufMappingTypePcie = 0x1,

1972 hipMemRangeFlagsMax = 0x7fffffff

1973} hipMemRangeFlags;

1974

1975// Doxygen end group GlobalDefs

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

2002hipError_t hipInit(unsigned int flags);

2003

2021hipError_t hipDriverGetVersion(int* driverVersion);

2036hipError_t hipRuntimeGetVersion(int* runtimeVersion);

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

2045

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

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

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

2085hipError_t hipDeviceGetP2PAttribute(int* value, hipDeviceP2PAttr attr,

2086 int srcDevice, int dstDevice);

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

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

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

2112// doxygen end initialization

2131hipError_t hipDeviceSynchronize(void);

2143hipError_t hipDeviceReset(void);

2175hipError_t hipSetDevice(int deviceId);

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

2201hipError_t hipGetDevice(int* deviceId);

2214hipError_t hipGetDeviceCount(int* count);

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

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

2261hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool);

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

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

2311hipError_t hipDeviceGetTexture1DLinearMaxWidth(size_t* max_width,

2312 const hipChannelFormatDesc* desc,

2313 int device);

2325hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig);

2336hipError_t hipDeviceGetCacheConfig(hipFuncCache_t* cacheConfig);

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

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

2382hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig* pConfig);

2390hipError_t hipGetDeviceFlags(unsigned int* flags);

2402hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config);

2434hipError_t hipSetDeviceFlags(unsigned flags);

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

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

2457// TODO: implement IPC apis

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

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

2535hipError_t hipIpcCloseMemHandle(void* devPtr);

2536

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

2554

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

2573

2574// end doxygen Device

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

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

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

2624//doxygen end execution

2646hipError_t hipGetLastError(void);

2647

2659hipError_t hipExtGetLastError(void);

2660

2671hipError_t hipPeekAtLastError(void);

2680const char* hipGetErrorName(hipError_t hip_error);

2689const char* hipGetErrorString(hipError_t hipError);

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

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

2710// end doxygen Error

2742hipError_t hipStreamCreate(hipStream_t* stream);

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

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

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

2821hipError_t hipStreamDestroy(hipStream_t stream);

2837hipError_t hipStreamQuery(hipStream_t stream);

2859hipError_t hipStreamSynchronize(hipStream_t stream);

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

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

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

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

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

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

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

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

2965 unsigned int flags);

2966

2974hipError_t hipStreamSetAttribute(hipStream_t stream, hipStreamAttrID attr,

2975 const hipStreamAttrValue *value);

2976

2984hipError_t hipStreamGetAttribute(hipStream_t stream, hipStreamAttrID attr,

2985 hipStreamAttrValue *value_out);

2986

2987// end doxygen Stream

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

3036 uint32_t mask __dparm(0xFFFFFFFF));

3037

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

3075 uint64_t mask __dparm(0xFFFFFFFFFFFFFFFF));

3076

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

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

3119

3139hipError_t hipStreamBatchMemOp(hipStream_t stream, unsigned int count,

3140 hipStreamBatchMemOpParams* paramArray, unsigned int flags);

3141

3159hipError_t hipGraphAddBatchMemOpNode(hipGraphNode_t *phGraphNode, hipGraph_t hGraph,

3160 const hipGraphNode_t *dependencies, size_t numDependencies,

3161 const hipBatchMemOpNodeParams* nodeParams);

3162

3183hipError_t hipGraphBatchMemOpNodeGetParams(hipGraphNode_t hNode,

3184 hipBatchMemOpNodeParams* nodeParams_out);

3185

3203hipError_t hipGraphBatchMemOpNodeSetParams(hipGraphNode_t hNode,

3204 hipBatchMemOpNodeParams* nodeParams);

3205

3225hipError_t hipGraphExecBatchMemOpNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

3226 const hipBatchMemOpNodeParams* nodeParams);

3227

3228// end doxygen Stream Memory Operations

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

3276hipError_t hipEventCreate(hipEvent_t* event);

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

3314 unsigned int flags __dparm(0));

3345#ifdef __cplusplus

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

3347#else

3348hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream);

3349#endif

3366hipError_t hipEventDestroy(hipEvent_t event);

3385hipError_t hipEventSynchronize(hipEvent_t event);

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

3431hipError_t hipEventQuery(hipEvent_t event);

3432// end doxygen Events

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

3464 hipDeviceptr_t ptr);

3465

3466

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

3501hipError_t hipPointerGetAttribute(void* data, hipPointer_attribute attribute,

3502 hipDeviceptr_t ptr);

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

3520 void** data, hipDeviceptr_t ptr);

3544hipError_t hipImportExternalSemaphore(hipExternalSemaphore_t* extSem_out,

3545 const hipExternalSemaphoreHandleDesc* semHandleDesc);

3561hipError_t hipSignalExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

3562 const hipExternalSemaphoreSignalParams* paramsArray,

3563 unsigned int numExtSems, hipStream_t stream);

3579hipError_t hipWaitExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

3580 const hipExternalSemaphoreWaitParams* paramsArray,

3581 unsigned int numExtSems, hipStream_t stream);

3594hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem);

3595

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

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

3629hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem);

3643hipError_t hipExternalMemoryGetMappedMipmappedArray(hipMipmappedArray_t* mipmap, hipExternalMemory_t extMem,

3644 const hipExternalMemoryMipmappedArrayDesc* mipmapDesc);

3645 // end of external resource

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

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

3683

3684

3707HIP_DEPRECATED("use hipHostMalloc instead")

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

3721HIP_DEPRECATED("use hipHostMalloc instead")

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

3723// end doxygen deprecated management memory

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

3795hipError_t hipMallocManaged(void** dev_ptr,

3796 size_t size,

3797 unsigned int flags __dparm(hipMemAttachGlobal));

3810hipError_t hipMemPrefetchAsync(const void* dev_ptr,

3811 size_t count,

3812 int device,

3813 hipStream_t stream __dparm(0));

3827hipError_t hipMemPrefetchAsync_v2(const void* dev_ptr,

3828 size_t count,

3829 hipMemLocation location,

3830 unsigned int flags,

3831 hipStream_t stream __dparm(0));

3851hipError_t hipMemAdvise(const void* dev_ptr,

3852 size_t count,

3853 hipMemoryAdvise advice,

3854 int device);

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

3875 hipMemLocation location);

3890hipError_t hipMemRangeGetAttribute(void* data,

3891 size_t data_size,

3892 hipMemRangeAttribute attribute,

3893 const void* dev_ptr,

3894 size_t count);

3911hipError_t hipMemRangeGetAttributes(void** data,

3912 size_t* data_sizes,

3913 hipMemRangeAttribute* attributes,

3914 size_t num_attributes,

3915 const void* dev_ptr,

3916 size_t count);

3932hipError_t hipStreamAttachMemAsync(hipStream_t stream,

3933 void* dev_ptr,

3934 size_t length __dparm(0),

3935 unsigned int flags __dparm(hipMemAttachSingle));

3936// end doxygen Managed Memory

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

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

4049hipError_t hipMemPoolTrimTo(hipMemPool_t mem_pool, size_t min_bytes_to_hold);

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

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

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

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

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

4216hipError_t hipMemPoolDestroy(hipMemPool_t mem_pool);

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

4277hipError_t hipMemPoolExportToShareableHandle(

4278 void* shared_handle,

4279 hipMemPool_t mem_pool,

4280 hipMemAllocationHandleType handle_type,

4281 unsigned int flags);

4305hipError_t hipMemPoolImportFromShareableHandle(

4306 hipMemPool_t* mem_pool,

4307 void* shared_handle,

4308 hipMemAllocationHandleType handle_type,

4309 unsigned int flags);

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

4358hipError_t hipMemPoolImportPointer(

4359 void** dev_ptr,

4360 hipMemPool_t mem_pool,

4361 hipMemPoolPtrExportData* export_data);

4362// Doxygen end of ordered memory allocator

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

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

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

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

4455hipError_t hipHostUnregister(void* hostPtr);

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

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

4498 unsigned int elementSizeBytes);

4512hipError_t hipFree(void* ptr);

4524hipError_t hipFreeHost(void* ptr);

4541hipError_t hipHostFree(void* ptr);

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

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

4587 hipMemcpyKind kind, hipStream_t stream);

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

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

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

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

4661 size_t ByteCount);

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

4681 size_t ByteCount);

4682

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

4703 size_t srcOffset, size_t ByteCount);

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

4723 hipStream_t stream);

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

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

4762 hipStream_t stream);

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

4783 size_t ByteCount, hipStream_t stream);

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

4804 size_t ByteCount, hipStream_t stream);

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

4822 hipModule_t hmod, const char* name);

4823

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

4834

4835

4836

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

4847

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

4868 hipDriverProcAddressQueryResult* symbolStatus);

4869

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

4891 size_t sizeBytes, size_t offset __dparm(0),

4892 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice));

4893

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

4908 size_t sizeBytes, size_t offset,

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

4910

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

4924 size_t sizeBytes, size_t offset __dparm(0),

4925 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost));

4926

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

4941 size_t sizeBytes, size_t offset,

4942 hipMemcpyKind kind,

4943 hipStream_t stream __dparm(0));

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

4973 hipStream_t stream __dparm(0));

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

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

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

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

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

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

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

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

5078 hipStream_t stream __dparm(0));

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

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

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

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

5121

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

5134 size_t height);

5147hipError_t hipMemsetD2D8Async(hipDeviceptr_t dst, size_t dstPitch, unsigned char value, size_t width,

5148 size_t height, hipStream_t stream __dparm(0));

5149

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

5162 size_t height);

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

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

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

5189 size_t height);

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

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

5204

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

5222

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

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

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

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

5269hipError_t hipArrayDestroy(hipArray_t array);

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

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

5300hipError_t hipFreeArray(hipArray_t array);

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

5313 struct hipExtent extent, unsigned int flags);

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

5327 hipArray_t array);

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

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

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

5399 size_t height, hipMemcpyKind kind);

5409hipError_t hipMemcpyParam2D(const hip_Memcpy2D* pCopy);

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

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

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

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

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

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

5501 size_t spitch, size_t width, size_t height, hipMemcpyKind kind,

5502 hipStream_t stream __dparm(0));

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

5522 hipArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc,

5523 size_t width, size_t height, hipMemcpyKind kind);

5542HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5544 size_t count, hipMemcpyKind kind);

5563HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5565 size_t count, hipMemcpyKind kind);

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

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

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

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

5641hipError_t hipMemcpy3D(const struct hipMemcpy3DParms* p);

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

5664hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D* pCopy);

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

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

5690

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

5707 hipMemcpyAttributes *attrs, size_t *attrsIdxs, size_t numAttrs,

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

5709

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

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

5724

5733hipError_t hipMemcpy3DPeer(hipMemcpy3DPeerParms *p);

5734

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

5744// doxygen end Memory

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

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

5805hipError_t hipDeviceDisablePeerAccess(int peerDeviceId);

5806

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

5819 size_t sizeBytes);

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

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

5834

5835// doxygen end PeerToPeer

5876HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5891HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5892hipError_t hipCtxDestroy(hipCtx_t ctx);

5906HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5907hipError_t hipCtxPopCurrent(hipCtx_t* ctx);

5921HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5922hipError_t hipCtxPushCurrent(hipCtx_t ctx);

5936HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5937hipError_t hipCtxSetCurrent(hipCtx_t ctx);

5951HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5952hipError_t hipCtxGetCurrent(hipCtx_t* ctx);

5966HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5967hipError_t hipCtxGetDevice(hipDevice_t* device);

5988HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6006HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6007hipError_t hipCtxGetCacheConfig(hipFuncCache_t* cacheConfig);

6024HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6025hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig);

6042HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6043hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config);

6060HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6061hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig* pConfig);

6076HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6077hipError_t hipCtxSynchronize(void);

6091HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6092hipError_t hipCtxGetFlags(unsigned int* flags);

6115HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6136HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6137hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx);

6138

6154HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6171HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6172hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev);

6187HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6202HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6203hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev);

6218HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6220// doxygen end Context Management

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

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

6268hipError_t hipModuleUnload(hipModule_t module);

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

6280

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

6291

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

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

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

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

6333 hipDriverEntryPointQueryResult* driverStatus);

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

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

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

6367 hipJitOption* options, void** optionValues);

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

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

6388 void** optionValues);

6389

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

6407 hipJitOption* options, void** optionValues);

6408

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

6424

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

6437 void** optionValues, hipLinkState_t* stateOut);

6446hipError_t hipLinkDestroy(hipLinkState_t state);

6447

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

6477 unsigned int gridDimZ, unsigned int blockDimX,

6478 unsigned int blockDimY, unsigned int blockDimZ,

6479 unsigned int sharedMemBytes, hipStream_t stream,

6480 void** kernelParams, void** extra);

6509hipError_t hipModuleLaunchCooperativeKernel(hipFunction_t f, unsigned int gridDimX,

6510 unsigned int gridDimY, unsigned int gridDimZ,

6511 unsigned int blockDimX, unsigned int blockDimY,

6512 unsigned int blockDimZ, unsigned int sharedMemBytes,

6513 hipStream_t stream, void** kernelParams);

6528hipError_t hipModuleLaunchCooperativeKernelMultiDevice(hipFunctionLaunchParams* launchParamsList,

6529 unsigned int numDevices,

6530 unsigned int flags);

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

6552 void** kernelParams, unsigned int sharedMemBytes,

6553 hipStream_t stream);

6565hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

6566 int numDevices, unsigned int flags);

6567

6568// Doxygen end group ModuleCooperativeG

6581hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

6582 int numDevices, unsigned int flags);

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

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

6613 void** extra);

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

6629 hipMemRangeHandleType handleType,

6630 unsigned long long flags);

6631// doxygen end Module

6659//TODO - Match CUoccupancyB2DSize

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

6661 hipFunction_t f, size_t dynSharedMemPerBlk,

6662 int blockSizeLimit);

6678//TODO - Match CUoccupancyB2DSize

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

6680 hipFunction_t f, size_t dynSharedMemPerBlk,

6681 int blockSizeLimit, unsigned int flags);

6691hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(

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

6703hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

6714hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(

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

6726hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

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

6743 const void* f, size_t dynSharedMemPerBlk,

6744 int blockSizeLimit);

6745// doxygen end Occupancy

6759// TODO - expand descriptions:

6766HIP_DEPRECATED("use roctracer/rocTX instead")

6767hipError_t hipProfilerStart();

6774HIP_DEPRECATED("use roctracer/rocTX instead")

6775hipError_t hipProfilerStop();

6776// doxygen end profiler

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

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

6823hipError_t hipLaunchByPtr(const void* func);

6840hipError_t __hipPushCallConfiguration(dim3 gridDim,

6841 dim3 blockDim,

6842 size_t sharedMem __dparm(0),

6843 hipStream_t stream __dparm(0));

6863hipError_t __hipPopCallConfiguration(dim3 *gridDim,

6864 dim3 *blockDim,

6865 size_t *sharedMem,

6866 hipStream_t *stream);

6883hipError_t hipLaunchKernel(const void* function_address,

6884 dim3 numBlocks,

6885 dim3 dimBlocks,

6886 void** args,

6887 size_t sharedMemBytes __dparm(0),

6888 hipStream_t stream __dparm(0));

6889

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

6916

6924hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D* pCopy);

6925//TODO: Move this to hip_ext.h

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

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

6949 hipEvent_t startEvent, hipEvent_t stopEvent, int flags);

6950// doxygen end Clang launch

6976hipError_t hipCreateTextureObject(

6977 hipTextureObject_t* pTexObject,

6978 const hipResourceDesc* pResDesc,

6979 const hipTextureDesc* pTexDesc,

6980 const struct hipResourceViewDesc* pResViewDesc);

6981

6990hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject);

6991

7001hipError_t hipGetChannelDesc(

7002 hipChannelFormatDesc* desc,

7003 hipArray_const_t array);

7004

7014hipError_t hipGetTextureObjectResourceDesc(

7015 hipResourceDesc* pResDesc,

7016 hipTextureObject_t textureObject);

7017

7027hipError_t hipGetTextureObjectResourceViewDesc(

7028 struct hipResourceViewDesc* pResViewDesc,

7029 hipTextureObject_t textureObject);

7030

7040hipError_t hipGetTextureObjectTextureDesc(

7041 hipTextureDesc* pTexDesc,

7042 hipTextureObject_t textureObject);

7043

7055hipError_t hipTexObjectCreate(

7056 hipTextureObject_t* pTexObject,

7057 const HIP_RESOURCE_DESC* pResDesc,

7058 const HIP_TEXTURE_DESC* pTexDesc,

7059 const HIP_RESOURCE_VIEW_DESC* pResViewDesc);

7060

7069hipError_t hipTexObjectDestroy(

7070 hipTextureObject_t texObject);

7071

7081hipError_t hipTexObjectGetResourceDesc(

7082 HIP_RESOURCE_DESC* pResDesc,

7083 hipTextureObject_t texObject);

7084

7094hipError_t hipTexObjectGetResourceViewDesc(

7095 HIP_RESOURCE_VIEW_DESC* pResViewDesc,

7096 hipTextureObject_t texObject);

7097

7107hipError_t hipTexObjectGetTextureDesc(

7108 HIP_TEXTURE_DESC* pTexDesc,

7109 hipTextureObject_t texObject);

7110

7125hipError_t hipMallocMipmappedArray(

7126 hipMipmappedArray_t *mipmappedArray,

7127 const struct hipChannelFormatDesc* desc,

7128 struct hipExtent extent,

7129 unsigned int numLevels,

7130 unsigned int flags __dparm(0));

7131

7142hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray);

7143

7156hipError_t hipGetMipmappedArrayLevel(

7157 hipArray_t *levelArray,

7158 hipMipmappedArray_const_t mipmappedArray,

7159 unsigned int level);

7160

7172hipError_t hipMipmappedArrayCreate(

7173 hipMipmappedArray_t* pHandle,

7174 HIP_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc,

7175 unsigned int numMipmapLevels);

7176

7187hipError_t hipMipmappedArrayDestroy(hipMipmappedArray_t hMipmappedArray);

7188

7201hipError_t hipMipmappedArrayGetLevel(

7202 hipArray_t* pLevelArray,

7203 hipMipmappedArray_t hMipMappedArray,

7204 unsigned int level);

7205

7224HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7225hipError_t hipBindTextureToMipmappedArray(

7226 const textureReference* tex,

7227 hipMipmappedArray_const_t mipmappedArray,

7228 const hipChannelFormatDesc* desc);

7229

7240HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7241hipError_t hipGetTextureReference(

7242 const textureReference** texref,

7243 const void* symbol);

7244

7255HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7257

7269HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7271

7283HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7284hipError_t hipTexRefSetAddressMode(

7285 textureReference* texRef,

7286 int dim,

7287 enum hipTextureAddressMode am);

7300HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7301hipError_t hipTexRefSetArray(

7302 textureReference* tex,

7303 hipArray_const_t array,

7304 unsigned int flags);

7316HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7317hipError_t hipTexRefSetFilterMode(

7318 textureReference* texRef,

7319 enum hipTextureFilterMode fm);

7331HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7332hipError_t hipTexRefSetFlags(

7333 textureReference* texRef,

7334 unsigned int Flags);

7347HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7348hipError_t hipTexRefSetFormat(

7349 textureReference* texRef,

7350 hipArray_Format fmt,

7351 int NumPackedComponents);

7366HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7367hipError_t hipBindTexture(

7368 size_t* offset,

7369 const textureReference* tex,

7370 const void* devPtr,

7371 const hipChannelFormatDesc* desc,

7372 size_t size __dparm(UINT_MAX));

7389HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7390hipError_t hipBindTexture2D(

7391 size_t* offset,

7392 const textureReference* tex,

7393 const void* devPtr,

7394 const hipChannelFormatDesc* desc,

7395 size_t width,

7396 size_t height,

7397 size_t pitch);

7410HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7411hipError_t hipBindTextureToArray(

7412 const textureReference* tex,

7413 hipArray_const_t array,

7414 const hipChannelFormatDesc* desc);

7426HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7427hipError_t hipGetTextureAlignmentOffset(

7428 size_t* offset,

7429 const textureReference* texref);

7440HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7441hipError_t hipUnbindTexture(const textureReference* tex);

7453HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7454hipError_t hipTexRefGetAddress(

7455 hipDeviceptr_t* dev_ptr,

7456 const textureReference* texRef);

7469HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7470hipError_t hipTexRefGetAddressMode(

7471 enum hipTextureAddressMode* pam,

7472 const textureReference* texRef,

7473 int dim);

7485HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7486hipError_t hipTexRefGetFilterMode(

7487 enum hipTextureFilterMode* pfm,

7488 const textureReference* texRef);

7500HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7501hipError_t hipTexRefGetFlags(

7502 unsigned int* pFlags,

7503 const textureReference* texRef);

7516HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7517hipError_t hipTexRefGetFormat(

7518 hipArray_Format* pFormat,

7519 int* pNumChannels,

7520 const textureReference* texRef);

7532HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7533hipError_t hipTexRefGetMaxAnisotropy(

7534 int* pmaxAnsio,

7535 const textureReference* texRef);

7547HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7548hipError_t hipTexRefGetMipmapFilterMode(

7549 enum hipTextureFilterMode* pfm,

7550 const textureReference* texRef);

7562HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7563hipError_t hipTexRefGetMipmapLevelBias(

7564 float* pbias,

7565 const textureReference* texRef);

7578HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7579hipError_t hipTexRefGetMipmapLevelClamp(

7580 float* pminMipmapLevelClamp,

7581 float* pmaxMipmapLevelClamp,

7582 const textureReference* texRef);

7594HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7595hipError_t hipTexRefGetMipMappedArray(

7596 hipMipmappedArray_t* pArray,

7597 const textureReference* texRef);

7611HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7612hipError_t hipTexRefSetAddress(

7613 size_t* ByteOffset,

7614 textureReference* texRef,

7615 hipDeviceptr_t dptr,

7616 size_t bytes);

7630HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7631hipError_t hipTexRefSetAddress2D(

7632 textureReference* texRef,

7633 const HIP_ARRAY_DESCRIPTOR* desc,

7634 hipDeviceptr_t dptr,

7635 size_t Pitch);

7647HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7648hipError_t hipTexRefSetMaxAnisotropy(

7649 textureReference* texRef,

7650 unsigned int maxAniso);

7662HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7663hipError_t hipTexRefSetBorderColor(

7664 textureReference* texRef,

7665 float* pBorderColor);

7677HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7678hipError_t hipTexRefSetMipmapFilterMode(

7679 textureReference* texRef,

7680 enum hipTextureFilterMode fm);

7692HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7693hipError_t hipTexRefSetMipmapLevelBias(

7694 textureReference* texRef,

7695 float bias);

7708HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7709hipError_t hipTexRefSetMipmapLevelClamp(

7710 textureReference* texRef,

7711 float minMipMapLevelClamp,

7712 float maxMipMapLevelClamp);

7725HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7726hipError_t hipTexRefSetMipmappedArray(

7727 textureReference* texRef,

7728 struct hipMipmappedArray* mipmappedArray,

7729 unsigned int Flags);

7730

7731// doxygen end deprecated texture management

7736// doxygen end Texture management

7748// This group is for HIPrtc

7749

7750// doxygen end Runtime

7769const char* hipApiName(uint32_t id);

7778const char* hipKernelNameRef(const hipFunction_t f);

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

7797int hipGetStreamDeviceId(hipStream_t stream);

7798

7799// doxygen end Callback

7821hipError_t hipStreamBeginCapture(hipStream_t stream, hipStreamCaptureMode mode);

7822

7842hipError_t hipStreamBeginCaptureToGraph(hipStream_t stream, hipGraph_t graph,

7843 const hipGraphNode_t* dependencies,

7844 const hipGraphEdgeData* dependencyData,

7845 size_t numDependencies, hipStreamCaptureMode mode);

7846

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

7857

7868hipError_t hipStreamGetCaptureInfo(hipStream_t stream, hipStreamCaptureStatus* pCaptureStatus,

7869 unsigned long long* pId);

7870

7884hipError_t hipStreamGetCaptureInfo_v2(hipStream_t stream, hipStreamCaptureStatus* captureStatus_out,

7885 unsigned long long* id_out __dparm(0),

7886 hipGraph_t* graph_out __dparm(0),

7887 const hipGraphNode_t** dependencies_out __dparm(0),

7888 size_t* numDependencies_out __dparm(0));

7889

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

7900

7912hipError_t hipStreamUpdateCaptureDependencies(hipStream_t stream, hipGraphNode_t* dependencies,

7913 size_t numDependencies,

7914 unsigned int flags __dparm(0));

7915

7923hipError_t hipThreadExchangeStreamCaptureMode(hipStreamCaptureMode* mode);

7924

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

7935

7944hipError_t hipGraphDestroy(hipGraph_t graph);

7945

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

7957 const hipGraphNode_t* to, size_t numDependencies);

7958

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

7970 const hipGraphNode_t* to, size_t numDependencies);

7971

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

7988 size_t* numEdges);

7989

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

8005

8020hipError_t hipGraphGetRootNodes(hipGraph_t graph, hipGraphNode_t* pRootNodes,

8021 size_t* pNumRootNodes);

8022

8037hipError_t hipGraphNodeGetDependencies(hipGraphNode_t node, hipGraphNode_t* pDependencies,

8038 size_t* pNumDependencies);

8039

8055hipError_t hipGraphNodeGetDependentNodes(hipGraphNode_t node, hipGraphNode_t* pDependentNodes,

8056 size_t* pNumDependentNodes);

8057

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

8067

8075hipError_t hipGraphDestroyNode(hipGraphNode_t node);

8076

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

8086

8096hipError_t hipGraphNodeFindInClone(hipGraphNode_t* pNode, hipGraphNode_t originalNode,

8097 hipGraph_t clonedGraph);

8098

8112hipError_t hipGraphInstantiate(hipGraphExec_t* pGraphExec, hipGraph_t graph,

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

8114

8125hipError_t hipGraphInstantiateWithFlags(hipGraphExec_t* pGraphExec, hipGraph_t graph,

8126 unsigned long long flags);

8127

8137hipError_t hipGraphInstantiateWithParams(hipGraphExec_t* pGraphExec, hipGraph_t graph,

8138 hipGraphInstantiateParams *instantiateParams);

8147hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream);

8148

8157hipError_t hipGraphUpload(hipGraphExec_t graphExec, hipStream_t stream);

8158

8170hipError_t hipGraphAddNode(hipGraphNode_t *pGraphNode, hipGraph_t graph,

8171 const hipGraphNode_t *pDependencies, size_t numDependencies,

8172 hipGraphNodeParams *nodeParams);

8173

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

8183

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

8193

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

8204

8213hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec);

8214

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

8227hipError_t hipGraphExecUpdate(hipGraphExec_t hGraphExec, hipGraph_t hGraph,

8228 hipGraphNode_t* hErrorNode_out,

8229 hipGraphExecUpdateResult* updateResult_out);

8230

8242hipError_t hipGraphAddKernelNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8243 const hipGraphNode_t* pDependencies, size_t numDependencies,

8244 const hipKernelNodeParams* pNodeParams);

8245

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

8255

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

8265

8275hipError_t hipGraphExecKernelNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8276 const hipKernelNodeParams* pNodeParams);

8277

8290hipError_t hipDrvGraphAddMemcpyNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

8291 const hipGraphNode_t* dependencies,

8292 size_t numDependencies,

8293 const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);

8305hipError_t hipGraphAddMemcpyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8306 const hipGraphNode_t* pDependencies, size_t numDependencies,

8307 const hipMemcpy3DParms* pCopyParams);

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

8317

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

8327

8337hipError_t hipGraphKernelNodeSetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

8338 const hipKernelNodeAttrValue* value);

8348hipError_t hipGraphKernelNodeGetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

8349 hipKernelNodeAttrValue* value);

8359hipError_t hipGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8360 hipMemcpy3DParms* pNodeParams);

8361

8376hipError_t hipGraphAddMemcpyNode1D(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8377 const hipGraphNode_t* pDependencies, size_t numDependencies,

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

8379

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

8392 size_t count, hipMemcpyKind kind);

8393

8407hipError_t hipGraphExecMemcpyNodeSetParams1D(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

8409 hipMemcpyKind kind);

8410

8426hipError_t hipGraphAddMemcpyNodeFromSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8427 const hipGraphNode_t* pDependencies,

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

8429 size_t count, size_t offset, hipMemcpyKind kind);

8430

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

8444 size_t count, size_t offset, hipMemcpyKind kind);

8445

8460hipError_t hipGraphExecMemcpyNodeSetParamsFromSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

8462 size_t offset, hipMemcpyKind kind);

8463

8479hipError_t hipGraphAddMemcpyNodeToSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8480 const hipGraphNode_t* pDependencies,

8481 size_t numDependencies, const void* symbol,

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

8483 hipMemcpyKind kind);

8484

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

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

8499 hipMemcpyKind kind);

8500

8501

8515hipError_t hipGraphExecMemcpyNodeSetParamsToSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8516 const void* symbol, const void* src,

8517 size_t count, size_t offset, hipMemcpyKind kind);

8518

8530hipError_t hipGraphAddMemsetNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8531 const hipGraphNode_t* pDependencies, size_t numDependencies,

8532 const hipMemsetParams* pMemsetParams);

8533

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

8543

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

8553

8563hipError_t hipGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8564 const hipMemsetParams* pNodeParams);

8565

8577hipError_t hipGraphAddHostNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8578 const hipGraphNode_t* pDependencies, size_t numDependencies,

8579 const hipHostNodeParams* pNodeParams);

8580

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

8590

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

8600

8610hipError_t hipGraphExecHostNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8611 const hipHostNodeParams* pNodeParams);

8612

8624hipError_t hipGraphAddChildGraphNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8625 const hipGraphNode_t* pDependencies, size_t numDependencies,

8626 hipGraph_t childGraph);

8627

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

8637

8647hipError_t hipGraphExecChildGraphNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8648 hipGraph_t childGraph);

8649

8660hipError_t hipGraphAddEmptyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8661 const hipGraphNode_t* pDependencies, size_t numDependencies);

8662

8663

8675hipError_t hipGraphAddEventRecordNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8676 const hipGraphNode_t* pDependencies, size_t numDependencies,

8677 hipEvent_t event);

8678

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

8688

8697hipError_t hipGraphEventRecordNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

8698

8708hipError_t hipGraphExecEventRecordNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8709 hipEvent_t event);

8710

8722hipError_t hipGraphAddEventWaitNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8723 const hipGraphNode_t* pDependencies, size_t numDependencies,

8724 hipEvent_t event);

8725

8726

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

8736

8745hipError_t hipGraphEventWaitNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

8746

8756hipError_t hipGraphExecEventWaitNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8757 hipEvent_t event);

8758

8770hipError_t hipGraphAddMemAllocNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

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

8772

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

8782

8794hipError_t hipGraphAddMemFreeNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

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

8796

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

8806

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

8817

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

8828

8836hipError_t hipDeviceGraphMemTrim(int device);

8837

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

8850 unsigned int initialRefcount, unsigned int flags);

8851

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

8861

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

8871

8882hipError_t hipGraphRetainUserObject(hipGraph_t graph, hipUserObject_t object,

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

8884

8894hipError_t hipGraphReleaseUserObject(hipGraph_t graph, hipUserObject_t object,

8895 unsigned int count __dparm(1));

8896

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

8907

8921hipError_t hipGraphKernelNodeCopyAttributes(hipGraphNode_t hSrc, hipGraphNode_t hDst);

8922

8944hipError_t hipGraphNodeSetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8945 unsigned int isEnabled);

8965hipError_t hipGraphNodeGetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8966 unsigned int* isEnabled);

8967

8979hipError_t hipGraphAddExternalSemaphoresWaitNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8980 const hipGraphNode_t* pDependencies, size_t numDependencies,

8981 const hipExternalSemaphoreWaitNodeParams* nodeParams);

8982

8994hipError_t hipGraphAddExternalSemaphoresSignalNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8995 const hipGraphNode_t* pDependencies, size_t numDependencies,

8996 const hipExternalSemaphoreSignalNodeParams* nodeParams);

9005hipError_t hipGraphExternalSemaphoresSignalNodeSetParams(hipGraphNode_t hNode,

9006 const hipExternalSemaphoreSignalNodeParams* nodeParams);

9015hipError_t hipGraphExternalSemaphoresWaitNodeSetParams(hipGraphNode_t hNode,

9016 const hipExternalSemaphoreWaitNodeParams* nodeParams);

9025hipError_t hipGraphExternalSemaphoresSignalNodeGetParams(hipGraphNode_t hNode,

9026 hipExternalSemaphoreSignalNodeParams* params_out);

9035hipError_t hipGraphExternalSemaphoresWaitNodeGetParams(hipGraphNode_t hNode,

9036 hipExternalSemaphoreWaitNodeParams* params_out);

9046hipError_t hipGraphExecExternalSemaphoresSignalNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9047 const hipExternalSemaphoreSignalNodeParams* nodeParams);

9057hipError_t hipGraphExecExternalSemaphoresWaitNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9058 const hipExternalSemaphoreWaitNodeParams* nodeParams);

9059

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

9069

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

9079

9092hipError_t hipDrvGraphAddMemsetNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

9093 const hipGraphNode_t* dependencies, size_t numDependencies,

9094 const hipMemsetParams* memsetParams, hipCtx_t ctx);

9095

9107hipError_t hipDrvGraphAddMemFreeNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

9108 const hipGraphNode_t* dependencies, size_t numDependencies,

9109 hipDeviceptr_t dptr);

9110

9121hipError_t hipDrvGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9122 const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);

9123

9134hipError_t hipDrvGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9135 const hipMemsetParams* memsetParams, hipCtx_t ctx);

9136

9137// doxygen end graph API

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

9169

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

9185

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

9200

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

9215

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

9229

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

9244

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

9257

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

9271

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

9287

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

9299

9310hipError_t hipMemRelease(hipMemGenericAllocationHandle_t handle);

9311

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

9324

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

9339

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

9352

9353// doxygen end virtual memory management API

9375hipError_t hipGraphicsMapResources(int count, hipGraphicsResource_t* resources,

9376 hipStream_t stream __dparm(0) );

9390hipError_t hipGraphicsSubResourceGetMappedArray(hipArray_t* array, hipGraphicsResource_t resource,

9391 unsigned int arrayIndex, unsigned int mipLevel);

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

9403 hipGraphicsResource_t resource);

9414hipError_t hipGraphicsUnmapResources(int count, hipGraphicsResource_t* resources,

9415 hipStream_t stream __dparm(0));

9424hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource);

9425// doxygen end GraphicsInterop

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

9459hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject);

9460// end of surface

9464#ifdef __cplusplus

9465} /* extern "c" */

9466#endif

9467#ifdef __cplusplus

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

9469template <typename T>

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

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

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

9473}

9474template <typename T>

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

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

9477 (void)flags;

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

9479 dynSharedMemPerBlk, blockSizeLimit);

9480}

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

9482

9492template <typename T>

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

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

9495}

9506template <typename T>

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

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

9509}

9510

9519template <typename T>

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

9521 size_t offset __dparm(0),

9522 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice)) {

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

9524}

9533template <typename T>

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

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

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

9537}

9545template <typename T>

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

9547 size_t sizeBytes, size_t offset __dparm(0),

9548 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost)) {

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

9550}

9558template <typename T>

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

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

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

9562}

9563

9575template <class T>

9576inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(

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

9578 return hipOccupancyMaxActiveBlocksPerMultiprocessor(

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

9580}

9594template <class T>

9595inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

9597 return hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

9599}

9620template<typename UnaryFunction, class T>

9621static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(

9622 int* min_grid_size,

9623 int* block_size,

9624 T func,

9625 UnaryFunction block_size_to_dynamic_smem_size,

9626 int block_size_limit = 0,

9627 unsigned int flags = 0) {

9628 if (min_grid_size == nullptr || block_size == nullptr ||

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

9630 return hipErrorInvalidValue;

9631 }

9632

9633 int dev;

9634 hipError_t status;

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

9636 return status;

9637 }

9638

9639 int max_threads_per_cu;

9640 if ((status = hipDeviceGetAttribute(&max_threads_per_cu,

9641 hipDeviceAttributeMaxThreadsPerMultiProcessor, dev)) != hipSuccess) {

9642 return status;

9643 }

9644

9645 int warp_size;

9646 if ((status = hipDeviceGetAttribute(&warp_size,

9647 hipDeviceAttributeWarpSize, dev)) != hipSuccess) {

9648 return status;

9649 }

9650

9651 int max_cu_count;

9652 if ((status = hipDeviceGetAttribute(&max_cu_count,

9653 hipDeviceAttributeMultiprocessorCount, dev)) != hipSuccess) {

9654 return status;

9655 }

9656

9657 struct hipFuncAttributes attr;

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

9659 return status;

9660 }

9661

9662 // Initial limits for the execution

9663 const int func_max_threads_per_block = attr.maxThreadsPerBlock;

9664 if (block_size_limit == 0) {

9665 block_size_limit = func_max_threads_per_block;

9666 }

9667

9668 if (func_max_threads_per_block < block_size_limit) {

9669 block_size_limit = func_max_threads_per_block;

9670 }

9671

9672 const int block_size_limit_aligned =

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

9674

9675 // For maximum search

9676 int max_threads = 0;

9677 int max_block_size{};

9678 int max_num_blocks{};

9679 for (int block_size_check_aligned = block_size_limit_aligned;

9680 block_size_check_aligned > 0;

9681 block_size_check_aligned -= warp_size) {

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

9683 int block_size_check = (block_size_limit < block_size_check_aligned) ?

9684 block_size_limit : block_size_check_aligned;

9685

9686 size_t dyn_smem_size = block_size_to_dynamic_smem_size(block_size_check);

9687 int optimal_blocks;

9688 if ((status = hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

9690 return status;

9691 }

9692

9693 int total_threads = block_size_check * optimal_blocks;

9694 if (total_threads > max_threads) {

9695 max_block_size = block_size_check;

9696 max_num_blocks = optimal_blocks;

9697 max_threads = total_threads;

9698 }

9699

9700 // Break if the logic reached possible maximum

9701 if (max_threads_per_cu == max_threads) {

9702 break;

9703 }

9704 }

9705

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

9707 *min_grid_size = max_num_blocks * max_cu_count;

9708 *block_size = max_block_size;

9709

9710 return status;

9711}

9712

9732template<typename UnaryFunction, class T>

9733static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMem(

9734 int* min_grid_size,

9735 int* block_size,

9736 T func,

9737 UnaryFunction block_size_to_dynamic_smem_size,

9738 int block_size_limit = 0)

9739{

9740 return hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(min_grid_size, block_size, func,

9741 block_size_to_dynamic_smem_size, block_size_limit);

9742}

9757template <typename F>

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

9759 F kernel, size_t dynSharedMemPerBlk, uint32_t blockSizeLimit) {

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

9761}

9783template <class T>

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

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

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

9787 blockDim, kernelParams, sharedMemBytes, stream);

9788}

9804template <class T>

9805inline hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

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

9807 return hipLaunchCooperativeKernelMultiDevice(launchParamsList, numDevices, flags);

9808}

9820template <class T>

9821inline hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

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

9823 return hipExtLaunchMultiKernelMultiDevice(launchParamsList, numDevices, flags);

9824}

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

9839HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

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

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

9843}

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

9859HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9860static inline hipError_t

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

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

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

9864}

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

9881HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9882static inline hipError_t hipBindTexture2D(

9883 size_t *offset,

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

9885 const void *devPtr,

9886 size_t width,

9887 size_t height,

9888 size_t pitch)

9889{

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

9891}

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

9909HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9910static inline hipError_t hipBindTexture2D(

9911 size_t *offset,

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

9913 const void *devPtr,

9914 const struct hipChannelFormatDesc &desc,

9915 size_t width,

9916 size_t height,

9917 size_t pitch)

9918{

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

9920}

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

9933HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9934static inline hipError_t hipBindTextureToArray(

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

9936 hipArray_const_t array)

9937{

9938 struct hipChannelFormatDesc desc;

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

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

9941}

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

9955HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9956static inline hipError_t hipBindTextureToArray(

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

9958 hipArray_const_t array,

9959 const struct hipChannelFormatDesc &desc)

9960{

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

9962}

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

9975HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9976static inline hipError_t hipBindTextureToMipmappedArray(

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

9978 hipMipmappedArray_const_t mipmappedArray)

9979{

9980 struct hipChannelFormatDesc desc;

9981 hipArray_t levelArray;

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

9983 if (err != hipSuccess) {

9984 return err;

9985 }

9986 err = hipGetChannelDesc(&desc, levelArray);

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

9988}

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

10002HIP_DEPRECATED(HIP_DEPRECATED_MSG)

10003static inline hipError_t hipBindTextureToMipmappedArray(

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

10005 hipMipmappedArray_const_t mipmappedArray,

10006 const struct hipChannelFormatDesc &desc)

10007{

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

10009}

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

10021HIP_DEPRECATED(HIP_DEPRECATED_MSG)

10022static inline hipError_t hipUnbindTexture(

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

10024{

10025 return hipUnbindTexture(&tex);

10026}

10050static inline hipError_t hipMallocAsync(

10051 void** dev_ptr,

10052 size_t size,

10053 hipMemPool_t mem_pool,

10054 hipStream_t stream) {

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

10056}

10067template<class T>

10068static inline hipError_t hipMallocAsync(

10069 T** dev_ptr,

10070 size_t size,

10071 hipMemPool_t mem_pool,

10072 hipStream_t stream) {

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

10074}

10085template<class T>

10086static inline hipError_t hipMallocAsync(

10087 T** dev_ptr,

10088 size_t size,

10089 hipStream_t stream) {

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

10091}

10102template<class T>

10103static inline hipError_t hipMallocFromPoolAsync(

10104 T** dev_ptr,

10105 size_t size,

10106 hipMemPool_t mem_pool,

10107 hipStream_t stream) {

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

10109}

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

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

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

10126 Params&&... args) {

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

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

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

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

10131}

10137#endif // __cplusplus

10138

10139#ifdef __GNUC__

10140#pragma GCC visibility pop

10141#endif

10142

10143

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

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

10146#else

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

10148#endif

10149

10150

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

10163template <class T>

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

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

10166}

10178template <class T>

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

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

10181}

10194template <class T>

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

10196 unsigned int flags = hipHostMallocDefault) {

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

10198}

10211template <class T>

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

10213 unsigned int flags = hipHostAllocDefault) {

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

10215}

10230template <class T>

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

10232 unsigned int flags = hipMemAttachGlobal) {

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

10234}

10235

10236

10237#endif

10238#endif

10239// doxygen end HIP API

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

10244

10245#if USE_PROF_API

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

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

hipCtxGetApiVersion

hipError_t hipCtxGetApiVersion(hipCtx_t ctx, unsigned int *apiVersion)

Returns the approximate HIP api version.

hipCtxPopCurrent

hipError_t hipCtxPopCurrent(hipCtx_t *ctx)

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

hipCtxGetSharedMemConfig

hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig *pConfig)

Get Shared memory bank configuration [Deprecated].

hipDevicePrimaryCtxSetFlags

hipError_t hipDevicePrimaryCtxSetFlags(hipDevice_t dev, unsigned int flags)

Set flags for the primary context [Deprecated].

hipDevicePrimaryCtxGetState

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

Get the state of the primary context [Deprecated].

hipCtxGetCurrent

hipError_t hipCtxGetCurrent(hipCtx_t *ctx)

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

hipDevicePrimaryCtxRelease

hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev)

Release the primary context on the GPU.

hipCtxSetCacheConfig

hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig)

Set L1/Shared cache partition [Deprecated].

hipCtxSetCurrent

hipError_t hipCtxSetCurrent(hipCtx_t ctx)

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

hipCtxEnablePeerAccess

hipError_t hipCtxEnablePeerAccess(hipCtx_t peerCtx, unsigned int flags)

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

hipCtxGetDevice

hipError_t hipCtxGetDevice(hipDevice_t *device)

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

hipCtxDestroy

hipError_t hipCtxDestroy(hipCtx_t ctx)

Destroy a HIP context [Deprecated].

hipCtxPushCurrent

hipError_t hipCtxPushCurrent(hipCtx_t ctx)

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

hipCtxGetCacheConfig

hipError_t hipCtxGetCacheConfig(hipFuncCache_t *cacheConfig)

Get Cache configuration for a specific function [Deprecated].

hipCtxCreate

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

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

hipDevicePrimaryCtxRetain

hipError_t hipDevicePrimaryCtxRetain(hipCtx_t *pctx, hipDevice_t dev)

Retain the primary context on the GPU [Deprecated].

hipDevicePrimaryCtxReset

hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev)

Resets the primary context on the GPU [Deprecated].

hipCtxSynchronize

hipError_t hipCtxSynchronize(void)

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

hipCtxSetSharedMemConfig

hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config)

Set Shared memory bank configuration [Deprecated].

hipCtxDisablePeerAccess

hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx)

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

hipGetDeviceFlags

hipError_t hipGetDeviceFlags(unsigned int *flags)

Gets the flags set for current device.

hipIpcGetEventHandle

hipError_t hipIpcGetEventHandle(hipIpcEventHandle_t *handle, hipEvent_t event)

Gets an opaque interprocess handle for an event.

hipDeviceGetDefaultMemPool

hipError_t hipDeviceGetDefaultMemPool(hipMemPool_t *mem_pool, int device)

Returns the default memory pool of the specified device.

hipDeviceGetSharedMemConfig

hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig *pConfig)

Returns bank width of shared memory for current device.

hipDeviceSetMemPool

hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool)

Sets the current memory pool of a device.

hipIpcOpenMemHandle

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

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

hipDeviceGetCacheConfig

hipError_t hipDeviceGetCacheConfig(hipFuncCache_t *cacheConfig)

Get Cache configuration for a specific Device.

hipSetDevice

hipError_t hipSetDevice(int deviceId)

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

hipExtGetLinkTypeAndHopCount

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

Returns the link type and hop count between two devices.

hipDeviceGetTexture1DLinearMaxWidth

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

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

hipSetDeviceFlags

hipError_t hipSetDeviceFlags(unsigned flags)

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

hipDeviceGetAttribute

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

Query for a specific device attribute.

hipGetDevice

hipError_t hipGetDevice(int *deviceId)

Return the default device id for the calling host thread.

hipGetDeviceCount

hipError_t hipGetDeviceCount(int *count)

Return number of compute-capable devices.

hipDeviceGetMemPool

hipError_t hipDeviceGetMemPool(hipMemPool_t *mem_pool, int device)

Gets the current memory pool for the specified device.

hipDeviceReset

hipError_t hipDeviceReset(void)

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

hipDeviceGetLimit

hipError_t hipDeviceGetLimit(size_t *pValue, enum hipLimit_t limit)

Gets resource limits of current device.

hipDeviceSetSharedMemConfig

hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config)

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

hipDeviceSetLimit

hipError_t hipDeviceSetLimit(enum hipLimit_t limit, size_t value)

Sets resource limits of current device.

hipDeviceSetCacheConfig

hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig)

Set L1/Shared cache partition.

hipIpcCloseMemHandle

hipError_t hipIpcCloseMemHandle(void *devPtr)

Close memory mapped with hipIpcOpenMemHandle.

hipSetValidDevices

hipError_t hipSetValidDevices(int *device_arr, int len)

Set a list of devices that can be used.

hipIpcOpenEventHandle

hipError_t hipIpcOpenEventHandle(hipEvent_t *event, hipIpcEventHandle_t handle)

Opens an interprocess event handles.

hipDeviceSynchronize

hipError_t hipDeviceSynchronize(void)

Waits on all active streams on current device.

hipIpcGetMemHandle

hipError_t hipIpcGetMemHandle(hipIpcMemHandle_t *handle, void *devPtr)

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

hipInit

hipError_t hipInit(unsigned int flags)

Explicitly initializes the HIP runtime.

hipDeviceComputeCapability

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

Returns the compute capability of the device.

hipDeviceGetName

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

Returns an identifer string for the device.

hipDeviceGetByPCIBusId

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

Returns a handle to a compute device.

hipDeviceGetUuid

hipError_t hipDeviceGetUuid(hipUUID *uuid, hipDevice_t device)

Returns an UUID for the device.[BETA].

hipDeviceTotalMem

hipError_t hipDeviceTotalMem(size_t *bytes, hipDevice_t device)

Returns the total amount of memory on the device.

hipDeviceGetPCIBusId

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

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

hipDeviceGet

hipError_t hipDeviceGet(hipDevice_t *device, int ordinal)

Returns a handle to a compute device.

hipRuntimeGetVersion

hipError_t hipRuntimeGetVersion(int *runtimeVersion)

Returns the approximate HIP Runtime version.

hipDeviceGetP2PAttribute

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

Returns a value for attribute of link between two devices.

hipDriverGetVersion

hipError_t hipDriverGetVersion(int *driverVersion)

Returns the approximate HIP driver version.

hipMemcpyKind

hipMemcpyKind

Definition driver_types.h:372

hipPointer_attribute

hipPointer_attribute

Definition driver_types.h:622

hipArray_t

struct hipArray * hipArray_t

Definition driver_types.h:75

hipDeviceptr_t

void * hipDeviceptr_t

Definition driver_types.h:46

hipFunction_attribute

hipFunction_attribute

Definition driver_types.h:608

hipArray_const_t

const struct hipArray * hipArray_const_t

Definition driver_types.h:76

hipArray_Format

hipArray_Format

Definition driver_types.h:80

hipResourceType

hipResourceType

Definition driver_types.h:159

hipMemcpyDeviceToHost

@ hipMemcpyDeviceToHost

Device-to-Host Copy.

Definition driver_types.h:375

hipMemcpyHostToDevice

@ hipMemcpyHostToDevice

Host-to-Device Copy.

Definition driver_types.h:374

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.

hipLaunchKernelExC

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

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

hipExtLaunchMultiKernelMultiDevice

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

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

hipModuleLaunchKernel

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

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

hipFuncSetSharedMemConfig

hipError_t hipFuncSetSharedMemConfig(const void *func, hipSharedMemConfig config)

Set shared memory configuation for a specific function.

hipFuncGetAttribute

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

Find out a specific attribute for a given function.

hipFuncSetAttribute

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

Set attribute for a specific function.

hipDrvLaunchKernelEx

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

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

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

hipMemRangeHandleType

hipMemRangeHandleType

Definition hip_runtime_api.h:1962

hipMemAllocationHandleType

hipMemAllocationHandleType

Definition hip_runtime_api.h:1196

hipGraphicsResource_t

hipGraphicsResource * hipGraphicsResource_t

Definition hip_runtime_api.h:1413

hipCtx_t

struct ihipCtx_t * hipCtx_t

Definition hip_runtime_api.h:661

__dparm

#define __dparm(x)

Definition hip_runtime_api.h:642

hipStream_t

struct ihipStream_t * hipStream_t

Definition hip_runtime_api.h:675

hipGraphInstantiateResult

hipGraphInstantiateResult

Definition hip_runtime_api.h:1679

hipDevice_t

int hipDevice_t

Definition hip_runtime_api.h:663

hipAccessProperty

hipAccessProperty

Definition hip_runtime_api.h:1491

hipLinkState_t

struct ihipLinkState_t * hipLinkState_t

Definition hip_runtime_api.h:686

hipGraphDependencyType

hipGraphDependencyType

Definition hip_runtime_api.h:1898

hipMemRangeAttribute

hipMemRangeAttribute

Definition hip_runtime_api.h:1090

hipMemAttachSingle

#define hipMemAttachSingle

Definition hip_runtime_api.h:855

hipMemoryAdvise

hipMemoryAdvise

Definition hip_runtime_api.h:1057

hipArrayDefault

#define hipArrayDefault

Definition hip_runtime_api.h:911

hipSharedMemConfig

hipSharedMemConfig

Definition hip_runtime_api.h:1243

hipKernelNodeAttrValue

#define hipKernelNodeAttrValue

Definition hip_runtime_api.h:1586

hipComputeMode

hipComputeMode

Definition hip_runtime_api.h:605

hipEvent_t

struct ihipEvent_t * hipEvent_t

Definition hip_runtime_api.h:704

hipStreamCaptureMode

hipStreamCaptureMode

Definition hip_runtime_api.h:1615

hipStreamBatchMemOpType

hipStreamBatchMemOpType

Definition hip_runtime_api.h:932

hipDriverProcAddressQueryResult

hipDriverProcAddressQueryResult

Definition hip_runtime_api.h:599

HIP_DEPRECATED_MSG

#define HIP_DEPRECATED_MSG

Definition hip_runtime_api.h:637

hipLaunchAttributeID

hipLaunchAttributeID

Definition hip_runtime_api.h:1539

hipSynchronizationPolicy

hipSynchronizationPolicy

Definition hip_runtime_api.h:1529

hipGraphNodeType

hipGraphNodeType

Definition hip_runtime_api.h:1437

hipExternalMemoryHandleType

hipExternalMemoryHandleType

Definition hip_runtime_api.h:1287

hipMemAttachGlobal

#define hipMemAttachGlobal

Definition hip_runtime_api.h:849

hipFuncAttribute

hipFuncAttribute

Definition hip_runtime_api.h:1226

hipExternalSemaphoreHandleType

hipExternalSemaphoreHandleType

Definition hip_runtime_api.h:1325

hipLaunchMemSyncDomain

hipLaunchMemSyncDomain

Definition hip_runtime_api.h:1520

hipDeviceP2PAttr

hipDeviceP2PAttr

Definition hip_runtime_api.h:664

hipGraphDebugDotFlags

hipGraphDebugDotFlags

Definition hip_runtime_api.h:1657

hipUserObjectRetainFlags

hipUserObjectRetainFlags

Definition hip_runtime_api.h:1642

hipStreamAttrID

#define hipStreamAttrID

Definition hip_runtime_api.h:1566

hipHostAllocDefault

#define hipHostAllocDefault

Definition hip_runtime_api.h:794

hipHostFn_t

void(* hipHostFn_t)(void *userData)

Definition hip_runtime_api.h:1456

hipOccupancyDefault

#define hipOccupancyDefault

Definition hip_runtime_api.h:916

hipStreamUpdateCaptureDependenciesFlags

hipStreamUpdateCaptureDependenciesFlags

Definition hip_runtime_api.h:1627

hipGraph_t

struct ihipGraph * hipGraph_t

Definition hip_runtime_api.h:1418

hipChooseDevice

#define hipChooseDevice

Definition hip_runtime_api.h:105

hipMemHandleType

hipMemHandleType

Definition hip_runtime_api.h:1761

hipFlushGPUDirectRDMAWritesOptions

hipFlushGPUDirectRDMAWritesOptions

Definition hip_runtime_api.h:612

hipFuncCache_t

hipFuncCache_t

Definition hip_runtime_api.h:1234

hipUserObjectFlags

hipUserObjectFlags

Definition hip_runtime_api.h:1638

__HIP_NODISCARD

#define __HIP_NODISCARD

Definition hip_runtime_api.h:292

hipGraphMemAttributeType

hipGraphMemAttributeType

Definition hip_runtime_api.h:1632

hipMemPoolAttr

hipMemPoolAttr

Definition hip_runtime_api.h:1106

hipDriverEntryPointQueryResult

hipDriverEntryPointQueryResult

Definition hip_runtime_api.h:670

hipMemRangeFlags

hipMemRangeFlags

Definition hip_runtime_api.h:1970

hipDeviceProp_t

#define hipDeviceProp_t

Definition hip_runtime_api.h:104

hipModule_t

struct ihipModule_t * hipModule_t

Definition hip_runtime_api.h:684

hipUserObject_t

struct hipUserObject * hipUserObject_t

Definition hip_runtime_api.h:1431

hipMemOperationType

hipMemOperationType

Definition hip_runtime_api.h:1768

hipExternalSemaphore_t

void * hipExternalSemaphore_t

Definition hip_runtime_api.h:1350

hipGraphicsRegisterFlags

hipGraphicsRegisterFlags

Definition hip_runtime_api.h:1401

hipStreamAttrValue

#define hipStreamAttrValue

Definition hip_runtime_api.h:1573

hipMemRangeCoherencyMode

hipMemRangeCoherencyMode

Definition hip_runtime_api.h:1078

hipMemAccessFlags

hipMemAccessFlags

Definition hip_runtime_api.h:1166

hipMemAllocationGranularity_flags

hipMemAllocationGranularity_flags

Definition hip_runtime_api.h:1753

hipGraphExec_t

struct hipGraphExec * hipGraphExec_t

Definition hip_runtime_api.h:1426

hipGraphExecUpdateResult

hipGraphExecUpdateResult

Definition hip_runtime_api.h:1600

hipFunction_t

struct ihipModuleSymbol_t * hipFunction_t

Definition hip_runtime_api.h:685

hipKernelNodeAttrID

#define hipKernelNodeAttrID

Definition hip_runtime_api.h:1578

hipExternalMemory_t

void * hipExternalMemory_t

Definition hip_runtime_api.h:1324

hipStreamCaptureStatus

hipStreamCaptureStatus

Definition hip_runtime_api.h:1620

hipDeviceAttribute_t

hipDeviceAttribute_t

Definition hip_runtime_api.h:424

hipGPUDirectRDMAWritesOrdering

hipGPUDirectRDMAWritesOrdering

Definition hip_runtime_api.h:617

hipGetDeviceProperties

#define hipGetDeviceProperties

Definition hip_runtime_api.h:103

hipHostMallocDefault

#define hipHostMallocDefault

Definition hip_runtime_api.h:798

HIP_DEPRECATED

#define HIP_DEPRECATED(msg)

Definition hip_runtime_api.h:635

hipGraphicsResource

struct _hipGraphicsResource hipGraphicsResource

Definition hip_runtime_api.h:1411

hipMemAllocationType

hipMemAllocationType

Definition hip_runtime_api.h:1184

hipError_t

hipError_t

Definition hip_runtime_api.h:302

hipGraphNode_t

struct hipGraphNode * hipGraphNode_t

Definition hip_runtime_api.h:1422

hipMemGenericAllocationHandle_t

struct ihipMemGenericAllocationHandle * hipMemGenericAllocationHandle_t

Definition hip_runtime_api.h:1748

hipMemoryType

hipMemoryType

Definition hip_runtime_api.h:260

hipGraphInstantiateFlags

hipGraphInstantiateFlags

Definition hip_runtime_api.h:1646

HIP_IPC_HANDLE_SIZE

#define HIP_IPC_HANDLE_SIZE

Definition hip_runtime_api.h:677

hipMemPool_t

struct ihipMemPoolHandle_t * hipMemPool_t

Definition hip_runtime_api.h:690

hipArraySparseSubresourceType

hipArraySparseSubresourceType

Definition hip_runtime_api.h:1776

hipExtLimitScratchMin

@ hipExtLimitScratchMin

Definition hip_runtime_api.h:720

hipLimitMallocHeapSize

@ hipLimitMallocHeapSize

Definition hip_runtime_api.h:718

hipLimitStackSize

@ hipLimitStackSize

Definition hip_runtime_api.h:713

hipLimitRange

@ hipLimitRange

Supported limit range.

Definition hip_runtime_api.h:728

hipLimitPrintfFifoSize

@ hipLimitPrintfFifoSize

Definition hip_runtime_api.h:716

hipExtLimitScratchMax

@ hipExtLimitScratchMax

Definition hip_runtime_api.h:722

hipExtLimitScratchCurrent

@ hipExtLimitScratchCurrent

Definition hip_runtime_api.h:724

hipMemRangeHandleTypeMax

@ hipMemRangeHandleTypeMax

Definition hip_runtime_api.h:1964

hipMemRangeHandleTypeDmaBufFd

@ hipMemRangeHandleTypeDmaBufFd

Definition hip_runtime_api.h:1963

hipMemHandleTypeWin32

@ hipMemHandleTypeWin32

Allows a Win32 NT handle for exporting. (HANDLE)

Definition hip_runtime_api.h:1199

hipMemHandleTypeWin32Kmt

@ hipMemHandleTypeWin32Kmt

Allows a Win32 KMT handle for exporting. (D3DKMT_HANDLE)

Definition hip_runtime_api.h:1200

hipMemHandleTypeNone

@ hipMemHandleTypeNone

Does not allow any export mechanism.

Definition hip_runtime_api.h:1197

hipMemHandleTypePosixFileDescriptor

@ hipMemHandleTypePosixFileDescriptor

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

Definition hip_runtime_api.h:1198

hipGraphInstantiateNodeOperationNotSupported

@ hipGraphInstantiateNodeOperationNotSupported

Definition hip_runtime_api.h:1685

hipGraphInstantiateMultipleDevicesNotSupported

@ hipGraphInstantiateMultipleDevicesNotSupported

Definition hip_runtime_api.h:1687

hipGraphInstantiateError

@ hipGraphInstantiateError

Definition hip_runtime_api.h:1681

hipGraphInstantiateInvalidStructure

@ hipGraphInstantiateInvalidStructure

Definition hip_runtime_api.h:1683

hipGraphInstantiateSuccess

@ hipGraphInstantiateSuccess

Definition hip_runtime_api.h:1680

hipAccessPropertyNormal

@ hipAccessPropertyNormal

Normal cache persistence.

Definition hip_runtime_api.h:1492

hipAccessPropertyPersisting

@ hipAccessPropertyPersisting

Persisting access is more likely to persist in cache.

Definition hip_runtime_api.h:1494

hipAccessPropertyStreaming

@ hipAccessPropertyStreaming

Streaming access is less likely to persist from cache.

Definition hip_runtime_api.h:1493

hipGraphDependencyTypeDefault

@ hipGraphDependencyTypeDefault

Definition hip_runtime_api.h:1899

hipGraphDependencyTypeProgrammatic

@ hipGraphDependencyTypeProgrammatic

Definition hip_runtime_api.h:1900

hipMemRangeAttributeLastPrefetchLocation

@ hipMemRangeAttributeLastPrefetchLocation

prefetched

Definition hip_runtime_api.h:1096

hipMemRangeAttributePreferredLocation

@ hipMemRangeAttributePreferredLocation

The preferred location of the range.

Definition hip_runtime_api.h:1093

hipMemRangeAttributeAccessedBy

@ hipMemRangeAttributeAccessedBy

Definition hip_runtime_api.h:1094

hipMemRangeAttributeReadMostly

@ hipMemRangeAttributeReadMostly

Definition hip_runtime_api.h:1091

hipMemRangeAttributeCoherencyMode

@ hipMemRangeAttributeCoherencyMode

Definition hip_runtime_api.h:1098

hipMemAdviseUnsetAccessedBy

@ hipMemAdviseUnsetAccessedBy

Definition hip_runtime_api.h:1066

hipMemAdviseUnsetCoarseGrain

@ hipMemAdviseUnsetCoarseGrain

Restores cache coherency policy back to fine-grain.

Definition hip_runtime_api.h:1073

hipMemAdviseSetCoarseGrain

@ hipMemAdviseSetCoarseGrain

Definition hip_runtime_api.h:1068

hipMemAdviseUnsetPreferredLocation

@ hipMemAdviseUnsetPreferredLocation

Clear the preferred location for the data.

Definition hip_runtime_api.h:1063

hipMemAdviseSetAccessedBy

@ hipMemAdviseSetAccessedBy

Definition hip_runtime_api.h:1064

hipMemAdviseSetPreferredLocation

@ hipMemAdviseSetPreferredLocation

Definition hip_runtime_api.h:1061

hipMemAdviseSetReadMostly

@ hipMemAdviseSetReadMostly

Definition hip_runtime_api.h:1058

hipMemAdviseUnsetReadMostly

@ hipMemAdviseUnsetReadMostly

Undo the effect of hipMemAdviseSetReadMostly.

Definition hip_runtime_api.h:1060

hipSharedMemBankSizeFourByte

@ hipSharedMemBankSizeFourByte

Definition hip_runtime_api.h:1245

hipSharedMemBankSizeEightByte

@ hipSharedMemBankSizeEightByte

Definition hip_runtime_api.h:1247

hipSharedMemBankSizeDefault

@ hipSharedMemBankSizeDefault

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

Definition hip_runtime_api.h:1244

hipComputeModeProhibited

@ hipComputeModeProhibited

Definition hip_runtime_api.h:608

hipComputeModeExclusive

@ hipComputeModeExclusive

Definition hip_runtime_api.h:607

hipComputeModeDefault

@ hipComputeModeDefault

Definition hip_runtime_api.h:606

hipComputeModeExclusiveProcess

@ hipComputeModeExclusiveProcess

Definition hip_runtime_api.h:609

hipStreamCaptureModeRelaxed

@ hipStreamCaptureModeRelaxed

Definition hip_runtime_api.h:1618

hipStreamCaptureModeThreadLocal

@ hipStreamCaptureModeThreadLocal

Definition hip_runtime_api.h:1617

hipStreamCaptureModeGlobal

@ hipStreamCaptureModeGlobal

Definition hip_runtime_api.h:1616

hipStreamMemOpWriteValue64

@ hipStreamMemOpWriteValue64

Definition hip_runtime_api.h:936

hipStreamMemOpBarrier

@ hipStreamMemOpBarrier

Currently not supported.

Definition hip_runtime_api.h:937

hipStreamMemOpWriteValue32

@ hipStreamMemOpWriteValue32

Definition hip_runtime_api.h:934

hipStreamMemOpWaitValue32

@ hipStreamMemOpWaitValue32

Definition hip_runtime_api.h:933

hipStreamMemOpWaitValue64

@ hipStreamMemOpWaitValue64

Definition hip_runtime_api.h:935

hipStreamMemOpFlushRemoteWrites

@ hipStreamMemOpFlushRemoteWrites

Currently not supported.

Definition hip_runtime_api.h:938

HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND

@ HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND

Definition hip_runtime_api.h:601

HIP_GET_PROC_ADDRESS_SUCCESS

@ HIP_GET_PROC_ADDRESS_SUCCESS

Definition hip_runtime_api.h:600

HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT

@ HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT

Definition hip_runtime_api.h:602

hipLaunchAttributePriority

@ hipLaunchAttributePriority

Valid for graph node, streams, launches.

Definition hip_runtime_api.h:1543

hipLaunchAttributeMax

@ hipLaunchAttributeMax

Definition hip_runtime_api.h:1546

hipLaunchAttributeMemSyncDomain

@ hipLaunchAttributeMemSyncDomain

Valid for streams, graph nodes, launches.

Definition hip_runtime_api.h:1545

hipLaunchAttributeMemSyncDomainMap

@ hipLaunchAttributeMemSyncDomainMap

Valid for streams, graph nodes, launches.

Definition hip_runtime_api.h:1544

hipLaunchAttributeSynchronizationPolicy

@ hipLaunchAttributeSynchronizationPolicy

Valid for streams.

Definition hip_runtime_api.h:1542

hipLaunchAttributeAccessPolicyWindow

@ hipLaunchAttributeAccessPolicyWindow

Valid for Streams, graph nodes, launches.

Definition hip_runtime_api.h:1540

hipLaunchAttributeCooperative

@ hipLaunchAttributeCooperative

Valid for graph nodes, launches.

Definition hip_runtime_api.h:1541

hipSyncPolicyYield

@ hipSyncPolicyYield

Definition hip_runtime_api.h:1532

hipSyncPolicyBlockingSync

@ hipSyncPolicyBlockingSync

Definition hip_runtime_api.h:1533

hipSyncPolicyAuto

@ hipSyncPolicyAuto

Definition hip_runtime_api.h:1530

hipSyncPolicySpin

@ hipSyncPolicySpin

Definition hip_runtime_api.h:1531

hipGraphNodeTypeBatchMemOp

@ hipGraphNodeTypeBatchMemOp

BatchMemOp node.

Definition hip_runtime_api.h:1452

hipGraphNodeTypeGraph

@ hipGraphNodeTypeGraph

Node which executes an embedded graph.

Definition hip_runtime_api.h:1442

hipGraphNodeTypeMemset

@ hipGraphNodeTypeMemset

Memset node.

Definition hip_runtime_api.h:1440

hipGraphNodeTypeEventRecord

@ hipGraphNodeTypeEventRecord

External event record node.

Definition hip_runtime_api.h:1445

hipGraphNodeTypeExtSemaphoreSignal

@ hipGraphNodeTypeExtSemaphoreSignal

External Semaphore signal node.

Definition hip_runtime_api.h:1446

hipGraphNodeTypeMemcpy

@ hipGraphNodeTypeMemcpy

Memcpy node.

Definition hip_runtime_api.h:1439

hipGraphNodeTypeWaitEvent

@ hipGraphNodeTypeWaitEvent

External event wait node.

Definition hip_runtime_api.h:1444

hipGraphNodeTypeCount

@ hipGraphNodeTypeCount

Definition hip_runtime_api.h:1453

hipGraphNodeTypeKernel

@ hipGraphNodeTypeKernel

GPU kernel node.

Definition hip_runtime_api.h:1438

hipGraphNodeTypeHost

@ hipGraphNodeTypeHost

Host (executable) node.

Definition hip_runtime_api.h:1441

hipGraphNodeTypeMemAlloc

@ hipGraphNodeTypeMemAlloc

Memory alloc node.

Definition hip_runtime_api.h:1448

hipGraphNodeTypeMemFree

@ hipGraphNodeTypeMemFree

Memory free node.

Definition hip_runtime_api.h:1449

hipGraphNodeTypeMemcpyFromSymbol

@ hipGraphNodeTypeMemcpyFromSymbol

MemcpyFromSymbol node.

Definition hip_runtime_api.h:1450

hipGraphNodeTypeMemcpyToSymbol

@ hipGraphNodeTypeMemcpyToSymbol

MemcpyToSymbol node.

Definition hip_runtime_api.h:1451

hipGraphNodeTypeEmpty

@ hipGraphNodeTypeEmpty

Empty (no-op) node.

Definition hip_runtime_api.h:1443

hipGraphNodeTypeExtSemaphoreWait

@ hipGraphNodeTypeExtSemaphoreWait

External Semaphore wait node.

Definition hip_runtime_api.h:1447

hipExternalMemoryHandleTypeD3D11Resource

@ hipExternalMemoryHandleTypeD3D11Resource

Definition hip_runtime_api.h:1293

hipExternalMemoryHandleTypeD3D12Resource

@ hipExternalMemoryHandleTypeD3D12Resource

Definition hip_runtime_api.h:1292

hipExternalMemoryHandleTypeNvSciBuf

@ hipExternalMemoryHandleTypeNvSciBuf

Definition hip_runtime_api.h:1295

hipExternalMemoryHandleTypeOpaqueFd

@ hipExternalMemoryHandleTypeOpaqueFd

Definition hip_runtime_api.h:1288

hipExternalMemoryHandleTypeD3D12Heap

@ hipExternalMemoryHandleTypeD3D12Heap

Definition hip_runtime_api.h:1291

hipExternalMemoryHandleTypeOpaqueWin32Kmt

@ hipExternalMemoryHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:1290

hipExternalMemoryHandleTypeOpaqueWin32

@ hipExternalMemoryHandleTypeOpaqueWin32

Definition hip_runtime_api.h:1289

hipExternalMemoryHandleTypeD3D11ResourceKmt

@ hipExternalMemoryHandleTypeD3D11ResourceKmt

Definition hip_runtime_api.h:1294

hipFuncAttributePreferredSharedMemoryCarveout

@ hipFuncAttributePreferredSharedMemoryCarveout

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

Definition hip_runtime_api.h:1228

hipFuncAttributeMaxDynamicSharedMemorySize

@ hipFuncAttributeMaxDynamicSharedMemorySize

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

Definition hip_runtime_api.h:1227

hipFuncAttributeMax

@ hipFuncAttributeMax

Definition hip_runtime_api.h:1229

hipExternalSemaphoreHandleTypeNvSciSync

@ hipExternalSemaphoreHandleTypeNvSciSync

Definition hip_runtime_api.h:1331

hipExternalSemaphoreHandleTypeKeyedMutexKmt

@ hipExternalSemaphoreHandleTypeKeyedMutexKmt

Definition hip_runtime_api.h:1333

hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

@ hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:1328

hipExternalSemaphoreHandleTypeKeyedMutex

@ hipExternalSemaphoreHandleTypeKeyedMutex

Definition hip_runtime_api.h:1332

hipExternalSemaphoreHandleTypeD3D11Fence

@ hipExternalSemaphoreHandleTypeD3D11Fence

Definition hip_runtime_api.h:1330

hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

@ hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

Definition hip_runtime_api.h:1335

hipExternalSemaphoreHandleTypeOpaqueFd

@ hipExternalSemaphoreHandleTypeOpaqueFd

Definition hip_runtime_api.h:1326

hipExternalSemaphoreHandleTypeOpaqueWin32

@ hipExternalSemaphoreHandleTypeOpaqueWin32

Definition hip_runtime_api.h:1327

hipExternalSemaphoreHandleTypeTimelineSemaphoreFd

@ hipExternalSemaphoreHandleTypeTimelineSemaphoreFd

Definition hip_runtime_api.h:1334

hipExternalSemaphoreHandleTypeD3D12Fence

@ hipExternalSemaphoreHandleTypeD3D12Fence

Definition hip_runtime_api.h:1329

hipLaunchMemSyncDomainRemote

@ hipLaunchMemSyncDomainRemote

Definition hip_runtime_api.h:1522

hipLaunchMemSyncDomainDefault

@ hipLaunchMemSyncDomainDefault

Definition hip_runtime_api.h:1521

hipDevP2PAttrAccessSupported

@ hipDevP2PAttrAccessSupported

Definition hip_runtime_api.h:666

hipDevP2PAttrHipArrayAccessSupported

@ hipDevP2PAttrHipArrayAccessSupported

Definition hip_runtime_api.h:668

hipDevP2PAttrNativeAtomicSupported

@ hipDevP2PAttrNativeAtomicSupported

Definition hip_runtime_api.h:667

hipDevP2PAttrPerformanceRank

@ hipDevP2PAttrPerformanceRank

Definition hip_runtime_api.h:665

hipGraphDebugDotFlagsKernelNodeAttributes

@ hipGraphDebugDotFlagsKernelNodeAttributes

Definition hip_runtime_api.h:1670

hipGraphDebugDotFlagsMemsetNodeParams

@ hipGraphDebugDotFlagsMemsetNodeParams

Definition hip_runtime_api.h:1662

hipGraphDebugDotFlagsKernelNodeParams

@ hipGraphDebugDotFlagsKernelNodeParams

Definition hip_runtime_api.h:1660

hipGraphDebugDotFlagsExtSemasWaitNodeParams

@ hipGraphDebugDotFlagsExtSemasWaitNodeParams

Definition hip_runtime_api.h:1668

hipGraphDebugDotFlagsHandles

@ hipGraphDebugDotFlagsHandles

Definition hip_runtime_api.h:1672

hipGraphDebugDotFlagsExtSemasSignalNodeParams

@ hipGraphDebugDotFlagsExtSemasSignalNodeParams

Definition hip_runtime_api.h:1666

hipGraphDebugDotFlagsHostNodeParams

@ hipGraphDebugDotFlagsHostNodeParams

Definition hip_runtime_api.h:1663

hipGraphDebugDotFlagsEventNodeParams

@ hipGraphDebugDotFlagsEventNodeParams

Definition hip_runtime_api.h:1664

hipGraphDebugDotFlagsVerbose

@ hipGraphDebugDotFlagsVerbose

Definition hip_runtime_api.h:1658

hipGraphDebugDotFlagsMemcpyNodeParams

@ hipGraphDebugDotFlagsMemcpyNodeParams

Definition hip_runtime_api.h:1661

hipGraphUserObjectMove

@ hipGraphUserObjectMove

Add new reference or retain.

Definition hip_runtime_api.h:1643

hipStreamAddCaptureDependencies

@ hipStreamAddCaptureDependencies

Add new nodes to the dependency set.

Definition hip_runtime_api.h:1628

hipStreamSetCaptureDependencies

@ hipStreamSetCaptureDependencies

Replace the dependency set with the new nodes.

Definition hip_runtime_api.h:1629

hipMemHandleTypeGeneric

@ hipMemHandleTypeGeneric

Generic handle type.

Definition hip_runtime_api.h:1762

hipFlushGPUDirectRDMAWritesOptionHost

@ hipFlushGPUDirectRDMAWritesOptionHost

Definition hip_runtime_api.h:613

hipFlushGPUDirectRDMAWritesOptionMemOps

@ hipFlushGPUDirectRDMAWritesOptionMemOps

Definition hip_runtime_api.h:614

hipFuncCachePreferNone

@ hipFuncCachePreferNone

no preference for shared memory or L1 (default)

Definition hip_runtime_api.h:1235

hipFuncCachePreferEqual

@ hipFuncCachePreferEqual

prefer equal size L1 cache and shared memory

Definition hip_runtime_api.h:1238

hipFuncCachePreferL1

@ hipFuncCachePreferL1

prefer larger L1 cache and smaller shared memory

Definition hip_runtime_api.h:1237

hipFuncCachePreferShared

@ hipFuncCachePreferShared

prefer larger shared memory and smaller L1 cache

Definition hip_runtime_api.h:1236

hipUserObjectNoDestructorSync

@ hipUserObjectNoDestructorSync

Destructor execution is not synchronized.

Definition hip_runtime_api.h:1639

hipGraphMemAttrReservedMemHigh

@ hipGraphMemAttrReservedMemHigh

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

Definition hip_runtime_api.h:1636

hipGraphMemAttrUsedMemCurrent

@ hipGraphMemAttrUsedMemCurrent

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

Definition hip_runtime_api.h:1633

hipGraphMemAttrUsedMemHigh

@ hipGraphMemAttrUsedMemHigh

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

Definition hip_runtime_api.h:1634

hipGraphMemAttrReservedMemCurrent

@ hipGraphMemAttrReservedMemCurrent

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

Definition hip_runtime_api.h:1635

hipMemPoolAttrUsedMemCurrent

@ hipMemPoolAttrUsedMemCurrent

Definition hip_runtime_api.h:1153

hipMemPoolAttrReservedMemHigh

@ hipMemPoolAttrReservedMemHigh

Definition hip_runtime_api.h:1148

hipMemPoolAttrReservedMemCurrent

@ hipMemPoolAttrReservedMemCurrent

Definition hip_runtime_api.h:1142

hipMemPoolAttrReleaseThreshold

@ hipMemPoolAttrReleaseThreshold

Definition hip_runtime_api.h:1137

hipMemPoolAttrUsedMemHigh

@ hipMemPoolAttrUsedMemHigh

Definition hip_runtime_api.h:1159

hipMemPoolReuseAllowInternalDependencies

@ hipMemPoolReuseAllowInternalDependencies

Definition hip_runtime_api.h:1128

hipMemPoolReuseFollowEventDependencies

@ hipMemPoolReuseFollowEventDependencies

Definition hip_runtime_api.h:1115

hipMemPoolReuseAllowOpportunistic

@ hipMemPoolReuseAllowOpportunistic

Definition hip_runtime_api.h:1121

hipDriverEntryPointSuccess

@ hipDriverEntryPointSuccess

Definition hip_runtime_api.h:671

hipDriverEntryPointSymbolNotFound

@ hipDriverEntryPointSymbolNotFound

Definition hip_runtime_api.h:672

hipDriverEntryPointVersionNotSufficent

@ hipDriverEntryPointVersionNotSufficent

Definition hip_runtime_api.h:673

hipMemRangeFlagsMax

@ hipMemRangeFlagsMax

Definition hip_runtime_api.h:1972

hipMemRangeFlagDmaBufMappingTypePcie

@ hipMemRangeFlagDmaBufMappingTypePcie

Definition hip_runtime_api.h:1971

hipMemOperationTypeMap

@ hipMemOperationTypeMap

Map operation.

Definition hip_runtime_api.h:1769

hipMemOperationTypeUnmap

@ hipMemOperationTypeUnmap

Unmap operation.

Definition hip_runtime_api.h:1770

hipGraphicsRegisterFlagsReadOnly

@ hipGraphicsRegisterFlagsReadOnly

HIP will not write to this registered resource.

Definition hip_runtime_api.h:1403

hipGraphicsRegisterFlagsTextureGather

@ hipGraphicsRegisterFlagsTextureGather

HIP will perform texture gather operations on this registered resource.

Definition hip_runtime_api.h:1407

hipGraphicsRegisterFlagsWriteDiscard

@ hipGraphicsRegisterFlagsWriteDiscard

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

Definition hip_runtime_api.h:1404

hipGraphicsRegisterFlagsNone

@ hipGraphicsRegisterFlagsNone

Definition hip_runtime_api.h:1402

hipGraphicsRegisterFlagsSurfaceLoadStore

@ hipGraphicsRegisterFlagsSurfaceLoadStore

HIP will bind this resource to a surface.

Definition hip_runtime_api.h:1406

hipMemRangeCoherencyModeFineGrain

@ hipMemRangeCoherencyModeFineGrain

Definition hip_runtime_api.h:1079

hipMemRangeCoherencyModeIndeterminate

@ hipMemRangeCoherencyModeIndeterminate

Definition hip_runtime_api.h:1083

hipMemRangeCoherencyModeCoarseGrain

@ hipMemRangeCoherencyModeCoarseGrain

Definition hip_runtime_api.h:1081

hipMemAccessFlagsProtRead

@ hipMemAccessFlagsProtRead

Set the address range read accessible.

Definition hip_runtime_api.h:1168

hipMemAccessFlagsProtNone

@ hipMemAccessFlagsProtNone

Default, make the address range not accessible.

Definition hip_runtime_api.h:1167

hipMemAccessFlagsProtReadWrite

@ hipMemAccessFlagsProtReadWrite

Set the address range read-write accessible.

Definition hip_runtime_api.h:1169

hipMemAllocationGranularityMinimum

@ hipMemAllocationGranularityMinimum

Minimum granularity.

Definition hip_runtime_api.h:1754

hipMemAllocationGranularityRecommended

@ hipMemAllocationGranularityRecommended

Recommended granularity for performance.

Definition hip_runtime_api.h:1755

hipGraphExecUpdateErrorNotSupported

@ hipGraphExecUpdateErrorNotSupported

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

Definition hip_runtime_api.h:1610

hipGraphExecUpdateErrorNodeTypeChanged

@ hipGraphExecUpdateErrorNodeTypeChanged

The update failed because a node type changed.

Definition hip_runtime_api.h:1605

hipGraphExecUpdateErrorTopologyChanged

@ hipGraphExecUpdateErrorTopologyChanged

The update failed because the topology changed.

Definition hip_runtime_api.h:1604

hipGraphExecUpdateErrorUnsupportedFunctionChange

@ hipGraphExecUpdateErrorUnsupportedFunctionChange

Definition hip_runtime_api.h:1612

hipGraphExecUpdateError

@ hipGraphExecUpdateError

Definition hip_runtime_api.h:1602

hipGraphExecUpdateErrorFunctionChanged

@ hipGraphExecUpdateErrorFunctionChanged

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

Definition hip_runtime_api.h:1606

hipGraphExecUpdateSuccess

@ hipGraphExecUpdateSuccess

The update succeeded.

Definition hip_runtime_api.h:1601

hipGraphExecUpdateErrorParametersChanged

@ hipGraphExecUpdateErrorParametersChanged

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

Definition hip_runtime_api.h:1608

hipStreamCaptureStatusInvalidated

@ hipStreamCaptureStatusInvalidated

Definition hip_runtime_api.h:1623

hipStreamCaptureStatusNone

@ hipStreamCaptureStatusNone

Stream is not capturing.

Definition hip_runtime_api.h:1621

hipStreamCaptureStatusActive

@ hipStreamCaptureStatusActive

Stream is actively capturing.

Definition hip_runtime_api.h:1622

hipDeviceAttributeDirectManagedMemAccessFromHost

@ hipDeviceAttributeDirectManagedMemAccessFromHost

Definition hip_runtime_api.h:449

hipDeviceAttributeSurfaceAlignment

@ hipDeviceAttributeSurfaceAlignment

Alignment requirement for surfaces.

Definition hip_runtime_api.h:536

hipDeviceAttributeMaxGridDimX

@ hipDeviceAttributeMaxGridDimX

Max grid size in width.

Definition hip_runtime_api.h:470

hipDeviceAttributeMaxSurfaceCubemapLayered

@ hipDeviceAttributeMaxSurfaceCubemapLayered

Definition hip_runtime_api.h:479

hipDeviceAttributeMaxSurface3D

@ hipDeviceAttributeMaxSurface3D

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

Definition hip_runtime_api.h:477

hipDeviceAttributeMaxPitch

@ hipDeviceAttributeMaxPitch

Maximum pitch in bytes allowed by memory copies.

Definition hip_runtime_api.h:504

hipDeviceAttributeTccDriver

@ hipDeviceAttributeTccDriver

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

Definition hip_runtime_api.h:537

hipDeviceAttributeHostNativeAtomicSupported

@ hipDeviceAttributeHostNativeAtomicSupported

Definition hip_runtime_api.h:452

hipDeviceAttributePageableMemoryAccessUsesHostPageTables

@ hipDeviceAttributePageableMemoryAccessUsesHostPageTables

Definition hip_runtime_api.h:514

hipDeviceAttributeUnused5

@ hipDeviceAttributeUnused5

Previously hipDeviceAttributeGcnArchName.

Definition hip_runtime_api.h:564

hipDeviceAttributeMaxBlockDimY

@ hipDeviceAttributeMaxBlockDimY

Max block size in height.

Definition hip_runtime_api.h:468

hipDeviceAttributeMaxSurfaceCubemap

@ hipDeviceAttributeMaxSurfaceCubemap

Cuda only. Maximum dimensions of Cubemap surface.

Definition hip_runtime_api.h:478

hipDeviceAttributePageableMemoryAccess

@ hipDeviceAttributePageableMemoryAccess

Definition hip_runtime_api.h:512

hipDeviceAttributeClockRate

@ hipDeviceAttributeClockRate

Peak clock frequency in kilohertz.

Definition hip_runtime_api.h:437

hipDeviceAttributeCudaCompatibleEnd

@ hipDeviceAttributeCudaCompatibleEnd

Definition hip_runtime_api.h:555

hipDeviceAttributeMaxTexture1DMipmap

@ hipDeviceAttributeMaxTexture1DMipmap

Maximum size of 1D mipmapped texture.

Definition hip_runtime_api.h:486

hipDeviceAttributeComputeCapabilityMajor

@ hipDeviceAttributeComputeCapabilityMajor

Major compute capability version number.

Definition hip_runtime_api.h:464

hipDeviceAttributeGlobalL1CacheSupported

@ hipDeviceAttributeGlobalL1CacheSupported

Device supports caching globals in L1.

Definition hip_runtime_api.h:451

hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

Definition hip_runtime_api.h:576

hipDeviceAttributeAccessPolicyMaxWindowSize

@ hipDeviceAttributeAccessPolicyMaxWindowSize

Definition hip_runtime_api.h:429

hipDeviceAttributeMaxTexture3DHeight

@ hipDeviceAttributeMaxTexture3DHeight

Maximum dimension height of 3D texture.

Definition hip_runtime_api.h:496

hipDeviceAttributeComputeCapabilityMinor

@ hipDeviceAttributeComputeCapabilityMinor

Minor compute capability version number.

Definition hip_runtime_api.h:507

hipDeviceAttributeNumberOfXccs

@ hipDeviceAttributeNumberOfXccs

The number of XCC(s) on the device.

Definition hip_runtime_api.h:588

hipDeviceAttributeMaxTextureCubemap

@ hipDeviceAttributeMaxTextureCubemap

Maximum dimensions of Cubemap texture.

Definition hip_runtime_api.h:499

hipDeviceAttributeDeviceOverlap

@ hipDeviceAttributeDeviceOverlap

Definition hip_runtime_api.h:447

hipDeviceAttributeMaxTexture2DLinear

@ hipDeviceAttributeMaxTexture2DLinear

Definition hip_runtime_api.h:492

hipDeviceAttributeMaxSurface2D

@ hipDeviceAttributeMaxSurface2D

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

Definition hip_runtime_api.h:475

hipDeviceAttributeMaxSurface1DLayered

@ hipDeviceAttributeMaxSurface1DLayered

Cuda only. Maximum dimensions of 1D layered surface.

Definition hip_runtime_api.h:474

hipDeviceAttributeHdpRegFlushCntl

@ hipDeviceAttributeHdpRegFlushCntl

Address of the HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:566

hipDeviceAttributeMaxAvailableVgprsPerThread

@ hipDeviceAttributeMaxAvailableVgprsPerThread

Definition hip_runtime_api.h:589

hipDeviceAttributeComputeMode

@ hipDeviceAttributeComputeMode

Compute mode that device is currently in.

Definition hip_runtime_api.h:438

hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

Definition hip_runtime_api.h:567

hipDeviceAttributeAsicRevision

@ hipDeviceAttributeAsicRevision

Revision of the GPU in this device.

Definition hip_runtime_api.h:580

hipDeviceAttributeUnused4

@ hipDeviceAttributeUnused4

Previously hipDeviceAttributeGcnArch.

Definition hip_runtime_api.h:563

hipDeviceAttributeCooperativeMultiDeviceLaunch

@ hipDeviceAttributeCooperativeMultiDeviceLaunch

Definition hip_runtime_api.h:445

hipDeviceAttributeMaxTexture2DHeight

@ hipDeviceAttributeMaxTexture2DHeight

Maximum dimension hight of 2D texture.

Definition hip_runtime_api.h:488

hipDeviceAttributePersistingL2CacheMaxSize

@ hipDeviceAttributePersistingL2CacheMaxSize

Maximum l2 persisting lines capacity in bytes.

Definition hip_runtime_api.h:521

hipDeviceAttributeEccEnabled

@ hipDeviceAttributeEccEnabled

Whether ECC support is enabled.

Definition hip_runtime_api.h:427

hipDeviceAttributeCanUseHostPointerForRegisteredMem

@ hipDeviceAttributeCanUseHostPointerForRegisteredMem

Definition hip_runtime_api.h:434

hipDeviceAttributePciBusId

@ hipDeviceAttributePciBusId

PCI Bus ID.

Definition hip_runtime_api.h:516

hipDeviceAttributeL2CacheSize

@ hipDeviceAttributeL2CacheSize

Definition hip_runtime_api.h:457

hipDeviceAttributeKernelExecTimeout

@ hipDeviceAttributeKernelExecTimeout

Run time limit for kernels executed on the device.

Definition hip_runtime_api.h:456

hipDeviceAttributeMaxThreadsDim

@ hipDeviceAttributeMaxThreadsDim

Maximum dimension of a block.

Definition hip_runtime_api.h:501

hipDeviceAttributeSingleToDoublePrecisionPerfRatio

@ hipDeviceAttributeSingleToDoublePrecisionPerfRatio

Definition hip_runtime_api.h:533

hipDeviceAttributeMaxGridDimY

@ hipDeviceAttributeMaxGridDimY

Max grid size in height.

Definition hip_runtime_api.h:471

hipDeviceAttributeMultiprocessorCount

@ hipDeviceAttributeMultiprocessorCount

Number of multiprocessors on the device.

Definition hip_runtime_api.h:510

hipDeviceAttributeAmdSpecificBegin

@ hipDeviceAttributeAmdSpecificBegin

Definition hip_runtime_api.h:556

hipDeviceAttributeMaxRegistersPerMultiprocessor

@ hipDeviceAttributeMaxRegistersPerMultiprocessor

32-bit registers available per block.

Definition hip_runtime_api.h:525

hipDeviceAttributeIsMultiGpuBoard

@ hipDeviceAttributeIsMultiGpuBoard

Multiple GPU devices.

Definition hip_runtime_api.h:455

hipDeviceAttributeSharedMemPerBlockOptin

@ hipDeviceAttributeSharedMemPerBlockOptin

Definition hip_runtime_api.h:530

hipDeviceAttributeMaxSurface2DLayered

@ hipDeviceAttributeMaxSurface2DLayered

Cuda only. Maximum dimensions of 2D layered surface.

Definition hip_runtime_api.h:476

hipDeviceAttributeAmdSpecificEnd

@ hipDeviceAttributeAmdSpecificEnd

Definition hip_runtime_api.h:594

hipDeviceAttributeMemoryClockRate

@ hipDeviceAttributeMemoryClockRate

Peak memory clock frequency in kilohertz.

Definition hip_runtime_api.h:506

hipDeviceAttributeMaxGridDimZ

@ hipDeviceAttributeMaxGridDimZ

Max grid size in depth.

Definition hip_runtime_api.h:472

hipDeviceAttributeHdpMemFlushCntl

@ hipDeviceAttributeHdpMemFlushCntl

Address of the HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:565

hipDeviceAttributeUnused2

@ hipDeviceAttributeUnused2

Previously hipDeviceAttributeUuid.

Definition hip_runtime_api.h:545

hipDeviceAttributeFineGrainSupport

@ hipDeviceAttributeFineGrainSupport

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

Definition hip_runtime_api.h:586

hipDeviceAttributeCooperativeLaunch

@ hipDeviceAttributeCooperativeLaunch

Support cooperative launch.

Definition hip_runtime_api.h:444

hipDeviceAttributeUnifiedAddressing

@ hipDeviceAttributeUnifiedAddressing

Definition hip_runtime_api.h:543

hipDeviceAttributeAsyncEngineCount

@ hipDeviceAttributeAsyncEngineCount

Asynchronous engines number.

Definition hip_runtime_api.h:431

hipDeviceAttributeMultiGpuBoardGroupID

@ hipDeviceAttributeMultiGpuBoardGroupID

Definition hip_runtime_api.h:508

hipDeviceAttributeStreamPrioritiesSupported

@ hipDeviceAttributeStreamPrioritiesSupported

Whether to support stream priorities.

Definition hip_runtime_api.h:535

hipDeviceAttributeMaxSharedMemoryPerBlock

@ hipDeviceAttributeMaxSharedMemoryPerBlock

Definition hip_runtime_api.h:528

hipDeviceAttributeLocalL1CacheSupported

@ hipDeviceAttributeLocalL1CacheSupported

caching locals in L1 is supported

Definition hip_runtime_api.h:459

hipDeviceAttributeCanUseStreamWaitValue

@ hipDeviceAttributeCanUseStreamWaitValue

Definition hip_runtime_api.h:581

hipDeviceAttributeMaxRegistersPerBlock

@ hipDeviceAttributeMaxRegistersPerBlock

Definition hip_runtime_api.h:522

hipDeviceAttributeMaxThreadsPerBlock

@ hipDeviceAttributeMaxThreadsPerBlock

Maximum number of threads per block.

Definition hip_runtime_api.h:502

hipDeviceAttributePciDomainId

@ hipDeviceAttributePciDomainId

PCI Domain Id.

Definition hip_runtime_api.h:518

hipDeviceAttributeMemoryBusWidth

@ hipDeviceAttributeMemoryBusWidth

Global memory bus width in bits.

Definition hip_runtime_api.h:505

hipDeviceAttributeMemoryPoolSupportedHandleTypes

@ hipDeviceAttributeMemoryPoolSupportedHandleTypes

Definition hip_runtime_api.h:552

hipDeviceAttributeComputePreemptionSupported

@ hipDeviceAttributeComputePreemptionSupported

Device supports Compute Preemption.

Definition hip_runtime_api.h:439

hipDeviceAttributeMaxSurface1D

@ hipDeviceAttributeMaxSurface1D

Maximum size of 1D surface.

Definition hip_runtime_api.h:473

hipDeviceAttributeUnused1

@ hipDeviceAttributeUnused1

Previously hipDeviceAttributeName.

Definition hip_runtime_api.h:511

hipDeviceAttributeMaxTexture3DAlt

@ hipDeviceAttributeMaxTexture3DAlt

Maximum dimensions of alternate 3D texture.

Definition hip_runtime_api.h:498

hipDeviceAttributeMaxTexture1DLinear

@ hipDeviceAttributeMaxTexture1DLinear

Definition hip_runtime_api.h:483

hipDeviceAttributeMaxTexture2DGather

@ hipDeviceAttributeMaxTexture2DGather

Definition hip_runtime_api.h:489

hipDeviceAttributeWallClockRate

@ hipDeviceAttributeWallClockRate

Constant frequency of wall clock in kilohertz.

Definition hip_runtime_api.h:587

hipDeviceAttributePciDeviceId

@ hipDeviceAttributePciDeviceId

PCI Device ID. Returns pcie slot id.

Definition hip_runtime_api.h:517

hipDeviceAttributeCanMapHostMemory

@ hipDeviceAttributeCanMapHostMemory

Definition hip_runtime_api.h:432

hipDeviceAttributeMaxTexture1DWidth

@ hipDeviceAttributeMaxTexture1DWidth

Maximum size of 1D texture.

Definition hip_runtime_api.h:481

hipDeviceAttributeConcurrentManagedAccess

@ hipDeviceAttributeConcurrentManagedAccess

Definition hip_runtime_api.h:442

hipDeviceAttributeVendorSpecificBegin

@ hipDeviceAttributeVendorSpecificBegin

Definition hip_runtime_api.h:595

hipDeviceAttributeManagedMemory

@ hipDeviceAttributeManagedMemory

Device supports allocating managed memory on this system.

Definition hip_runtime_api.h:465

hipDeviceAttributeIntegrated

@ hipDeviceAttributeIntegrated

Device is integrated GPU.

Definition hip_runtime_api.h:454

hipDeviceAttributeMaxTexture2DLayered

@ hipDeviceAttributeMaxTexture2DLayered

Maximum dimensions of 2D layered texture.

Definition hip_runtime_api.h:491

hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

Definition hip_runtime_api.h:570

hipDeviceAttributeMaxTexture3DDepth

@ hipDeviceAttributeMaxTexture3DDepth

Maximum dimension depth of 3D texture.

Definition hip_runtime_api.h:497

hipDeviceAttributePciChipId

@ hipDeviceAttributePciChipId

GPU Manufacturer device id.

Definition hip_runtime_api.h:592

hipDeviceAttributeImageSupport

@ hipDeviceAttributeImageSupport

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

Definition hip_runtime_api.h:583

hipDeviceAttributeTotalGlobalMem

@ hipDeviceAttributeTotalGlobalMem

Global memory available on devicice.

Definition hip_runtime_api.h:542

hipDeviceAttributeMaxBlocksPerMultiProcessor

@ hipDeviceAttributeMaxBlocksPerMultiProcessor

Max block size per multiprocessor.

Definition hip_runtime_api.h:466

hipDeviceAttributeIsLargeBar

@ hipDeviceAttributeIsLargeBar

Whether it is LargeBar.

Definition hip_runtime_api.h:579

hipDeviceAttributeMaxTexture2DWidth

@ hipDeviceAttributeMaxTexture2DWidth

Maximum dimension width of 2D texture.

Definition hip_runtime_api.h:487

hipDeviceAttributeMaxBlockDimX

@ hipDeviceAttributeMaxBlockDimX

Max block size in width.

Definition hip_runtime_api.h:467

hipDeviceAttributeMaxTexture3DWidth

@ hipDeviceAttributeMaxTexture3DWidth

Maximum dimension width of 3D texture.

Definition hip_runtime_api.h:495

hipDeviceAttributeUnused3

@ hipDeviceAttributeUnused3

Previously hipDeviceAttributeArch.

Definition hip_runtime_api.h:561

hipDeviceAttributeTotalConstantMemory

@ hipDeviceAttributeTotalConstantMemory

Constant memory size in bytes.

Definition hip_runtime_api.h:541

hipDeviceAttributeTextureAlignment

@ hipDeviceAttributeTextureAlignment

Alignment requirement for textures.

Definition hip_runtime_api.h:538

hipDeviceAttributeMaxTexture1DLayered

@ hipDeviceAttributeMaxTexture1DLayered

Maximum dimensions of 1D layered texture.

Definition hip_runtime_api.h:482

hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

@ hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

Maximum Shared Memory PerMultiprocessor.

Definition hip_runtime_api.h:562

hipDeviceAttributeReservedSharedMemPerBlock

@ hipDeviceAttributeReservedSharedMemPerBlock

Definition hip_runtime_api.h:526

hipDeviceAttributeCudaCompatibleBegin

@ hipDeviceAttributeCudaCompatibleBegin

Definition hip_runtime_api.h:425

hipDeviceAttributeConcurrentKernels

@ hipDeviceAttributeConcurrentKernels

Definition hip_runtime_api.h:440

hipDeviceAttributeLuid

@ hipDeviceAttributeLuid

Definition hip_runtime_api.h:460

hipDeviceAttributePciDomainID

@ hipDeviceAttributePciDomainID

PCI Domain ID, for backward compatibility.

Definition hip_runtime_api.h:519

hipDeviceAttributeMaxThreadsPerMultiProcessor

@ hipDeviceAttributeMaxThreadsPerMultiProcessor

Maximum resident threads per multiprocessor.

Definition hip_runtime_api.h:503

hipDeviceAttributeTexturePitchAlignment

@ hipDeviceAttributeTexturePitchAlignment

Definition hip_runtime_api.h:539

hipDeviceAttributePhysicalMultiProcessorCount

@ hipDeviceAttributePhysicalMultiProcessorCount

Definition hip_runtime_api.h:584

hipDeviceAttributeHostRegisterSupported

@ hipDeviceAttributeHostRegisterSupported

Definition hip_runtime_api.h:550

hipDeviceAttributeSharedMemPerMultiprocessor

@ hipDeviceAttributeSharedMemPerMultiprocessor

Shared memory available per multiprocessor.

Definition hip_runtime_api.h:532

hipDeviceAttributeLuidDeviceNodeMask

@ hipDeviceAttributeLuidDeviceNodeMask

Definition hip_runtime_api.h:462

hipDeviceAttributeMaxTextureCubemapLayered

@ hipDeviceAttributeMaxTextureCubemapLayered

Maximum dimensions of Cubemap layered texture.

Definition hip_runtime_api.h:500

hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

Definition hip_runtime_api.h:573

hipDeviceAttributeVirtualMemoryManagementSupported

@ hipDeviceAttributeVirtualMemoryManagementSupported

Definition hip_runtime_api.h:548

hipDeviceAttributeMemoryPoolsSupported

@ hipDeviceAttributeMemoryPoolsSupported

Device supports HIP Stream Ordered Memory Allocator.

Definition hip_runtime_api.h:547

hipDeviceAttributeClockInstructionRate

@ hipDeviceAttributeClockInstructionRate

Definition hip_runtime_api.h:558

hipDeviceAttributeMaxTexture2DMipmap

@ hipDeviceAttributeMaxTexture2DMipmap

Maximum dimensions of 2D mipmapped texture.

Definition hip_runtime_api.h:494

hipDeviceAttributeMaxBlockDimZ

@ hipDeviceAttributeMaxBlockDimZ

Max block size in depth.

Definition hip_runtime_api.h:469

hipDeviceAttributeWarpSize

@ hipDeviceAttributeWarpSize

Warp size in threads.

Definition hip_runtime_api.h:546

hipGPUDirectRDMAWritesOrderingOwner

@ hipGPUDirectRDMAWritesOrderingOwner

Definition hip_runtime_api.h:619

hipGPUDirectRDMAWritesOrderingNone

@ hipGPUDirectRDMAWritesOrderingNone

Definition hip_runtime_api.h:618

hipGPUDirectRDMAWritesOrderingAllDevices

@ hipGPUDirectRDMAWritesOrderingAllDevices

Definition hip_runtime_api.h:620

hipMemAllocationTypeMax

@ hipMemAllocationTypeMax

Definition hip_runtime_api.h:1190

hipMemAllocationTypePinned

@ hipMemAllocationTypePinned

Definition hip_runtime_api.h:1189

hipMemAllocationTypeInvalid

@ hipMemAllocationTypeInvalid

Definition hip_runtime_api.h:1185

hipErrorInvalidSource

@ hipErrorInvalidSource

Invalid source.

Definition hip_runtime_api.h:348

hipErrorPriorLaunchFailure

@ hipErrorPriorLaunchFailure

Definition hip_runtime_api.h:324

hipErrorInvalidDevice

@ hipErrorInvalidDevice

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

Definition hip_runtime_api.h:327

hipErrorGraphExecUpdateFailure

@ hipErrorGraphExecUpdateFailure

Definition hip_runtime_api.h:403

hipErrorArrayIsMapped

@ hipErrorArrayIsMapped

Definition hip_runtime_api.h:335

hipErrorRuntimeMemory

@ hipErrorRuntimeMemory

Definition hip_runtime_api.h:411

hipErrorUnsupportedLimit

@ hipErrorUnsupportedLimit

Unsupported limit.

Definition hip_runtime_api.h:343

hipErrorSetOnActiveProcess

@ hipErrorSetOnActiveProcess

The process is active.

Definition hip_runtime_api.h:368

hipErrorMapFailed

@ hipErrorMapFailed

Definition hip_runtime_api.h:331

hipErrorInvalidTexture

@ hipErrorInvalidTexture

Invalid texture.

Definition hip_runtime_api.h:408

hipErrorInvalidValue

@ hipErrorInvalidValue

Definition hip_runtime_api.h:304

hipErrorStreamCaptureUnsupported

@ hipErrorStreamCaptureUnsupported

Definition hip_runtime_api.h:381

hipErrorSharedObjectSymbolNotFound

@ hipErrorSharedObjectSymbolNotFound

Definition hip_runtime_api.h:350

hipErrorStreamCaptureImplicit

@ hipErrorStreamCaptureImplicit

Definition hip_runtime_api.h:394

hipErrorProfilerNotInitialized

@ hipErrorProfilerNotInitialized

Definition hip_runtime_api.h:314

hipErrorIllegalState

@ hipErrorIllegalState

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

Definition hip_runtime_api.h:356

hipErrorNotFound

@ hipErrorNotFound

Not found.

Definition hip_runtime_api.h:357

hipErrorNotInitialized

@ hipErrorNotInitialized

Invalid not initialized.

Definition hip_runtime_api.h:309

hipErrorProfilerAlreadyStarted

@ hipErrorProfilerAlreadyStarted

Definition hip_runtime_api.h:315

hipErrorPeerAccessNotEnabled

@ hipErrorPeerAccessNotEnabled

Peer access was never enabled from the current device.

Definition hip_runtime_api.h:367

hipErrorInvalidDevicePointer

@ hipErrorInvalidDevicePointer

Invalid Device Pointer.

Definition hip_runtime_api.h:320

hipErrorStreamCaptureInvalidated

@ hipErrorStreamCaptureInvalidated

Definition hip_runtime_api.h:383

hipErrorInsufficientDriver

@ hipErrorInsufficientDriver

Definition hip_runtime_api.h:322

hipErrorStreamCaptureUnmatched

@ hipErrorStreamCaptureUnmatched

The capture was not initiated in this stream.

Definition hip_runtime_api.h:387

hipErrorNotMappedAsArray

@ hipErrorNotMappedAsArray

Definition hip_runtime_api.h:340

hipErrorLaunchFailure

@ hipErrorLaunchFailure

An exception occurred on the device while executing a kernel.

Definition hip_runtime_api.h:375

hipErrorLaunchOutOfResources

@ hipErrorLaunchOutOfResources

Out of resources error.

Definition hip_runtime_api.h:363

hipErrorECCNotCorrectable

@ hipErrorECCNotCorrectable

Definition hip_runtime_api.h:342

hipErrorDeinitialized

@ hipErrorDeinitialized

Deinitialized.

Definition hip_runtime_api.h:312

hipErrorInvalidConfiguration

@ hipErrorInvalidConfiguration

Invalide configuration.

Definition hip_runtime_api.h:317

hipErrorRuntimeOther

@ hipErrorRuntimeOther

Definition hip_runtime_api.h:413

hipErrorAlreadyAcquired

@ hipErrorAlreadyAcquired

Definition hip_runtime_api.h:338

hipErrorStreamCaptureIsolation

@ hipErrorStreamCaptureIsolation

Definition hip_runtime_api.h:390

hipErrorPeerAccessAlreadyEnabled

@ hipErrorPeerAccessAlreadyEnabled

Definition hip_runtime_api.h:365

hipErrorOperatingSystem

@ hipErrorOperatingSystem

Not the correct operating system.

Definition hip_runtime_api.h:352

hipErrorLaunchTimeOut

@ hipErrorLaunchTimeOut

Timeout for the launch.

Definition hip_runtime_api.h:364

hipErrorStreamCaptureMerge

@ hipErrorStreamCaptureMerge

Definition hip_runtime_api.h:385

hipErrorInvalidImage

@ hipErrorInvalidImage

Invalid image.

Definition hip_runtime_api.h:328

hipErrorHostMemoryNotRegistered

@ hipErrorHostMemoryNotRegistered

Definition hip_runtime_api.h:373

hipErrorOutOfMemory

@ hipErrorOutOfMemory

out of memory range.

Definition hip_runtime_api.h:306

hipErrorProfilerAlreadyStopped

@ hipErrorProfilerAlreadyStopped

Definition hip_runtime_api.h:316

hipErrorInvalidPitchValue

@ hipErrorInvalidPitchValue

Invalid pitch value.

Definition hip_runtime_api.h:318

hipErrorNotMappedAsPointer

@ hipErrorNotMappedAsPointer

Definition hip_runtime_api.h:341

hipErrorInitializationError

@ hipErrorInitializationError

Definition hip_runtime_api.h:311

hipErrorMemoryAllocation

@ hipErrorMemoryAllocation

Memory allocation error.

Definition hip_runtime_api.h:308

hipErrorInvalidHandle

@ hipErrorInvalidHandle

Invalide handle.

Definition hip_runtime_api.h:353

hipErrorNotSupported

@ hipErrorNotSupported

Produced when the hip API is not supported/implemented.

Definition hip_runtime_api.h:380

hipErrorInvalidResourceHandle

@ hipErrorInvalidResourceHandle

Resource handle (hipEvent_t or hipStream_t) invalid.

Definition hip_runtime_api.h:355

hipErrorUnmapFailed

@ hipErrorUnmapFailed

Definition hip_runtime_api.h:334

hipErrorHostMemoryAlreadyRegistered

@ hipErrorHostMemoryAlreadyRegistered

Definition hip_runtime_api.h:371

hipErrorNotMapped

@ hipErrorNotMapped

Definition hip_runtime_api.h:339

hipErrorSharedObjectInitFailed

@ hipErrorSharedObjectInitFailed

Failed to initialize shared object.

Definition hip_runtime_api.h:351

hipErrorUnknown

@ hipErrorUnknown

Unknown error.

Definition hip_runtime_api.h:409

hipErrorNotReady

@ hipErrorNotReady

Definition hip_runtime_api.h:358

hipSuccess

@ hipSuccess

Successful completion.

Definition hip_runtime_api.h:303

hipErrorAssert

@ hipErrorAssert

Produced when the kernel calls assert.

Definition hip_runtime_api.h:370

hipErrorProfilerDisabled

@ hipErrorProfilerDisabled

Definition hip_runtime_api.h:313

hipErrorNoBinaryForGpu

@ hipErrorNoBinaryForGpu

Definition hip_runtime_api.h:337

hipErrorCooperativeLaunchTooLarge

@ hipErrorCooperativeLaunchTooLarge

Definition hip_runtime_api.h:376

hipErrorContextIsDestroyed

@ hipErrorContextIsDestroyed

The context is already destroyed.

Definition hip_runtime_api.h:369

hipErrorMapBufferObjectFailed

@ hipErrorMapBufferObjectFailed

Produced when the IPC memory attach failed from ROCr.

Definition hip_runtime_api.h:333

hipErrorTbd

@ hipErrorTbd

Marker that more error codes are needed.

Definition hip_runtime_api.h:415

hipErrorInvalidGraphicsContext

@ hipErrorInvalidGraphicsContext

Definition hip_runtime_api.h:347

hipErrorStreamCaptureUnjoined

@ hipErrorStreamCaptureUnjoined

Definition hip_runtime_api.h:388

hipErrorNoDevice

@ hipErrorNoDevice

Call to hipGetDeviceCount returned 0 devices.

Definition hip_runtime_api.h:326

hipErrorInvalidSymbol

@ hipErrorInvalidSymbol

Invalid symbol.

Definition hip_runtime_api.h:319

hipErrorPeerAccessUnsupported

@ hipErrorPeerAccessUnsupported

Definition hip_runtime_api.h:345

hipErrorInvalidContext

@ hipErrorInvalidContext

Produced when input context is invalid.

Definition hip_runtime_api.h:329

hipErrorFileNotFound

@ hipErrorFileNotFound

the file is not found.

Definition hip_runtime_api.h:349

hipErrorInvalidDeviceFunction

@ hipErrorInvalidDeviceFunction

Invalid device function.

Definition hip_runtime_api.h:325

hipErrorAlreadyMapped

@ hipErrorAlreadyMapped

Definition hip_runtime_api.h:336

hipErrorInvalidMemcpyDirection

@ hipErrorInvalidMemcpyDirection

Invalid memory copy direction.

Definition hip_runtime_api.h:321

hipErrorInvalidKernelFile

@ hipErrorInvalidKernelFile

In CUDA DRV, it is CUDA_ERROR_INVALID_PTX.

Definition hip_runtime_api.h:346

hipErrorInvalidChannelDescriptor

@ hipErrorInvalidChannelDescriptor

Invalid channel descriptor.

Definition hip_runtime_api.h:407

hipErrorCapturedEvent

@ hipErrorCapturedEvent

Definition hip_runtime_api.h:397

hipErrorContextAlreadyInUse

@ hipErrorContextAlreadyInUse

The context is already in use.

Definition hip_runtime_api.h:344

hipErrorStreamCaptureWrongThread

@ hipErrorStreamCaptureWrongThread

Definition hip_runtime_api.h:399

hipErrorIllegalAddress

@ hipErrorIllegalAddress

Definition hip_runtime_api.h:362

hipErrorMissingConfiguration

@ hipErrorMissingConfiguration

Definition hip_runtime_api.h:323

hipErrorContextAlreadyCurrent

@ hipErrorContextAlreadyCurrent

Definition hip_runtime_api.h:330

hipMemoryTypeDevice

@ hipMemoryTypeDevice

Definition hip_runtime_api.h:263

hipMemoryTypeHost

@ hipMemoryTypeHost

Memory is physically located on host.

Definition hip_runtime_api.h:262

hipMemoryTypeUnregistered

@ hipMemoryTypeUnregistered

Unregistered memory.

Definition hip_runtime_api.h:261

hipMemoryTypeArray

@ hipMemoryTypeArray

Definition hip_runtime_api.h:268

hipMemoryTypeManaged

@ hipMemoryTypeManaged

Definition hip_runtime_api.h:265

hipMemoryTypeUnified

@ hipMemoryTypeUnified

unified address space

Definition hip_runtime_api.h:270

hipGraphInstantiateFlagAutoFreeOnLaunch

@ hipGraphInstantiateFlagAutoFreeOnLaunch

Automatically free memory allocated in a graph before relaunching.

Definition hip_runtime_api.h:1647

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

hipGraphInstantiateFlagUpload

@ hipGraphInstantiateFlagUpload

Automatically upload the graph after instantiation.

Definition hip_runtime_api.h:1649

hipGraphInstantiateFlagDeviceLaunch

@ hipGraphInstantiateFlagDeviceLaunch

Instantiate the graph to be launched from the device.

Definition hip_runtime_api.h:1651

hipArraySparseSubresourceTypeSparseLevel

@ hipArraySparseSubresourceTypeSparseLevel

Sparse level.

Definition hip_runtime_api.h:1777

hipArraySparseSubresourceTypeMiptail

@ hipArraySparseSubresourceTypeMiptail

Miptail.

Definition hip_runtime_api.h:1778

hipGraphKernelNodeSetParams

hipError_t hipGraphKernelNodeSetParams(hipGraphNode_t node, const hipKernelNodeParams *pNodeParams)

Sets a kernel node's parameters.

hipGraphMemFreeNodeGetParams

hipError_t hipGraphMemFreeNodeGetParams(hipGraphNode_t node, void *dev_ptr)

Returns parameters for memory free node.

hipDrvGraphExecMemsetNodeSetParams

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

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

hipGraphNodeGetDependencies

hipError_t hipGraphNodeGetDependencies(hipGraphNode_t node, hipGraphNode_t *pDependencies, size_t *pNumDependencies)

Returns a node's dependencies.

hipGraphCreate

hipError_t hipGraphCreate(hipGraph_t *pGraph, unsigned int flags)

Creates a graph.

hipGraphAddMemcpyNode1D

hipError_t hipGraphAddMemcpyNode1D(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, void *dst, const void *src, size_t count, hipMemcpyKind kind)

Creates a 1D memcpy node and adds it to a graph.

hipDrvGraphMemcpyNodeGetParams

hipError_t hipDrvGraphMemcpyNodeGetParams(hipGraphNode_t hNode, HIP_MEMCPY3D *nodeParams)

Gets a memcpy node's parameters.

hipDeviceSetGraphMemAttribute

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

Set the mem attribute for graphs.

hipGraphMemcpyNodeSetParams

hipError_t hipGraphMemcpyNodeSetParams(hipGraphNode_t node, const hipMemcpy3DParms *pNodeParams)

Sets a memcpy node's parameters.

hipUserObjectCreate

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

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

hipGraphExecUpdate

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

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

hipGraphNodeFindInClone

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

Finds a cloned version of a node.

hipGraphAddEventWaitNode

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

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

hipGraphMemcpyNodeSetParamsToSymbol

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

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

hipStreamIsCapturing

hipError_t hipStreamIsCapturing(hipStream_t stream, hipStreamCaptureStatus *pCaptureStatus)

Get stream's capture state.

hipGraphNodeGetEnabled

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

Query whether a node in the given graphExec is enabled.

hipGraphAddChildGraphNode

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

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

hipGraphExternalSemaphoresSignalNodeSetParams

hipError_t hipGraphExternalSemaphoresSignalNodeSetParams(hipGraphNode_t hNode, const hipExternalSemaphoreSignalNodeParams *nodeParams)

Updates node parameters in the external semaphore signal node.

hipGraphDestroyNode

hipError_t hipGraphDestroyNode(hipGraphNode_t node)

Remove a node from the graph.

hipGraphMemcpyNodeSetParamsFromSymbol

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

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

hipGraphReleaseUserObject

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

Release user object from graphs.

hipDrvGraphAddMemcpyNode

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

Creates a memcpy node and adds it to a graph.

hipGraphRemoveDependencies

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

Removes dependency edges from a graph.

hipGraphMemcpyNodeSetParams1D

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

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

hipGraphExecMemcpyNodeSetParams1D

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

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

hipGraphExecDestroy

hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec)

Destroys an executable graph.

hipGraphAddExternalSemaphoresSignalNode

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

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

hipGraphExecExternalSemaphoresWaitNodeSetParams

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

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

hipGraphExecHostNodeSetParams

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

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

hipGraphExecChildGraphNodeSetParams

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

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

hipStreamGetCaptureInfo

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

Get capture status of a stream.

hipGraphAddDependencies

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

Adds dependency edges to a graph.

hipDrvGraphAddMemFreeNode

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

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

hipGraphExecKernelNodeSetParams

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

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

hipGraphNodeGetDependentNodes

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

Returns a node's dependent nodes.

hipDeviceGetGraphMemAttribute

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

Get the mem attribute for graphs.

hipGraphHostNodeGetParams

hipError_t hipGraphHostNodeGetParams(hipGraphNode_t node, hipHostNodeParams *pNodeParams)

Returns a host node's parameters.

hipGraphInstantiateWithFlags

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

Creates an executable graph from a graph.

hipGraphExternalSemaphoresSignalNodeGetParams

hipError_t hipGraphExternalSemaphoresSignalNodeGetParams(hipGraphNode_t hNode, hipExternalSemaphoreSignalNodeParams *params_out)

Returns external semaphore signal node params.

hipGraphUpload

hipError_t hipGraphUpload(hipGraphExec_t graphExec, hipStream_t stream)

Uploads an executable graph to a stream.

hipDrvGraphAddMemsetNode

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

Creates a memset node and adds it to a graph.

hipGraphExecExternalSemaphoresSignalNodeSetParams

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

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

hipGraphExecMemcpyNodeSetParamsToSymbol

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

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

hipUserObjectRelease

hipError_t hipUserObjectRelease(hipUserObject_t object, unsigned int count)

Release number of references to resource.

hipGraphKernelNodeGetParams

hipError_t hipGraphKernelNodeGetParams(hipGraphNode_t node, hipKernelNodeParams *pNodeParams)

Gets kernel node's parameters.

hipGraphAddMemcpyNodeFromSymbol

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

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

hipGraphKernelNodeCopyAttributes

hipError_t hipGraphKernelNodeCopyAttributes(hipGraphNode_t hSrc, hipGraphNode_t hDst)

Copies attributes from source node to destination node.

hipGraphAddMemFreeNode

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

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

hipDrvGraphMemcpyNodeSetParams

hipError_t hipDrvGraphMemcpyNodeSetParams(hipGraphNode_t hNode, const HIP_MEMCPY3D *nodeParams)

Sets a memcpy node's parameters.

hipGraphMemcpyNodeGetParams

hipError_t hipGraphMemcpyNodeGetParams(hipGraphNode_t node, hipMemcpy3DParms *pNodeParams)

Gets a memcpy node's parameters.

hipGraphNodeSetParams

hipError_t hipGraphNodeSetParams(hipGraphNode_t node, hipGraphNodeParams *nodeParams)

Updates parameters of a graph's node.

hipGraphAddEventRecordNode

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

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

hipDrvGraphExecMemcpyNodeSetParams

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

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

hipStreamBeginCapture

hipError_t hipStreamBeginCapture(hipStream_t stream, hipStreamCaptureMode mode)

Begins graph capture on a stream.

hipStreamEndCapture

hipError_t hipStreamEndCapture(hipStream_t stream, hipGraph_t *pGraph)

Ends capture on a stream, returning the captured graph.

hipGraphExecGetFlags

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

Return the flags of an executable graph.

hipUserObjectRetain

hipError_t hipUserObjectRetain(hipUserObject_t object, unsigned int count)

Retain number of references to resource.

hipGraphNodeGetType

hipError_t hipGraphNodeGetType(hipGraphNode_t node, hipGraphNodeType *pType)

Returns a node's type.

hipGraphNodeSetEnabled

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

Enables or disables the specified node in the given graphExec.

hipGraphExecMemcpyNodeSetParams

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

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

hipGraphExecNodeSetParams

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

Updates parameters of an executable graph's node.

hipGraphHostNodeSetParams

hipError_t hipGraphHostNodeSetParams(hipGraphNode_t node, const hipHostNodeParams *pNodeParams)

Sets a host node's parameters.

hipGraphMemAllocNodeGetParams

hipError_t hipGraphMemAllocNodeGetParams(hipGraphNode_t node, hipMemAllocNodeParams *pNodeParams)

Returns parameters for memory allocation node.

hipGraphInstantiateWithParams

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

Creates an executable graph from a graph.

hipGraphExecEventRecordNodeSetEvent

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

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

hipGraphExternalSemaphoresWaitNodeSetParams

hipError_t hipGraphExternalSemaphoresWaitNodeSetParams(hipGraphNode_t hNode, const hipExternalSemaphoreWaitNodeParams *nodeParams)

Updates node parameters in the external semaphore wait node.

hipGraphMemsetNodeGetParams

hipError_t hipGraphMemsetNodeGetParams(hipGraphNode_t node, hipMemsetParams *pNodeParams)

Gets a memset node's parameters.

hipGraphChildGraphNodeGetGraph

hipError_t hipGraphChildGraphNodeGetGraph(hipGraphNode_t node, hipGraph_t *pGraph)

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

hipGraphKernelNodeGetAttribute

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

Gets a node's attribute.

hipThreadExchangeStreamCaptureMode

hipError_t hipThreadExchangeStreamCaptureMode(hipStreamCaptureMode *mode)

Swaps the stream capture mode of a thread.

hipGraphLaunch

hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream)

Launches an executable graph in the specified stream.

hipGraphDebugDotPrint

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

Write a DOT file describing graph structure.

hipGraphExecMemsetNodeSetParams

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

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

hipGraphGetEdges

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

Returns a graph's dependency edges.

hipGraphAddKernelNode

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

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

hipGraphExecEventWaitNodeSetEvent

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

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

hipStreamGetCaptureInfo_v2

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

Get stream's capture state.

hipStreamBeginCaptureToGraph

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

Begins graph capture on a stream to an existing graph.

hipGraphAddExternalSemaphoresWaitNode

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

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

hipGraphEventWaitNodeSetEvent

hipError_t hipGraphEventWaitNodeSetEvent(hipGraphNode_t node, hipEvent_t event)

Sets an event wait node's event.

hipGraphEventRecordNodeSetEvent

hipError_t hipGraphEventRecordNodeSetEvent(hipGraphNode_t node, hipEvent_t event)

Sets an event record node's event.

hipGraphEventWaitNodeGetEvent

hipError_t hipGraphEventWaitNodeGetEvent(hipGraphNode_t node, hipEvent_t *event_out)

Returns the event associated with an event wait node.

hipGraphKernelNodeSetAttribute

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

Sets a node's attribute.

hipGraphMemsetNodeSetParams

hipError_t hipGraphMemsetNodeSetParams(hipGraphNode_t node, const hipMemsetParams *pNodeParams)

Sets a memset node's parameters.

hipGraphEventRecordNodeGetEvent

hipError_t hipGraphEventRecordNodeGetEvent(hipGraphNode_t node, hipEvent_t *event_out)

Returns the event associated with an event record node.

hipGraphAddEmptyNode

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

Creates an empty node and adds it to a graph.

hipGraphAddMemcpyNodeToSymbol

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

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

hipGraphDestroy

hipError_t hipGraphDestroy(hipGraph_t graph)

Destroys a graph.

hipGraphRetainUserObject

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

Retain user object for graphs.

hipGraphExecMemcpyNodeSetParamsFromSymbol

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

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

hipGraphAddMemAllocNode

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

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

hipGraphAddHostNode

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

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

hipGraphAddNode

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

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

hipGraphGetNodes

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

Returns a graph's nodes.

hipGraphAddMemsetNode

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

Creates a memset node and adds it to a graph.

hipStreamUpdateCaptureDependencies

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

Update the set of dependencies in a capturing stream.

hipGraphInstantiate

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

Creates an executable graph from a graph.

hipDeviceGraphMemTrim

hipError_t hipDeviceGraphMemTrim(int device)

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

hipGraphExternalSemaphoresWaitNodeGetParams

hipError_t hipGraphExternalSemaphoresWaitNodeGetParams(hipGraphNode_t hNode, hipExternalSemaphoreWaitNodeParams *params_out)

Returns external semaphore wait node params.

hipGraphClone

hipError_t hipGraphClone(hipGraph_t *pGraphClone, hipGraph_t originalGraph)

Clones a graph.

hipGraphGetRootNodes

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

Returns a graph's root nodes.

hipGraphAddMemcpyNode

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

Creates a memcpy node and adds it to a graph.

hipGraphicsUnregisterResource

hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource)

Unregisters a graphics resource.

hipGraphicsUnmapResources

hipError_t hipGraphicsUnmapResources(int count, hipGraphicsResource_t *resources, hipStream_t stream)

Unmaps graphics resources.

hipGraphicsSubResourceGetMappedArray

hipError_t hipGraphicsSubResourceGetMappedArray(hipArray_t *array, hipGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel)

Get an array through which to access a subresource of a mapped graphics resource.

hipGraphicsResourceGetMappedPointer

hipError_t hipGraphicsResourceGetMappedPointer(void **devPtr, size_t *size, hipGraphicsResource_t resource)

Gets device accessible address of a graphics resource.

hipGraphicsMapResources

hipError_t hipGraphicsMapResources(int count, hipGraphicsResource_t *resources, hipStream_t stream)

Maps a graphics resource for access.

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 HIP-Clang hip host memory allocation API This API performs an implicit h...

hipMallocHost

hipError_t hipMallocHost(void **ptr, size_t size)

Allocate pinned host memory [Deprecated].

hipMemcpyToArray

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

Copies data between host and device [Deprecated].

hipMemcpyFromArray

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

Copies data between host and device [Deprecated].

hipMemAllocHost

hipError_t hipMemAllocHost(void **ptr, size_t size)

Allocate pinned host memory [Deprecated].

hipMemcpyAtoA

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

Copies from one 1D array to another.

hipHostAlloc

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

Allocate device accessible page locked host memory.

hipMemcpy3DBatchAsync

hipError_t hipMemcpy3DBatchAsync(size_t numOps, struct hipMemcpy3DBatchOp *opList, size_t *failIdx, unsigned long long flags, hipStream_t stream)

Perform Batch of 3D copies.

hipMemcpy2DArrayToArray

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

Copies data between host and device.

hipMemsetD8Async

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

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

hipMemcpyAtoHAsync

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

Copies from one 1D array to host memory.

hipFreeHost

hipError_t hipFreeHost(void *ptr)

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

hipMemset2DAsync

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

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

hipMemGetInfo

hipError_t hipMemGetInfo(size_t *free, size_t *total)

Query memory info.

hipExtMallocWithFlags

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

Allocate memory on the default accelerator.

hipMemcpy3D

hipError_t hipMemcpy3D(const struct hipMemcpy3DParms *p)

Copies data between host and device.

hipMalloc3DArray

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

Allocate an array on the device.

hipArrayCreate

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

Create an array memory pointer on the device.

hipMemset3D

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

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

hipMemsetD16

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

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

hipMemcpyAtoD

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

Copies from one 1D array to device memory.

hipMalloc

hipError_t hipMalloc(void **ptr, size_t size)

Allocate memory on the default accelerator.

hipHostUnregister

hipError_t hipHostUnregister(void *hostPtr)

Un-register host pointer.

hipHostGetFlags

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

Return flags associated with host pointer.

hipMemcpyFromSymbolAsync

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

Copies data from the given symbol on the device asynchronously.

hipMemsetD2D32

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

Fills 2D memory range of 'width' 32-bit values synchronously to the specified int value....

hipMemsetD32

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

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

hipMemset3DAsync

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

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

hipMemcpyFromSymbol

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

Copies data from the given symbol on the device.

hipDrvMemcpy3DAsync

hipError_t hipDrvMemcpy3DAsync(const HIP_MEMCPY3D *pCopy, hipStream_t stream)

Copies data between host and device asynchronously.

hipMemsetD2D32Async

hipError_t hipMemsetD2D32Async(hipDeviceptr_t dst, size_t dstPitch, unsigned int value, size_t width, size_t height, hipStream_t stream)

Fills 2D memory range of 'width' 32-bit values asynchronously to the specified int value....

hipArray3DGetDescriptor

hipError_t hipArray3DGetDescriptor(HIP_ARRAY3D_DESCRIPTOR *pArrayDescriptor, hipArray_t array)

Gets a 3D array descriptor.

hipMemcpy2DAsync

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

Copies data between host and device asynchronously.

hipArrayGetDescriptor

hipError_t hipArrayGetDescriptor(HIP_ARRAY_DESCRIPTOR *pArrayDescriptor, hipArray_t array)

Gets a 1D or 2D array descriptor.

hipFree

hipError_t hipFree(void *ptr)

Free memory allocated by the HIP-Clang hip memory allocation API. This API performs an implicit hipDe...

hipMemcpyHtoAAsync

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

Copies from host memory to a 1D array.

hipMemsetD16Async

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

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

hipGetProcAddress

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

Gets the pointer of requested HIP driver function.

hipPointerGetAttributes

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

Returns attributes for the specified pointer.

hipMallocPitch

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

hipMemcpy3DPeer

hipError_t hipMemcpy3DPeer(hipMemcpy3DPeerParms *p)

Performs 3D memory copies between devices This API is asynchronous with respect to host.

hipMemcpyDtoD

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

Copy data from Device to Device.

hipMallocArray

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

Allocate an array on the device.

hipMemcpy2D

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

Copies data between host and device.

hipHostGetDevicePointer

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

Get Device pointer from Host Pointer allocated through hipHostMalloc.

hipMemcpyDtoA

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

Copies from device memory to a 1D array.

hipMemcpy2DFromArrayAsync

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

Copies data between host and device asynchronously.

hipMemsetD2D16Async

hipError_t hipMemsetD2D16Async(hipDeviceptr_t dst, size_t dstPitch, unsigned short value, size_t width, size_t height, hipStream_t stream)

Fills 2D memory range of 'width' 16-bit values asynchronously to the specified short value....

hipMemcpy2DFromArray

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

Copies data between host and device.

hipMemcpy3DAsync

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

Copies data between host and device asynchronously.

hipArray3DCreate

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

Create a 3D array memory pointer on the device.

hipArrayGetInfo

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

Gets info about the specified array.

hipDrvMemcpy3D

hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D *pCopy)

Copies data between host and device.

hipMemcpyParam2D

hipError_t hipMemcpyParam2D(const hip_Memcpy2D *pCopy)

Copies memory for 2D arrays.

hipMemcpyHtoA

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

Copies data between host and device.

hipMemcpyToSymbolAsync

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

Copies data to the given symbol on the device asynchronously.

hipHostMalloc

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

Allocates device accessible page locked (pinned) host memory.

hipMemsetD2D8

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

Fills 2D memory range of 'width' 8-bit values synchronously to the specified char value....

hipMemcpy2DToArrayAsync

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

Copies data between host and device.

hipHostRegister

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

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

hipMemsetD2D16

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

Fills 2D memory range of 'width' 16-bit values synchronously to the specified short value....

hipMemcpyBatchAsync

hipError_t hipMemcpyBatchAsync(void **dsts, void **srcs, size_t *sizes, size_t count, hipMemcpyAttributes *attrs, size_t *attrsIdxs, size_t numAttrs, size_t *failIdx, hipStream_t stream)

Perform Batch of 1D copies.

hipMemcpyAtoH

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

Copies data between host and device.

hipMemcpyToSymbol

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

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

hipMemcpy

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

Copy data from src to dst.

hipMemset

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

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

hipMemGetAddressRange

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

Get information on memory allocations.

hipMemcpy2DToArray

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

Copies data between host and device.

hipMemcpyParam2DAsync

hipError_t hipMemcpyParam2DAsync(const hip_Memcpy2D *pCopy, hipStream_t stream)

Copies memory for 2D arrays.

hipDrvPointerGetAttributes

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

Returns information about the specified pointer.[BETA].

hipMalloc3D

hipError_t hipMalloc3D(hipPitchedPtr *pitchedDevPtr, hipExtent extent)

Create a 3D memory pointer on the device.

hipPointerSetAttribute

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

Sets information on the specified pointer.[BETA].

hipMemcpyDtoDAsync

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

Copy data from Device to Device asynchronously.

hipMemAllocPitch

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

hipMemsetD8

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

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

hipMemcpyAsync

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

Copies data from src to dst asynchronously.

hipMemcpyDtoHAsync

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

Copy data from Device to Host asynchronously.

hipFreeArray

hipError_t hipFreeArray(hipArray_t array)

Frees an array on the device.

hipMemcpyHtoD

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

Copy data from Host to Device.

hipMemsetD32Async

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

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

hipMemset2D

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

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

hipGetSymbolSize

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

Gets the size of the given symbol on the device.

hipMemcpyDtoH

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

Copy data from Device to Host.

hipMemcpyHtoDAsync

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

Copy data from Host to Device asynchronously.

hipMemsetAsync

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

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

hipMemcpyWithStream

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

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

hipGetSymbolAddress

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

Gets device pointer associated with symbol on the device.

hipPointerGetAttribute

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

Returns information about the specified pointer.[BETA].

hipMemsetD2D8Async

hipError_t hipMemsetD2D8Async(hipDeviceptr_t dst, size_t dstPitch, unsigned char value, size_t width, size_t height, hipStream_t stream)

Fills 2D memory range of 'width' 8-bit values asynchronously to the specified char value....

hipMemcpy3DPeerAsync

hipError_t hipMemcpy3DPeerAsync(hipMemcpy3DPeerParms *p, hipStream_t stream)

Performs 3D memory copies between devices asynchronously.

hipMemPtrGetInfo

hipError_t hipMemPtrGetInfo(void *ptr, size_t *size)

Get allocated memory size via memory pointer.

hipArrayDestroy

hipError_t hipArrayDestroy(hipArray_t array)

Destroy an array memory pointer on the device.

hipMemPrefetchAsync

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

Prefetches memory to the specified destination device using HIP.

hipMemPrefetchAsync_v2

hipError_t hipMemPrefetchAsync_v2(const void *dev_ptr, size_t count, hipMemLocation location, unsigned int flags, hipStream_t stream)

Prefetches memory to the specified destination device using HIP.

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.

hipMemAdvise_v2

hipError_t hipMemAdvise_v2(const void *dev_ptr, size_t count, hipMemoryAdvise advice, hipMemLocation location)

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

hipModuleLaunchCooperativeKernelMultiDevice

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

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

hipLaunchCooperativeKernelMultiDevice

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

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

hipModuleLaunchCooperativeKernel

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

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

hipLaunchCooperativeKernel

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

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

hipModuleGetTexRef

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

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

hipLinkComplete

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

Completes the linking of the given program.

hipModuleGetFunctionCount

hipError_t hipModuleGetFunctionCount(unsigned int *count, hipModule_t mod)

Returns the number of functions within a module.

hipModuleLoad

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

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

hipModuleGetGlobal

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

Returns a global pointer from a module.

hipModuleLoadDataEx

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

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

hipLinkAddFile

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

Adds a file with bitcode to be linked with options.

hipGetFuncBySymbol

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

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

hipLinkDestroy

hipError_t hipLinkDestroy(hipLinkState_t state)

Deletes the linker instance.

hipMemGetHandleForAddressRange

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

Returns a handle for the address range requested.

hipModuleGetFunction

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

Function with kname will be extracted if present in module.

hipLinkCreate

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

Creates a linker instance with options.

hipGetDriverEntryPoint

hipError_t hipGetDriverEntryPoint(const char *symbol, void **funcPtr, unsigned long long flags, hipDriverEntryPointQueryResult *driverStatus)

Gets function pointer of a requested HIP API.

hipModuleLoadData

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

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

hipModuleLoadFatBinary

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

Loads fatbin object.

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)

Adds bitcode data to be linked with options.

hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags

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

Returns occupancy for a device function.

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)

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

hipDeviceEnablePeerAccess

hipError_t hipDeviceEnablePeerAccess(int peerDeviceId, unsigned int flags)

Enables direct access to memory allocations on a peer device.

hipMemcpyPeer

hipError_t hipMemcpyPeer(void *dst, int dstDeviceId, const void *src, int srcDeviceId, size_t sizeBytes)

Copies memory between two peer accessible devices.

hipMemcpyPeerAsync

hipError_t hipMemcpyPeerAsync(void *dst, int dstDeviceId, const void *src, int srcDevice, size_t sizeBytes, hipStream_t stream)

Copies memory between two peer accessible devices asynchronously.

hipDeviceDisablePeerAccess

hipError_t hipDeviceDisablePeerAccess(int peerDeviceId)

Disables direct access to memory allocations on a peer device.

hipProfilerStart

hipError_t hipProfilerStart()

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

hipProfilerStop

hipError_t hipProfilerStop()

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

hipDeviceGetStreamPriorityRange

hipError_t hipDeviceGetStreamPriorityRange(int *leastPriority, int *greatestPriority)

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

hipStreamDestroy

hipError_t hipStreamDestroy(hipStream_t stream)

Destroys the specified stream.

hipStreamGetFlags

hipError_t hipStreamGetFlags(hipStream_t stream, unsigned int *flags)

Returns flags associated with this stream.

hipStreamAddCallback

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

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

hipStreamCallback_t

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

Definition hip_runtime_api.h:2948

hipStreamGetDevice

hipError_t hipStreamGetDevice(hipStream_t stream, hipDevice_t *device)

Gets the device associated with the stream.

hipStreamQuery

hipError_t hipStreamQuery(hipStream_t stream)

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

hipStreamSynchronize

hipError_t hipStreamSynchronize(hipStream_t stream)

Waits for all commands in the stream to complete.

hipStreamSetAttribute

hipError_t hipStreamSetAttribute(hipStream_t stream, hipStreamAttrID attr, const hipStreamAttrValue *value)

Sets stream attribute. Updated attribute is applied to work submitted to the stream.

hipStreamWaitEvent

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

Makes the specified compute stream wait for the specified event.

hipStreamCreateWithPriority

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

Creates an asynchronous stream with the specified priority.

hipExtStreamCreateWithCUMask

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

Creates an asynchronous stream with the specified CU mask.

hipStreamGetPriority

hipError_t hipStreamGetPriority(hipStream_t stream, int *priority)

Queries the priority of a stream.

hipExtStreamGetCUMask

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

Gets CU mask associated with an asynchronous stream.

hipStreamGetAttribute

hipError_t hipStreamGetAttribute(hipStream_t stream, hipStreamAttrID attr, hipStreamAttrValue *value_out)

queries stream attribute.

hipStreamCreateWithFlags

hipError_t hipStreamCreateWithFlags(hipStream_t *stream, unsigned int flags)

Creates an asynchronous stream with flag.

hipStreamCreate

hipError_t hipStreamCreate(hipStream_t *stream)

Creates an asynchronous stream.

hipStreamWriteValue64

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

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

hipStreamWriteValue32

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

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

hipGraphExecBatchMemOpNodeSetParams

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

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

hipGraphAddBatchMemOpNode

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

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

hipStreamWaitValue64

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

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

hipGraphBatchMemOpNodeGetParams

hipError_t hipGraphBatchMemOpNodeGetParams(hipGraphNode_t hNode, hipBatchMemOpNodeParams *nodeParams_out)

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

hipStreamBatchMemOp

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

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

hipGraphBatchMemOpNodeSetParams

hipError_t hipGraphBatchMemOpNodeSetParams(hipGraphNode_t hNode, hipBatchMemOpNodeParams *nodeParams)

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

hipStreamWaitValue32

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

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

hipMemPoolImportPointer

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

Import a memory pool allocation from another process.

hipMemPoolImportFromShareableHandle

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

Imports a memory pool from a shared handle.

hipMallocFromPoolAsync

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

Allocates memory from a specified pool with stream ordered semantics.

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

HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

@ HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

Definition hip_runtime_api.h:53

HIP_ERROR_INVALID_VALUE

@ HIP_ERROR_INVALID_VALUE

Definition hip_runtime_api.h:51

HIP_SUCCESS

@ HIP_SUCCESS

Definition hip_runtime_api.h:50

HIP_ERROR_NOT_INITIALIZED

@ HIP_ERROR_NOT_INITIALIZED

Definition hip_runtime_api.h:52

linker_types.h

hip_impl

Definition hip_runtime_api.h:651

hip_impl::hip_init

hipError_t hip_init()

HIP_ARRAY3D_DESCRIPTOR

Definition driver_types.h:103

HIP_ARRAY_DESCRIPTOR

Definition driver_types.h:93

HIP_LAUNCH_CONFIG

Definition hip_runtime_api.h:1946

HIP_LAUNCH_CONFIG::gridDimZ

unsigned int gridDimZ

Grid depth in blocks.

Definition hip_runtime_api.h:1949

HIP_LAUNCH_CONFIG::sharedMemBytes

unsigned int sharedMemBytes

Dynamic shared-memory size in bytes per block.

Definition hip_runtime_api.h:1953

HIP_LAUNCH_CONFIG::blockDimY

unsigned int blockDimY

Thread block dimension in Y.

Definition hip_runtime_api.h:1951

HIP_LAUNCH_CONFIG::hStream

hipStream_t hStream

HIP stream identifier.

Definition hip_runtime_api.h:1954

HIP_LAUNCH_CONFIG::attrs

hipLaunchAttribute * attrs

Attribute list.

Definition hip_runtime_api.h:1955

HIP_LAUNCH_CONFIG::blockDimZ

unsigned int blockDimZ

Thread block dimension in Z.

Definition hip_runtime_api.h:1952

HIP_LAUNCH_CONFIG::numAttrs

unsigned int numAttrs

Number of attributes.

Definition hip_runtime_api.h:1956

HIP_LAUNCH_CONFIG::gridDimX

unsigned int gridDimX

Grid width in blocks.

Definition hip_runtime_api.h:1947

HIP_LAUNCH_CONFIG::gridDimY

unsigned int gridDimY

Grid height in blocks.

Definition hip_runtime_api.h:1948

HIP_LAUNCH_CONFIG::blockDimX

unsigned int blockDimX

Thread block dimension in X.

Definition hip_runtime_api.h:1950

HIP_MEMCPY3D

Definition driver_types.h:423

HIP_RESOURCE_DESC

Definition driver_types.h:312

HIP_RESOURCE_VIEW_DESC

Definition driver_types.h:357

HIP_TEXTURE_DESC

Definition driver_types.h:190

dim3

Definition hip_runtime_api.h:1253

dim3::y

uint32_t y

y

Definition hip_runtime_api.h:1255

dim3::z

uint32_t z

z

Definition hip_runtime_api.h:1256

dim3::x

uint32_t x

x

Definition hip_runtime_api.h:1254

dim3::dim3

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

Definition hip_runtime_api.h:1258

hip_Memcpy2D

Definition driver_types.h:115

hipAccessPolicyWindow

Definition hip_runtime_api.h:1501

hipAccessPolicyWindow::hitProp

hipAccessProperty hitProp

hipAccessProperty set for hit

Definition hip_runtime_api.h:1503

hipAccessPolicyWindow::missProp

hipAccessProperty missProp

hipAccessProperty set for miss

Definition hip_runtime_api.h:1505

hipAccessPolicyWindow::hitRatio

float hitRatio

hitRatio specifies percentage of lines assigned hitProp

Definition hip_runtime_api.h:1504

hipAccessPolicyWindow::base_ptr

void * base_ptr

Starting address of the access policy window.

Definition hip_runtime_api.h:1502

hipAccessPolicyWindow::num_bytes

size_t num_bytes

Size in bytes of the window policy.

Definition hip_runtime_api.h:1506

hipArrayMapInfo

Definition hip_runtime_api.h:1784

hipArrayMapInfo::level

unsigned int level

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

Definition hip_runtime_api.h:1793

hipArrayMapInfo::flags

unsigned int flags

flags for future use, must be zero now.

Definition hip_runtime_api.h:1815

hipArrayMapInfo::subresourceType

hipArraySparseSubresourceType subresourceType

Sparse subresource type.

Definition hip_runtime_api.h:1790

hipArrayMapInfo::extentDepth

unsigned int extentDepth

Depth in elements.

Definition hip_runtime_api.h:1800

hipArrayMapInfo::offsetX

unsigned int offsetX

X offset in elements.

Definition hip_runtime_api.h:1795

hipArrayMapInfo::array

hipArray_t array

Definition hip_runtime_api.h:1788

hipArrayMapInfo::resourceType

hipResourceType resourceType

Resource type.

Definition hip_runtime_api.h:1785

hipArrayMapInfo::memOperationType

hipMemOperationType memOperationType

Memory operation type.

Definition hip_runtime_api.h:1808

hipArrayMapInfo::miptail

struct hipArrayMapInfo::@35::@38 miptail

hipArrayMapInfo::reserved

unsigned int reserved[2]

Reserved for future use, must be zero now.

Definition hip_runtime_api.h:1816

hipArrayMapInfo::extentWidth

unsigned int extentWidth

Width in elements.

Definition hip_runtime_api.h:1798

hipArrayMapInfo::sparseLevel

struct hipArrayMapInfo::@35::@37 sparseLevel

hipArrayMapInfo::extentHeight

unsigned int extentHeight

Height in elements.

Definition hip_runtime_api.h:1799

hipArrayMapInfo::offsetY

unsigned int offsetY

Y offset in elements.

Definition hip_runtime_api.h:1796

hipArrayMapInfo::memHandleType

hipMemHandleType memHandleType

Memory handle type.

Definition hip_runtime_api.h:1809

hipArrayMapInfo::memHandle

hipMemGenericAllocationHandle_t memHandle

Definition hip_runtime_api.h:1811

hipArrayMapInfo::mipmap

hipMipmappedArray mipmap

Definition hip_runtime_api.h:1787

hipArrayMapInfo::subresource

union hipArrayMapInfo::@35 subresource

hipArrayMapInfo::layer

unsigned int layer

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

Definition hip_runtime_api.h:1794

hipArrayMapInfo::deviceBitMask

unsigned int deviceBitMask

Device ordinal bit mask.

Definition hip_runtime_api.h:1814

hipArrayMapInfo::size

unsigned long long size

Extent in bytes.

Definition hip_runtime_api.h:1805

hipArrayMapInfo::offset

unsigned long long offset

Offset within mip tail.

Definition hip_runtime_api.h:1804

hipArrayMapInfo::offsetZ

unsigned int offsetZ

Z offset in elements.

Definition hip_runtime_api.h:1797

hipArrayMapInfo::resource

union hipArrayMapInfo::@34 resource

hipBatchMemOpNodeParams

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

Definition hip_runtime_api.h:1037

hipBatchMemOpNodeParams::paramArray

hipStreamBatchMemOpParams * paramArray

Definition hip_runtime_api.h:1040

hipBatchMemOpNodeParams::count

unsigned int count

Definition hip_runtime_api.h:1039

hipBatchMemOpNodeParams::flags

unsigned int flags

Definition hip_runtime_api.h:1041

hipBatchMemOpNodeParams::ctx

hipCtx_t ctx

Definition hip_runtime_api.h:1038

hipChannelFormatDesc

Definition driver_types.h:59

hipChildGraphNodeParams

Definition hip_runtime_api.h:1831

hipChildGraphNodeParams::graph

hipGraph_t graph

Definition hip_runtime_api.h:1832

hipDeviceArch_t

Definition hip_runtime_api.h:65

hipDeviceArch_t::hasSharedInt64Atomics

unsigned hasSharedInt64Atomics

64-bit integer atomics for shared memory.

Definition hip_runtime_api.h:75

hipDeviceArch_t::hasSharedInt32Atomics

unsigned hasSharedInt32Atomics

32-bit integer atomics for shared memory.

Definition hip_runtime_api.h:69

hipDeviceArch_t::hasFloatAtomicAdd

unsigned hasFloatAtomicAdd

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

Definition hip_runtime_api.h:71

hipDeviceArch_t::hasDoubles

unsigned hasDoubles

Double-precision floating point.

Definition hip_runtime_api.h:78

hipDeviceArch_t::hasWarpVote

unsigned hasWarpVote

Warp vote instructions (__any, __all).

Definition hip_runtime_api.h:81

hipDeviceArch_t::hasWarpShuffle

unsigned hasWarpShuffle

Warp shuffle operations. (__shfl_*).

Definition hip_runtime_api.h:83

hipDeviceArch_t::hasGlobalInt32Atomics

unsigned hasGlobalInt32Atomics

32-bit integer atomics for global memory.

Definition hip_runtime_api.h:67

hipDeviceArch_t::hasGlobalFloatAtomicExch

unsigned hasGlobalFloatAtomicExch

32-bit float atomic exch for global memory.

Definition hip_runtime_api.h:68

hipDeviceArch_t::hasDynamicParallelism

unsigned hasDynamicParallelism

Dynamic parallelism.

Definition hip_runtime_api.h:93

hipDeviceArch_t::hasSurfaceFuncs

unsigned hasSurfaceFuncs

Surface functions.

Definition hip_runtime_api.h:91

hipDeviceArch_t::has3dGrid

unsigned has3dGrid

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

Definition hip_runtime_api.h:92

hipDeviceArch_t::hasFunnelShift

unsigned hasFunnelShift

Funnel two words into one with shift&mask caps.

Definition hip_runtime_api.h:84

hipDeviceArch_t::hasThreadFenceSystem

unsigned hasThreadFenceSystem

__threadfence_system.

Definition hip_runtime_api.h:87

hipDeviceArch_t::hasGlobalInt64Atomics

unsigned hasGlobalInt64Atomics

64-bit integer atomics for global memory.

Definition hip_runtime_api.h:74

hipDeviceArch_t::hasSyncThreadsExt

unsigned hasSyncThreadsExt

__syncthreads_count, syncthreads_and, syncthreads_or.

Definition hip_runtime_api.h:88

hipDeviceArch_t::hasWarpBallot

unsigned hasWarpBallot

Warp ballot instructions (__ballot).

Definition hip_runtime_api.h:82

hipDeviceArch_t::hasSharedFloatAtomicExch

unsigned hasSharedFloatAtomicExch

32-bit float atomic exch for shared memory.

Definition hip_runtime_api.h:70

hipDeviceProp_t

Definition hip_runtime_api.h:111

hipDeviceProp_t::ECCEnabled

int ECCEnabled

Device has ECC support enabled.

Definition hip_runtime_api.h:168

hipDeviceProp_t::ipcEventSupported

int ipcEventSupported

Device supports IPC events.

Definition hip_runtime_api.h:223

hipDeviceProp_t::computePreemptionSupported

int computePreemptionSupported

Is compute preemption supported on the device.

Definition hip_runtime_api.h:194

hipDeviceProp_t::maxTexture1DLinear

int maxTexture1DLinear

Maximum size for 1D textures bound to linear memory.

Definition hip_runtime_api.h:147

hipDeviceProp_t::timelineSemaphoreInteropSupported

int timelineSemaphoreInteropSupported

Indicates external timeline semaphore support.

Definition hip_runtime_api.h:213

hipDeviceProp_t::pciBusID

int pciBusID

PCI Bus ID.

Definition hip_runtime_api.h:169

hipDeviceProp_t::maxTexture1D

int maxTexture1D

Maximum number of elements in 1D images.

Definition hip_runtime_api.h:145

hipDeviceProp_t::memoryBusWidth

int memoryBusWidth

Global memory bus width in bits.

Definition hip_runtime_api.h:176

hipDeviceProp_t::maxTexture2DMipmap

int maxTexture2DMipmap[2]

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

Definition hip_runtime_api.h:149

hipDeviceProp_t::clockRate

int clockRate

Max clock frequency of the multiProcessors in khz.

Definition hip_runtime_api.h:125

hipDeviceProp_t::maxThreadsPerMultiProcessor

int maxThreadsPerMultiProcessor

Maximum resident threads per multi-processor.

Definition hip_runtime_api.h:179

hipDeviceProp_t::l2CacheSize

int l2CacheSize

L2 cache size.

Definition hip_runtime_api.h:177

hipDeviceProp_t::deferredMappingHipArraySupported

int deferredMappingHipArraySupported

Definition hip_runtime_api.h:221

hipDeviceProp_t::asyncEngineCount

int asyncEngineCount

Number of async engines.

Definition hip_runtime_api.h:173

hipDeviceProp_t::accessPolicyMaxWindowSize

int accessPolicyMaxWindowSize

Max value of access policy window.

Definition hip_runtime_api.h:207

hipDeviceProp_t::totalConstMem

size_t totalConstMem

Definition hip_runtime_api.h:126

hipDeviceProp_t::memoryPoolsSupported

int memoryPoolsSupported

Indicates if device supports hipMallocAsync and hipMemPool APIs.

Definition hip_runtime_api.h:214

hipDeviceProp_t::unifiedFunctionPointers

int unifiedFunctionPointers

Indicates device supports unified function pointers.

Definition hip_runtime_api.h:225

hipDeviceProp_t::maxTexture2DGather

int maxTexture2DGather[2]

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

Definition hip_runtime_api.h:151

hipDeviceProp_t::memPitch

size_t memPitch

Definition hip_runtime_api.h:120

hipDeviceProp_t::gpuDirectRDMAWritesOrdering

int gpuDirectRDMAWritesOrdering

value of hipGPUDirectRDMAWritesOrdering

Definition hip_runtime_api.h:218

hipDeviceProp_t::uuid

hipUUID uuid

UUID of a device.

Definition hip_runtime_api.h:113

hipDeviceProp_t::sharedMemPerBlock

size_t sharedMemPerBlock

Size of shared memory per block (in bytes).

Definition hip_runtime_api.h:117

hipDeviceProp_t::gpuDirectRDMAFlushWritesOptions

unsigned int gpuDirectRDMAFlushWritesOptions

Definition hip_runtime_api.h:216

hipDeviceProp_t::surfaceAlignment

size_t surfaceAlignment

Alignment requirement for surface.

Definition hip_runtime_api.h:166

hipDeviceProp_t::reserved

int reserved[63]

CUDA Reserved.

Definition hip_runtime_api.h:226

hipDeviceProp_t::maxTexture2DLayered

int maxTexture2DLayered[3]

Maximum number of elements in 2D array images.

Definition hip_runtime_api.h:157

hipDeviceProp_t::streamPrioritiesSupported

int streamPrioritiesSupported

Device supports stream priority.

Definition hip_runtime_api.h:180

hipDeviceProp_t::cooperativeMultiDeviceLaunch

int cooperativeMultiDeviceLaunch

Definition hip_runtime_api.h:198

hipDeviceProp_t::hostRegisterSupported

int hostRegisterSupported

Device supports hipHostRegister.

Definition hip_runtime_api.h:209

hipDeviceProp_t::pageableMemoryAccess

int pageableMemoryAccess

Definition hip_runtime_api.h:190

hipDeviceProp_t::name

char name[256]

Device name.

Definition hip_runtime_api.h:112

hipDeviceProp_t::textureAlignment

size_t textureAlignment

Alignment requirement for textures.

Definition hip_runtime_api.h:137

hipDeviceProp_t::globalL1CacheSupported

int globalL1CacheSupported

Indicates globals are cached in L1.

Definition hip_runtime_api.h:181

hipDeviceProp_t::hostNativeAtomicSupported

int hostNativeAtomicSupported

Link between host and device supports native atomics.

Definition hip_runtime_api.h:188

hipDeviceProp_t::maxSurfaceCubemapLayered

int maxSurfaceCubemapLayered[2]

Maximum cubemap layered surface size.

Definition hip_runtime_api.h:165

hipDeviceProp_t::maxTextureCubemapLayered

int maxTextureCubemapLayered[2]

Maximum cubemaps layered texture dims.

Definition hip_runtime_api.h:158

hipDeviceProp_t::sharedMemPerBlockOptin

size_t sharedMemPerBlockOptin

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

Definition hip_runtime_api.h:201

hipDeviceProp_t::sharedMemPerMultiprocessor

size_t sharedMemPerMultiprocessor

Amount of shared memory available per multiprocessor.

Definition hip_runtime_api.h:183

hipDeviceProp_t::singleToDoublePrecisionPerfRatio

int singleToDoublePrecisionPerfRatio

Deprecated. CUDA only.

Definition hip_runtime_api.h:189

hipDeviceProp_t::maxSurface2D

int maxSurface2D[2]

Maximum 2D surface size.

Definition hip_runtime_api.h:160

hipDeviceProp_t::memoryClockRate

int memoryClockRate

Max global memory clock frequency in khz.

Definition hip_runtime_api.h:175

hipDeviceProp_t::maxTexture2DLinear

int maxTexture2DLinear[3]

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

Definition hip_runtime_api.h:150

hipDeviceProp_t::sparseHipArraySupported

int sparseHipArraySupported

Indicates if device supports sparse hip arrays.

Definition hip_runtime_api.h:210

hipDeviceProp_t::clockInstructionRate

int clockInstructionRate

Definition hip_runtime_api.h:233

hipDeviceProp_t::localL1CacheSupported

int localL1CacheSupported

Locals are cahced in L1.

Definition hip_runtime_api.h:182

hipDeviceProp_t::regsPerMultiprocessor

int regsPerMultiprocessor

registers available per multiprocessor

Definition hip_runtime_api.h:184

hipDeviceProp_t::regsPerBlock

int regsPerBlock

Registers per block.

Definition hip_runtime_api.h:118

hipDeviceProp_t::maxTexture2D

int maxTexture2D[2]

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

Definition hip_runtime_api.h:148

hipDeviceProp_t::cooperativeLaunch

int cooperativeLaunch

HIP device supports cooperative launch.

Definition hip_runtime_api.h:197

hipDeviceProp_t::maxTexture3D

int maxTexture3D[3]

Definition hip_runtime_api.h:152

hipDeviceProp_t::directManagedMemAccessFromHost

int directManagedMemAccessFromHost

Definition hip_runtime_api.h:204

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedFunc

int cooperativeMultiDeviceUnmatchedFunc

Definition hip_runtime_api.h:238

hipDeviceProp_t::deviceOverlap

int deviceOverlap

Deprecated. Use asyncEngineCount instead.

Definition hip_runtime_api.h:139

hipDeviceProp_t::pageableMemoryAccessUsesHostPageTables

int pageableMemoryAccessUsesHostPageTables

Definition hip_runtime_api.h:202

hipDeviceProp_t::hdpRegFlushCntl

unsigned int * hdpRegFlushCntl

Addres of HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:237

hipDeviceProp_t::maxThreadsDim

int maxThreadsDim[3]

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

Definition hip_runtime_api.h:123

hipDeviceProp_t::unifiedAddressing

int unifiedAddressing

Does device and host share unified address space.

Definition hip_runtime_api.h:174

hipDeviceProp_t::multiGpuBoardGroupID

int multiGpuBoardGroupID

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

Definition hip_runtime_api.h:187

hipDeviceProp_t::isMultiGpuBoard

int isMultiGpuBoard

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

Definition hip_runtime_api.h:186

hipDeviceProp_t::canUseHostPointerForRegisteredMem

int canUseHostPointerForRegisteredMem

Definition hip_runtime_api.h:195

hipDeviceProp_t::maxTexture1DLayered

int maxTexture1DLayered[2]

Maximum number of elements in 1D array images.

Definition hip_runtime_api.h:156

hipDeviceProp_t::pciDomainID

int pciDomainID

PCI Domain ID.

Definition hip_runtime_api.h:171

hipDeviceProp_t::maxSharedMemoryPerMultiProcessor

size_t maxSharedMemoryPerMultiProcessor

Maximum Shared Memory Per CU. HIP Only.

Definition hip_runtime_api.h:232

hipDeviceProp_t::maxTextureCubemap

int maxTextureCubemap

Maximum cubemap texture dims.

Definition hip_runtime_api.h:155

hipDeviceProp_t::hipReserved

int hipReserved[32]

Reserved for adding new entries for HIP/CUDA.

Definition hip_runtime_api.h:228

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedGridDim

int cooperativeMultiDeviceUnmatchedGridDim

Definition hip_runtime_api.h:241

hipDeviceProp_t::gpuDirectRDMASupported

int gpuDirectRDMASupported

Indicates device support of RDMA APIs.

Definition hip_runtime_api.h:215

hipDeviceProp_t::minor

int minor

Definition hip_runtime_api.h:132

hipDeviceProp_t::gcnArchName

char gcnArchName[256]

AMD GCN Arch Name. HIP Only.

Definition hip_runtime_api.h:231

hipDeviceProp_t::luid

char luid[8]

8-byte unique identifier. Only valid on windows

Definition hip_runtime_api.h:114

hipDeviceProp_t::kernelExecTimeoutEnabled

int kernelExecTimeoutEnabled

Run time limit for kernels executed on the device.

Definition hip_runtime_api.h:141

hipDeviceProp_t::memoryPoolSupportedHandleTypes

unsigned int memoryPoolSupportedHandleTypes

Bitmask of handle types support with mempool based IPC.

Definition hip_runtime_api.h:220

hipDeviceProp_t::hdpMemFlushCntl

unsigned int * hdpMemFlushCntl

Addres of HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:236

hipDeviceProp_t::concurrentManagedAccess

int concurrentManagedAccess

Definition hip_runtime_api.h:192

hipDeviceProp_t::integrated

int integrated

APU vs dGPU.

Definition hip_runtime_api.h:142

hipDeviceProp_t::canMapHostMemory

int canMapHostMemory

Check whether HIP can map host memory.

Definition hip_runtime_api.h:143

hipDeviceProp_t::reservedSharedMemPerBlock

size_t reservedSharedMemPerBlock

Shared memory reserved by driver per block.

Definition hip_runtime_api.h:208

hipDeviceProp_t::maxSurfaceCubemap

int maxSurfaceCubemap

Maximum cubemap surface size.

Definition hip_runtime_api.h:164

hipDeviceProp_t::maxSurface3D

int maxSurface3D[3]

Maximum 3D surface size.

Definition hip_runtime_api.h:161

hipDeviceProp_t::asicRevision

int asicRevision

Revision of the GPU in this device.

Definition hip_runtime_api.h:251

hipDeviceProp_t::totalGlobalMem

size_t totalGlobalMem

Size of global memory region (in bytes).

Definition hip_runtime_api.h:116

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedBlockDim

int cooperativeMultiDeviceUnmatchedBlockDim

Definition hip_runtime_api.h:244

hipDeviceProp_t::maxSurface1DLayered

int maxSurface1DLayered[2]

Maximum 1D layered surface size.

Definition hip_runtime_api.h:162

hipDeviceProp_t::persistingL2CacheMaxSize

int persistingL2CacheMaxSize

Device's max L2 persisting lines in bytes.

Definition hip_runtime_api.h:178

hipDeviceProp_t::maxSurface1D

int maxSurface1D

Maximum 1D surface size.

Definition hip_runtime_api.h:159

hipDeviceProp_t::concurrentKernels

int concurrentKernels

Device can possibly execute multiple kernels concurrently.

Definition hip_runtime_api.h:167

hipDeviceProp_t::isLargeBar

int isLargeBar

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

Definition hip_runtime_api.h:250

hipDeviceProp_t::clusterLaunch

int clusterLaunch

Device supports cluster launch.

Definition hip_runtime_api.h:224

hipDeviceProp_t::maxTexture1DMipmap

int maxTexture1DMipmap

Maximum 1D mipmap texture size.

Definition hip_runtime_api.h:146

hipDeviceProp_t::multiProcessorCount

int multiProcessorCount

Number of multi-processors (compute units).

Definition hip_runtime_api.h:140

hipDeviceProp_t::maxTexture3DAlt

int maxTexture3DAlt[3]

Maximum alternate 3D texture dims.

Definition hip_runtime_api.h:154

hipDeviceProp_t::maxGridSize

int maxGridSize[3]

Max grid dimensions (XYZ).

Definition hip_runtime_api.h:124

hipDeviceProp_t::pciDeviceID

int pciDeviceID

PCI Device ID.

Definition hip_runtime_api.h:170

hipDeviceProp_t::maxBlocksPerMultiProcessor

int maxBlocksPerMultiProcessor

Max number of blocks on CU.

Definition hip_runtime_api.h:206

hipDeviceProp_t::computeMode

int computeMode

Compute mode.

Definition hip_runtime_api.h:144

hipDeviceProp_t::maxSurface2DLayered

int maxSurface2DLayered[3]

Maximum 2D layared surface size.

Definition hip_runtime_api.h:163

hipDeviceProp_t::major

int major

Definition hip_runtime_api.h:128

hipDeviceProp_t::warpSize

int warpSize

Warp size.

Definition hip_runtime_api.h:119

hipDeviceProp_t::tccDriver

int tccDriver

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

Definition hip_runtime_api.h:172

hipDeviceProp_t::luidDeviceNodeMask

unsigned int luidDeviceNodeMask

LUID node mask.

Definition hip_runtime_api.h:115

hipDeviceProp_t::hostRegisterReadOnlySupported

int hostRegisterReadOnlySupported

Definition hip_runtime_api.h:211

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedSharedMem

int cooperativeMultiDeviceUnmatchedSharedMem

Definition hip_runtime_api.h:247

hipDeviceProp_t::maxThreadsPerBlock

int maxThreadsPerBlock

Max work items per work group or workgroup max size.

Definition hip_runtime_api.h:122

hipDeviceProp_t::arch

hipDeviceArch_t arch

Architectural feature flags. New for HIP.

Definition hip_runtime_api.h:235

hipDeviceProp_t::managedMemory

int managedMemory

Device supports allocating managed memory on this system.

Definition hip_runtime_api.h:185

hipDeviceProp_t::texturePitchAlignment

size_t texturePitchAlignment

Pitch alignment requirement for texture references bound to.

Definition hip_runtime_api.h:138

hipEventRecordNodeParams

Definition hip_runtime_api.h:1846

hipEventRecordNodeParams::event

hipEvent_t event

The event to be recorded when node executes.

Definition hip_runtime_api.h:1847

hipEventWaitNodeParams

Definition hip_runtime_api.h:1839

hipEventWaitNodeParams::event

hipEvent_t event

Event to wait on.

Definition hip_runtime_api.h:1840

hipExtent

Definition driver_types.h:393

hipExternalMemoryBufferDesc

Definition hip_runtime_api.h:1311

hipExternalMemoryBufferDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1314

hipExternalMemoryBufferDesc::offset

unsigned long long offset

Definition hip_runtime_api.h:1312

hipExternalMemoryBufferDesc::size

unsigned long long size

Definition hip_runtime_api.h:1313

hipExternalMemoryHandleDesc

Definition hip_runtime_api.h:1297

hipExternalMemoryHandleDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1308

hipExternalMemoryHandleDesc::name

const void * name

Definition hip_runtime_api.h:1303

hipExternalMemoryHandleDesc::fd

int fd

Definition hip_runtime_api.h:1300

hipExternalMemoryHandleDesc::size

unsigned long long size

Definition hip_runtime_api.h:1307

hipExternalMemoryHandleDesc::type

hipExternalMemoryHandleType type

Definition hip_runtime_api.h:1298

hipExternalMemoryHandleDesc::nvSciBufObject

const void * nvSciBufObject

Definition hip_runtime_api.h:1305

hipExternalMemoryHandleDesc::handle

void * handle

Definition hip_runtime_api.h:1302

hipExternalMemoryMipmappedArrayDesc

Definition hip_runtime_api.h:1317

hipExternalMemoryMipmappedArrayDesc::extent

hipExtent extent

Definition hip_runtime_api.h:1320

hipExternalMemoryMipmappedArrayDesc::numLevels

unsigned int numLevels

Definition hip_runtime_api.h:1322

hipExternalMemoryMipmappedArrayDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1321

hipExternalMemoryMipmappedArrayDesc::offset

unsigned long long offset

Definition hip_runtime_api.h:1318

hipExternalMemoryMipmappedArrayDesc::formatDesc

hipChannelFormatDesc formatDesc

Definition hip_runtime_api.h:1319

hipExternalSemaphoreHandleDesc

Definition hip_runtime_api.h:1337

hipExternalSemaphoreHandleDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1347

hipExternalSemaphoreHandleDesc::name

const void * name

Definition hip_runtime_api.h:1343

hipExternalSemaphoreHandleDesc::NvSciSyncObj

const void * NvSciSyncObj

Definition hip_runtime_api.h:1345

hipExternalSemaphoreHandleDesc::type

hipExternalSemaphoreHandleType type

Definition hip_runtime_api.h:1338

hipExternalSemaphoreHandleDesc::handle

void * handle

Definition hip_runtime_api.h:1342

hipExternalSemaphoreHandleDesc::fd

int fd

Definition hip_runtime_api.h:1340

hipExternalSemaphoreSignalNodeParams

Definition hip_runtime_api.h:1724

hipExternalSemaphoreSignalNodeParams::paramsArray

const hipExternalSemaphoreSignalParams * paramsArray

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

Definition hip_runtime_api.h:1728

hipExternalSemaphoreSignalNodeParams::extSemArray

hipExternalSemaphore_t * extSemArray

< Array containing external semaphore handles.

Definition hip_runtime_api.h:1726

hipExternalSemaphoreSignalNodeParams::numExtSems

unsigned int numExtSems

Definition hip_runtime_api.h:1730

hipExternalSemaphoreSignalParams

Definition hip_runtime_api.h:1351

hipExternalSemaphoreSignalParams::reserved

unsigned long long reserved

Definition hip_runtime_api.h:1358

hipExternalSemaphoreSignalParams::value

unsigned long long value

Definition hip_runtime_api.h:1354

hipExternalSemaphoreSignalParams::fence

void * fence

Definition hip_runtime_api.h:1357

hipExternalSemaphoreSignalParams::flags

unsigned int flags

Definition hip_runtime_api.h:1365

hipExternalSemaphoreSignalParams::key

unsigned long long key

Definition hip_runtime_api.h:1361

hipExternalSemaphoreWaitNodeParams

Definition hip_runtime_api.h:1736

hipExternalSemaphoreWaitNodeParams::numExtSems

unsigned int numExtSems

Definition hip_runtime_api.h:1742

hipExternalSemaphoreWaitNodeParams::paramsArray

const hipExternalSemaphoreWaitParams * paramsArray

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

Definition hip_runtime_api.h:1740

hipExternalSemaphoreWaitNodeParams::extSemArray

hipExternalSemaphore_t * extSemArray

< Array containing external semaphore handles.

Definition hip_runtime_api.h:1738

hipExternalSemaphoreWaitParams

Definition hip_runtime_api.h:1371

hipExternalSemaphoreWaitParams::value

unsigned long long value

Definition hip_runtime_api.h:1374

hipExternalSemaphoreWaitParams::fence

void * fence

Definition hip_runtime_api.h:1377

hipExternalSemaphoreWaitParams::timeoutMs

unsigned int timeoutMs

Definition hip_runtime_api.h:1382

hipExternalSemaphoreWaitParams::key

unsigned long long key

Definition hip_runtime_api.h:1381

hipExternalSemaphoreWaitParams::flags

unsigned int flags

Definition hip_runtime_api.h:1386

hipExternalSemaphoreWaitParams::reserved

unsigned long long reserved

Definition hip_runtime_api.h:1378

hipFuncAttributes

Definition hip_runtime_api.h:692

hipFuncAttributes::cacheModeCA

int cacheModeCA

Definition hip_runtime_api.h:694

hipFuncAttributes::binaryVersion

int binaryVersion

Definition hip_runtime_api.h:693

hipFuncAttributes::constSizeBytes

size_t constSizeBytes

Definition hip_runtime_api.h:695

hipFuncAttributes::preferredShmemCarveout

int preferredShmemCarveout

Definition hip_runtime_api.h:700

hipFuncAttributes::sharedSizeBytes

size_t sharedSizeBytes

Definition hip_runtime_api.h:702

hipFuncAttributes::maxDynamicSharedSizeBytes

int maxDynamicSharedSizeBytes

Definition hip_runtime_api.h:697

hipFuncAttributes::ptxVersion

int ptxVersion

Definition hip_runtime_api.h:701

hipFuncAttributes::numRegs

int numRegs

Definition hip_runtime_api.h:699

hipFuncAttributes::localSizeBytes

size_t localSizeBytes

Definition hip_runtime_api.h:696

hipFuncAttributes::maxThreadsPerBlock

int maxThreadsPerBlock

Definition hip_runtime_api.h:698

hipFunctionLaunchParams

Definition hip_runtime_api.h:1275

hipFunctionLaunchParams::gridDimX

unsigned int gridDimX

Width(X) of grid in blocks.

Definition hip_runtime_api.h:1277

hipFunctionLaunchParams::blockDimX

unsigned int blockDimX

X dimension of each thread block.

Definition hip_runtime_api.h:1280

hipFunctionLaunchParams::function

hipFunction_t function

Kernel to launch.

Definition hip_runtime_api.h:1276

hipFunctionLaunchParams::hStream

hipStream_t hStream

Stream identifier.

Definition hip_runtime_api.h:1284

hipFunctionLaunchParams::blockDimY

unsigned int blockDimY

Y dimension of each thread block.

Definition hip_runtime_api.h:1281

hipFunctionLaunchParams::gridDimY

unsigned int gridDimY

Height(Y) of grid in blocks.

Definition hip_runtime_api.h:1278

hipFunctionLaunchParams::gridDimZ

unsigned int gridDimZ

Depth(Z) of grid in blocks.

Definition hip_runtime_api.h:1279

hipFunctionLaunchParams::sharedMemBytes

unsigned int sharedMemBytes

Shared memory.

Definition hip_runtime_api.h:1283

hipFunctionLaunchParams::blockDimZ

unsigned int blockDimZ

Z dimension of each thread block.

Definition hip_runtime_api.h:1282

hipFunctionLaunchParams::kernelParams

void ** kernelParams

Kernel parameters.

Definition hip_runtime_api.h:1285

hipGraphEdgeData

Definition hip_runtime_api.h:1903

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

hipGraphEdgeData::reserved

unsigned char reserved[5]

These bytes are unused and must be zeroed.

Definition hip_runtime_api.h:1912

hipGraphEdgeData::type

unsigned char type

This should be populated with a value from hipGraphDependencyType.

Definition hip_runtime_api.h:1915

hipGraphEdgeData::from_port

unsigned char from_port

Definition hip_runtime_api.h:1905

hipGraphInstantiateParams

Definition hip_runtime_api.h:1694

hipGraphInstantiateParams::result_out

hipGraphInstantiateResult result_out

Definition hip_runtime_api.h:1697

hipGraphInstantiateParams::uploadStream

hipStream_t uploadStream

Definition hip_runtime_api.h:1699

hipGraphInstantiateParams::errNode_out

hipGraphNode_t errNode_out

Definition hip_runtime_api.h:1695

hipGraphInstantiateParams::flags

unsigned long long flags

Definition hip_runtime_api.h:1696

hipGraphNodeParams

Definition hip_runtime_api.h:1860

hipGraphNodeParams::type

hipGraphNodeType type

Definition hip_runtime_api.h:1861

hipGraphNodeParams::reserved0

int reserved0[3]

Definition hip_runtime_api.h:1862

hipGraphNodeParams::alloc

hipMemAllocNodeParams alloc

Definition hip_runtime_api.h:1874

hipGraphNodeParams::reserved1

long long reserved1[29]

Definition hip_runtime_api.h:1864

hipGraphNodeParams::eventRecord

hipEventRecordNodeParams eventRecord

Definition hip_runtime_api.h:1871

hipGraphNodeParams::extSemSignal

hipExternalSemaphoreSignalNodeParams extSemSignal

Definition hip_runtime_api.h:1872

hipGraphNodeParams::free

hipMemFreeNodeParams free

Definition hip_runtime_api.h:1875

hipGraphNodeParams::graph

hipChildGraphNodeParams graph

Definition hip_runtime_api.h:1869

hipGraphNodeParams::extSemWait

hipExternalSemaphoreWaitNodeParams extSemWait

Definition hip_runtime_api.h:1873

hipGraphNodeParams::memset

hipMemsetParams memset

Definition hip_runtime_api.h:1867

hipGraphNodeParams::host

hipHostNodeParams host

Definition hip_runtime_api.h:1868

hipGraphNodeParams::reserved2

long long reserved2

Definition hip_runtime_api.h:1878

hipGraphNodeParams::kernel

hipKernelNodeParams kernel

Definition hip_runtime_api.h:1865

hipGraphNodeParams::eventWait

hipEventWaitNodeParams eventWait

Definition hip_runtime_api.h:1870

hipGraphNodeParams::memcpy

hipMemcpyNodeParams memcpy

Definition hip_runtime_api.h:1866

hipHostNodeParams

Definition hip_runtime_api.h:1457

hipHostNodeParams::fn

hipHostFn_t fn

Definition hip_runtime_api.h:1458

hipHostNodeParams::userData

void * userData

Definition hip_runtime_api.h:1459

hipIpcEventHandle_t

Definition hip_runtime_api.h:681

hipIpcMemHandle_t

Definition hip_runtime_api.h:678

hipKernelNodeParams

Definition hip_runtime_api.h:1461

hipKernelNodeParams::gridDim

dim3 gridDim

Definition hip_runtime_api.h:1465

hipKernelNodeParams::sharedMemBytes

unsigned int sharedMemBytes

Definition hip_runtime_api.h:1467

hipKernelNodeParams::blockDim

dim3 blockDim

Definition hip_runtime_api.h:1462

hipKernelNodeParams::kernelParams

void ** kernelParams

Definition hip_runtime_api.h:1466

hipKernelNodeParams::extra

void ** extra

Definition hip_runtime_api.h:1463

hipKernelNodeParams::func

void * func

Definition hip_runtime_api.h:1464

hipLaunchAttribute

Definition hip_runtime_api.h:1922

hipLaunchAttribute::val

hipLaunchAttributeValue val

Value associated with the launch attribute.

Definition hip_runtime_api.h:1926

hipLaunchAttribute::id

hipLaunchAttributeID id

Identifier of the launch attribute.

Definition hip_runtime_api.h:1923

hipLaunchAttribute::value

hipLaunchAttributeValue value

Value associated with the launch attribute.

Definition hip_runtime_api.h:1927

hipLaunchConfig_t

Definition hip_runtime_api.h:1934

hipLaunchConfig_t::blockDim

dim3 blockDim

Block dimensions.

Definition hip_runtime_api.h:1936

hipLaunchConfig_t::gridDim

dim3 gridDim

Grid dimensions.

Definition hip_runtime_api.h:1935

hipLaunchConfig_t::numAttrs

unsigned int numAttrs

Number of attributes.

Definition hip_runtime_api.h:1940

hipLaunchConfig_t::stream

hipStream_t stream

Stream identifier.

Definition hip_runtime_api.h:1938

hipLaunchConfig_t::dynamicSmemBytes

size_t dynamicSmemBytes

Dynamic shared-memory size per thread block.

Definition hip_runtime_api.h:1937

hipLaunchConfig_t::attrs

hipLaunchAttribute * attrs

Attributes list.

Definition hip_runtime_api.h:1939

hipLaunchMemSyncDomainMap

Definition hip_runtime_api.h:1512

hipLaunchMemSyncDomainMap::remote

unsigned char remote

Definition hip_runtime_api.h:1514

hipLaunchMemSyncDomainMap::default_

unsigned char default_

Definition hip_runtime_api.h:1513

hipLaunchParams

Definition hip_runtime_api.h:1264

hipLaunchParams::sharedMem

size_t sharedMem

Shared memory.

Definition hip_runtime_api.h:1269

hipLaunchParams::args

void ** args

Arguments.

Definition hip_runtime_api.h:1268

hipLaunchParams::blockDim

dim3 blockDim

Block dimensions.

Definition hip_runtime_api.h:1267

hipLaunchParams::gridDim

dim3 gridDim

Grid dimensions.

Definition hip_runtime_api.h:1266

hipLaunchParams::func

void * func

Device function symbol.

Definition hip_runtime_api.h:1265

hipLaunchParams::stream

hipStream_t stream

Stream identifier.

Definition hip_runtime_api.h:1270

hipMemAccessDesc

Definition hip_runtime_api.h:1177

hipMemAccessDesc::flags

hipMemAccessFlags flags

Accessibility flags to set.

Definition hip_runtime_api.h:1179

hipMemAccessDesc::location

hipMemLocation location

Location on which the accessibility has to change.

Definition hip_runtime_api.h:1178

hipMemAllocNodeParams

Definition hip_runtime_api.h:1478

hipMemAllocNodeParams::accessDescs

const hipMemAccessDesc * accessDescs

The number of memory access descriptors.

Definition hip_runtime_api.h:1481

hipMemAllocNodeParams::bytesize

size_t bytesize

The size of the requested allocation in bytes.

Definition hip_runtime_api.h:1484

hipMemAllocNodeParams::poolProps

hipMemPoolProps poolProps

Definition hip_runtime_api.h:1479

hipMemAllocNodeParams::accessDescCount

size_t accessDescCount

Definition hip_runtime_api.h:1482

hipMemAllocNodeParams::dptr

void * dptr

Returned device address of the allocation.

Definition hip_runtime_api.h:1485

hipMemAllocationProp

Definition hip_runtime_api.h:1706

hipMemAllocationProp::win32HandleMetaData

void * win32HandleMetaData

Metadata for Win32 handles.

Definition hip_runtime_api.h:1713

hipMemAllocationProp::type

hipMemAllocationType type

Memory allocation type.

Definition hip_runtime_api.h:1707

hipMemAllocationProp::allocFlags

struct hipMemAllocationProp::@33 allocFlags

hipMemAllocationProp::gpuDirectRDMACapable

unsigned char gpuDirectRDMACapable

RDMA capable.

Definition hip_runtime_api.h:1716

hipMemAllocationProp::requestedHandleTypes

hipMemAllocationHandleType requestedHandleTypes

Requested handle types.

Definition hip_runtime_api.h:1710

hipMemAllocationProp::usage

unsigned short usage

Usage.

Definition hip_runtime_api.h:1717

hipMemAllocationProp::requestedHandleType

hipMemAllocationHandleType requestedHandleType

Requested handle type.

Definition hip_runtime_api.h:1709

hipMemAllocationProp::location

hipMemLocation location

Memory location.

Definition hip_runtime_api.h:1712

hipMemAllocationProp::compressionType

unsigned char compressionType

Compression type.

Definition hip_runtime_api.h:1715

hipMemFreeNodeParams

Definition hip_runtime_api.h:1853

hipMemFreeNodeParams::dptr

void * dptr

the pointer to be freed

Definition hip_runtime_api.h:1854

hipMemLocation

Definition driver_types.h:464

hipMemPoolProps

Definition hip_runtime_api.h:1205

hipMemPoolProps::maxSize

size_t maxSize

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

Definition hip_runtime_api.h:1213

hipMemPoolProps::reserved

unsigned char reserved[56]

Reserved for future use, must be 0.

Definition hip_runtime_api.h:1214

hipMemPoolProps::location

hipMemLocation location

Location where allocations should reside.

Definition hip_runtime_api.h:1208

hipMemPoolProps::handleTypes

hipMemAllocationHandleType handleTypes

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

Definition hip_runtime_api.h:1207

hipMemPoolProps::allocType

hipMemAllocationType allocType

Allocation type. Currently must be specified as hipMemAllocationTypePinned.

Definition hip_runtime_api.h:1206

hipMemPoolProps::win32SecurityAttributes

void * win32SecurityAttributes

Definition hip_runtime_api.h:1212

hipMemPoolPtrExportData

Definition hip_runtime_api.h:1219

hipMemPoolPtrExportData::reserved

unsigned char reserved[64]

Definition hip_runtime_api.h:1220

hipMemcpy3DBatchOp

Definition driver_types.h:536

hipMemcpy3DParms

Definition driver_types.h:410

hipMemcpy3DPeerParms

Definition driver_types.h:545

hipMemcpyAttributes

Definition driver_types.h:491

hipMemcpyNodeParams

Definition hip_runtime_api.h:1822

hipMemcpyNodeParams::reserved

int reserved[3]

Must be zero.

Definition hip_runtime_api.h:1824

hipMemcpyNodeParams::flags

int flags

Must be zero.

Definition hip_runtime_api.h:1823

hipMemcpyNodeParams::copyParams

hipMemcpy3DParms copyParams

Params set for the memory copy.

Definition hip_runtime_api.h:1825

hipMemsetParams

Definition hip_runtime_api.h:1469

hipMemsetParams::dst

void * dst

Definition hip_runtime_api.h:1470

hipMemsetParams::value

unsigned int value

Definition hip_runtime_api.h:1474

hipMemsetParams::elementSize

unsigned int elementSize

Definition hip_runtime_api.h:1471

hipMemsetParams::width

size_t width

Definition hip_runtime_api.h:1475

hipMemsetParams::pitch

size_t pitch

Definition hip_runtime_api.h:1473

hipMemsetParams::height

size_t height

Definition hip_runtime_api.h:1472

hipMipmappedArray

Definition driver_types.h:137

hipPitchedPtr

Definition driver_types.h:384

hipPointerAttribute_t

Definition hip_runtime_api.h:277

hipPointerAttribute_t::device

int device

Definition hip_runtime_api.h:279

hipPointerAttribute_t::hostPointer

void * hostPointer

Definition hip_runtime_api.h:281

hipPointerAttribute_t::type

enum hipMemoryType type

Definition hip_runtime_api.h:278

hipPointerAttribute_t::isManaged

int isManaged

Definition hip_runtime_api.h:282

hipPointerAttribute_t::devicePointer

void * devicePointer

Definition hip_runtime_api.h:280

hipPointerAttribute_t::allocationFlags

unsigned allocationFlags

Definition hip_runtime_api.h:283

hipResourceDesc

Definition driver_types.h:285

hipResourceViewDesc

Definition driver_types.h:344

hipStreamBatchMemOpParams::hipStreamMemOpFlushRemoteWritesParams_t

Definition hip_runtime_api.h:999

hipStreamBatchMemOpParams::hipStreamMemOpFlushRemoteWritesParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:1001

hipStreamBatchMemOpParams::hipStreamMemOpFlushRemoteWritesParams_t::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:1000

hipStreamBatchMemOpParams::hipStreamMemOpMemoryBarrierParams_t

Definition hip_runtime_api.h:1003

hipStreamBatchMemOpParams::hipStreamMemOpMemoryBarrierParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:1005

hipStreamBatchMemOpParams::hipStreamMemOpMemoryBarrierParams_t::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:1004

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t

Definition hip_runtime_api.h:979

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:980

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::value64

uint64_t value64

Definition hip_runtime_api.h:984

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::address

hipDeviceptr_t address

Definition hip_runtime_api.h:981

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::alias

hipDeviceptr_t alias

Not valid for AMD backend. Initial value is unimportant.

Definition hip_runtime_api.h:987

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::value

uint32_t value

Definition hip_runtime_api.h:983

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:986

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t

Definition hip_runtime_api.h:989

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::address

hipDeviceptr_t address

Definition hip_runtime_api.h:991

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::alias

hipDeviceptr_t alias

Not valid for AMD backend. Initial value is unimportant.

Definition hip_runtime_api.h:997

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::value

uint32_t value

Definition hip_runtime_api.h:993

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:990

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:996

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::value64

uint64_t value64

Definition hip_runtime_api.h:994

hipTextureDesc

Definition texture_types.h:116

hipUUID

Definition hip_runtime_api.h:96

texture

Definition texture_types.h:147

textureReference

Definition texture_types.h:95

textureReference::channelDesc

struct hipChannelFormatDesc channelDesc

Definition texture_types.h:100

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

hipTextureAddressMode

hipTextureAddressMode

Definition texture_types.h:75

hipTextureFilterMode

hipTextureFilterMode

Definition texture_types.h:85

hipLaunchAttributeValue

Definition hip_runtime_api.h:1553

hipLaunchAttributeValue::priority

int priority

Value of launch attribute :: hipLaunchAttributePriority. Execution priority of kernel.

Definition hip_runtime_api.h:1557

hipLaunchAttributeValue::pad

char pad[64]

64 byte padding

Definition hip_runtime_api.h:1554

hipLaunchAttributeValue::memSyncDomain

hipLaunchMemSyncDomain memSyncDomain

Value of launch attribute hipLaunchAttributeMemSyncDomain.

Definition hip_runtime_api.h:1560

hipLaunchAttributeValue::cooperative

int cooperative

Value of launch attribute hipLaunchAttributeCooperative. Indicates whether the kernel is cooperative.

Definition hip_runtime_api.h:1556

hipLaunchAttributeValue::accessPolicyWindow

hipAccessPolicyWindow accessPolicyWindow

Value of launch attribute hipLaunchAttributeAccessPolicyWindow.

Definition hip_runtime_api.h:1555

hipLaunchAttributeValue::syncPolicy

hipSynchronizationPolicy syncPolicy

Value of launch attribute :: hipLaunchAttributeSynchronizationPolicy. Used to work queued up in strea...

Definition hip_runtime_api.h:1558

hipLaunchAttributeValue::memSyncDomainMap

hipLaunchMemSyncDomainMap memSyncDomainMap

Value of launch attribute hipLaunchAttributeMemSyncDomainMap.

Definition hip_runtime_api.h:1559

hipStreamBatchMemOpParams

Union representing batch memory operation parameters for HIP streams.

Definition hip_runtime_api.h:977

hipStreamBatchMemOpParams::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:978