include/hip/hip_runtime_api.h Source File

• include
• hip

hip_runtime_api.h

Go to the documentation of this file.

1/*

2 * Copyright (c) Advanced Micro Devices, Inc., or its affiliates.

3 *

4 * SPDX-License-Identifier: MIT

5 */

6

15#ifndef HIP_INCLUDE_HIP_HIP_RUNTIME_API_H

16#define HIP_INCLUDE_HIP_HIP_RUNTIME_API_H

17

18#if __cplusplus

19#include <climits>

20#include <cstdint>

21#include <cstdlib>

22#include <utility>

23#else

24#include <limits.h>

25#include <stdint.h>

26#include <stdlib.h>

27#endif

28

29#include <hip/hip_version.h>

30#include <hip/hip_common.h>

31#include <hip/linker_types.h>

32

33enum {

34 HIP_SUCCESS = 0,

35 HIP_ERROR_INVALID_VALUE,

36 HIP_ERROR_NOT_INITIALIZED,

37 HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

38};

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

49typedef struct {

50 // 32-bit Atomics

51 unsigned hasGlobalInt32Atomics : 1;

52 unsigned hasGlobalFloatAtomicExch : 1;

53 unsigned hasSharedInt32Atomics : 1;

54 unsigned hasSharedFloatAtomicExch : 1;

55 unsigned hasFloatAtomicAdd : 1;

56

57 // 64-bit Atomics

58 unsigned hasGlobalInt64Atomics : 1;

59 unsigned hasSharedInt64Atomics : 1;

60

61 // Doubles

62 unsigned hasDoubles : 1;

63

64 // Warp cross-lane operations

65 unsigned hasWarpVote : 1;

66 unsigned hasWarpBallot : 1;

67 unsigned hasWarpShuffle : 1;

68 unsigned hasFunnelShift : 1;

69

70 // Sync

71 unsigned hasThreadFenceSystem : 1;

72 unsigned hasSyncThreadsExt : 1;

73

74 // Misc

75 unsigned hasSurfaceFuncs : 1;

76 unsigned has3dGrid : 1;

77 unsigned hasDynamicParallelism : 1;

78} hipDeviceArch_t;

79

80typedef struct hipUUID_t {

81 char bytes[16];

82} hipUUID;

83

84//---

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

86

87#define hipGetDeviceProperties hipGetDevicePropertiesR0600

88#define hipDeviceProp_t hipDeviceProp_tR0600

89#define hipChooseDevice hipChooseDeviceR0600

90

95typedef struct hipDeviceProp_t {

96 char name[256];

97 hipUUID uuid;

98 char luid[8];

99 unsigned int luidDeviceNodeMask;

100 size_t totalGlobalMem;

101 size_t sharedMemPerBlock;

102 int regsPerBlock;

103 int warpSize;

104 size_t memPitch;

106 int maxThreadsPerBlock;

107 int maxThreadsDim[3];

108 int maxGridSize[3];

109 int clockRate;

110 size_t totalConstMem;

112 int major;

116 int minor;

121 size_t textureAlignment;

122 size_t texturePitchAlignment;

123 int deviceOverlap;

124 int multiProcessorCount;

128 int kernelExecTimeoutEnabled;

129 int integrated;

130 int canMapHostMemory;

131 int computeMode;

132 int maxTexture1D;

133 int maxTexture1DMipmap;

134 int maxTexture1DLinear;

135 int maxTexture2D[2];

136 int maxTexture2DMipmap[2];

137 int maxTexture2DLinear[3];

138 int maxTexture2DGather[2];

139 int maxTexture3D[3];

141 int maxTexture3DAlt[3];

142 int maxTextureCubemap;

143 int maxTexture1DLayered[2];

144 int maxTexture2DLayered[3];

145 int maxTextureCubemapLayered[2];

146 int maxSurface1D;

147 int maxSurface2D[2];

148 int maxSurface3D[3];

149 int maxSurface1DLayered[2];

150 int maxSurface2DLayered[3];

151 int maxSurfaceCubemap;

152 int maxSurfaceCubemapLayered[2];

153 size_t surfaceAlignment;

154 int concurrentKernels;

155 int ECCEnabled;

156 int pciBusID;

157 int pciDeviceID;

158 int pciDomainID;

159 int tccDriver;

160 int asyncEngineCount;

161 int unifiedAddressing;

162 int memoryClockRate;

163 int memoryBusWidth;

164 int l2CacheSize;

165 int persistingL2CacheMaxSize;

166 int maxThreadsPerMultiProcessor;

167 int streamPrioritiesSupported;

168 int globalL1CacheSupported;

169 int localL1CacheSupported;

170 size_t sharedMemPerMultiprocessor;

171 int regsPerMultiprocessor;

172 int managedMemory;

173 int isMultiGpuBoard;

174 int multiGpuBoardGroupID;

175 int hostNativeAtomicSupported;

176 int singleToDoublePrecisionPerfRatio;

177 int pageableMemoryAccess;

179 int concurrentManagedAccess;

181 int computePreemptionSupported;

182 int canUseHostPointerForRegisteredMem;

184 int cooperativeLaunch;

185 int cooperativeMultiDeviceLaunch;

187 size_t sharedMemPerBlockOptin;

188 int pageableMemoryAccessUsesHostPageTables;

190 int directManagedMemAccessFromHost;

192 int maxBlocksPerMultiProcessor;

193 int accessPolicyMaxWindowSize;

194 size_t reservedSharedMemPerBlock;

195 int hostRegisterSupported;

196 int sparseHipArraySupported;

197 int hostRegisterReadOnlySupported;

199 int timelineSemaphoreInteropSupported;

200 int memoryPoolsSupported;

201 int gpuDirectRDMASupported;

202 unsigned int gpuDirectRDMAFlushWritesOptions;

204 int gpuDirectRDMAWritesOrdering;

205 unsigned int

206 memoryPoolSupportedHandleTypes;

207 int deferredMappingHipArraySupported;

209 int ipcEventSupported;

210 int clusterLaunch;

211 int unifiedFunctionPointers;

212 int reserved[63];

213

214 int hipReserved[32];

215

216 /* HIP Only struct members */

217 char gcnArchName[256];

218 size_t maxSharedMemoryPerMultiProcessor;

219 int clockInstructionRate;

221 hipDeviceArch_t arch;

222 unsigned int* hdpMemFlushCntl;

223 unsigned int* hdpRegFlushCntl;

224 int cooperativeMultiDeviceUnmatchedFunc;

227 int cooperativeMultiDeviceUnmatchedGridDim;

230 int cooperativeMultiDeviceUnmatchedBlockDim;

233 int cooperativeMultiDeviceUnmatchedSharedMem;

236 int isLargeBar;

237 int asicRevision;

238} hipDeviceProp_t;

239

247typedef enum hipMemoryType {

248 hipMemoryTypeUnregistered = 0,

249 hipMemoryTypeHost = 1,

250 hipMemoryTypeDevice = 2,

252 hipMemoryTypeManaged = 3,

255 hipMemoryTypeArray = 10,

257 hipMemoryTypeUnified = 11

258

259} hipMemoryType;

260

264typedef struct hipPointerAttribute_t {

265 enum hipMemoryType type;

266 int device;

267 void* devicePointer;

268 void* hostPointer;

269 int isManaged;

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

271 /* peers? */

272} hipPointerAttribute_t;

273

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

275// we can make that yield a warning

276#if __cplusplus >= 201703L

277#define __HIP_NODISCARD [[nodiscard]]

278#else

279#define __HIP_NODISCARD

280#endif

281

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

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

288

289typedef enum __HIP_NODISCARD hipError_t {

290 hipSuccess = 0,

291 hipErrorInvalidValue = 1,

293 hipErrorOutOfMemory = 2,

294 // Deprecated

295 hipErrorMemoryAllocation = 2,

296 hipErrorNotInitialized = 3,

297 // Deprecated

298 hipErrorInitializationError = 3,

299 hipErrorDeinitialized = 4,

300 hipErrorProfilerDisabled = 5,

301 hipErrorProfilerNotInitialized = 6,

302 hipErrorProfilerAlreadyStarted = 7,

303 hipErrorProfilerAlreadyStopped = 8,

304 hipErrorInvalidConfiguration = 9,

305 hipErrorInvalidPitchValue = 12,

306 hipErrorInvalidSymbol = 13,

307 hipErrorInvalidDevicePointer = 17,

308 hipErrorInvalidMemcpyDirection = 21,

309 hipErrorInsufficientDriver = 35,

310 hipErrorMissingConfiguration = 52,

311 hipErrorPriorLaunchFailure = 53,

312 hipErrorInvalidDeviceFunction = 98,

313 hipErrorNoDevice = 100,

314 hipErrorInvalidDevice = 101,

315 hipErrorInvalidImage = 200,

316 hipErrorInvalidContext = 201,

317 hipErrorContextAlreadyCurrent = 202,

318 hipErrorMapFailed = 205,

319 // Deprecated

320 hipErrorMapBufferObjectFailed = 205,

321 hipErrorUnmapFailed = 206,

322 hipErrorArrayIsMapped = 207,

323 hipErrorAlreadyMapped = 208,

324 hipErrorNoBinaryForGpu = 209,

325 hipErrorAlreadyAcquired = 210,

326 hipErrorNotMapped = 211,

327 hipErrorNotMappedAsArray = 212,

328 hipErrorNotMappedAsPointer = 213,

329 hipErrorECCNotCorrectable = 214,

330 hipErrorUnsupportedLimit = 215,

331 hipErrorContextAlreadyInUse = 216,

332 hipErrorPeerAccessUnsupported = 217,

333 hipErrorInvalidKernelFile = 218,

334 hipErrorInvalidGraphicsContext = 219,

335 hipErrorInvalidSource = 300,

336 hipErrorFileNotFound = 301,

337 hipErrorSharedObjectSymbolNotFound = 302,

338 hipErrorSharedObjectInitFailed = 303,

339 hipErrorOperatingSystem = 304,

340 hipErrorInvalidHandle = 400,

341 // Deprecated

342 hipErrorInvalidResourceHandle = 400,

343 hipErrorIllegalState = 401,

344 hipErrorNotFound = 500,

345 hipErrorNotReady = 600,

349 hipErrorIllegalAddress = 700,

350 hipErrorLaunchOutOfResources = 701,

351 hipErrorLaunchTimeOut = 702,

352 hipErrorPeerAccessAlreadyEnabled = 704,

354 hipErrorPeerAccessNotEnabled = 705,

355 hipErrorSetOnActiveProcess = 708,

356 hipErrorContextIsDestroyed = 709,

357 hipErrorAssert = 710,

358 hipErrorHostMemoryAlreadyRegistered = 712,

360 hipErrorHostMemoryNotRegistered = 713,

362 hipErrorLaunchFailure = 719,

363 hipErrorCooperativeLaunchTooLarge = 720,

367 hipErrorNotSupported = 801,

368 hipErrorStreamCaptureUnsupported = 900,

370 hipErrorStreamCaptureInvalidated = 901,

372 hipErrorStreamCaptureMerge = 902,

374 hipErrorStreamCaptureUnmatched = 903,

375 hipErrorStreamCaptureUnjoined = 904,

377 hipErrorStreamCaptureIsolation = 905,

381 hipErrorStreamCaptureImplicit = 906,

384 hipErrorCapturedEvent = 907,

386 hipErrorStreamCaptureWrongThread = 908,

390 hipErrorGraphExecUpdateFailure = 910,

394 hipErrorInvalidChannelDescriptor = 911,

395 hipErrorInvalidTexture = 912,

396 hipErrorUnknown = 999,

397 // HSA Runtime Error Codes start here.

398 hipErrorRuntimeMemory = 1052,

400 hipErrorRuntimeOther = 1053,

402 hipErrorTbd

403} hipError_t;

404

405#undef __HIP_NODISCARD

406

411typedef enum hipDeviceAttribute_t {

412 hipDeviceAttributeCudaCompatibleBegin = 0,

413

414 hipDeviceAttributeEccEnabled =

415 hipDeviceAttributeCudaCompatibleBegin,

416 hipDeviceAttributeAccessPolicyMaxWindowSize,

418 hipDeviceAttributeAsyncEngineCount,

419 hipDeviceAttributeCanMapHostMemory,

421 hipDeviceAttributeCanUseHostPointerForRegisteredMem,

424 hipDeviceAttributeClockRate,

425 hipDeviceAttributeComputeMode,

426 hipDeviceAttributeComputePreemptionSupported,

427 hipDeviceAttributeConcurrentKernels,

429 hipDeviceAttributeConcurrentManagedAccess,

431 hipDeviceAttributeCooperativeLaunch,

432 hipDeviceAttributeCooperativeMultiDeviceLaunch,

434 hipDeviceAttributeDeviceOverlap,

436 hipDeviceAttributeDirectManagedMemAccessFromHost,

438 hipDeviceAttributeGlobalL1CacheSupported,

439 hipDeviceAttributeHostNativeAtomicSupported,

441 hipDeviceAttributeIntegrated,

442 hipDeviceAttributeIsMultiGpuBoard,

443 hipDeviceAttributeKernelExecTimeout,

444 hipDeviceAttributeL2CacheSize,

446 hipDeviceAttributeLocalL1CacheSupported,

447 hipDeviceAttributeLuid,

449 hipDeviceAttributeLuidDeviceNodeMask,

451 hipDeviceAttributeComputeCapabilityMajor,

452 hipDeviceAttributeManagedMemory,

453 hipDeviceAttributeMaxBlocksPerMultiProcessor,

454 hipDeviceAttributeMaxBlockDimX,

455 hipDeviceAttributeMaxBlockDimY,

456 hipDeviceAttributeMaxBlockDimZ,

457 hipDeviceAttributeMaxGridDimX,

458 hipDeviceAttributeMaxGridDimY,

459 hipDeviceAttributeMaxGridDimZ,

460 hipDeviceAttributeMaxSurface1D,

461 hipDeviceAttributeMaxSurface1DLayered,

462 hipDeviceAttributeMaxSurface2D,

463 hipDeviceAttributeMaxSurface2DLayered,

464 hipDeviceAttributeMaxSurface3D,

465 hipDeviceAttributeMaxSurfaceCubemap,

466 hipDeviceAttributeMaxSurfaceCubemapLayered,

468 hipDeviceAttributeMaxTexture1DWidth,

469 hipDeviceAttributeMaxTexture1DLayered,

470 hipDeviceAttributeMaxTexture1DLinear,

473 hipDeviceAttributeMaxTexture1DMipmap,

474 hipDeviceAttributeMaxTexture2DWidth,

475 hipDeviceAttributeMaxTexture2DHeight,

476 hipDeviceAttributeMaxTexture2DGather,

478 hipDeviceAttributeMaxTexture2DLayered,

479 hipDeviceAttributeMaxTexture2DLinear,

481 hipDeviceAttributeMaxTexture2DMipmap,

482 hipDeviceAttributeMaxTexture3DWidth,

483 hipDeviceAttributeMaxTexture3DHeight,

484 hipDeviceAttributeMaxTexture3DDepth,

485 hipDeviceAttributeMaxTexture3DAlt,

486 hipDeviceAttributeMaxTextureCubemap,

487 hipDeviceAttributeMaxTextureCubemapLayered,

488 hipDeviceAttributeMaxThreadsDim,

489 hipDeviceAttributeMaxThreadsPerBlock,

490 hipDeviceAttributeMaxThreadsPerMultiProcessor,

491 hipDeviceAttributeMaxPitch,

492 hipDeviceAttributeMemoryBusWidth,

493 hipDeviceAttributeMemoryClockRate,

494 hipDeviceAttributeComputeCapabilityMinor,

495 hipDeviceAttributeMultiGpuBoardGroupID,

497 hipDeviceAttributeMultiprocessorCount,

501 hipDeviceAttributeUnused1,

502 hipDeviceAttributePageableMemoryAccess,

504 hipDeviceAttributePageableMemoryAccessUsesHostPageTables,

506 hipDeviceAttributePciBusId,

507 hipDeviceAttributePciDeviceId,

508 hipDeviceAttributePciDomainId,

509 hipDeviceAttributePciDomainID =

510 hipDeviceAttributePciDomainId,

511 hipDeviceAttributePersistingL2CacheMaxSize,

512 hipDeviceAttributeMaxRegistersPerBlock,

515 hipDeviceAttributeMaxRegistersPerMultiprocessor,

516 hipDeviceAttributeReservedSharedMemPerBlock,

518 hipDeviceAttributeMaxSharedMemoryPerBlock,

520 hipDeviceAttributeSharedMemPerBlockOptin,

522 hipDeviceAttributeSharedMemPerMultiprocessor,

523 hipDeviceAttributeSingleToDoublePrecisionPerfRatio,

525 hipDeviceAttributeStreamPrioritiesSupported,

526 hipDeviceAttributeSurfaceAlignment,

527 hipDeviceAttributeTccDriver,

528 hipDeviceAttributeTextureAlignment,

529 hipDeviceAttributeTexturePitchAlignment,

531 hipDeviceAttributeTotalConstantMemory,

532 hipDeviceAttributeTotalGlobalMem,

533 hipDeviceAttributeUnifiedAddressing,

535 hipDeviceAttributeUnused2,

536 hipDeviceAttributeWarpSize,

537 hipDeviceAttributeMemoryPoolsSupported,

538 hipDeviceAttributeVirtualMemoryManagementSupported,

540 hipDeviceAttributeHostRegisterSupported,

542 hipDeviceAttributeMemoryPoolSupportedHandleTypes,

544 hipDeviceAttributeHostNumaId,

546 hipDeviceAttributeDmaBufSupported,

547

548 hipDeviceAttributeCudaCompatibleEnd = 9999,

549 hipDeviceAttributeAmdSpecificBegin = 10000,

550

551 hipDeviceAttributeClockInstructionRate =

552 hipDeviceAttributeAmdSpecificBegin,

554 hipDeviceAttributeUnused3,

555 hipDeviceAttributeMaxSharedMemoryPerMultiprocessor,

556 hipDeviceAttributeUnused4,

557 hipDeviceAttributeUnused5,

558 hipDeviceAttributeHdpMemFlushCntl,

559 hipDeviceAttributeHdpRegFlushCntl,

560 hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc,

563 hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim,

566 hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim,

569 hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem,

572 hipDeviceAttributeIsLargeBar,

573 hipDeviceAttributeAsicRevision,

574 hipDeviceAttributeCanUseStreamWaitValue,

576 hipDeviceAttributeImageSupport,

577 hipDeviceAttributePhysicalMultiProcessorCount,

579 hipDeviceAttributeFineGrainSupport,

580 hipDeviceAttributeWallClockRate,

581 hipDeviceAttributeNumberOfXccs,

582 hipDeviceAttributeMaxAvailableVgprsPerThread,

585 hipDeviceAttributePciChipId,

586 hipDeviceAttributeExpertSchedMode,

588

589 hipDeviceAttributeAmdSpecificEnd = 19999,

590 hipDeviceAttributeVendorSpecificBegin = 20000,

591 // Extended attributes for vendors

592} hipDeviceAttribute_t;

593

594// Flags that can be used with hipGetProcAddress.

598#define HIP_GET_PROC_ADDRESS_DEFAULT 0x0

599

601#define HIP_GET_PROC_ADDRESS_LEGACY_STREAM 0x1

602

605#define HIP_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM 0x2

606

607typedef enum hipDriverProcAddressQueryResult {

608 HIP_GET_PROC_ADDRESS_SUCCESS = 0,

609 HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND = 1,

610 HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT = 2

611} hipDriverProcAddressQueryResult;

612

613enum hipComputeMode {

614 hipComputeModeDefault = 0,

615 hipComputeModeExclusive = 1,

616 hipComputeModeProhibited = 2,

617 hipComputeModeExclusiveProcess = 3

618};

619

620enum hipFlushGPUDirectRDMAWritesOptions {

621 hipFlushGPUDirectRDMAWritesOptionHost = 1 << 0,

622 hipFlushGPUDirectRDMAWritesOptionMemOps = 1 << 1

623};

624

625enum hipGPUDirectRDMAWritesOrdering {

626 hipGPUDirectRDMAWritesOrderingNone = 0,

627 hipGPUDirectRDMAWritesOrderingOwner = 100,

628 hipGPUDirectRDMAWritesOrderingAllDevices = 200

629};

630

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

632

633#ifndef GENERIC_GRID_LAUNCH

634#define GENERIC_GRID_LAUNCH 1

635#endif

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

637#include <hip/driver_types.h>

638#include <hip/texture_types.h>

639#include <hip/surface_types.h>

640#if defined(_MSC_VER)

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

642#else // !defined(_MSC_VER)

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

644#endif // !defined(_MSC_VER)

645#define HIP_DEPRECATED_MSG \

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

647 "details please refer " \

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

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

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

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

652#ifdef __cplusplus

653#define __dparm(x) = x

654#else

655#define __dparm(x)

656#endif

657#ifdef __GNUC__

658#pragma GCC visibility push(default)

659#endif

660#ifdef __cplusplus

661namespace hip_impl {

662hipError_t hip_init();

663} // namespace hip_impl

664#endif

665// Structure definitions:

666#ifdef __cplusplus

667extern "C" {

668#endif

669//---

670// API-visible structures

671typedef struct ihipCtx_t* hipCtx_t;

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

673typedef int hipDevice_t;

674typedef enum hipDeviceP2PAttr {

675 hipDevP2PAttrPerformanceRank = 0,

676 hipDevP2PAttrAccessSupported,

677 hipDevP2PAttrNativeAtomicSupported,

678 hipDevP2PAttrHipArrayAccessSupported

679} hipDeviceP2PAttr;

680typedef enum hipDriverEntryPointQueryResult {

681 hipDriverEntryPointSuccess = 0,

682 hipDriverEntryPointSymbolNotFound = 1,

683 hipDriverEntryPointVersionNotSufficent = 2

684} hipDriverEntryPointQueryResult;

685typedef struct ihipStream_t* hipStream_t;

686#define hipIpcMemLazyEnablePeerAccess 0x01

687#define HIP_IPC_HANDLE_SIZE 64

688typedef struct hipIpcMemHandle_st {

689 char reserved[HIP_IPC_HANDLE_SIZE];

690} hipIpcMemHandle_t;

691typedef struct hipIpcEventHandle_st {

692 char reserved[HIP_IPC_HANDLE_SIZE];

693} hipIpcEventHandle_t;

694typedef struct ihipModule_t* hipModule_t;

695typedef struct ihipModuleSymbol_t* hipFunction_t;

696typedef struct ihipLinkState_t* hipLinkState_t;

697typedef struct ihipLibrary_t* hipLibrary_t;

698typedef struct ihipKernel_t* hipKernel_t;

702typedef struct ihipMemPoolHandle_t* hipMemPool_t;

703

704typedef struct hipFuncAttributes {

705 int binaryVersion;

706 int cacheModeCA;

707 size_t constSizeBytes;

708 size_t localSizeBytes;

709 int maxDynamicSharedSizeBytes;

710 int maxThreadsPerBlock;

711 int numRegs;

712 int preferredShmemCarveout;

713 int ptxVersion;

714 size_t sharedSizeBytes;

715} hipFuncAttributes;

716typedef struct ihipEvent_t* hipEvent_t;

717

724enum hipLimit_t {

725 hipLimitStackSize = 0x0,

728 hipLimitPrintfFifoSize = 0x01,

730 hipLimitMallocHeapSize = 0x02,

732 hipExtLimitScratchMin = 0x1000,

734 hipExtLimitScratchMax = 0x1001,

736 hipExtLimitScratchCurrent = 0x1002,

740 hipLimitRange

741};

742

746// Flags that can be used with hipStreamCreateWithFlags.

748#define hipStreamDefault 0x00

749

751#define hipStreamNonBlocking 0x01

752

753// Flags that can be used with hipEventCreateWithFlags.

755#define hipEventDefault 0x0

756

758#define hipEventBlockingSync 0x1

759

761#define hipEventDisableTiming 0x2

762

764#define hipEventInterprocess 0x4

765

766// Flags that can be used with hipEventRecordWithFlags.

768#define hipEventRecordDefault 0x00

769

771#define hipEventRecordExternal 0x01

772

773//Flags that can be used with hipStreamWaitEvent.

775#define hipEventWaitDefault 0x00

776

778#define hipEventWaitExternal 0x01

779

788#define hipEventDisableSystemFence 0x20000000

789

792#define hipEventReleaseToDevice 0x40000000

793

796#define hipEventReleaseToSystem 0x80000000

797

798// Flags that can be used with hipGetDriverEntryPoint.

802#define hipEnableDefault 0x0

803

805#define hipEnableLegacyStream 0x1

806

809#define hipEnablePerThreadDefaultStream 0x2

810

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

813#define hipHostAllocDefault 0x0

814

817#define hipHostMallocDefault 0x0

818

820#define hipHostAllocPortable 0x1

821

824#define hipHostMallocPortable 0x1

825

828#define hipHostAllocMapped 0x2

829

833#define hipHostMallocMapped 0x2

834

840#define hipHostAllocWriteCombined 0x4

841

848#define hipHostMallocWriteCombined 0x4

849

855#define hipHostMallocUncached 0x10000000

856#define hipHostAllocUncached hipHostMallocUncached

857

862#define hipHostMallocNumaUser 0x20000000

863

865#define hipHostMallocCoherent 0x40000000

866

868#define hipHostMallocNonCoherent 0x80000000

869

871#define hipMemAttachGlobal 0x01

872

874#define hipMemAttachHost 0x02

875

877#define hipMemAttachSingle 0x04

878

879#define hipDeviceMallocDefault 0x0

880

882#define hipDeviceMallocFinegrained 0x1

883

885#define hipMallocSignalMemory 0x2

886

888#define hipDeviceMallocUncached 0x3

889

891#define hipDeviceMallocContiguous 0x4

892

893// Flags that can be used with hipHostRegister.

895#define hipHostRegisterDefault 0x0

896

898#define hipHostRegisterPortable 0x1

899

902#define hipHostRegisterMapped 0x2

903

908#define hipHostRegisterIoMemory 0x4

909

911#define hipHostRegisterReadOnly 0x08

912

914#define hipExtHostRegisterCoarseGrained 0x8

915

919#define hipExtHostRegisterUncached 0x80000000

920

922#define hipDeviceScheduleAuto 0x0

923

926#define hipDeviceScheduleSpin 0x1

927

930#define hipDeviceScheduleYield 0x2

931#define hipDeviceScheduleBlockingSync 0x4

932#define hipDeviceScheduleMask 0x7

933#define hipDeviceMapHost 0x8

934#define hipDeviceLmemResizeToMax 0x10

936#define hipArrayDefault 0x00

937#define hipArrayLayered 0x01

938#define hipArraySurfaceLoadStore 0x02

939#define hipArrayCubemap 0x04

940#define hipArrayTextureGather 0x08

941#define hipOccupancyDefault 0x00

942#define hipOccupancyDisableCachingOverride 0x01

943#define hipCooperativeLaunchMultiDeviceNoPreSync 0x01

944#define hipCooperativeLaunchMultiDeviceNoPostSync 0x02

945#define hipCpuDeviceId ((int)-1)

946#define hipInvalidDeviceId ((int)-2)

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

949#define hipExtAnyOrderLaunch 0x01

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

951#define hipStreamWaitValueGte 0x0

952#define hipStreamWaitValueEq 0x1

953#define hipStreamWaitValueAnd 0x2

954#define hipStreamWaitValueNor 0x3

955

957typedef enum hipStreamBatchMemOpType {

958 hipStreamMemOpWaitValue32 = 0x1,

959 hipStreamMemOpWriteValue32 = 0x2,

960 hipStreamMemOpWaitValue64 = 0x4,

961 hipStreamMemOpWriteValue64 = 0x5,

962 hipStreamMemOpBarrier = 0x6,

963 hipStreamMemOpFlushRemoteWrites = 0x3

964} hipStreamBatchMemOpType;

965

1002typedef union hipStreamBatchMemOpParams_union {

1003 hipStreamBatchMemOpType operation;

1004 struct hipStreamMemOpWaitValueParams_t {

1005 hipStreamBatchMemOpType operation;

1006 hipDeviceptr_t address;

1007 union {

1008 uint32_t value;

1009 uint64_t value64;

1010 };

1011 unsigned int flags;

1012 hipDeviceptr_t alias;

1013 } waitValue;

1014 struct hipStreamMemOpWriteValueParams_t {

1015 hipStreamBatchMemOpType operation;

1016 hipDeviceptr_t address;

1017 union {

1018 uint32_t value;

1019 uint64_t value64;

1020 };

1021 unsigned int flags;

1022 hipDeviceptr_t alias;

1023 } writeValue;

1024 struct hipStreamMemOpFlushRemoteWritesParams_t {

1025 hipStreamBatchMemOpType operation;

1026 unsigned int flags;

1027 } flushRemoteWrites;

1028 struct hipStreamMemOpMemoryBarrierParams_t {

1029 hipStreamBatchMemOpType operation;

1030 unsigned int flags;

1031 } memoryBarrier;

1032 uint64_t pad[6];

1033} hipStreamBatchMemOpParams;

1034

1062typedef struct hipBatchMemOpNodeParams {

1063 hipCtx_t ctx;

1064 unsigned int count;

1065 hipStreamBatchMemOpParams* paramArray;

1066 unsigned int flags;

1067} hipBatchMemOpNodeParams;

1068

1069// Stream per thread

1071#define hipStreamPerThread ((hipStream_t)2)

1072

1073#define hipStreamLegacy ((hipStream_t)1)

1074

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

1076#define hipExternalMemoryDedicated 0x1

1082typedef enum hipMemoryAdvise {

1083 hipMemAdviseSetReadMostly = 1,

1085 hipMemAdviseUnsetReadMostly = 2,

1086 hipMemAdviseSetPreferredLocation = 3,

1088 hipMemAdviseUnsetPreferredLocation = 4,

1089 hipMemAdviseSetAccessedBy = 5,

1091 hipMemAdviseUnsetAccessedBy = 6,

1093 hipMemAdviseSetCoarseGrain = 100,

1098 hipMemAdviseUnsetCoarseGrain = 101

1099} hipMemoryAdvise;

1103typedef enum hipMemRangeCoherencyMode {

1104 hipMemRangeCoherencyModeFineGrain = 0,

1106 hipMemRangeCoherencyModeCoarseGrain = 1,

1108 hipMemRangeCoherencyModeIndeterminate = 2

1111} hipMemRangeCoherencyMode;

1115typedef enum hipMemRangeAttribute {

1116 hipMemRangeAttributeReadMostly = 1,

1118 hipMemRangeAttributePreferredLocation = 2,

1119 hipMemRangeAttributeAccessedBy = 3,

1121 hipMemRangeAttributeLastPrefetchLocation = 4,

1123 hipMemRangeAttributeCoherencyMode = 100,

1125} hipMemRangeAttribute;

1126

1130typedef enum hipMemPoolAttr {

1139 hipMemPoolReuseFollowEventDependencies = 0x1,

1145 hipMemPoolReuseAllowOpportunistic = 0x2,

1152 hipMemPoolReuseAllowInternalDependencies = 0x3,

1161 hipMemPoolAttrReleaseThreshold = 0x4,

1166 hipMemPoolAttrReservedMemCurrent = 0x5,

1172 hipMemPoolAttrReservedMemHigh = 0x6,

1177 hipMemPoolAttrUsedMemCurrent = 0x7,

1183 hipMemPoolAttrUsedMemHigh = 0x8

1184} hipMemPoolAttr;

1185

1190typedef enum hipMemAccessFlags {

1191 hipMemAccessFlagsProtNone = 0,

1192 hipMemAccessFlagsProtRead = 1,

1193 hipMemAccessFlagsProtReadWrite = 3

1194} hipMemAccessFlags;

1201typedef struct hipMemAccessDesc {

1202 hipMemLocation location;

1203 hipMemAccessFlags flags;

1204} hipMemAccessDesc;

1208typedef enum hipMemAllocationType {

1209 hipMemAllocationTypeInvalid = 0x0,

1213 hipMemAllocationTypePinned = 0x1,

1214 hipMemAllocationTypeManaged = 0x2,

1215 hipMemAllocationTypeUncached = 0x40000000,

1216 hipMemAllocationTypeMax = 0x7FFFFFFF

1217} hipMemAllocationType;

1222typedef enum hipMemAllocationHandleType {

1223 hipMemHandleTypeNone = 0x0,

1224 hipMemHandleTypePosixFileDescriptor =

1225 0x1,

1226 hipMemHandleTypeWin32 = 0x2,

1227 hipMemHandleTypeWin32Kmt = 0x4

1228} hipMemAllocationHandleType;

1232typedef struct hipMemPoolProps {

1233 hipMemAllocationType

1234 allocType;

1235 hipMemAllocationHandleType

1236 handleTypes;

1237 hipMemLocation location;

1241 void* win32SecurityAttributes;

1242 size_t maxSize;

1243 unsigned char reserved[56];

1244} hipMemPoolProps;

1248typedef struct hipMemPoolPtrExportData {

1249 unsigned char reserved[64];

1250} hipMemPoolPtrExportData;

1251

1255typedef enum hipFuncAttribute {

1256 hipFuncAttributeMaxDynamicSharedMemorySize =

1257 8,

1258 hipFuncAttributePreferredSharedMemoryCarveout =

1259 9,

1260 hipFuncAttributeMax

1261} hipFuncAttribute;

1265typedef enum hipFuncCache_t {

1266 hipFuncCachePreferNone,

1267 hipFuncCachePreferShared,

1268 hipFuncCachePreferL1,

1269 hipFuncCachePreferEqual,

1270} hipFuncCache_t;

1274typedef enum hipSharedMemConfig {

1275 hipSharedMemBankSizeDefault,

1276 hipSharedMemBankSizeFourByte,

1278 hipSharedMemBankSizeEightByte

1280} hipSharedMemConfig;

1284typedef struct dim3 {

1285 uint32_t x;

1286 uint32_t y;

1287 uint32_t z;

1288#ifdef __cplusplus

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

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

1291#endif

1292} dim3;

1296typedef struct hipLaunchParams_t {

1297 void* func;

1298 dim3 gridDim;

1299 dim3 blockDim;

1300 void** args;

1301 size_t sharedMem;

1302 hipStream_t stream;

1303} hipLaunchParams;

1307typedef struct hipFunctionLaunchParams_t {

1308 hipFunction_t function;

1309 unsigned int gridDimX;

1310 unsigned int gridDimY;

1311 unsigned int gridDimZ;

1312 unsigned int blockDimX;

1313 unsigned int blockDimY;

1314 unsigned int blockDimZ;

1315 unsigned int sharedMemBytes;

1316 hipStream_t hStream;

1317 void** kernelParams;

1318} hipFunctionLaunchParams;

1319typedef enum hipExternalMemoryHandleType_enum {

1320 hipExternalMemoryHandleTypeOpaqueFd = 1,

1321 hipExternalMemoryHandleTypeOpaqueWin32 = 2,

1322 hipExternalMemoryHandleTypeOpaqueWin32Kmt = 3,

1323 hipExternalMemoryHandleTypeD3D12Heap = 4,

1324 hipExternalMemoryHandleTypeD3D12Resource = 5,

1325 hipExternalMemoryHandleTypeD3D11Resource = 6,

1326 hipExternalMemoryHandleTypeD3D11ResourceKmt = 7,

1327 hipExternalMemoryHandleTypeNvSciBuf = 8

1328} hipExternalMemoryHandleType;

1329typedef struct hipExternalMemoryHandleDesc_st {

1330 hipExternalMemoryHandleType type;

1331 union {

1332 int fd;

1333 struct {

1334 void* handle;

1335 const void* name;

1336 } win32;

1337 const void* nvSciBufObject;

1338 } handle;

1339 unsigned long long size;

1340 unsigned int flags;

1341 unsigned int reserved[16];

1342} hipExternalMemoryHandleDesc;

1343typedef struct hipExternalMemoryBufferDesc_st {

1344 unsigned long long offset;

1345 unsigned long long size;

1346 unsigned int flags;

1347 unsigned int reserved[16];

1348} hipExternalMemoryBufferDesc;

1349typedef struct hipExternalMemoryMipmappedArrayDesc_st {

1350 unsigned long long offset;

1351 hipChannelFormatDesc formatDesc;

1352 hipExtent extent;

1353 unsigned int flags;

1354 unsigned int numLevels;

1355} hipExternalMemoryMipmappedArrayDesc;

1356typedef void* hipExternalMemory_t;

1357typedef enum hipExternalSemaphoreHandleType_enum {

1358 hipExternalSemaphoreHandleTypeOpaqueFd = 1,

1359 hipExternalSemaphoreHandleTypeOpaqueWin32 = 2,

1360 hipExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3,

1361 hipExternalSemaphoreHandleTypeD3D12Fence = 4,

1362 hipExternalSemaphoreHandleTypeD3D11Fence = 5,

1363 hipExternalSemaphoreHandleTypeNvSciSync = 6,

1364 hipExternalSemaphoreHandleTypeKeyedMutex = 7,

1365 hipExternalSemaphoreHandleTypeKeyedMutexKmt = 8,

1366 hipExternalSemaphoreHandleTypeTimelineSemaphoreFd = 9,

1367 hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = 10

1368} hipExternalSemaphoreHandleType;

1369typedef struct hipExternalSemaphoreHandleDesc_st {

1370 hipExternalSemaphoreHandleType type;

1371 union {

1372 int fd;

1373 struct {

1374 void* handle;

1375 const void* name;

1376 } win32;

1377 const void* NvSciSyncObj;

1378 } handle;

1379 unsigned int flags;

1380 unsigned int reserved[16];

1381} hipExternalSemaphoreHandleDesc;

1382typedef void* hipExternalSemaphore_t;

1383typedef struct hipExternalSemaphoreSignalParams_st {

1384 struct {

1385 struct {

1386 unsigned long long value;

1387 } fence;

1388 union {

1389 void* fence;

1390 unsigned long long reserved;

1391 } nvSciSync;

1392 struct {

1393 unsigned long long key;

1394 } keyedMutex;

1395 unsigned int reserved[12];

1396 } params;

1397 unsigned int flags;

1398 unsigned int reserved[16];

1399} hipExternalSemaphoreSignalParams;

1403typedef struct hipExternalSemaphoreWaitParams_st {

1404 struct {

1405 struct {

1406 unsigned long long value;

1407 } fence;

1408 union {

1409 void* fence;

1410 unsigned long long reserved;

1411 } nvSciSync;

1412 struct {

1413 unsigned long long key;

1414 unsigned int timeoutMs;

1415 } keyedMutex;

1416 unsigned int reserved[10];

1417 } params;

1418 unsigned int flags;

1419 unsigned int reserved[16];

1420} hipExternalSemaphoreWaitParams;

1421

1422#if __HIP_HAS_GET_PCH

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

1428#endif

1429

1433typedef enum hipGraphicsRegisterFlags {

1434 hipGraphicsRegisterFlagsNone = 0,

1435 hipGraphicsRegisterFlagsReadOnly = 1,

1436 hipGraphicsRegisterFlagsWriteDiscard =

1437 2,

1438 hipGraphicsRegisterFlagsSurfaceLoadStore = 4,

1439 hipGraphicsRegisterFlagsTextureGather =

1440 8

1441} hipGraphicsRegisterFlags;

1442

1443typedef struct _hipGraphicsResource hipGraphicsResource;

1444

1445typedef hipGraphicsResource* hipGraphicsResource_t;

1446

1450typedef struct ihipGraph* hipGraph_t;

1454typedef struct hipGraphNode* hipGraphNode_t;

1458typedef struct hipGraphExec* hipGraphExec_t;

1459

1463typedef struct hipUserObject* hipUserObject_t;

1464

1465

1469typedef enum hipGraphNodeType {

1470 hipGraphNodeTypeKernel = 0,

1471 hipGraphNodeTypeMemcpy = 1,

1472 hipGraphNodeTypeMemset = 2,

1473 hipGraphNodeTypeHost = 3,

1474 hipGraphNodeTypeGraph = 4,

1475 hipGraphNodeTypeEmpty = 5,

1476 hipGraphNodeTypeWaitEvent = 6,

1477 hipGraphNodeTypeEventRecord = 7,

1478 hipGraphNodeTypeExtSemaphoreSignal = 8,

1479 hipGraphNodeTypeExtSemaphoreWait = 9,

1480 hipGraphNodeTypeMemAlloc = 10,

1481 hipGraphNodeTypeMemFree = 11,

1482 hipGraphNodeTypeMemcpyFromSymbol = 12,

1483 hipGraphNodeTypeMemcpyToSymbol = 13,

1484 hipGraphNodeTypeBatchMemOp = 14,

1485 hipGraphNodeTypeCount

1486} hipGraphNodeType;

1487

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

1489typedef struct hipHostNodeParams {

1490 hipHostFn_t fn;

1491 void* userData;

1492} hipHostNodeParams;

1493typedef struct hipKernelNodeParams {

1494 dim3 blockDim;

1495 void** extra;

1496 void* func;

1497 dim3 gridDim;

1498 void** kernelParams;

1499 unsigned int sharedMemBytes;

1500} hipKernelNodeParams;

1501typedef struct hipMemsetParams {

1502 void* dst;

1503 unsigned int elementSize;

1504 size_t height;

1505 size_t pitch;

1506 unsigned int value;

1507 size_t width;

1508} hipMemsetParams;

1509

1510typedef struct hipMemAllocNodeParams {

1511 hipMemPoolProps poolProps;

1513 const hipMemAccessDesc* accessDescs;

1514 size_t accessDescCount;

1516 size_t bytesize;

1517 void* dptr;

1518} hipMemAllocNodeParams;

1519

1523typedef enum hipAccessProperty {

1524 hipAccessPropertyNormal = 0,

1525 hipAccessPropertyStreaming = 1,

1526 hipAccessPropertyPersisting = 2,

1527} hipAccessProperty;

1528

1529/***

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

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

1532 */

1533typedef struct hipAccessPolicyWindow {

1534 void* base_ptr;

1535 hipAccessProperty hitProp;

1536 float hitRatio;

1537 hipAccessProperty missProp;

1538 size_t num_bytes;

1539} hipAccessPolicyWindow;

1540

1544typedef struct hipLaunchMemSyncDomainMap {

1545 unsigned char default_;

1546 unsigned char remote;

1547} hipLaunchMemSyncDomainMap;

1548

1552typedef enum hipLaunchMemSyncDomain {

1553 hipLaunchMemSyncDomainDefault = 0,

1554 hipLaunchMemSyncDomainRemote = 1

1555} hipLaunchMemSyncDomain;

1556

1561typedef enum hipSynchronizationPolicy {

1562 hipSyncPolicyAuto = 1,

1563 hipSyncPolicySpin = 2,

1564 hipSyncPolicyYield = 3,

1565 hipSyncPolicyBlockingSync = 4

1566} hipSynchronizationPolicy;

1567

1571typedef enum hipLaunchAttributeID {

1572 hipLaunchAttributeAccessPolicyWindow = 1,

1573 hipLaunchAttributeCooperative = 2,

1574 hipLaunchAttributeSynchronizationPolicy = 3,

1575 hipLaunchAttributePriority = 8,

1576 hipLaunchAttributeMemSyncDomainMap = 9,

1577 hipLaunchAttributeMemSyncDomain = 10,

1578 hipLaunchAttributeMax

1579} hipLaunchAttributeID;

1580

1581

1585typedef union hipLaunchAttributeValue {

1586 char pad[64];

1587 hipAccessPolicyWindow

1588 accessPolicyWindow;

1589 int cooperative;

1591 int priority;

1593 hipSynchronizationPolicy

1594 syncPolicy;

1596 hipLaunchMemSyncDomainMap

1597 memSyncDomainMap;

1598 hipLaunchMemSyncDomain

1599 memSyncDomain;

1600} hipLaunchAttributeValue;

1601

1605#define hipStreamAttrID hipLaunchAttributeID

1606#define hipStreamAttributeAccessPolicyWindow hipLaunchAttributeAccessPolicyWindow

1607#define hipStreamAttributeSynchronizationPolicy hipLaunchAttributeSynchronizationPolicy

1608#define hipStreamAttributeMemSyncDomainMap hipLaunchAttributeMemSyncDomainMap

1609#define hipStreamAttributeMemSyncDomain hipLaunchAttributeMemSyncDomain

1610#define hipStreamAttributePriority hipLaunchAttributePriority

1611

1612#define hipStreamAttrValue hipLaunchAttributeValue

1613

1617#define hipKernelNodeAttrID hipLaunchAttributeID

1618#define hipKernelNodeAttributeAccessPolicyWindow hipLaunchAttributeAccessPolicyWindow

1619#define hipKernelNodeAttributeCooperative hipLaunchAttributeCooperative

1620#define hipKernelNodeAttributePriority hipLaunchAttributePriority

1621

1625#define hipKernelNodeAttrValue hipLaunchAttributeValue

1626

1630#define hipDrvLaunchAttributeCooperative hipLaunchAttributeCooperative

1631

1632#define hipDrvLaunchAttributeID hipLaunchAttributeID

1633#define hipDrvLaunchAttributeValue hipLaunchAttributeValue

1634#define hipDrvLaunchAttribute hipLaunchAttribute

1635

1639typedef enum hipGraphExecUpdateResult {

1640 hipGraphExecUpdateSuccess = 0x0,

1641 hipGraphExecUpdateError = 0x1,

1643 hipGraphExecUpdateErrorTopologyChanged = 0x2,

1644 hipGraphExecUpdateErrorNodeTypeChanged = 0x3,

1645 hipGraphExecUpdateErrorFunctionChanged =

1646 0x4,

1647 hipGraphExecUpdateErrorParametersChanged =

1648 0x5,

1649 hipGraphExecUpdateErrorNotSupported =

1650 0x6,

1651 hipGraphExecUpdateErrorUnsupportedFunctionChange = 0x7

1652} hipGraphExecUpdateResult;

1653

1654typedef enum hipStreamCaptureMode {

1655 hipStreamCaptureModeGlobal = 0,

1656 hipStreamCaptureModeThreadLocal,

1657 hipStreamCaptureModeRelaxed

1658} hipStreamCaptureMode;

1659typedef enum hipStreamCaptureStatus {

1660 hipStreamCaptureStatusNone = 0,

1661 hipStreamCaptureStatusActive,

1662 hipStreamCaptureStatusInvalidated

1664} hipStreamCaptureStatus;

1665

1666typedef enum hipStreamUpdateCaptureDependenciesFlags {

1667 hipStreamAddCaptureDependencies = 0,

1668 hipStreamSetCaptureDependencies,

1669} hipStreamUpdateCaptureDependenciesFlags;

1670

1671typedef enum hipGraphMemAttributeType {

1672 hipGraphMemAttrUsedMemCurrent =

1673 0,

1674 hipGraphMemAttrUsedMemHigh,

1676 hipGraphMemAttrReservedMemCurrent,

1678 hipGraphMemAttrReservedMemHigh,

1680} hipGraphMemAttributeType;

1681typedef enum hipUserObjectFlags {

1682 hipUserObjectNoDestructorSync = 0x1,

1683} hipUserObjectFlags;

1684

1685typedef enum hipUserObjectRetainFlags {

1686 hipGraphUserObjectMove = 0x1,

1687} hipUserObjectRetainFlags;

1688

1689typedef enum hipGraphInstantiateFlags {

1690 hipGraphInstantiateFlagAutoFreeOnLaunch =

1691 1,

1692 hipGraphInstantiateFlagUpload = 2,

1693 hipGraphInstantiateFlagDeviceLaunch =

1694 4,

1695 hipGraphInstantiateFlagUseNodePriority =

1696 8,

1698} hipGraphInstantiateFlags;

1699

1700enum hipGraphDebugDotFlags {

1701 hipGraphDebugDotFlagsVerbose =

1702 1 << 0,

1703 hipGraphDebugDotFlagsKernelNodeParams = 1 << 2,

1704 hipGraphDebugDotFlagsMemcpyNodeParams = 1 << 3,

1705 hipGraphDebugDotFlagsMemsetNodeParams = 1 << 4,

1706 hipGraphDebugDotFlagsHostNodeParams = 1 << 5,

1707 hipGraphDebugDotFlagsEventNodeParams =

1708 1 << 6,

1709 hipGraphDebugDotFlagsExtSemasSignalNodeParams =

1710 1 << 7,

1711 hipGraphDebugDotFlagsExtSemasWaitNodeParams =

1712 1 << 8,

1713 hipGraphDebugDotFlagsKernelNodeAttributes =

1714 1 << 9,

1715 hipGraphDebugDotFlagsHandles =

1716 1 << 10

1717};

1718

1722typedef enum hipGraphInstantiateResult {

1723 hipGraphInstantiateSuccess = 0,

1724 hipGraphInstantiateError = 1,

1726 hipGraphInstantiateInvalidStructure = 2,

1728 hipGraphInstantiateNodeOperationNotSupported = 3,

1730 hipGraphInstantiateMultipleDevicesNotSupported = 4,

1732} hipGraphInstantiateResult;

1733

1737typedef struct hipGraphInstantiateParams {

1738 hipGraphNode_t errNode_out;

1739 unsigned long long flags;

1740 hipGraphInstantiateResult result_out;

1742 hipStream_t uploadStream;

1743} hipGraphInstantiateParams;

1744

1745

1749typedef struct hipMemAllocationProp {

1750 hipMemAllocationType type;

1751 union {

1752 hipMemAllocationHandleType requestedHandleType;

1753 hipMemAllocationHandleType requestedHandleTypes;

1754 };

1755 hipMemLocation location;

1756 void* win32HandleMetaData;

1757 struct {

1758 unsigned char compressionType;

1759 unsigned char gpuDirectRDMACapable;

1760 unsigned short usage;

1761 } allocFlags;

1762} hipMemAllocationProp;

1763

1767typedef struct hipExternalSemaphoreSignalNodeParams {

1769 hipExternalSemaphore_t* extSemArray;

1771 const hipExternalSemaphoreSignalParams* paramsArray;

1773 unsigned int numExtSems;

1774} hipExternalSemaphoreSignalNodeParams;

1775

1779typedef struct hipExternalSemaphoreWaitNodeParams {

1781 hipExternalSemaphore_t* extSemArray;

1783 const hipExternalSemaphoreWaitParams* paramsArray;

1785 unsigned int numExtSems;

1786} hipExternalSemaphoreWaitNodeParams;

1787

1791typedef struct ihipMemGenericAllocationHandle* hipMemGenericAllocationHandle_t;

1792

1796typedef enum hipMemAllocationGranularity_flags {

1797 hipMemAllocationGranularityMinimum = 0x0,

1798 hipMemAllocationGranularityRecommended = 0x1

1799} hipMemAllocationGranularity_flags;

1800

1804typedef enum hipMemHandleType {

1805 hipMemHandleTypeGeneric = 0x0

1806} hipMemHandleType;

1807

1811typedef enum hipMemOperationType {

1812 hipMemOperationTypeMap = 0x1,

1813 hipMemOperationTypeUnmap = 0x2

1814} hipMemOperationType;

1815

1819typedef enum hipArraySparseSubresourceType {

1820 hipArraySparseSubresourceTypeSparseLevel = 0x0,

1821 hipArraySparseSubresourceTypeMiptail = 0x1

1822} hipArraySparseSubresourceType;

1823

1827typedef struct hipArrayMapInfo {

1828 hipResourceType resourceType;

1829 union {

1830 hipMipmappedArray mipmap;

1831 hipArray_t array;

1832 } resource;

1833 hipArraySparseSubresourceType subresourceType;

1834 union {

1835 struct {

1836 unsigned int

1837 level;

1838 unsigned int

1839 layer;

1840 unsigned int offsetX;

1841 unsigned int offsetY;

1842 unsigned int offsetZ;

1843 unsigned int extentWidth;

1844 unsigned int extentHeight;

1845 unsigned int extentDepth;

1846 } sparseLevel;

1847 struct {

1848 unsigned int

1849 layer;

1850 unsigned long long offset;

1851 unsigned long long size;

1852 } miptail;

1853 } subresource;

1854 hipMemOperationType memOperationType;

1855 hipMemHandleType memHandleType;

1856 union {

1857 hipMemGenericAllocationHandle_t memHandle;

1858 } memHandle;

1859 unsigned long long offset;

1860 unsigned int deviceBitMask;

1861 unsigned int flags;

1862 unsigned int reserved[2];

1863} hipArrayMapInfo;

1864

1868typedef struct hipMemcpyNodeParams {

1869 int flags;

1870 int reserved[3];

1871 hipMemcpy3DParms copyParams;

1872} hipMemcpyNodeParams;

1873

1877typedef struct hipChildGraphNodeParams {

1878 hipGraph_t graph;

1880} hipChildGraphNodeParams;

1881

1885typedef struct hipEventWaitNodeParams {

1886 hipEvent_t event;

1887} hipEventWaitNodeParams;

1888

1892typedef struct hipEventRecordNodeParams {

1893 hipEvent_t event;

1894} hipEventRecordNodeParams;

1895

1899typedef struct hipMemFreeNodeParams {

1900 void* dptr;

1901} hipMemFreeNodeParams;

1902

1906typedef struct hipGraphNodeParams {

1907 hipGraphNodeType type;

1908 int reserved0[3];

1909 union {

1910 long long reserved1[29];

1911 hipKernelNodeParams kernel;

1912 hipMemcpyNodeParams memcpy;

1913 hipMemsetParams memset;

1914 hipHostNodeParams host;

1915 hipChildGraphNodeParams graph;

1916 hipEventWaitNodeParams eventWait;

1917 hipEventRecordNodeParams eventRecord;

1918 hipExternalSemaphoreSignalNodeParams extSemSignal;

1919 hipExternalSemaphoreWaitNodeParams extSemWait;

1920 hipMemAllocNodeParams alloc;

1921 hipMemFreeNodeParams free;

1922 };

1923

1924 long long reserved2;

1925} hipGraphNodeParams;

1926

1930#define hipGraphKernelNodePortDefault 0

1931

1935#define hipGraphKernelNodePortLaunchCompletion 2

1936

1942#define hipGraphKernelNodePortProgrammatic 1

1943

1944typedef enum hipGraphDependencyType {

1945 hipGraphDependencyTypeDefault = 0,

1946 hipGraphDependencyTypeProgrammatic = 1

1947} hipGraphDependencyType;

1948

1949typedef struct hipGraphEdgeData {

1950 unsigned char

1951 from_port;

1958 unsigned char reserved[5];

1959 unsigned char

1960 to_port;

1961 unsigned char type;

1962} hipGraphEdgeData;

1963

1964

1968typedef struct hipLaunchAttribute_st {

1969 hipLaunchAttributeID id;

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

1971 union {

1972 hipLaunchAttributeValue val;

1973 hipLaunchAttributeValue value;

1974 };

1975} hipLaunchAttribute;

1976

1980typedef struct hipLaunchConfig_st {

1981 dim3 gridDim;

1982 dim3 blockDim;

1983 size_t dynamicSmemBytes;

1984 hipStream_t stream;

1985 hipLaunchAttribute* attrs;

1986 unsigned int numAttrs;

1987} hipLaunchConfig_t;

1988

1992typedef struct HIP_LAUNCH_CONFIG_st {

1993 unsigned int gridDimX;

1994 unsigned int gridDimY;

1995 unsigned int gridDimZ;

1996 unsigned int blockDimX;

1997 unsigned int blockDimY;

1998 unsigned int blockDimZ;

1999 unsigned int sharedMemBytes;

2000 hipStream_t hStream;

2001 hipLaunchAttribute* attrs;

2002 unsigned int numAttrs;

2003} HIP_LAUNCH_CONFIG;

2004

2008typedef struct hipArrayMemoryRequirements {

2009 size_t alignment;

2010 size_t size;

2011} hipArrayMemoryRequirements;

2012

2016typedef enum hipMemRangeHandleType {

2017 hipMemRangeHandleTypeDmaBufFd = 0x1,

2018 hipMemRangeHandleTypeMax = 0x7fffffff

2019} hipMemRangeHandleType;

2020

2024typedef enum hipMemRangeFlags {

2025 hipMemRangeFlagDmaBufMappingTypePcie = 0x1,

2026 hipMemRangeFlagsMax = 0x7fffffff

2027} hipMemRangeFlags;

2028

2029// Doxygen end group GlobalDefs

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

2056hipError_t hipInit(unsigned int flags);

2057

2075hipError_t hipDriverGetVersion(int* driverVersion);

2090hipError_t hipRuntimeGetVersion(int* runtimeVersion);

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

2099

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

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

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

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

2140 int dstDevice);

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

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

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

2166// doxygen end initialization

2185hipError_t hipDeviceSynchronize(void);

2197hipError_t hipDeviceReset(void);

2229hipError_t hipSetDevice(int deviceId);

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

2256hipError_t hipGetDevice(int* deviceId);

2269hipError_t hipGetDeviceCount(int* count);

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

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

2316hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool);

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

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

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

2368 int device);

2380hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig);

2391hipError_t hipDeviceGetCacheConfig(hipFuncCache_t* cacheConfig);

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

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

2437hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig* pConfig);

2445hipError_t hipGetDeviceFlags(unsigned int* flags);

2457hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config);

2489hipError_t hipSetDeviceFlags(unsigned flags);

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

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

2513 uint32_t* hopcount);

2514// TODO: implement IPC apis

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

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

2592hipError_t hipIpcCloseMemHandle(void* devPtr);

2593

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

2611

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

2631

2632// end doxygen Device

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

2657

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

2674

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

2684

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

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

2711// doxygen end execution

2733hipError_t hipGetLastError(void);

2734

2746hipError_t hipExtGetLastError(void);

2747

2758hipError_t hipPeekAtLastError(void);

2767const char* hipGetErrorName(hipError_t hip_error);

2776const char* hipGetErrorString(hipError_t hipError);

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

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

2797// end doxygen Error

2830hipError_t hipStreamCreate(hipStream_t* stream);

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

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

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

2910hipError_t hipStreamDestroy(hipStream_t stream);

2926hipError_t hipStreamQuery(hipStream_t stream);

2948hipError_t hipStreamSynchronize(hipStream_t stream);

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

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

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

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

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

3037hipError_t hipExtStreamCreateWithCUMask(hipStream_t* stream, uint32_t cuMaskSize,

3038 const uint32_t* cuMask);

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

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

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

3072 unsigned int flags);

3073

3081hipError_t hipStreamSetAttribute(hipStream_t stream, hipStreamAttrID attr,

3082 const hipStreamAttrValue* value);

3083

3091hipError_t hipStreamGetAttribute(hipStream_t stream, hipStreamAttrID attr,

3092 hipStreamAttrValue* value_out);

3093

3100hipError_t hipStreamCopyAttributes(hipStream_t dst, hipStream_t src);

3101

3102// end doxygen Stream

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

3151 uint32_t mask __dparm(0xFFFFFFFF));

3152

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

3190 uint64_t mask __dparm(0xFFFFFFFFFFFFFFFF));

3191

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

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

3234

3254hipError_t hipStreamBatchMemOp(hipStream_t stream, unsigned int count,

3255 hipStreamBatchMemOpParams* paramArray, unsigned int flags);

3256

3274hipError_t hipGraphAddBatchMemOpNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

3275 const hipGraphNode_t* dependencies, size_t numDependencies,

3276 const hipBatchMemOpNodeParams* nodeParams);

3277

3298hipError_t hipGraphBatchMemOpNodeGetParams(hipGraphNode_t hNode,

3299 hipBatchMemOpNodeParams* nodeParams_out);

3300

3318hipError_t hipGraphBatchMemOpNodeSetParams(hipGraphNode_t hNode,

3319 hipBatchMemOpNodeParams* nodeParams);

3320

3340hipError_t hipGraphExecBatchMemOpNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

3341 const hipBatchMemOpNodeParams* nodeParams);

3342

3343// end doxygen Stream Memory Operations

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

3391hipError_t hipEventCreate(hipEvent_t* event);

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

3429 unsigned int flags __dparm(0));

3460#ifdef __cplusplus

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

3462#else

3463hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream);

3464#endif

3481hipError_t hipEventDestroy(hipEvent_t event);

3500hipError_t hipEventSynchronize(hipEvent_t event);

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

3546hipError_t hipEventQuery(hipEvent_t event);

3547// end doxygen Events

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

3579 hipDeviceptr_t ptr);

3580

3581

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

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

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

3634 void** data, hipDeviceptr_t ptr);

3658hipError_t hipImportExternalSemaphore(hipExternalSemaphore_t* extSem_out,

3659 const hipExternalSemaphoreHandleDesc* semHandleDesc);

3675hipError_t hipSignalExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

3676 const hipExternalSemaphoreSignalParams* paramsArray,

3677 unsigned int numExtSems, hipStream_t stream);

3693hipError_t hipWaitExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

3694 const hipExternalSemaphoreWaitParams* paramsArray,

3695 unsigned int numExtSems, hipStream_t stream);

3709hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem);

3710

3722hipError_t hipImportExternalMemory(hipExternalMemory_t* extMem_out,

3723 const hipExternalMemoryHandleDesc* memHandleDesc);

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

3736 const hipExternalMemoryBufferDesc* bufferDesc);

3746hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem);

3761hipError_t hipExternalMemoryGetMappedMipmappedArray(

3762 hipMipmappedArray_t* mipmap, hipExternalMemory_t extMem,

3763 const hipExternalMemoryMipmappedArrayDesc* mipmapDesc);

3764// end of external resource

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

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

3802

3803

3826HIP_DEPRECATED("use hipHostMalloc instead")

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

3840HIP_DEPRECATED("use hipHostMalloc instead")

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

3842// end doxygen deprecated management memory

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

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

3915 unsigned int flags __dparm(hipMemAttachGlobal));

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

3929 hipStream_t stream __dparm(0));

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

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

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

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

3985 hipMemLocation location);

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

4001 const void* dev_ptr, size_t count);

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

4019 hipMemRangeAttribute* attributes, size_t num_attributes,

4020 const void* dev_ptr, size_t count);

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

4037 unsigned int flags __dparm(hipMemAttachSingle));

4038// end doxygen Managed Memory

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

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

4151hipError_t hipMemPoolTrimTo(hipMemPool_t mem_pool, size_t min_bytes_to_hold);

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

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

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

4250 size_t count);

4270hipError_t hipMemPoolGetAccess(hipMemAccessFlags* flags, hipMemPool_t mem_pool,

4271 hipMemLocation* location);

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

4324hipError_t hipMemPoolDestroy(hipMemPool_t mem_pool);

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

4361 hipStream_t stream);

4388hipError_t hipMemPoolExportToShareableHandle(void* shared_handle, hipMemPool_t mem_pool,

4389 hipMemAllocationHandleType handle_type,

4390 unsigned int flags);

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

4415 hipMemAllocationHandleType handle_type,

4416 unsigned int flags);

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

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

4466 hipMemPoolPtrExportData* export_data);

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

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

4479 hipMemAllocationType type);

4480// Doxygen end of ordered memory allocator

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

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

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

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

4573hipError_t hipHostUnregister(void* hostPtr);

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

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

4616 unsigned int elementSizeBytes);

4630hipError_t hipFree(void* ptr);

4642hipError_t hipFreeHost(void* ptr);

4659hipError_t hipHostFree(void* ptr);

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

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

4708 hipStream_t stream);

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

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

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

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

4782 size_t ByteCount);

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

4802 size_t ByteCount);

4803

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

4824 size_t srcOffset, size_t ByteCount);

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

4844 hipStream_t stream);

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

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

4883 hipStream_t stream);

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

4904 size_t ByteCount, hipStream_t stream);

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

4925 size_t ByteCount, hipStream_t stream);

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

4943 const char* name);

4944

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

4955

4956

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

4967

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

4988 hipDriverProcAddressQueryResult* symbolStatus);

4989

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

5012 size_t offset __dparm(0),

5013 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice));

5014

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

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

5030

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

5044 size_t offset __dparm(0),

5045 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost));

5046

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

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

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

5091 hipStream_t stream __dparm(0));

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

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

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

5128 hipStream_t stream __dparm(0));

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

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

5155 hipStream_t stream __dparm(0));

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

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

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

5198 hipStream_t stream __dparm(0));

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

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

5222 hipStream_t stream __dparm(0));

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

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

5242 hipStream_t stream __dparm(0));

5243

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

5256 size_t height);

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

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

5271

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

5284 size_t height);

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

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

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

5311 size_t height);

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

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

5326

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

5344

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

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

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

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

5391hipError_t hipArrayDestroy(hipArray_t array);

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

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

5422hipError_t hipFreeArray(hipArray_t array);

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

5435 struct hipExtent extent, unsigned int flags);

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

5449 hipArray_t array);

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

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

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

5521 size_t height, hipMemcpyKind kind);

5531hipError_t hipMemcpyParam2D(const hip_Memcpy2D* pCopy);

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

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

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

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

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

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

5623 size_t spitch, size_t width, size_t height, hipMemcpyKind kind,

5624 hipStream_t stream __dparm(0));

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

5644 hipArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc,

5645 size_t width, size_t height, hipMemcpyKind kind);

5664HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5666 size_t count, hipMemcpyKind kind);

5685HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5687 size_t count, hipMemcpyKind kind);

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

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

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

5726 size_t hOffset, size_t width, size_t height,

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

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

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

5766hipError_t hipMemcpy3D(const struct hipMemcpy3DParms* p);

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

5789hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D* pCopy);

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

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

5815

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

5832 hipMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs,

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

5834

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

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

5849

5858hipError_t hipMemcpy3DPeer(hipMemcpy3DPeerParms* p);

5859

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

5869

5885hipError_t hipMipmappedArrayGetMemoryRequirements(hipArrayMemoryRequirements* memoryRequirements,

5886 hipMipmappedArray_t mipmap, hipDevice_t device);

5887// doxygen end Memory

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

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

5948hipError_t hipDeviceDisablePeerAccess(int peerDeviceId);

5949

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

5962 size_t sizeBytes);

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

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

5977

5978// doxygen end PeerToPeer

6019HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6034HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6035hipError_t hipCtxDestroy(hipCtx_t ctx);

6049HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6050hipError_t hipCtxPopCurrent(hipCtx_t* ctx);

6064HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6065hipError_t hipCtxPushCurrent(hipCtx_t ctx);

6079HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6080hipError_t hipCtxSetCurrent(hipCtx_t ctx);

6094HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6095hipError_t hipCtxGetCurrent(hipCtx_t* ctx);

6109HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6110hipError_t hipCtxGetDevice(hipDevice_t* device);

6131HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6149HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6150hipError_t hipCtxGetCacheConfig(hipFuncCache_t* cacheConfig);

6167HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6168hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig);

6185HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6186hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config);

6203HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6204hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig* pConfig);

6219HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6220hipError_t hipCtxSynchronize(void);

6234HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6235hipError_t hipCtxGetFlags(unsigned int* flags);

6258HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6279HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6280hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx);

6281

6297HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6314HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6315hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev);

6330HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6345HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6346hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev);

6361HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6363// doxygen end Context Management

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

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

6411hipError_t hipModuleUnload(hipModule_t module);

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

6423

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

6434

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

6463 hipDevice_t dev);

6464

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

6479 void** jitOptionsValues, unsigned int numJitOptions,

6480 hipLibraryOption* libraryOptions, void** libraryOptionValues,

6481 unsigned int numLibraryOptions);

6482

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

6497 hipJitOption* jitOptions, void** jitOptionsValues,

6498 unsigned int numJitOptions, hipLibraryOption* libraryOptions,

6499 void** libraryOptionValues, unsigned int numLibraryOptions);

6500

6507hipError_t hipLibraryUnload(hipLibrary_t library);

6508

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

6518

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

6527

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

6537 hipLibrary_t library);

6538

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

6547

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

6556

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

6568 size_t* paramSize);

6569

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

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

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

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

6611 hipDriverEntryPointQueryResult* driverStatus);

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

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

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

6659 hipJitOption* options, void** optionValues);

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

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

6680 void** optionValues);

6681

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

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

6700

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

6716

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

6729 hipLinkState_t* stateOut);

6738hipError_t hipLinkDestroy(hipLinkState_t state);

6739

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

6769 unsigned int gridDimZ, unsigned int blockDimX,

6770 unsigned int blockDimY, unsigned int blockDimZ,

6771 unsigned int sharedMemBytes, hipStream_t stream,

6772 void** kernelParams, void** extra);

6801hipError_t hipModuleLaunchCooperativeKernel(hipFunction_t f, unsigned int gridDimX,

6802 unsigned int gridDimY, unsigned int gridDimZ,

6803 unsigned int blockDimX, unsigned int blockDimY,

6804 unsigned int blockDimZ, unsigned int sharedMemBytes,

6805 hipStream_t stream, void** kernelParams);

6820hipError_t hipModuleLaunchCooperativeKernelMultiDevice(hipFunctionLaunchParams* launchParamsList,

6821 unsigned int numDevices, unsigned int flags);

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

6843 void** kernelParams, unsigned int sharedMemBytes,

6844 hipStream_t stream);

6856hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList, int numDevices,

6857 unsigned int flags);

6858

6859// Doxygen end group ModuleCooperativeG

6873hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList, int numDevices,

6874 unsigned int flags);

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

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

6905 void** extra);

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

6921 hipMemRangeHandleType handleType,

6922 unsigned long long flags);

6923// doxygen end Module

6951// TODO - Match CUoccupancyB2DSize

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

6953 size_t dynSharedMemPerBlk, int blockSizeLimit);

6969// TODO - Match CUoccupancyB2DSize

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

6971 hipFunction_t f,

6972 size_t dynSharedMemPerBlk,

6973 int blockSizeLimit, unsigned int flags);

6983hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, hipFunction_t f,

6984 int blockSize,

6985 size_t dynSharedMemPerBlk);

6996hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

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

7008 int blockSize, size_t dynSharedMemPerBlk);

7019hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

7021 unsigned int flags __dparm(hipOccupancyDefault));

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

7037 size_t dynSharedMemPerBlk, int blockSizeLimit);

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

7054 int numBlocks, int blockSize);

7055// doxygen end Occupancy

7069// TODO - expand descriptions:

7076HIP_DEPRECATED("use roctracer/rocTX instead")

7077hipError_t hipProfilerStart();

7084HIP_DEPRECATED("use roctracer/rocTX instead")

7085hipError_t hipProfilerStop();

7086// doxygen end profiler

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

7114 hipStream_t stream __dparm(0));

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

7134hipError_t hipLaunchByPtr(const void* func);

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

7152 hipStream_t stream __dparm(0));

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

7173 hipStream_t* stream);

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

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

7192 hipStream_t stream __dparm(0));

7193

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

7221

7229hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D* pCopy);

7230// TODO: Move this to hip_ext.h

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

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

7254 hipEvent_t startEvent, hipEvent_t stopEvent, int flags);

7255// doxygen end Clang launch

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

7282 const hipTextureDesc* pTexDesc,

7283 const struct hipResourceViewDesc* pResViewDesc);

7284

7293hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject);

7294

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

7305

7315hipError_t hipGetTextureObjectResourceDesc(hipResourceDesc* pResDesc,

7316 hipTextureObject_t textureObject);

7317

7327hipError_t hipGetTextureObjectResourceViewDesc(struct hipResourceViewDesc* pResViewDesc,

7328 hipTextureObject_t textureObject);

7329

7339hipError_t hipGetTextureObjectTextureDesc(hipTextureDesc* pTexDesc,

7340 hipTextureObject_t textureObject);

7341

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

7354 const HIP_TEXTURE_DESC* pTexDesc,

7355 const HIP_RESOURCE_VIEW_DESC* pResViewDesc);

7356

7365hipError_t hipTexObjectDestroy(hipTextureObject_t texObject);

7366

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

7377

7387hipError_t hipTexObjectGetResourceViewDesc(HIP_RESOURCE_VIEW_DESC* pResViewDesc,

7388 hipTextureObject_t texObject);

7389

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

7400

7415hipError_t hipMallocMipmappedArray(hipMipmappedArray_t* mipmappedArray,

7416 const struct hipChannelFormatDesc* desc, struct hipExtent extent,

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

7418

7429hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray);

7430

7443hipError_t hipGetMipmappedArrayLevel(hipArray_t* levelArray,

7444 hipMipmappedArray_const_t mipmappedArray, unsigned int level);

7445

7457hipError_t hipMipmappedArrayCreate(hipMipmappedArray_t* pHandle,

7458 HIP_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc,

7459 unsigned int numMipmapLevels);

7460

7471hipError_t hipMipmappedArrayDestroy(hipMipmappedArray_t hMipmappedArray);

7472

7485hipError_t hipMipmappedArrayGetLevel(hipArray_t* pLevelArray, hipMipmappedArray_t hMipMappedArray,

7486 unsigned int level);

7487

7506HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7507hipError_t hipBindTextureToMipmappedArray(const textureReference* tex,

7508 hipMipmappedArray_const_t mipmappedArray,

7509 const hipChannelFormatDesc* desc);

7510

7521HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7523

7534HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7536

7548HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7550

7562HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7563hipError_t hipTexRefSetAddressMode(textureReference* texRef, int dim,

7564 enum hipTextureAddressMode am);

7577HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7590HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7603HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7617HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7618hipError_t hipTexRefSetFormat(textureReference* texRef, hipArray_Format fmt,

7619 int NumPackedComponents);

7634HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

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

7653HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

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

7656 size_t pitch);

7669HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7671 const hipChannelFormatDesc* desc);

7683HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7695HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7696hipError_t hipUnbindTexture(const textureReference* tex);

7708HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7722HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7724 int dim);

7736HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7749HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7763HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7765 const textureReference* texRef);

7777HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7790HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7791hipError_t hipTexRefGetMipmapFilterMode(enum hipTextureFilterMode* pfm,

7792 const textureReference* texRef);

7804HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7818HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7820 const textureReference* texRef);

7832HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7847HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7849 size_t bytes);

7863HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7865 hipDeviceptr_t dptr, size_t Pitch);

7877HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7890HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7903HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7916HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7930HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7931hipError_t hipTexRefSetMipmapLevelClamp(textureReference* texRef, float minMipMapLevelClamp,

7932 float maxMipMapLevelClamp);

7945HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7946hipError_t hipTexRefSetMipmappedArray(textureReference* texRef,

7947 struct hipMipmappedArray* mipmappedArray, unsigned int Flags);

7948

7949// doxygen end deprecated texture management

7954// doxygen end Texture management

7966// This group is for HIPrtc

7967

7968// doxygen end Runtime

7987const char* hipApiName(uint32_t id);

7996const char* hipKernelNameRef(const hipFunction_t f);

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

8015int hipGetStreamDeviceId(hipStream_t stream);

8016

8017// doxygen end Callback

8039hipError_t hipStreamBeginCapture(hipStream_t stream, hipStreamCaptureMode mode);

8040

8060hipError_t hipStreamBeginCaptureToGraph(hipStream_t stream, hipGraph_t graph,

8061 const hipGraphNode_t* dependencies,

8062 const hipGraphEdgeData* dependencyData,

8063 size_t numDependencies, hipStreamCaptureMode mode);

8064

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

8075

8086hipError_t hipStreamGetCaptureInfo(hipStream_t stream, hipStreamCaptureStatus* pCaptureStatus,

8087 unsigned long long* pId);

8088

8103hipError_t hipStreamGetCaptureInfo_v2(hipStream_t stream, hipStreamCaptureStatus* captureStatus_out,

8104 unsigned long long* id_out __dparm(0),

8105 hipGraph_t* graph_out __dparm(0),

8106 const hipGraphNode_t** dependencies_out __dparm(0),

8107 size_t* numDependencies_out __dparm(0));

8108

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

8119

8131hipError_t hipStreamUpdateCaptureDependencies(hipStream_t stream, hipGraphNode_t* dependencies,

8132 size_t numDependencies,

8133 unsigned int flags __dparm(0));

8134

8142hipError_t hipThreadExchangeStreamCaptureMode(hipStreamCaptureMode* mode);

8143

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

8154

8163hipError_t hipGraphDestroy(hipGraph_t graph);

8164

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

8176 const hipGraphNode_t* to, size_t numDependencies);

8177

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

8189 const hipGraphNode_t* to, size_t numDependencies);

8190

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

8207 size_t* numEdges);

8208

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

8224

8239hipError_t hipGraphGetRootNodes(hipGraph_t graph, hipGraphNode_t* pRootNodes,

8240 size_t* pNumRootNodes);

8241

8256hipError_t hipGraphNodeGetDependencies(hipGraphNode_t node, hipGraphNode_t* pDependencies,

8257 size_t* pNumDependencies);

8258

8274hipError_t hipGraphNodeGetDependentNodes(hipGraphNode_t node, hipGraphNode_t* pDependentNodes,

8275 size_t* pNumDependentNodes);

8276

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

8286

8294hipError_t hipGraphDestroyNode(hipGraphNode_t node);

8295

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

8305

8315hipError_t hipGraphNodeFindInClone(hipGraphNode_t* pNode, hipGraphNode_t originalNode,

8316 hipGraph_t clonedGraph);

8317

8331hipError_t hipGraphInstantiate(hipGraphExec_t* pGraphExec, hipGraph_t graph,

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

8333

8344hipError_t hipGraphInstantiateWithFlags(hipGraphExec_t* pGraphExec, hipGraph_t graph,

8345 unsigned long long flags);

8346

8356hipError_t hipGraphInstantiateWithParams(hipGraphExec_t* pGraphExec, hipGraph_t graph,

8357 hipGraphInstantiateParams* instantiateParams);

8366hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream);

8367

8376hipError_t hipGraphUpload(hipGraphExec_t graphExec, hipStream_t stream);

8377

8389hipError_t hipGraphAddNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8390 const hipGraphNode_t* pDependencies, size_t numDependencies,

8391 hipGraphNodeParams* nodeParams);

8392

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

8402

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

8413

8424hipError_t hipGraphExecNodeSetParams(hipGraphExec_t graphExec, hipGraphNode_t node,

8425 hipGraphNodeParams* nodeParams);

8426

8435hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec);

8436

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

8449hipError_t hipGraphExecUpdate(hipGraphExec_t hGraphExec, hipGraph_t hGraph,

8450 hipGraphNode_t* hErrorNode_out,

8451 hipGraphExecUpdateResult* updateResult_out);

8452

8464hipError_t hipGraphAddKernelNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8465 const hipGraphNode_t* pDependencies, size_t numDependencies,

8466 const hipKernelNodeParams* pNodeParams);

8467

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

8477

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

8487

8497hipError_t hipGraphExecKernelNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8498 const hipKernelNodeParams* pNodeParams);

8499

8512hipError_t hipDrvGraphAddMemcpyNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

8513 const hipGraphNode_t* dependencies, size_t numDependencies,

8514 const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);

8526hipError_t hipGraphAddMemcpyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8527 const hipGraphNode_t* pDependencies, size_t numDependencies,

8528 const hipMemcpy3DParms* pCopyParams);

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

8538

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

8548

8558hipError_t hipGraphKernelNodeSetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

8559 const hipKernelNodeAttrValue* value);

8569hipError_t hipGraphKernelNodeGetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

8570 hipKernelNodeAttrValue* value);

8580hipError_t hipGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8581 hipMemcpy3DParms* pNodeParams);

8582

8597hipError_t hipGraphAddMemcpyNode1D(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8598 const hipGraphNode_t* pDependencies, size_t numDependencies,

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

8600

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

8613 size_t count, hipMemcpyKind kind);

8614

8628hipError_t hipGraphExecMemcpyNodeSetParams1D(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

8630 hipMemcpyKind kind);

8631

8647hipError_t hipGraphAddMemcpyNodeFromSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8648 const hipGraphNode_t* pDependencies,

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

8650 size_t count, size_t offset, hipMemcpyKind kind);

8651

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

8665 size_t count, size_t offset, hipMemcpyKind kind);

8666

8681hipError_t hipGraphExecMemcpyNodeSetParamsFromSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

8683 size_t offset, hipMemcpyKind kind);

8684

8700hipError_t hipGraphAddMemcpyNodeToSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8701 const hipGraphNode_t* pDependencies,

8702 size_t numDependencies, const void* symbol,

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

8704 hipMemcpyKind kind);

8705

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

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

8720 hipMemcpyKind kind);

8721

8722

8736hipError_t hipGraphExecMemcpyNodeSetParamsToSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8737 const void* symbol, const void* src,

8738 size_t count, size_t offset, hipMemcpyKind kind);

8739

8751hipError_t hipGraphAddMemsetNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8752 const hipGraphNode_t* pDependencies, size_t numDependencies,

8753 const hipMemsetParams* pMemsetParams);

8754

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

8764

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

8774

8784hipError_t hipGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8785 const hipMemsetParams* pNodeParams);

8786

8798hipError_t hipGraphAddHostNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8799 const hipGraphNode_t* pDependencies, size_t numDependencies,

8800 const hipHostNodeParams* pNodeParams);

8801

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

8811

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

8821

8831hipError_t hipGraphExecHostNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8832 const hipHostNodeParams* pNodeParams);

8833

8845hipError_t hipGraphAddChildGraphNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8846 const hipGraphNode_t* pDependencies, size_t numDependencies,

8847 hipGraph_t childGraph);

8848

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

8858

8868hipError_t hipGraphExecChildGraphNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8869 hipGraph_t childGraph);

8870

8881hipError_t hipGraphAddEmptyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8882 const hipGraphNode_t* pDependencies, size_t numDependencies);

8883

8884

8896hipError_t hipGraphAddEventRecordNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8897 const hipGraphNode_t* pDependencies, size_t numDependencies,

8898 hipEvent_t event);

8899

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

8909

8918hipError_t hipGraphEventRecordNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

8919

8929hipError_t hipGraphExecEventRecordNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8930 hipEvent_t event);

8931

8943hipError_t hipGraphAddEventWaitNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8944 const hipGraphNode_t* pDependencies, size_t numDependencies,

8945 hipEvent_t event);

8946

8947

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

8957

8966hipError_t hipGraphEventWaitNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

8967

8977hipError_t hipGraphExecEventWaitNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8978 hipEvent_t event);

8979

8992hipError_t hipGraphAddMemAllocNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8993 const hipGraphNode_t* pDependencies, size_t numDependencies,

8994 hipMemAllocNodeParams* pNodeParams);

8995

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

9005

9017hipError_t hipGraphAddMemFreeNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

9018 const hipGraphNode_t* pDependencies, size_t numDependencies,

9019 void* dev_ptr);

9020

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

9030

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

9041

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

9052

9060hipError_t hipDeviceGraphMemTrim(int device);

9061

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

9074 unsigned int initialRefcount, unsigned int flags);

9075

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

9085

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

9095

9106hipError_t hipGraphRetainUserObject(hipGraph_t graph, hipUserObject_t object,

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

9108

9118hipError_t hipGraphReleaseUserObject(hipGraph_t graph, hipUserObject_t object,

9119 unsigned int count __dparm(1));

9120

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

9131

9145hipError_t hipGraphKernelNodeCopyAttributes(hipGraphNode_t hSrc, hipGraphNode_t hDst);

9146

9168hipError_t hipGraphNodeSetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9169 unsigned int isEnabled);

9189hipError_t hipGraphNodeGetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9190 unsigned int* isEnabled);

9191

9203hipError_t hipGraphAddExternalSemaphoresWaitNode(

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

9205 size_t numDependencies, const hipExternalSemaphoreWaitNodeParams* nodeParams);

9206

9218hipError_t hipGraphAddExternalSemaphoresSignalNode(

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

9220 size_t numDependencies, const hipExternalSemaphoreSignalNodeParams* nodeParams);

9229hipError_t hipGraphExternalSemaphoresSignalNodeSetParams(

9230 hipGraphNode_t hNode, const hipExternalSemaphoreSignalNodeParams* nodeParams);

9239hipError_t hipGraphExternalSemaphoresWaitNodeSetParams(

9240 hipGraphNode_t hNode, const hipExternalSemaphoreWaitNodeParams* nodeParams);

9249hipError_t hipGraphExternalSemaphoresSignalNodeGetParams(

9250 hipGraphNode_t hNode, hipExternalSemaphoreSignalNodeParams* params_out);

9259hipError_t hipGraphExternalSemaphoresWaitNodeGetParams(

9260 hipGraphNode_t hNode, hipExternalSemaphoreWaitNodeParams* params_out);

9270hipError_t hipGraphExecExternalSemaphoresSignalNodeSetParams(

9271 hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9272 const hipExternalSemaphoreSignalNodeParams* nodeParams);

9282hipError_t hipGraphExecExternalSemaphoresWaitNodeSetParams(

9283 hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9284 const hipExternalSemaphoreWaitNodeParams* nodeParams);

9285

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

9295

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

9305

9318hipError_t hipDrvGraphAddMemsetNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

9319 const hipGraphNode_t* dependencies, size_t numDependencies,

9320 const hipMemsetParams* memsetParams, hipCtx_t ctx);

9321

9333hipError_t hipDrvGraphAddMemFreeNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

9334 const hipGraphNode_t* dependencies, size_t numDependencies,

9335 hipDeviceptr_t dptr);

9336

9347hipError_t hipDrvGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9348 const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);

9349

9360hipError_t hipDrvGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9361 const hipMemsetParams* memsetParams, hipCtx_t ctx);

9362

9363// doxygen end graph API

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

9395

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

9411 unsigned long long flags);

9412

9426hipError_t hipMemCreate(hipMemGenericAllocationHandle_t* handle, size_t size,

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

9428

9442hipError_t hipMemExportToShareableHandle(void* shareableHandle,

9443 hipMemGenericAllocationHandle_t handle,

9444 hipMemAllocationHandleType handleType,

9445 unsigned long long flags);

9446

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

9460

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

9475 hipMemAllocationGranularity_flags option);

9476

9488hipError_t hipMemGetAllocationPropertiesFromHandle(hipMemAllocationProp* prop,

9489 hipMemGenericAllocationHandle_t handle);

9490

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

9504 hipMemAllocationHandleType shHandleType);

9505

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

9521 unsigned long long flags);

9522

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

9534 hipStream_t stream);

9535

9547hipError_t hipMemRelease(hipMemGenericAllocationHandle_t handle);

9548

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

9561

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

9577

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

9590

9591// doxygen end virtual memory management API

9613hipError_t hipGraphicsMapResources(int count, hipGraphicsResource_t* resources,

9614 hipStream_t stream __dparm(0));

9628hipError_t hipGraphicsSubResourceGetMappedArray(hipArray_t* array, hipGraphicsResource_t resource,

9629 unsigned int arrayIndex, unsigned int mipLevel);

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

9641 hipGraphicsResource_t resource);

9652hipError_t hipGraphicsUnmapResources(int count, hipGraphicsResource_t* resources,

9653 hipStream_t stream __dparm(0));

9662hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource);

9663// doxygen end GraphicsInterop

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

9697hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject);

9698// end of surface

9713hipError_t hipExtEnableLogging();

9724hipError_t hipExtDisableLogging();

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

9740

9741#ifdef __cplusplus

9742} /* extern "c" */

9743#endif

9744#ifdef __cplusplus

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

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

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

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

9749 dynSharedMemPerBlk, blockSizeLimit);

9750}

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

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

9753 unsigned int flags = 0) {

9754 (void)flags;

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

9756 dynSharedMemPerBlk, blockSizeLimit);

9757}

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

9759

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

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

9771}

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

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

9784}

9785

9794template <typename T>

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

9796 size_t offset __dparm(0),

9797 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice)) {

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

9799}

9808template <typename T>

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

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

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

9812}

9820template <typename T>

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

9822 size_t offset __dparm(0),

9823 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost)) {

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

9825}

9833template <typename T>

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

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

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

9837}

9838

9850template <class T>

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

9852 size_t dynSharedMemPerBlk) {

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

9854 blockSize, dynSharedMemPerBlk);

9855}

9869template <class T> inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

9871 return hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

9873}

9896template <typename UnaryFunction, class T>

9897static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(

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

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

9900 if (min_grid_size == nullptr || block_size == nullptr ||

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

9902 return hipErrorInvalidValue;

9903 }

9904

9905 int dev;

9906 hipError_t status;

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

9908 return status;

9909 }

9910

9911 int max_threads_per_cu;

9912 if ((status = hipDeviceGetAttribute(&max_threads_per_cu,

9913 hipDeviceAttributeMaxThreadsPerMultiProcessor, dev)) !=

9914 hipSuccess) {

9915 return status;

9916 }

9917

9918 int warp_size;

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

9920 return status;

9921 }

9922

9923 int max_cu_count;

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

9925 hipSuccess) {

9926 return status;

9927 }

9928

9929 struct hipFuncAttributes attr;

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

9931 return status;

9932 }

9933

9934 // Initial limits for the execution

9935 const int func_max_threads_per_block = attr.maxThreadsPerBlock;

9936 if (block_size_limit == 0) {

9937 block_size_limit = func_max_threads_per_block;

9938 }

9939

9940 if (func_max_threads_per_block < block_size_limit) {

9941 block_size_limit = func_max_threads_per_block;

9942 }

9943

9944 const int block_size_limit_aligned =

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

9946

9947 // For maximum search

9948 int max_threads = 0;

9949 int max_block_size{};

9950 int max_num_blocks{};

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

9952 block_size_check_aligned -= warp_size) {

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

9954 int block_size_check =

9955 (block_size_limit < block_size_check_aligned) ? block_size_limit : block_size_check_aligned;

9956

9957 size_t dyn_smem_size = block_size_to_dynamic_smem_size(block_size_check);

9958 int optimal_blocks;

9959 if ((status = hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

9961 return status;

9962 }

9963

9964 int total_threads = block_size_check * optimal_blocks;

9965 if (total_threads > max_threads) {

9966 max_block_size = block_size_check;

9967 max_num_blocks = optimal_blocks;

9968 max_threads = total_threads;

9969 }

9970

9971 // Break if the logic reached possible maximum

9972 if (max_threads_per_cu == max_threads) {

9973 break;

9974 }

9975 }

9976

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

9978 *min_grid_size = max_num_blocks * max_cu_count;

9979 *block_size = max_block_size;

9980

9981 return status;

9982}

9983

10005template <typename UnaryFunction, class T>

10006static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMem(

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

10008 int block_size_limit = 0) {

10009 return hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(

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

10011}

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

10028 int* blockSize, F kernel,

10029 size_t dynSharedMemPerBlk,

10030 uint32_t blockSizeLimit) {

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

10032 dynSharedMemPerBlk, blockSizeLimit);

10033}

10034

10050template <typename F>

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

10052 int numBlocks, int blockSize) {

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

10054 numBlocks, blockSize);

10055}

10077template <class T>

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

10079 unsigned int sharedMemBytes, hipStream_t stream) {

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

10081 kernelParams, sharedMemBytes, stream);

10082}

10098template <class T>

10099inline hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

10100 unsigned int numDevices,

10101 unsigned int flags = 0) {

10102 return hipLaunchCooperativeKernelMultiDevice(launchParamsList, numDevices, flags);

10103}

10116template <class T>

10117inline hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

10118 unsigned int numDevices,

10119 unsigned int flags = 0) {

10120 return hipExtLaunchMultiKernelMultiDevice(launchParamsList, numDevices, flags);

10121}

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

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

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

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

10139}

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

10155static inline hipError_t

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

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

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

10159}

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

10176static inline hipError_t

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

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

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

10180}

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

10198static inline hipError_t

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

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

10201 size_t height, size_t pitch) {

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

10203}

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

10216static inline hipError_t

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

10218 struct hipChannelFormatDesc desc;

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

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

10221}

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

10235static inline hipError_t

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

10237 const struct hipChannelFormatDesc& desc) {

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

10239}

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

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

10253 hipMipmappedArray_const_t mipmappedArray) {

10254 struct hipChannelFormatDesc desc;

10255 hipArray_t levelArray;

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

10257 if (err != hipSuccess) {

10258 return err;

10259 }

10260 err = hipGetChannelDesc(&desc, levelArray);

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

10262}

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

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

10277 hipMipmappedArray_const_t mipmappedArray,

10278 const struct hipChannelFormatDesc& desc) {

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

10280}

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

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

10293 return hipUnbindTexture(&tex);

10294}

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

10319 hipStream_t stream) {

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

10321}

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

10333 hipMemPool_t mem_pool,

10334 hipStream_t stream) {

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

10336}

10347template <class T>

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

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

10350}

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

10362 hipMemPool_t mem_pool,

10363 hipStream_t stream) {

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

10365}

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

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

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

10382 Params&&... args) {

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

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

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

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

10387}

10393#endif // __cplusplus

10394

10395#ifdef __GNUC__

10396#pragma GCC visibility pop

10397#endif

10398

10399

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

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

10402#else

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

10404#endif

10405

10406

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

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

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

10421}

10433template <class T>

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

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

10436}

10449template <class T>

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

10451 unsigned int flags = hipHostMallocDefault) {

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

10453}

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

10467 unsigned int flags = hipHostAllocDefault) {

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

10469}

10484template <class T>

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

10486 unsigned int flags = hipMemAttachGlobal) {

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

10488}

10489

10490

10491#endif

10492#endif

10493// doxygen end HIP API

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

10498

10499#if USE_PROF_API

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

10501#endif

driver_types.h

err

hipError_t err

Definition hip_runtime_api.h:10219

tex

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

Definition hip_runtime_api.h:10136

size

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

Definition hip_runtime_api.h:10137

pitch

const struct texture< T, dim, readMode > const void size_t int enum hipTextureReadMode readMode const struct texture< T, dim, readMode > const void const struct hipChannelFormatDesc size_t int enum hipTextureReadMode readMode const struct texture< T, dim, readMode > const void size_t size_t size_t pitch

Definition hip_runtime_api.h:10178

hipExtEnableLogging

hipError_t hipExtEnableLogging()

Enable HIP runtime logging.

levelArray

hipArray_t levelArray

Definition hip_runtime_api.h:10255

dim

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

Definition hip_runtime_api.h:10154

mipmappedArray

readMode hipMipmappedArray_const_t mipmappedArray

Definition hip_runtime_api.h:10253

height

const struct texture< T, dim, readMode > const void size_t int enum hipTextureReadMode readMode const struct texture< T, dim, readMode > const void const struct hipChannelFormatDesc size_t int enum hipTextureReadMode readMode const struct texture< T, dim, readMode > const void size_t size_t height

Definition hip_runtime_api.h:10178

hipExtDisableLogging

hipError_t hipExtDisableLogging()

Disable HIP runtime logging.

devPtr

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

Definition hip_runtime_api.h:10137

desc

const struct texture< T, dim, readMode > const void size_t int enum hipTextureReadMode readMode const struct texture< T, dim, readMode > const void const struct hipChannelFormatDesc & desc

Definition hip_runtime_api.h:10157

hipExtSetLoggingParams

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

Set HIP runtime logging parameters.

array

readMode hipArray_const_t array

Definition hip_runtime_api.h:10217

width

const struct texture< T, dim, readMode > const void size_t int enum hipTextureReadMode readMode const struct texture< T, dim, readMode > const void const struct hipChannelFormatDesc size_t int enum hipTextureReadMode readMode const struct texture< T, dim, readMode > const void size_t width

Definition hip_runtime_api.h:10178

hipApiName

const char * hipApiName(uint32_t id)

Returns HIP API name by ID.

hipKernelNameRef

const char * hipKernelNameRef(const hipFunction_t f)

Returns kernel name reference by function name.

hipKernelNameRefByPtr

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

Retrives kernel for a given host pointer, unless stated otherwise.

hipGetStreamDeviceId

int hipGetStreamDeviceId(hipStream_t stream)

Returns device ID on the stream.

hipSetupArgument

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

Set a kernel argument.

__hipPopCallConfiguration

hipError_t __hipPopCallConfiguration(dim3 *gridDim, dim3 *blockDim, size_t *sharedMem, hipStream_t *stream)

Pop configuration of a kernel launch.

hipLaunchHostFunc

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

Enqueues a host function call in a stream.

hipLaunchKernel

hipError_t hipLaunchKernel(const void *function_address, dim3 numBlocks, dim3 dimBlocks, void **args, size_t sharedMemBytes, hipStream_t stream)

C compliant kernel launch API.

hipExtLaunchKernel

hipError_t hipExtLaunchKernel(const void *function_address, dim3 numBlocks, dim3 dimBlocks, void **args, size_t sharedMemBytes, hipStream_t stream, hipEvent_t startEvent, hipEvent_t stopEvent, int flags)

Launches kernel from the pointer address, with arguments and shared memory on stream.

__hipPushCallConfiguration

hipError_t __hipPushCallConfiguration(dim3 gridDim, dim3 blockDim, size_t sharedMem, hipStream_t stream)

Push configuration of a kernel launch.

hipLaunchByPtr

hipError_t hipLaunchByPtr(const void *func)

Launch a kernel.

hipDrvMemcpy2DUnaligned

hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D *pCopy)

hipConfigureCall

hipError_t hipConfigureCall(dim3 gridDim, dim3 blockDim, size_t sharedMem, hipStream_t stream)

Configure a kernel launch.

hipCtxGetFlags

hipError_t hipCtxGetFlags(unsigned int *flags)

Return flags used for creating default context [Deprecated].

hipCtxGetApiVersion

hipError_t hipCtxGetApiVersion(hipCtx_t ctx, unsigned int *apiVersion)

Returns the approximate HIP api version.

hipCtxPopCurrent

hipError_t hipCtxPopCurrent(hipCtx_t *ctx)

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

hipCtxGetSharedMemConfig

hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig *pConfig)

Get Shared memory bank configuration [Deprecated].

hipDevicePrimaryCtxSetFlags

hipError_t hipDevicePrimaryCtxSetFlags(hipDevice_t dev, unsigned int flags)

Set flags for the primary context [Deprecated].

hipDevicePrimaryCtxGetState

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

Get the state of the primary context [Deprecated].

hipCtxGetCurrent

hipError_t hipCtxGetCurrent(hipCtx_t *ctx)

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

hipDevicePrimaryCtxRelease

hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev)

Release the primary context on the GPU.

hipCtxSetCacheConfig

hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig)

Set L1/Shared cache partition [Deprecated].

hipCtxSetCurrent

hipError_t hipCtxSetCurrent(hipCtx_t ctx)

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

hipCtxEnablePeerAccess

hipError_t hipCtxEnablePeerAccess(hipCtx_t peerCtx, unsigned int flags)

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

hipCtxGetDevice

hipError_t hipCtxGetDevice(hipDevice_t *device)

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

hipCtxDestroy

hipError_t hipCtxDestroy(hipCtx_t ctx)

Destroy a HIP context [Deprecated].

hipCtxPushCurrent

hipError_t hipCtxPushCurrent(hipCtx_t ctx)

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

hipCtxGetCacheConfig

hipError_t hipCtxGetCacheConfig(hipFuncCache_t *cacheConfig)

Get Cache configuration for a specific function [Deprecated].

hipCtxCreate

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

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

hipDevicePrimaryCtxRetain

hipError_t hipDevicePrimaryCtxRetain(hipCtx_t *pctx, hipDevice_t dev)

Retain the primary context on the GPU [Deprecated].

hipDevicePrimaryCtxReset

hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev)

Resets the primary context on the GPU [Deprecated].

hipCtxSynchronize

hipError_t hipCtxSynchronize(void)

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

hipCtxSetSharedMemConfig

hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config)

Set Shared memory bank configuration [Deprecated].

hipCtxDisablePeerAccess

hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx)

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

hipGetDeviceFlags

hipError_t hipGetDeviceFlags(unsigned int *flags)

Gets the flags set for current device.

hipIpcGetEventHandle

hipError_t hipIpcGetEventHandle(hipIpcEventHandle_t *handle, hipEvent_t event)

Gets an opaque interprocess handle for an event.

hipDeviceGetDefaultMemPool

hipError_t hipDeviceGetDefaultMemPool(hipMemPool_t *mem_pool, int device)

Returns the default memory pool of the specified device.

hipDeviceGetSharedMemConfig

hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig *pConfig)

Returns bank width of shared memory for current device.

hipDeviceSetMemPool

hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool)

Sets the current memory pool of a device.

hipIpcOpenMemHandle

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

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

hipDeviceGetCacheConfig

hipError_t hipDeviceGetCacheConfig(hipFuncCache_t *cacheConfig)

Get Cache configuration for a specific Device.

hipSetDevice

hipError_t hipSetDevice(int deviceId)

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

hipExtGetLinkTypeAndHopCount

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

Returns the link type and hop count between two devices.

hipDeviceGetTexture1DLinearMaxWidth

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

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

hipSetDeviceFlags

hipError_t hipSetDeviceFlags(unsigned flags)

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

hipDeviceGetAttribute

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

Query for a specific device attribute.

hipGetDevice

hipError_t hipGetDevice(int *deviceId)

Return the default device id for the calling host thread.

hipGetDeviceCount

hipError_t hipGetDeviceCount(int *count)

Return number of compute-capable devices.

hipDeviceGetMemPool

hipError_t hipDeviceGetMemPool(hipMemPool_t *mem_pool, int device)

Gets the current memory pool for the specified device.

hipDeviceReset

hipError_t hipDeviceReset(void)

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

hipDeviceGetLimit

hipError_t hipDeviceGetLimit(size_t *pValue, enum hipLimit_t limit)

Gets resource limits of current device.

hipDeviceSetSharedMemConfig

hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config)

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

hipDeviceSetLimit

hipError_t hipDeviceSetLimit(enum hipLimit_t limit, size_t value)

Sets resource limits of current device.

hipDeviceSetCacheConfig

hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig)

Set L1/Shared cache partition.

hipIpcCloseMemHandle

hipError_t hipIpcCloseMemHandle(void *devPtr)

Close memory mapped with hipIpcOpenMemHandle.

hipSetValidDevices

hipError_t hipSetValidDevices(int *device_arr, int len)

Set a list of devices that can be used.

hipIpcOpenEventHandle

hipError_t hipIpcOpenEventHandle(hipEvent_t *event, hipIpcEventHandle_t handle)

Opens an interprocess event handles.

hipDeviceSynchronize

hipError_t hipDeviceSynchronize(void)

Waits on all active streams on current device.

hipIpcGetMemHandle

hipError_t hipIpcGetMemHandle(hipIpcMemHandle_t *handle, void *devPtr)

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

hipInit

hipError_t hipInit(unsigned int flags)

Explicitly initializes the HIP runtime.

hipDeviceComputeCapability

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

Returns the compute capability of the device.

hipDeviceGetName

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

Returns an identifer string for the device.

hipDeviceGetByPCIBusId

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

Returns a handle to a compute device.

hipDeviceGetUuid

hipError_t hipDeviceGetUuid(hipUUID *uuid, hipDevice_t device)

Returns an UUID for the device.[BETA].

hipDeviceTotalMem

hipError_t hipDeviceTotalMem(size_t *bytes, hipDevice_t device)

Returns the total amount of memory on the device.

hipDeviceGetPCIBusId

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

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

hipDeviceGet

hipError_t hipDeviceGet(hipDevice_t *device, int ordinal)

Returns a handle to a compute device.

hipRuntimeGetVersion

hipError_t hipRuntimeGetVersion(int *runtimeVersion)

Returns the approximate HIP Runtime version.

hipDeviceGetP2PAttribute

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

Returns a value for attribute of link between two devices.

hipDriverGetVersion

hipError_t hipDriverGetVersion(int *driverVersion)

Returns the approximate HIP driver version.

hipMemcpyKind

hipMemcpyKind

Definition driver_types.h:357

hipPointer_attribute

hipPointer_attribute

Definition driver_types.h:629

hipArray_t

struct hipArray * hipArray_t

Definition driver_types.h:59

hipDeviceptr_t

void * hipDeviceptr_t

Definition driver_types.h:30

hipFunction_attribute

hipFunction_attribute

Definition driver_types.h:608

hipArray_const_t

const struct hipArray * hipArray_const_t

Definition driver_types.h:60

hipArray_Format

hipArray_Format

Definition driver_types.h:64

hipResourceType

hipResourceType

Definition driver_types.h:143

hipMemcpyDeviceToHost

@ hipMemcpyDeviceToHost

Device-to-Host Copy.

Definition driver_types.h:360

hipMemcpyHostToDevice

@ hipMemcpyHostToDevice

Host-to-Device Copy.

Definition driver_types.h:359

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

hipKernelGetFunction

hipError_t hipKernelGetFunction(hipFunction_t *pFunc, hipKernel_t kernel)

Function will be extracted for specific kernel.

hipModuleLaunchKernel

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

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

hipFuncSetSharedMemConfig

hipError_t hipFuncSetSharedMemConfig(const void *func, hipSharedMemConfig config)

Set shared memory configuation for a specific function.

hipFuncGetAttribute

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

Find out a specific attribute for a given function.

hipFuncSetAttribute

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

Set attribute for a specific function.

hipDrvLaunchKernelEx

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

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

hipKernelSetAttribute

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

Set attribute for a specific kernel.

hipFuncSetCacheConfig

hipError_t hipFuncSetCacheConfig(const void *func, hipFuncCache_t config)

Set Cache configuration for a specific function.

hipDestroyExternalMemory

hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem)

Destroys an external memory object.

hipImportExternalSemaphore

hipError_t hipImportExternalSemaphore(hipExternalSemaphore_t *extSem_out, const hipExternalSemaphoreHandleDesc *semHandleDesc)

Imports an external semaphore.

hipImportExternalMemory

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

Imports an external memory object.

hipDestroyExternalSemaphore

hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem)

Destroys an external semaphore object and releases any references to the underlying resource....

hipWaitExternalSemaphoresAsync

hipError_t hipWaitExternalSemaphoresAsync(const hipExternalSemaphore_t *extSemArray, const hipExternalSemaphoreWaitParams *paramsArray, unsigned int numExtSems, hipStream_t stream)

Waits on a set of external semaphore objects.

hipSignalExternalSemaphoresAsync

hipError_t hipSignalExternalSemaphoresAsync(const hipExternalSemaphore_t *extSemArray, const hipExternalSemaphoreSignalParams *paramsArray, unsigned int numExtSems, hipStream_t stream)

Signals a set of external semaphore objects.

hipExternalMemoryGetMappedMipmappedArray

hipError_t hipExternalMemoryGetMappedMipmappedArray(hipMipmappedArray_t *mipmap, hipExternalMemory_t extMem, const hipExternalMemoryMipmappedArrayDesc *mipmapDesc)

Maps a mipmapped array onto an external memory object.

hipExternalMemoryGetMappedBuffer

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

Maps a buffer onto an imported memory object.

hipLimit_t

hipLimit_t

Definition hip_runtime_api.h:724

hipMemRangeHandleType

hipMemRangeHandleType

Definition hip_runtime_api.h:2016

hipMemAllocationHandleType

hipMemAllocationHandleType

Definition hip_runtime_api.h:1222

hipGraphicsResource_t

hipGraphicsResource * hipGraphicsResource_t

Definition hip_runtime_api.h:1445

hipCtx_t

struct ihipCtx_t * hipCtx_t

Definition hip_runtime_api.h:671

__dparm

#define __dparm(x)

Definition hip_runtime_api.h:653

hipStream_t

struct ihipStream_t * hipStream_t

Definition hip_runtime_api.h:685

hipGraphInstantiateResult

hipGraphInstantiateResult

Definition hip_runtime_api.h:1722

hipDevice_t

int hipDevice_t

Definition hip_runtime_api.h:673

hipAccessProperty

hipAccessProperty

Definition hip_runtime_api.h:1523

hipLinkState_t

struct ihipLinkState_t * hipLinkState_t

Definition hip_runtime_api.h:696

hipGraphDependencyType

hipGraphDependencyType

Definition hip_runtime_api.h:1944

hipMemRangeAttribute

hipMemRangeAttribute

Definition hip_runtime_api.h:1115

hipMemAttachSingle

#define hipMemAttachSingle

Definition hip_runtime_api.h:877

hipMemoryAdvise

hipMemoryAdvise

Definition hip_runtime_api.h:1082

hipArrayDefault

#define hipArrayDefault

Definition hip_runtime_api.h:936

hipSharedMemConfig

hipSharedMemConfig

Definition hip_runtime_api.h:1274

hipKernelNodeAttrValue

#define hipKernelNodeAttrValue

Definition hip_runtime_api.h:1625

hipComputeMode

hipComputeMode

Definition hip_runtime_api.h:613

hipEvent_t

struct ihipEvent_t * hipEvent_t

Definition hip_runtime_api.h:716

hipStreamCaptureMode

hipStreamCaptureMode

Definition hip_runtime_api.h:1654

hipStreamBatchMemOpType

hipStreamBatchMemOpType

Definition hip_runtime_api.h:957

hipDriverProcAddressQueryResult

hipDriverProcAddressQueryResult

Definition hip_runtime_api.h:607

HIP_DEPRECATED_MSG

#define HIP_DEPRECATED_MSG

Definition hip_runtime_api.h:645

hipLaunchAttributeID

hipLaunchAttributeID

Definition hip_runtime_api.h:1571

hipKernel_t

struct ihipKernel_t * hipKernel_t

Definition hip_runtime_api.h:698

hipSynchronizationPolicy

hipSynchronizationPolicy

Definition hip_runtime_api.h:1561

hipGraphNodeType

hipGraphNodeType

Definition hip_runtime_api.h:1469

hipExternalMemoryHandleType

hipExternalMemoryHandleType

Definition hip_runtime_api.h:1319

hipMemAttachGlobal

#define hipMemAttachGlobal

Definition hip_runtime_api.h:871

hipLibrary_t

struct ihipLibrary_t * hipLibrary_t

Definition hip_runtime_api.h:697

hipFuncAttribute

hipFuncAttribute

Definition hip_runtime_api.h:1255

hipExternalSemaphoreHandleType

hipExternalSemaphoreHandleType

Definition hip_runtime_api.h:1357

hipLaunchMemSyncDomain

hipLaunchMemSyncDomain

Definition hip_runtime_api.h:1552

hipDeviceP2PAttr

hipDeviceP2PAttr

Definition hip_runtime_api.h:674

hipGraphDebugDotFlags

hipGraphDebugDotFlags

Definition hip_runtime_api.h:1700

hipUserObjectRetainFlags

hipUserObjectRetainFlags

Definition hip_runtime_api.h:1685

hipStreamAttrID

#define hipStreamAttrID

Definition hip_runtime_api.h:1605

hipError_t

enum __HIP_NODISCARD hipError_t hipError_t

Definition hip_runtime_api.h:289

hipHostAllocDefault

#define hipHostAllocDefault

Definition hip_runtime_api.h:813

hipHostFn_t

void(* hipHostFn_t)(void *userData)

Definition hip_runtime_api.h:1488

hipOccupancyDefault

#define hipOccupancyDefault

Definition hip_runtime_api.h:941

hipStreamUpdateCaptureDependenciesFlags

hipStreamUpdateCaptureDependenciesFlags

Definition hip_runtime_api.h:1666

hipGraph_t

struct ihipGraph * hipGraph_t

Definition hip_runtime_api.h:1450

hipChooseDevice

#define hipChooseDevice

Definition hip_runtime_api.h:89

hipMemHandleType

hipMemHandleType

Definition hip_runtime_api.h:1804

hipFlushGPUDirectRDMAWritesOptions

hipFlushGPUDirectRDMAWritesOptions

Definition hip_runtime_api.h:620

hipFuncCache_t

hipFuncCache_t

Definition hip_runtime_api.h:1265

hipUserObjectFlags

hipUserObjectFlags

Definition hip_runtime_api.h:1681

__HIP_NODISCARD

#define __HIP_NODISCARD

Definition hip_runtime_api.h:279

hipGraphMemAttributeType

hipGraphMemAttributeType

Definition hip_runtime_api.h:1671

hipMemPoolAttr

hipMemPoolAttr

Definition hip_runtime_api.h:1130

hipDriverEntryPointQueryResult

hipDriverEntryPointQueryResult

Definition hip_runtime_api.h:680

hipMemRangeFlags

hipMemRangeFlags

Definition hip_runtime_api.h:2024

hipDeviceProp_t

#define hipDeviceProp_t

Definition hip_runtime_api.h:88

hipModule_t

struct ihipModule_t * hipModule_t

Definition hip_runtime_api.h:694

hipUserObject_t

struct hipUserObject * hipUserObject_t

Definition hip_runtime_api.h:1463

hipMemOperationType

hipMemOperationType

Definition hip_runtime_api.h:1811

hipExternalSemaphore_t

void * hipExternalSemaphore_t

Definition hip_runtime_api.h:1382

hipGraphicsRegisterFlags

hipGraphicsRegisterFlags

Definition hip_runtime_api.h:1433

hipStreamAttrValue

#define hipStreamAttrValue

Definition hip_runtime_api.h:1612

hipMemRangeCoherencyMode

hipMemRangeCoherencyMode

Definition hip_runtime_api.h:1103

hipMemAccessFlags

hipMemAccessFlags

Definition hip_runtime_api.h:1190

hipMemAllocationGranularity_flags

hipMemAllocationGranularity_flags

Definition hip_runtime_api.h:1796

hipGraphExec_t

struct hipGraphExec * hipGraphExec_t

Definition hip_runtime_api.h:1458

hipGraphExecUpdateResult

hipGraphExecUpdateResult

Definition hip_runtime_api.h:1639

hipFunction_t

struct ihipModuleSymbol_t * hipFunction_t

Definition hip_runtime_api.h:695

hipKernelNodeAttrID

#define hipKernelNodeAttrID

Definition hip_runtime_api.h:1617

hipExternalMemory_t

void * hipExternalMemory_t

Definition hip_runtime_api.h:1356

hipStreamCaptureStatus

hipStreamCaptureStatus

Definition hip_runtime_api.h:1659

hipDeviceAttribute_t

hipDeviceAttribute_t

Definition hip_runtime_api.h:411

hipGPUDirectRDMAWritesOrdering

hipGPUDirectRDMAWritesOrdering

Definition hip_runtime_api.h:625

hipGetDeviceProperties

#define hipGetDeviceProperties

Definition hip_runtime_api.h:87

hipHostMallocDefault

#define hipHostMallocDefault

Definition hip_runtime_api.h:817

HIP_DEPRECATED

#define HIP_DEPRECATED(msg)

Definition hip_runtime_api.h:643

hipGraphicsResource

struct _hipGraphicsResource hipGraphicsResource

Definition hip_runtime_api.h:1443

hipMemAllocationType

hipMemAllocationType

Definition hip_runtime_api.h:1208

hipGraphNode_t

struct hipGraphNode * hipGraphNode_t

Definition hip_runtime_api.h:1454

hipMemGenericAllocationHandle_t

struct ihipMemGenericAllocationHandle * hipMemGenericAllocationHandle_t

Definition hip_runtime_api.h:1791

hipMemoryType

hipMemoryType

Definition hip_runtime_api.h:247

hipGraphInstantiateFlags

hipGraphInstantiateFlags

Definition hip_runtime_api.h:1689

HIP_IPC_HANDLE_SIZE

#define HIP_IPC_HANDLE_SIZE

Definition hip_runtime_api.h:687

hipMemPool_t

struct ihipMemPoolHandle_t * hipMemPool_t

Definition hip_runtime_api.h:702

hipArraySparseSubresourceType

hipArraySparseSubresourceType

Definition hip_runtime_api.h:1819

hipExtLimitScratchMin

@ hipExtLimitScratchMin

Definition hip_runtime_api.h:732

hipLimitMallocHeapSize

@ hipLimitMallocHeapSize

Definition hip_runtime_api.h:730

hipLimitStackSize

@ hipLimitStackSize

Definition hip_runtime_api.h:725

hipLimitRange

@ hipLimitRange

Supported limit range.

Definition hip_runtime_api.h:740

hipLimitPrintfFifoSize

@ hipLimitPrintfFifoSize

Definition hip_runtime_api.h:728

hipExtLimitScratchMax

@ hipExtLimitScratchMax

Definition hip_runtime_api.h:734

hipExtLimitScratchCurrent

@ hipExtLimitScratchCurrent

Definition hip_runtime_api.h:736

hipMemRangeHandleTypeMax

@ hipMemRangeHandleTypeMax

Definition hip_runtime_api.h:2018

hipMemRangeHandleTypeDmaBufFd

@ hipMemRangeHandleTypeDmaBufFd

Definition hip_runtime_api.h:2017

hipMemHandleTypeWin32

@ hipMemHandleTypeWin32

Allows a Win32 NT handle for exporting. (HANDLE)

Definition hip_runtime_api.h:1226

hipMemHandleTypeWin32Kmt

@ hipMemHandleTypeWin32Kmt

Allows a Win32 KMT handle for exporting. (D3DKMT_HANDLE)

Definition hip_runtime_api.h:1227

hipMemHandleTypeNone

@ hipMemHandleTypeNone

Does not allow any export mechanism.

Definition hip_runtime_api.h:1223

hipMemHandleTypePosixFileDescriptor

@ hipMemHandleTypePosixFileDescriptor

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

Definition hip_runtime_api.h:1224

hipGraphInstantiateNodeOperationNotSupported

@ hipGraphInstantiateNodeOperationNotSupported

Definition hip_runtime_api.h:1728

hipGraphInstantiateMultipleDevicesNotSupported

@ hipGraphInstantiateMultipleDevicesNotSupported

Definition hip_runtime_api.h:1730

hipGraphInstantiateError

@ hipGraphInstantiateError

Definition hip_runtime_api.h:1724

hipGraphInstantiateInvalidStructure

@ hipGraphInstantiateInvalidStructure

Definition hip_runtime_api.h:1726

hipGraphInstantiateSuccess

@ hipGraphInstantiateSuccess

Definition hip_runtime_api.h:1723

hipAccessPropertyNormal

@ hipAccessPropertyNormal

Normal cache persistence.

Definition hip_runtime_api.h:1524

hipAccessPropertyPersisting

@ hipAccessPropertyPersisting

Persisting access is more likely to persist in cache.

Definition hip_runtime_api.h:1526

hipAccessPropertyStreaming

@ hipAccessPropertyStreaming

Streaming access is less likely to persist from cache.

Definition hip_runtime_api.h:1525

hipGraphDependencyTypeDefault

@ hipGraphDependencyTypeDefault

Definition hip_runtime_api.h:1945

hipGraphDependencyTypeProgrammatic

@ hipGraphDependencyTypeProgrammatic

Definition hip_runtime_api.h:1946

hipMemRangeAttributeLastPrefetchLocation

@ hipMemRangeAttributeLastPrefetchLocation

Definition hip_runtime_api.h:1121

hipMemRangeAttributePreferredLocation

@ hipMemRangeAttributePreferredLocation

The preferred location of the range.

Definition hip_runtime_api.h:1118

hipMemRangeAttributeAccessedBy

@ hipMemRangeAttributeAccessedBy

Definition hip_runtime_api.h:1119

hipMemRangeAttributeReadMostly

@ hipMemRangeAttributeReadMostly

Definition hip_runtime_api.h:1116

hipMemRangeAttributeCoherencyMode

@ hipMemRangeAttributeCoherencyMode

Definition hip_runtime_api.h:1123

hipMemAdviseUnsetAccessedBy

@ hipMemAdviseUnsetAccessedBy

Definition hip_runtime_api.h:1091

hipMemAdviseUnsetCoarseGrain

@ hipMemAdviseUnsetCoarseGrain

Restores cache coherency policy back to fine-grain.

Definition hip_runtime_api.h:1098

hipMemAdviseSetCoarseGrain

@ hipMemAdviseSetCoarseGrain

Definition hip_runtime_api.h:1093

hipMemAdviseUnsetPreferredLocation

@ hipMemAdviseUnsetPreferredLocation

Clear the preferred location for the data.

Definition hip_runtime_api.h:1088

hipMemAdviseSetAccessedBy

@ hipMemAdviseSetAccessedBy

Definition hip_runtime_api.h:1089

hipMemAdviseSetPreferredLocation

@ hipMemAdviseSetPreferredLocation

Definition hip_runtime_api.h:1086

hipMemAdviseSetReadMostly

@ hipMemAdviseSetReadMostly

Definition hip_runtime_api.h:1083

hipMemAdviseUnsetReadMostly

@ hipMemAdviseUnsetReadMostly

Undo the effect of hipMemAdviseSetReadMostly.

Definition hip_runtime_api.h:1085

hipSharedMemBankSizeFourByte

@ hipSharedMemBankSizeFourByte

Definition hip_runtime_api.h:1276

hipSharedMemBankSizeEightByte

@ hipSharedMemBankSizeEightByte

Definition hip_runtime_api.h:1278

hipSharedMemBankSizeDefault

@ hipSharedMemBankSizeDefault

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

Definition hip_runtime_api.h:1275

hipComputeModeProhibited

@ hipComputeModeProhibited

Definition hip_runtime_api.h:616

hipComputeModeExclusive

@ hipComputeModeExclusive

Definition hip_runtime_api.h:615

hipComputeModeDefault

@ hipComputeModeDefault

Definition hip_runtime_api.h:614

hipComputeModeExclusiveProcess

@ hipComputeModeExclusiveProcess

Definition hip_runtime_api.h:617

hipStreamCaptureModeRelaxed

@ hipStreamCaptureModeRelaxed

Definition hip_runtime_api.h:1657

hipStreamCaptureModeThreadLocal

@ hipStreamCaptureModeThreadLocal

Definition hip_runtime_api.h:1656

hipStreamCaptureModeGlobal

@ hipStreamCaptureModeGlobal

Definition hip_runtime_api.h:1655

hipStreamMemOpWriteValue64

@ hipStreamMemOpWriteValue64

Definition hip_runtime_api.h:961

hipStreamMemOpBarrier

@ hipStreamMemOpBarrier

Currently not supported.

Definition hip_runtime_api.h:962

hipStreamMemOpWriteValue32

@ hipStreamMemOpWriteValue32

Definition hip_runtime_api.h:959

hipStreamMemOpWaitValue32

@ hipStreamMemOpWaitValue32

Definition hip_runtime_api.h:958

hipStreamMemOpWaitValue64

@ hipStreamMemOpWaitValue64

Definition hip_runtime_api.h:960

hipStreamMemOpFlushRemoteWrites

@ hipStreamMemOpFlushRemoteWrites

Currently not supported.

Definition hip_runtime_api.h:963

HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND

@ HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND

Definition hip_runtime_api.h:609

HIP_GET_PROC_ADDRESS_SUCCESS

@ HIP_GET_PROC_ADDRESS_SUCCESS

Definition hip_runtime_api.h:608

HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT

@ HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT

Definition hip_runtime_api.h:610

hipLaunchAttributePriority

@ hipLaunchAttributePriority

Valid for graph node, streams, launches.

Definition hip_runtime_api.h:1575

hipLaunchAttributeMax

@ hipLaunchAttributeMax

Definition hip_runtime_api.h:1578

hipLaunchAttributeMemSyncDomain

@ hipLaunchAttributeMemSyncDomain

Valid for streams, graph nodes, launches.

Definition hip_runtime_api.h:1577

hipLaunchAttributeMemSyncDomainMap

@ hipLaunchAttributeMemSyncDomainMap

Valid for streams, graph nodes, launches.

Definition hip_runtime_api.h:1576

hipLaunchAttributeSynchronizationPolicy

@ hipLaunchAttributeSynchronizationPolicy

Valid for streams.

Definition hip_runtime_api.h:1574

hipLaunchAttributeAccessPolicyWindow

@ hipLaunchAttributeAccessPolicyWindow

Valid for Streams, graph nodes, launches.

Definition hip_runtime_api.h:1572

hipLaunchAttributeCooperative

@ hipLaunchAttributeCooperative

Valid for graph nodes, launches.

Definition hip_runtime_api.h:1573

hipSyncPolicyYield

@ hipSyncPolicyYield

Definition hip_runtime_api.h:1564

hipSyncPolicyBlockingSync

@ hipSyncPolicyBlockingSync

Definition hip_runtime_api.h:1565

hipSyncPolicyAuto

@ hipSyncPolicyAuto

Definition hip_runtime_api.h:1562

hipSyncPolicySpin

@ hipSyncPolicySpin

Definition hip_runtime_api.h:1563

hipGraphNodeTypeBatchMemOp

@ hipGraphNodeTypeBatchMemOp

BatchMemOp node.

Definition hip_runtime_api.h:1484

hipGraphNodeTypeGraph

@ hipGraphNodeTypeGraph

Node which executes an embedded graph.

Definition hip_runtime_api.h:1474

hipGraphNodeTypeMemset

@ hipGraphNodeTypeMemset

Memset node.

Definition hip_runtime_api.h:1472

hipGraphNodeTypeEventRecord

@ hipGraphNodeTypeEventRecord

External event record node.

Definition hip_runtime_api.h:1477

hipGraphNodeTypeExtSemaphoreSignal

@ hipGraphNodeTypeExtSemaphoreSignal

External Semaphore signal node.

Definition hip_runtime_api.h:1478

hipGraphNodeTypeMemcpy

@ hipGraphNodeTypeMemcpy

Memcpy node.

Definition hip_runtime_api.h:1471

hipGraphNodeTypeWaitEvent

@ hipGraphNodeTypeWaitEvent

External event wait node.

Definition hip_runtime_api.h:1476

hipGraphNodeTypeCount

@ hipGraphNodeTypeCount

Definition hip_runtime_api.h:1485

hipGraphNodeTypeKernel

@ hipGraphNodeTypeKernel

GPU kernel node.

Definition hip_runtime_api.h:1470

hipGraphNodeTypeHost

@ hipGraphNodeTypeHost

Host (executable) node.

Definition hip_runtime_api.h:1473

hipGraphNodeTypeMemAlloc

@ hipGraphNodeTypeMemAlloc

Memory alloc node.

Definition hip_runtime_api.h:1480

hipGraphNodeTypeMemFree

@ hipGraphNodeTypeMemFree

Memory free node.

Definition hip_runtime_api.h:1481

hipGraphNodeTypeMemcpyFromSymbol

@ hipGraphNodeTypeMemcpyFromSymbol

MemcpyFromSymbol node.

Definition hip_runtime_api.h:1482

hipGraphNodeTypeMemcpyToSymbol

@ hipGraphNodeTypeMemcpyToSymbol

MemcpyToSymbol node.

Definition hip_runtime_api.h:1483

hipGraphNodeTypeEmpty

@ hipGraphNodeTypeEmpty

Empty (no-op) node.

Definition hip_runtime_api.h:1475

hipGraphNodeTypeExtSemaphoreWait

@ hipGraphNodeTypeExtSemaphoreWait

External Semaphore wait node.

Definition hip_runtime_api.h:1479

hipExternalMemoryHandleTypeD3D11Resource

@ hipExternalMemoryHandleTypeD3D11Resource

Definition hip_runtime_api.h:1325

hipExternalMemoryHandleTypeD3D12Resource

@ hipExternalMemoryHandleTypeD3D12Resource

Definition hip_runtime_api.h:1324

hipExternalMemoryHandleTypeNvSciBuf

@ hipExternalMemoryHandleTypeNvSciBuf

Definition hip_runtime_api.h:1327

hipExternalMemoryHandleTypeOpaqueFd

@ hipExternalMemoryHandleTypeOpaqueFd

Definition hip_runtime_api.h:1320

hipExternalMemoryHandleTypeD3D12Heap

@ hipExternalMemoryHandleTypeD3D12Heap

Definition hip_runtime_api.h:1323

hipExternalMemoryHandleTypeOpaqueWin32Kmt

@ hipExternalMemoryHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:1322

hipExternalMemoryHandleTypeOpaqueWin32

@ hipExternalMemoryHandleTypeOpaqueWin32

Definition hip_runtime_api.h:1321

hipExternalMemoryHandleTypeD3D11ResourceKmt

@ hipExternalMemoryHandleTypeD3D11ResourceKmt

Definition hip_runtime_api.h:1326

hipFuncAttributePreferredSharedMemoryCarveout

@ hipFuncAttributePreferredSharedMemoryCarveout

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

Definition hip_runtime_api.h:1258

hipFuncAttributeMaxDynamicSharedMemorySize

@ hipFuncAttributeMaxDynamicSharedMemorySize

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

Definition hip_runtime_api.h:1256

hipFuncAttributeMax

@ hipFuncAttributeMax

Definition hip_runtime_api.h:1260

hipExternalSemaphoreHandleTypeNvSciSync

@ hipExternalSemaphoreHandleTypeNvSciSync

Definition hip_runtime_api.h:1363

hipExternalSemaphoreHandleTypeKeyedMutexKmt

@ hipExternalSemaphoreHandleTypeKeyedMutexKmt

Definition hip_runtime_api.h:1365

hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

@ hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:1360

hipExternalSemaphoreHandleTypeKeyedMutex

@ hipExternalSemaphoreHandleTypeKeyedMutex

Definition hip_runtime_api.h:1364

hipExternalSemaphoreHandleTypeD3D11Fence

@ hipExternalSemaphoreHandleTypeD3D11Fence

Definition hip_runtime_api.h:1362

hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

@ hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

Definition hip_runtime_api.h:1367

hipExternalSemaphoreHandleTypeOpaqueFd

@ hipExternalSemaphoreHandleTypeOpaqueFd

Definition hip_runtime_api.h:1358

hipExternalSemaphoreHandleTypeOpaqueWin32

@ hipExternalSemaphoreHandleTypeOpaqueWin32

Definition hip_runtime_api.h:1359

hipExternalSemaphoreHandleTypeTimelineSemaphoreFd

@ hipExternalSemaphoreHandleTypeTimelineSemaphoreFd

Definition hip_runtime_api.h:1366

hipExternalSemaphoreHandleTypeD3D12Fence

@ hipExternalSemaphoreHandleTypeD3D12Fence

Definition hip_runtime_api.h:1361

hipLaunchMemSyncDomainRemote

@ hipLaunchMemSyncDomainRemote

Definition hip_runtime_api.h:1554

hipLaunchMemSyncDomainDefault

@ hipLaunchMemSyncDomainDefault

Definition hip_runtime_api.h:1553

hipDevP2PAttrAccessSupported

@ hipDevP2PAttrAccessSupported

Definition hip_runtime_api.h:676

hipDevP2PAttrHipArrayAccessSupported

@ hipDevP2PAttrHipArrayAccessSupported

Definition hip_runtime_api.h:678

hipDevP2PAttrNativeAtomicSupported

@ hipDevP2PAttrNativeAtomicSupported

Definition hip_runtime_api.h:677

hipDevP2PAttrPerformanceRank

@ hipDevP2PAttrPerformanceRank

Definition hip_runtime_api.h:675

hipGraphDebugDotFlagsKernelNodeAttributes

@ hipGraphDebugDotFlagsKernelNodeAttributes

Definition hip_runtime_api.h:1713

hipGraphDebugDotFlagsMemsetNodeParams

@ hipGraphDebugDotFlagsMemsetNodeParams

Definition hip_runtime_api.h:1705

hipGraphDebugDotFlagsKernelNodeParams

@ hipGraphDebugDotFlagsKernelNodeParams

Definition hip_runtime_api.h:1703

hipGraphDebugDotFlagsExtSemasWaitNodeParams

@ hipGraphDebugDotFlagsExtSemasWaitNodeParams

Definition hip_runtime_api.h:1711

hipGraphDebugDotFlagsHandles

@ hipGraphDebugDotFlagsHandles

Definition hip_runtime_api.h:1715

hipGraphDebugDotFlagsExtSemasSignalNodeParams

@ hipGraphDebugDotFlagsExtSemasSignalNodeParams

Definition hip_runtime_api.h:1709

hipGraphDebugDotFlagsHostNodeParams

@ hipGraphDebugDotFlagsHostNodeParams

Definition hip_runtime_api.h:1706

hipGraphDebugDotFlagsEventNodeParams

@ hipGraphDebugDotFlagsEventNodeParams

Definition hip_runtime_api.h:1707

hipGraphDebugDotFlagsVerbose

@ hipGraphDebugDotFlagsVerbose

Definition hip_runtime_api.h:1701

hipGraphDebugDotFlagsMemcpyNodeParams

@ hipGraphDebugDotFlagsMemcpyNodeParams

Definition hip_runtime_api.h:1704

hipGraphUserObjectMove

@ hipGraphUserObjectMove

Add new reference or retain.

Definition hip_runtime_api.h:1686

hipStreamAddCaptureDependencies

@ hipStreamAddCaptureDependencies

Add new nodes to the dependency set.

Definition hip_runtime_api.h:1667

hipStreamSetCaptureDependencies

@ hipStreamSetCaptureDependencies

Replace the dependency set with the new nodes.

Definition hip_runtime_api.h:1668

hipMemHandleTypeGeneric

@ hipMemHandleTypeGeneric

Generic handle type.

Definition hip_runtime_api.h:1805

hipFlushGPUDirectRDMAWritesOptionHost

@ hipFlushGPUDirectRDMAWritesOptionHost

Definition hip_runtime_api.h:621

hipFlushGPUDirectRDMAWritesOptionMemOps

@ hipFlushGPUDirectRDMAWritesOptionMemOps

Definition hip_runtime_api.h:622

hipFuncCachePreferNone

@ hipFuncCachePreferNone

no preference for shared memory or L1 (default)

Definition hip_runtime_api.h:1266

hipFuncCachePreferEqual

@ hipFuncCachePreferEqual

prefer equal size L1 cache and shared memory

Definition hip_runtime_api.h:1269

hipFuncCachePreferL1

@ hipFuncCachePreferL1

prefer larger L1 cache and smaller shared memory

Definition hip_runtime_api.h:1268

hipFuncCachePreferShared

@ hipFuncCachePreferShared

prefer larger shared memory and smaller L1 cache

Definition hip_runtime_api.h:1267

hipUserObjectNoDestructorSync

@ hipUserObjectNoDestructorSync

Destructor execution is not synchronized.

Definition hip_runtime_api.h:1682

hipGraphMemAttrReservedMemHigh

@ hipGraphMemAttrReservedMemHigh

Definition hip_runtime_api.h:1678

hipGraphMemAttrUsedMemCurrent

@ hipGraphMemAttrUsedMemCurrent

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

Definition hip_runtime_api.h:1672

hipGraphMemAttrUsedMemHigh

@ hipGraphMemAttrUsedMemHigh

Definition hip_runtime_api.h:1674

hipGraphMemAttrReservedMemCurrent

@ hipGraphMemAttrReservedMemCurrent

Definition hip_runtime_api.h:1676

hipMemPoolAttrUsedMemCurrent

@ hipMemPoolAttrUsedMemCurrent

Definition hip_runtime_api.h:1177

hipMemPoolAttrReservedMemHigh

@ hipMemPoolAttrReservedMemHigh

Definition hip_runtime_api.h:1172

hipMemPoolAttrReservedMemCurrent

@ hipMemPoolAttrReservedMemCurrent

Definition hip_runtime_api.h:1166

hipMemPoolAttrReleaseThreshold

@ hipMemPoolAttrReleaseThreshold

Definition hip_runtime_api.h:1161

hipMemPoolAttrUsedMemHigh

@ hipMemPoolAttrUsedMemHigh

Definition hip_runtime_api.h:1183

hipMemPoolReuseAllowInternalDependencies

@ hipMemPoolReuseAllowInternalDependencies

Definition hip_runtime_api.h:1152

hipMemPoolReuseFollowEventDependencies

@ hipMemPoolReuseFollowEventDependencies

Definition hip_runtime_api.h:1139

hipMemPoolReuseAllowOpportunistic

@ hipMemPoolReuseAllowOpportunistic

Definition hip_runtime_api.h:1145

hipDriverEntryPointSuccess

@ hipDriverEntryPointSuccess

Definition hip_runtime_api.h:681

hipDriverEntryPointSymbolNotFound

@ hipDriverEntryPointSymbolNotFound

Definition hip_runtime_api.h:682

hipDriverEntryPointVersionNotSufficent

@ hipDriverEntryPointVersionNotSufficent

Definition hip_runtime_api.h:683

hipMemRangeFlagsMax

@ hipMemRangeFlagsMax

Definition hip_runtime_api.h:2026

hipMemRangeFlagDmaBufMappingTypePcie

@ hipMemRangeFlagDmaBufMappingTypePcie

Definition hip_runtime_api.h:2025

hipMemOperationTypeMap

@ hipMemOperationTypeMap

Map operation.

Definition hip_runtime_api.h:1812

hipMemOperationTypeUnmap

@ hipMemOperationTypeUnmap

Unmap operation.

Definition hip_runtime_api.h:1813

hipGraphicsRegisterFlagsReadOnly

@ hipGraphicsRegisterFlagsReadOnly

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

Definition hip_runtime_api.h:1435

hipGraphicsRegisterFlagsTextureGather

@ hipGraphicsRegisterFlagsTextureGather

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

Definition hip_runtime_api.h:1439

hipGraphicsRegisterFlagsWriteDiscard

@ hipGraphicsRegisterFlagsWriteDiscard

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

Definition hip_runtime_api.h:1436

hipGraphicsRegisterFlagsNone

@ hipGraphicsRegisterFlagsNone

Definition hip_runtime_api.h:1434

hipGraphicsRegisterFlagsSurfaceLoadStore

@ hipGraphicsRegisterFlagsSurfaceLoadStore

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

Definition hip_runtime_api.h:1438

hipMemRangeCoherencyModeFineGrain

@ hipMemRangeCoherencyModeFineGrain

Definition hip_runtime_api.h:1104

hipMemRangeCoherencyModeIndeterminate

@ hipMemRangeCoherencyModeIndeterminate

Definition hip_runtime_api.h:1108

hipMemRangeCoherencyModeCoarseGrain

@ hipMemRangeCoherencyModeCoarseGrain

Definition hip_runtime_api.h:1106

hipMemAccessFlagsProtRead

@ hipMemAccessFlagsProtRead

Set the address range read accessible.

Definition hip_runtime_api.h:1192

hipMemAccessFlagsProtNone

@ hipMemAccessFlagsProtNone

Default, make the address range not accessible.

Definition hip_runtime_api.h:1191

hipMemAccessFlagsProtReadWrite

@ hipMemAccessFlagsProtReadWrite

Set the address range read-write accessible.

Definition hip_runtime_api.h:1193

hipMemAllocationGranularityMinimum

@ hipMemAllocationGranularityMinimum

Minimum granularity.

Definition hip_runtime_api.h:1797

hipMemAllocationGranularityRecommended

@ hipMemAllocationGranularityRecommended

Recommended granularity for performance.

Definition hip_runtime_api.h:1798

hipGraphExecUpdateErrorNotSupported

@ hipGraphExecUpdateErrorNotSupported

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

Definition hip_runtime_api.h:1649

hipGraphExecUpdateErrorNodeTypeChanged

@ hipGraphExecUpdateErrorNodeTypeChanged

The update failed because a node type changed.

Definition hip_runtime_api.h:1644

hipGraphExecUpdateErrorTopologyChanged

@ hipGraphExecUpdateErrorTopologyChanged

The update failed because the topology changed.

Definition hip_runtime_api.h:1643

hipGraphExecUpdateErrorUnsupportedFunctionChange

@ hipGraphExecUpdateErrorUnsupportedFunctionChange

Definition hip_runtime_api.h:1651

hipGraphExecUpdateError

@ hipGraphExecUpdateError

Definition hip_runtime_api.h:1641

hipGraphExecUpdateErrorFunctionChanged

@ hipGraphExecUpdateErrorFunctionChanged

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

Definition hip_runtime_api.h:1645

hipGraphExecUpdateSuccess

@ hipGraphExecUpdateSuccess

The update succeeded.

Definition hip_runtime_api.h:1640

hipGraphExecUpdateErrorParametersChanged

@ hipGraphExecUpdateErrorParametersChanged

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

Definition hip_runtime_api.h:1647

hipStreamCaptureStatusInvalidated

@ hipStreamCaptureStatusInvalidated

Definition hip_runtime_api.h:1662

hipStreamCaptureStatusNone

@ hipStreamCaptureStatusNone

Stream is not capturing.

Definition hip_runtime_api.h:1660

hipStreamCaptureStatusActive

@ hipStreamCaptureStatusActive

Stream is actively capturing.

Definition hip_runtime_api.h:1661

hipDeviceAttributeDirectManagedMemAccessFromHost

@ hipDeviceAttributeDirectManagedMemAccessFromHost

Definition hip_runtime_api.h:436

hipDeviceAttributeSurfaceAlignment

@ hipDeviceAttributeSurfaceAlignment

Alignment requirement for surfaces.

Definition hip_runtime_api.h:526

hipDeviceAttributeMaxGridDimX

@ hipDeviceAttributeMaxGridDimX

Max grid size in width.

Definition hip_runtime_api.h:457

hipDeviceAttributeMaxSurfaceCubemapLayered

@ hipDeviceAttributeMaxSurfaceCubemapLayered

Definition hip_runtime_api.h:466

hipDeviceAttributeMaxSurface3D

@ hipDeviceAttributeMaxSurface3D

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

Definition hip_runtime_api.h:464

hipDeviceAttributeMaxPitch

@ hipDeviceAttributeMaxPitch

Maximum pitch in bytes allowed by memory copies.

Definition hip_runtime_api.h:491

hipDeviceAttributeTccDriver

@ hipDeviceAttributeTccDriver

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

Definition hip_runtime_api.h:527

hipDeviceAttributeHostNativeAtomicSupported

@ hipDeviceAttributeHostNativeAtomicSupported

Definition hip_runtime_api.h:439

hipDeviceAttributePageableMemoryAccessUsesHostPageTables

@ hipDeviceAttributePageableMemoryAccessUsesHostPageTables

Definition hip_runtime_api.h:504

hipDeviceAttributeUnused5

@ hipDeviceAttributeUnused5

Previously hipDeviceAttributeGcnArchName.

Definition hip_runtime_api.h:557

hipDeviceAttributeMaxBlockDimY

@ hipDeviceAttributeMaxBlockDimY

Max block size in height.

Definition hip_runtime_api.h:455

hipDeviceAttributeMaxSurfaceCubemap

@ hipDeviceAttributeMaxSurfaceCubemap

Cuda only. Maximum dimensions of Cubemap surface.

Definition hip_runtime_api.h:465

hipDeviceAttributePageableMemoryAccess

@ hipDeviceAttributePageableMemoryAccess

Definition hip_runtime_api.h:502

hipDeviceAttributeClockRate

@ hipDeviceAttributeClockRate

Peak clock frequency in kilohertz.

Definition hip_runtime_api.h:424

hipDeviceAttributeCudaCompatibleEnd

@ hipDeviceAttributeCudaCompatibleEnd

Definition hip_runtime_api.h:548

hipDeviceAttributeMaxTexture1DMipmap

@ hipDeviceAttributeMaxTexture1DMipmap

Maximum size of 1D mipmapped texture.

Definition hip_runtime_api.h:473

hipDeviceAttributeComputeCapabilityMajor

@ hipDeviceAttributeComputeCapabilityMajor

Major compute capability version number.

Definition hip_runtime_api.h:451

hipDeviceAttributeGlobalL1CacheSupported

@ hipDeviceAttributeGlobalL1CacheSupported

Device supports caching globals in L1.

Definition hip_runtime_api.h:438

hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

Definition hip_runtime_api.h:569

hipDeviceAttributeAccessPolicyMaxWindowSize

@ hipDeviceAttributeAccessPolicyMaxWindowSize

Definition hip_runtime_api.h:416

hipDeviceAttributeMaxTexture3DHeight

@ hipDeviceAttributeMaxTexture3DHeight

Maximum dimension height of 3D texture.

Definition hip_runtime_api.h:483

hipDeviceAttributeComputeCapabilityMinor

@ hipDeviceAttributeComputeCapabilityMinor

Minor compute capability version number.

Definition hip_runtime_api.h:494

hipDeviceAttributeNumberOfXccs

@ hipDeviceAttributeNumberOfXccs

The number of XCC(s) on the device.

Definition hip_runtime_api.h:581

hipDeviceAttributeMaxTextureCubemap

@ hipDeviceAttributeMaxTextureCubemap

Maximum dimensions of Cubemap texture.

Definition hip_runtime_api.h:486

hipDeviceAttributeDeviceOverlap

@ hipDeviceAttributeDeviceOverlap

Definition hip_runtime_api.h:434

hipDeviceAttributeMaxTexture2DLinear

@ hipDeviceAttributeMaxTexture2DLinear

Definition hip_runtime_api.h:479

hipDeviceAttributeMaxSurface2D

@ hipDeviceAttributeMaxSurface2D

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

Definition hip_runtime_api.h:462

hipDeviceAttributeMaxSurface1DLayered

@ hipDeviceAttributeMaxSurface1DLayered

Cuda only. Maximum dimensions of 1D layered surface.

Definition hip_runtime_api.h:461

hipDeviceAttributeHdpRegFlushCntl

@ hipDeviceAttributeHdpRegFlushCntl

Address of the HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:559

hipDeviceAttributeMaxAvailableVgprsPerThread

@ hipDeviceAttributeMaxAvailableVgprsPerThread

Definition hip_runtime_api.h:582

hipDeviceAttributeComputeMode

@ hipDeviceAttributeComputeMode

Compute mode that device is currently in.

Definition hip_runtime_api.h:425

hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

Definition hip_runtime_api.h:560

hipDeviceAttributeAsicRevision

@ hipDeviceAttributeAsicRevision

Revision of the GPU in this device.

Definition hip_runtime_api.h:573

hipDeviceAttributeUnused4

@ hipDeviceAttributeUnused4

Previously hipDeviceAttributeGcnArch.

Definition hip_runtime_api.h:556

hipDeviceAttributeCooperativeMultiDeviceLaunch

@ hipDeviceAttributeCooperativeMultiDeviceLaunch

Definition hip_runtime_api.h:432

hipDeviceAttributeMaxTexture2DHeight

@ hipDeviceAttributeMaxTexture2DHeight

Maximum dimension hight of 2D texture.

Definition hip_runtime_api.h:475

hipDeviceAttributePersistingL2CacheMaxSize

@ hipDeviceAttributePersistingL2CacheMaxSize

Maximum l2 persisting lines capacity in bytes.

Definition hip_runtime_api.h:511

hipDeviceAttributeEccEnabled

@ hipDeviceAttributeEccEnabled

Whether ECC support is enabled.

Definition hip_runtime_api.h:414

hipDeviceAttributeDmaBufSupported

@ hipDeviceAttributeDmaBufSupported

Device supports DMABuf buffer sharing.

Definition hip_runtime_api.h:546

hipDeviceAttributeExpertSchedMode

@ hipDeviceAttributeExpertSchedMode

Definition hip_runtime_api.h:586

hipDeviceAttributeCanUseHostPointerForRegisteredMem

@ hipDeviceAttributeCanUseHostPointerForRegisteredMem

Definition hip_runtime_api.h:421

hipDeviceAttributePciBusId

@ hipDeviceAttributePciBusId

PCI Bus ID.

Definition hip_runtime_api.h:506

hipDeviceAttributeL2CacheSize

@ hipDeviceAttributeL2CacheSize

Definition hip_runtime_api.h:444

hipDeviceAttributeKernelExecTimeout

@ hipDeviceAttributeKernelExecTimeout

Run time limit for kernels executed on the device.

Definition hip_runtime_api.h:443

hipDeviceAttributeMaxThreadsDim

@ hipDeviceAttributeMaxThreadsDim

Maximum dimension of a block.

Definition hip_runtime_api.h:488

hipDeviceAttributeSingleToDoublePrecisionPerfRatio

@ hipDeviceAttributeSingleToDoublePrecisionPerfRatio

Definition hip_runtime_api.h:523

hipDeviceAttributeMaxGridDimY

@ hipDeviceAttributeMaxGridDimY

Max grid size in height.

Definition hip_runtime_api.h:458

hipDeviceAttributeMultiprocessorCount

@ hipDeviceAttributeMultiprocessorCount

Definition hip_runtime_api.h:497

hipDeviceAttributeAmdSpecificBegin

@ hipDeviceAttributeAmdSpecificBegin

Definition hip_runtime_api.h:549

hipDeviceAttributeMaxRegistersPerMultiprocessor

@ hipDeviceAttributeMaxRegistersPerMultiprocessor

32-bit registers available per block.

Definition hip_runtime_api.h:515

hipDeviceAttributeIsMultiGpuBoard

@ hipDeviceAttributeIsMultiGpuBoard

Multiple GPU devices.

Definition hip_runtime_api.h:442

hipDeviceAttributeSharedMemPerBlockOptin

@ hipDeviceAttributeSharedMemPerBlockOptin

Definition hip_runtime_api.h:520

hipDeviceAttributeMaxSurface2DLayered

@ hipDeviceAttributeMaxSurface2DLayered

Cuda only. Maximum dimensions of 2D layered surface.

Definition hip_runtime_api.h:463

hipDeviceAttributeAmdSpecificEnd

@ hipDeviceAttributeAmdSpecificEnd

Definition hip_runtime_api.h:589

hipDeviceAttributeMemoryClockRate

@ hipDeviceAttributeMemoryClockRate

Peak memory clock frequency in kilohertz.

Definition hip_runtime_api.h:493

hipDeviceAttributeMaxGridDimZ

@ hipDeviceAttributeMaxGridDimZ

Max grid size in depth.

Definition hip_runtime_api.h:459

hipDeviceAttributeHdpMemFlushCntl

@ hipDeviceAttributeHdpMemFlushCntl

Address of the HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:558

hipDeviceAttributeUnused2

@ hipDeviceAttributeUnused2

Previously hipDeviceAttributeUuid.

Definition hip_runtime_api.h:535

hipDeviceAttributeFineGrainSupport

@ hipDeviceAttributeFineGrainSupport

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

Definition hip_runtime_api.h:579

hipDeviceAttributeCooperativeLaunch

@ hipDeviceAttributeCooperativeLaunch

Support cooperative launch.

Definition hip_runtime_api.h:431

hipDeviceAttributeUnifiedAddressing

@ hipDeviceAttributeUnifiedAddressing

Definition hip_runtime_api.h:533

hipDeviceAttributeAsyncEngineCount

@ hipDeviceAttributeAsyncEngineCount

Asynchronous engines number.

Definition hip_runtime_api.h:418

hipDeviceAttributeMultiGpuBoardGroupID

@ hipDeviceAttributeMultiGpuBoardGroupID

Definition hip_runtime_api.h:495

hipDeviceAttributeStreamPrioritiesSupported

@ hipDeviceAttributeStreamPrioritiesSupported

Whether to support stream priorities.

Definition hip_runtime_api.h:525

hipDeviceAttributeMaxSharedMemoryPerBlock

@ hipDeviceAttributeMaxSharedMemoryPerBlock

Definition hip_runtime_api.h:518

hipDeviceAttributeLocalL1CacheSupported

@ hipDeviceAttributeLocalL1CacheSupported

caching locals in L1 is supported

Definition hip_runtime_api.h:446

hipDeviceAttributeCanUseStreamWaitValue

@ hipDeviceAttributeCanUseStreamWaitValue

Definition hip_runtime_api.h:574

hipDeviceAttributeMaxRegistersPerBlock

@ hipDeviceAttributeMaxRegistersPerBlock

Definition hip_runtime_api.h:512

hipDeviceAttributeMaxThreadsPerBlock

@ hipDeviceAttributeMaxThreadsPerBlock

Maximum number of threads per block.

Definition hip_runtime_api.h:489

hipDeviceAttributePciDomainId

@ hipDeviceAttributePciDomainId

PCI Domain Id.

Definition hip_runtime_api.h:508

hipDeviceAttributeMemoryBusWidth

@ hipDeviceAttributeMemoryBusWidth

Global memory bus width in bits.

Definition hip_runtime_api.h:492

hipDeviceAttributeMemoryPoolSupportedHandleTypes

@ hipDeviceAttributeMemoryPoolSupportedHandleTypes

Definition hip_runtime_api.h:542

hipDeviceAttributeComputePreemptionSupported

@ hipDeviceAttributeComputePreemptionSupported

Device supports Compute Preemption.

Definition hip_runtime_api.h:426

hipDeviceAttributeMaxSurface1D

@ hipDeviceAttributeMaxSurface1D

Maximum size of 1D surface.

Definition hip_runtime_api.h:460

hipDeviceAttributeUnused1

@ hipDeviceAttributeUnused1

Previously hipDeviceAttributeName.

Definition hip_runtime_api.h:501

hipDeviceAttributeMaxTexture3DAlt

@ hipDeviceAttributeMaxTexture3DAlt

Maximum dimensions of alternate 3D texture.

Definition hip_runtime_api.h:485

hipDeviceAttributeMaxTexture1DLinear

@ hipDeviceAttributeMaxTexture1DLinear

Definition hip_runtime_api.h:470

hipDeviceAttributeMaxTexture2DGather

@ hipDeviceAttributeMaxTexture2DGather

Definition hip_runtime_api.h:476

hipDeviceAttributeWallClockRate

@ hipDeviceAttributeWallClockRate

Constant frequency of wall clock in kilohertz.

Definition hip_runtime_api.h:580

hipDeviceAttributePciDeviceId

@ hipDeviceAttributePciDeviceId

PCI Device ID. Returns pcie slot id.

Definition hip_runtime_api.h:507

hipDeviceAttributeCanMapHostMemory

@ hipDeviceAttributeCanMapHostMemory

Definition hip_runtime_api.h:419

hipDeviceAttributeMaxTexture1DWidth

@ hipDeviceAttributeMaxTexture1DWidth

Maximum size of 1D texture.

Definition hip_runtime_api.h:468

hipDeviceAttributeConcurrentManagedAccess

@ hipDeviceAttributeConcurrentManagedAccess

Definition hip_runtime_api.h:429

hipDeviceAttributeVendorSpecificBegin

@ hipDeviceAttributeVendorSpecificBegin

Definition hip_runtime_api.h:590

hipDeviceAttributeManagedMemory

@ hipDeviceAttributeManagedMemory

Device supports allocating managed memory on this system.

Definition hip_runtime_api.h:452

hipDeviceAttributeHostNumaId

@ hipDeviceAttributeHostNumaId

Definition hip_runtime_api.h:544

hipDeviceAttributeIntegrated

@ hipDeviceAttributeIntegrated

Device is integrated GPU.

Definition hip_runtime_api.h:441

hipDeviceAttributeMaxTexture2DLayered

@ hipDeviceAttributeMaxTexture2DLayered

Maximum dimensions of 2D layered texture.

Definition hip_runtime_api.h:478

hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

Definition hip_runtime_api.h:563

hipDeviceAttributeMaxTexture3DDepth

@ hipDeviceAttributeMaxTexture3DDepth

Maximum dimension depth of 3D texture.

Definition hip_runtime_api.h:484

hipDeviceAttributePciChipId

@ hipDeviceAttributePciChipId

GPU Manufacturer device id.

Definition hip_runtime_api.h:585

hipDeviceAttributeImageSupport

@ hipDeviceAttributeImageSupport

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

Definition hip_runtime_api.h:576

hipDeviceAttributeTotalGlobalMem

@ hipDeviceAttributeTotalGlobalMem

Global memory available on devicice.

Definition hip_runtime_api.h:532

hipDeviceAttributeMaxBlocksPerMultiProcessor

@ hipDeviceAttributeMaxBlocksPerMultiProcessor

Max block size per multiprocessor.

Definition hip_runtime_api.h:453

hipDeviceAttributeIsLargeBar

@ hipDeviceAttributeIsLargeBar

Whether it is LargeBar.

Definition hip_runtime_api.h:572

hipDeviceAttributeMaxTexture2DWidth

@ hipDeviceAttributeMaxTexture2DWidth

Maximum dimension width of 2D texture.

Definition hip_runtime_api.h:474

hipDeviceAttributeMaxBlockDimX

@ hipDeviceAttributeMaxBlockDimX

Max block size in width.

Definition hip_runtime_api.h:454

hipDeviceAttributeMaxTexture3DWidth

@ hipDeviceAttributeMaxTexture3DWidth

Maximum dimension width of 3D texture.

Definition hip_runtime_api.h:482

hipDeviceAttributeUnused3

@ hipDeviceAttributeUnused3

Previously hipDeviceAttributeArch.

Definition hip_runtime_api.h:554

hipDeviceAttributeTotalConstantMemory

@ hipDeviceAttributeTotalConstantMemory

Constant memory size in bytes.

Definition hip_runtime_api.h:531

hipDeviceAttributeTextureAlignment

@ hipDeviceAttributeTextureAlignment

Alignment requirement for textures.

Definition hip_runtime_api.h:528

hipDeviceAttributeMaxTexture1DLayered

@ hipDeviceAttributeMaxTexture1DLayered

Maximum dimensions of 1D layered texture.

Definition hip_runtime_api.h:469

hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

@ hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

Maximum Shared Memory PerMultiprocessor.

Definition hip_runtime_api.h:555

hipDeviceAttributeReservedSharedMemPerBlock

@ hipDeviceAttributeReservedSharedMemPerBlock

Definition hip_runtime_api.h:516

hipDeviceAttributeCudaCompatibleBegin

@ hipDeviceAttributeCudaCompatibleBegin

Definition hip_runtime_api.h:412

hipDeviceAttributeConcurrentKernels

@ hipDeviceAttributeConcurrentKernels

Definition hip_runtime_api.h:427

hipDeviceAttributeLuid

@ hipDeviceAttributeLuid

Definition hip_runtime_api.h:447

hipDeviceAttributePciDomainID

@ hipDeviceAttributePciDomainID

PCI Domain ID, for backward compatibility.

Definition hip_runtime_api.h:509

hipDeviceAttributeMaxThreadsPerMultiProcessor

@ hipDeviceAttributeMaxThreadsPerMultiProcessor

Maximum resident threads per multiprocessor.

Definition hip_runtime_api.h:490

hipDeviceAttributeTexturePitchAlignment

@ hipDeviceAttributeTexturePitchAlignment

Definition hip_runtime_api.h:529

hipDeviceAttributePhysicalMultiProcessorCount

@ hipDeviceAttributePhysicalMultiProcessorCount

Definition hip_runtime_api.h:577

hipDeviceAttributeHostRegisterSupported

@ hipDeviceAttributeHostRegisterSupported

Definition hip_runtime_api.h:540

hipDeviceAttributeSharedMemPerMultiprocessor

@ hipDeviceAttributeSharedMemPerMultiprocessor

Shared memory available per multiprocessor.

Definition hip_runtime_api.h:522

hipDeviceAttributeLuidDeviceNodeMask

@ hipDeviceAttributeLuidDeviceNodeMask

Definition hip_runtime_api.h:449

hipDeviceAttributeMaxTextureCubemapLayered

@ hipDeviceAttributeMaxTextureCubemapLayered

Maximum dimensions of Cubemap layered texture.

Definition hip_runtime_api.h:487

hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

Definition hip_runtime_api.h:566

hipDeviceAttributeVirtualMemoryManagementSupported

@ hipDeviceAttributeVirtualMemoryManagementSupported

Definition hip_runtime_api.h:538

hipDeviceAttributeMemoryPoolsSupported

@ hipDeviceAttributeMemoryPoolsSupported

Device supports HIP Stream Ordered Memory Allocator.

Definition hip_runtime_api.h:537

hipDeviceAttributeClockInstructionRate

@ hipDeviceAttributeClockInstructionRate

Definition hip_runtime_api.h:551

hipDeviceAttributeMaxTexture2DMipmap

@ hipDeviceAttributeMaxTexture2DMipmap

Maximum dimensions of 2D mipmapped texture.

Definition hip_runtime_api.h:481

hipDeviceAttributeMaxBlockDimZ

@ hipDeviceAttributeMaxBlockDimZ

Max block size in depth.

Definition hip_runtime_api.h:456

hipDeviceAttributeWarpSize

@ hipDeviceAttributeWarpSize

Warp size in threads.

Definition hip_runtime_api.h:536

hipGPUDirectRDMAWritesOrderingOwner

@ hipGPUDirectRDMAWritesOrderingOwner

Definition hip_runtime_api.h:627

hipGPUDirectRDMAWritesOrderingNone

@ hipGPUDirectRDMAWritesOrderingNone

Definition hip_runtime_api.h:626

hipGPUDirectRDMAWritesOrderingAllDevices

@ hipGPUDirectRDMAWritesOrderingAllDevices

Definition hip_runtime_api.h:628

hipMemAllocationTypeManaged

@ hipMemAllocationTypeManaged

Definition hip_runtime_api.h:1214

hipMemAllocationTypeMax

@ hipMemAllocationTypeMax

Definition hip_runtime_api.h:1216

hipMemAllocationTypePinned

@ hipMemAllocationTypePinned

Definition hip_runtime_api.h:1213

hipMemAllocationTypeUncached

@ hipMemAllocationTypeUncached

Definition hip_runtime_api.h:1215

hipMemAllocationTypeInvalid

@ hipMemAllocationTypeInvalid

Definition hip_runtime_api.h:1209

hipMemoryTypeDevice

@ hipMemoryTypeDevice

Definition hip_runtime_api.h:250

hipMemoryTypeHost

@ hipMemoryTypeHost

Memory is physically located on host.

Definition hip_runtime_api.h:249

hipMemoryTypeUnregistered

@ hipMemoryTypeUnregistered

Unregistered memory.

Definition hip_runtime_api.h:248

hipMemoryTypeArray

@ hipMemoryTypeArray

Definition hip_runtime_api.h:255

hipMemoryTypeManaged

@ hipMemoryTypeManaged

Definition hip_runtime_api.h:252

hipMemoryTypeUnified

@ hipMemoryTypeUnified

unified address space

Definition hip_runtime_api.h:257

hipGraphInstantiateFlagAutoFreeOnLaunch

@ hipGraphInstantiateFlagAutoFreeOnLaunch

Automatically free memory allocated in a graph before relaunching.

Definition hip_runtime_api.h:1690

hipGraphInstantiateFlagUseNodePriority

@ hipGraphInstantiateFlagUseNodePriority

Definition hip_runtime_api.h:1695

hipGraphInstantiateFlagUpload

@ hipGraphInstantiateFlagUpload

Automatically upload the graph after instantiation.

Definition hip_runtime_api.h:1692

hipGraphInstantiateFlagDeviceLaunch

@ hipGraphInstantiateFlagDeviceLaunch

Instantiate the graph to be launched from the device.

Definition hip_runtime_api.h:1693

hipArraySparseSubresourceTypeSparseLevel

@ hipArraySparseSubresourceTypeSparseLevel

Sparse level.

Definition hip_runtime_api.h:1820

hipArraySparseSubresourceTypeMiptail

@ hipArraySparseSubresourceTypeMiptail

Miptail.

Definition hip_runtime_api.h:1821

hipGraphKernelNodeSetParams

hipError_t hipGraphKernelNodeSetParams(hipGraphNode_t node, const hipKernelNodeParams *pNodeParams)

Sets a kernel node's parameters.

hipGraphMemFreeNodeGetParams

hipError_t hipGraphMemFreeNodeGetParams(hipGraphNode_t node, void *dev_ptr)

Returns parameters for memory free node.

hipDrvGraphExecMemsetNodeSetParams

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

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

hipGraphNodeGetDependencies

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

Returns a node's dependencies.

hipGraphCreate

hipError_t hipGraphCreate(hipGraph_t *pGraph, unsigned int flags)

Creates a graph.

hipGraphAddMemcpyNode1D

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

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

hipDrvGraphMemcpyNodeGetParams

hipError_t hipDrvGraphMemcpyNodeGetParams(hipGraphNode_t hNode, HIP_MEMCPY3D *nodeParams)

Gets a memcpy node's parameters.

hipDeviceSetGraphMemAttribute

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

Set the mem attribute for graphs.

hipGraphMemcpyNodeSetParams

hipError_t hipGraphMemcpyNodeSetParams(hipGraphNode_t node, const hipMemcpy3DParms *pNodeParams)

Sets a memcpy node's parameters.

hipUserObjectCreate

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

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

hipGraphExecUpdate

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

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

hipGraphNodeFindInClone

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

Finds a cloned version of a node.

hipGraphAddEventWaitNode

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

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

hipGraphMemcpyNodeSetParamsToSymbol

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

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

hipStreamIsCapturing

hipError_t hipStreamIsCapturing(hipStream_t stream, hipStreamCaptureStatus *pCaptureStatus)

Get stream's capture state.

hipGraphNodeGetEnabled

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

Query whether a node in the given graphExec is enabled.

hipGraphAddChildGraphNode

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

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

hipGraphExternalSemaphoresSignalNodeSetParams

hipError_t hipGraphExternalSemaphoresSignalNodeSetParams(hipGraphNode_t hNode, const hipExternalSemaphoreSignalNodeParams *nodeParams)

Updates node parameters in the external semaphore signal node.

hipGraphDestroyNode

hipError_t hipGraphDestroyNode(hipGraphNode_t node)

Remove a node from the graph.

hipGraphMemcpyNodeSetParamsFromSymbol

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

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

hipGraphReleaseUserObject

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

Release user object from graphs.

hipDrvGraphAddMemcpyNode

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

Creates a memcpy node and adds it to a graph.

hipGraphRemoveDependencies

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

Removes dependency edges from a graph.

hipGraphMemcpyNodeSetParams1D

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

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

hipGraphExecMemcpyNodeSetParams1D

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

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

hipGraphExecDestroy

hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec)

Destroys an executable graph.

hipGraphAddExternalSemaphoresSignalNode

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

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

hipGraphExecExternalSemaphoresWaitNodeSetParams

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

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

hipGraphExecHostNodeSetParams

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

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

hipGraphExecChildGraphNodeSetParams

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

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

hipStreamGetCaptureInfo

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

Get capture status of a stream.

hipGraphAddDependencies

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

Adds dependency edges to a graph.

hipDrvGraphAddMemFreeNode

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

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

hipGraphExecKernelNodeSetParams

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

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

hipGraphNodeGetDependentNodes

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

Returns a node's dependent nodes.

hipDeviceGetGraphMemAttribute

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

Get the mem attribute for graphs.

hipGraphHostNodeGetParams

hipError_t hipGraphHostNodeGetParams(hipGraphNode_t node, hipHostNodeParams *pNodeParams)

Returns a host node's parameters.

hipGraphInstantiateWithFlags

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

Creates an executable graph from a graph.

hipGraphExternalSemaphoresSignalNodeGetParams

hipError_t hipGraphExternalSemaphoresSignalNodeGetParams(hipGraphNode_t hNode, hipExternalSemaphoreSignalNodeParams *params_out)

Returns external semaphore signal node params.

hipGraphUpload

hipError_t hipGraphUpload(hipGraphExec_t graphExec, hipStream_t stream)

Uploads an executable graph to a stream.

hipDrvGraphAddMemsetNode

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

Creates a memset node and adds it to a graph.

hipGraphExecExternalSemaphoresSignalNodeSetParams

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

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

hipGraphExecMemcpyNodeSetParamsToSymbol

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

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

hipUserObjectRelease

hipError_t hipUserObjectRelease(hipUserObject_t object, unsigned int count)

Release number of references to resource.

hipGraphKernelNodeGetParams

hipError_t hipGraphKernelNodeGetParams(hipGraphNode_t node, hipKernelNodeParams *pNodeParams)

Gets kernel node's parameters.

hipGraphAddMemcpyNodeFromSymbol

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

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

hipGraphKernelNodeCopyAttributes

hipError_t hipGraphKernelNodeCopyAttributes(hipGraphNode_t hSrc, hipGraphNode_t hDst)

Copies attributes from source node to destination node.

hipGraphAddMemFreeNode

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

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

hipDrvGraphMemcpyNodeSetParams

hipError_t hipDrvGraphMemcpyNodeSetParams(hipGraphNode_t hNode, const HIP_MEMCPY3D *nodeParams)

Sets a memcpy node's parameters.

hipGraphMemcpyNodeGetParams

hipError_t hipGraphMemcpyNodeGetParams(hipGraphNode_t node, hipMemcpy3DParms *pNodeParams)

Gets a memcpy node's parameters.

hipGraphNodeSetParams

hipError_t hipGraphNodeSetParams(hipGraphNode_t node, hipGraphNodeParams *nodeParams)

Updates parameters of a graph's node.

hipGraphAddEventRecordNode

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

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

hipDrvGraphExecMemcpyNodeSetParams

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

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

hipStreamBeginCapture

hipError_t hipStreamBeginCapture(hipStream_t stream, hipStreamCaptureMode mode)

Begins graph capture on a stream.

hipStreamEndCapture

hipError_t hipStreamEndCapture(hipStream_t stream, hipGraph_t *pGraph)

Ends capture on a stream, returning the captured graph.

hipGraphExecGetFlags

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

Return the flags of an executable graph.

hipUserObjectRetain

hipError_t hipUserObjectRetain(hipUserObject_t object, unsigned int count)

Retain number of references to resource.

hipGraphNodeGetType

hipError_t hipGraphNodeGetType(hipGraphNode_t node, hipGraphNodeType *pType)

Returns a node's type.

hipGraphNodeSetEnabled

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

Enables or disables the specified node in the given graphExec.

hipGraphExecMemcpyNodeSetParams

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

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

hipGraphExecNodeSetParams

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

Updates parameters of an executable graph's node.

hipGraphHostNodeSetParams

hipError_t hipGraphHostNodeSetParams(hipGraphNode_t node, const hipHostNodeParams *pNodeParams)

Sets a host node's parameters.

hipGraphMemAllocNodeGetParams

hipError_t hipGraphMemAllocNodeGetParams(hipGraphNode_t node, hipMemAllocNodeParams *pNodeParams)

Returns parameters for memory allocation node.

hipGraphInstantiateWithParams

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

Creates an executable graph from a graph.

hipGraphExecEventRecordNodeSetEvent

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

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

hipGraphExternalSemaphoresWaitNodeSetParams

hipError_t hipGraphExternalSemaphoresWaitNodeSetParams(hipGraphNode_t hNode, const hipExternalSemaphoreWaitNodeParams *nodeParams)

Updates node parameters in the external semaphore wait node.

hipGraphMemsetNodeGetParams

hipError_t hipGraphMemsetNodeGetParams(hipGraphNode_t node, hipMemsetParams *pNodeParams)

Gets a memset node's parameters.

hipGraphChildGraphNodeGetGraph

hipError_t hipGraphChildGraphNodeGetGraph(hipGraphNode_t node, hipGraph_t *pGraph)

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

hipGraphKernelNodeGetAttribute

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

Gets a node's attribute.

hipThreadExchangeStreamCaptureMode

hipError_t hipThreadExchangeStreamCaptureMode(hipStreamCaptureMode *mode)

Swaps the stream capture mode of a thread.

hipGraphLaunch

hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream)

Launches an executable graph in the specified stream.

hipGraphDebugDotPrint

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

Write a DOT file describing graph structure.

hipGraphExecMemsetNodeSetParams

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

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

hipGraphGetEdges

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

Returns a graph's dependency edges.

hipGraphAddKernelNode

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

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

hipGraphExecEventWaitNodeSetEvent

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

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

hipStreamGetCaptureInfo_v2

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

Get stream's capture state.

hipStreamBeginCaptureToGraph

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

Begins graph capture on a stream to an existing graph.

hipGraphAddExternalSemaphoresWaitNode

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

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

hipGraphEventWaitNodeSetEvent

hipError_t hipGraphEventWaitNodeSetEvent(hipGraphNode_t node, hipEvent_t event)

Sets an event wait node's event.

hipGraphEventRecordNodeSetEvent

hipError_t hipGraphEventRecordNodeSetEvent(hipGraphNode_t node, hipEvent_t event)

Sets an event record node's event.

hipGraphEventWaitNodeGetEvent

hipError_t hipGraphEventWaitNodeGetEvent(hipGraphNode_t node, hipEvent_t *event_out)

Returns the event associated with an event wait node.

hipGraphKernelNodeSetAttribute

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

Sets a node's attribute.

hipGraphMemsetNodeSetParams

hipError_t hipGraphMemsetNodeSetParams(hipGraphNode_t node, const hipMemsetParams *pNodeParams)

Sets a memset node's parameters.

hipGraphEventRecordNodeGetEvent

hipError_t hipGraphEventRecordNodeGetEvent(hipGraphNode_t node, hipEvent_t *event_out)

Returns the event associated with an event record node.

hipGraphAddEmptyNode

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

Creates an empty node and adds it to a graph.

hipGraphAddMemcpyNodeToSymbol

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

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

hipGraphDestroy

hipError_t hipGraphDestroy(hipGraph_t graph)

Destroys a graph.

hipGraphRetainUserObject

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

Retain user object for graphs.

hipGraphExecMemcpyNodeSetParamsFromSymbol

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

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

hipGraphAddMemAllocNode

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

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

hipGraphAddHostNode

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

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

hipGraphAddNode

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

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

hipGraphGetNodes

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

Returns a graph's nodes.

hipGraphAddMemsetNode

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

Creates a memset node and adds it to a graph.

hipStreamUpdateCaptureDependencies

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

Update the set of dependencies in a capturing stream.

hipGraphInstantiate

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

Creates an executable graph from a graph.

hipDeviceGraphMemTrim

hipError_t hipDeviceGraphMemTrim(int device)

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

hipGraphExternalSemaphoresWaitNodeGetParams

hipError_t hipGraphExternalSemaphoresWaitNodeGetParams(hipGraphNode_t hNode, hipExternalSemaphoreWaitNodeParams *params_out)

Returns external semaphore wait node params.

hipGraphClone

hipError_t hipGraphClone(hipGraph_t *pGraphClone, hipGraph_t originalGraph)

Clones a graph.

hipGraphGetRootNodes

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

Returns a graph's root nodes.

hipGraphAddMemcpyNode

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

Creates a memcpy node and adds it to a graph.

hipGraphicsUnregisterResource

hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource)

Unregisters a graphics resource.

hipGraphicsUnmapResources

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

Unmaps graphics resources.

hipGraphicsSubResourceGetMappedArray

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

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

hipGraphicsResourceGetMappedPointer

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

Gets device accessible address of a graphics resource.

hipGraphicsMapResources

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

Maps a graphics resource for access.

hipLibraryOption

hipLibraryOption

Definition linker_types.h:108

hipJitOption

hipJitOption

Definition linker_types.h:31

hipJitInputType

hipJitInputType

Definition linker_types.h:76

hipHostFree

hipError_t hipHostFree(void *ptr)

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

hipMallocHost

hipError_t hipMallocHost(void **ptr, size_t size)

Allocate pinned host memory [Deprecated].

hipMemcpyToArray

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

Copies data between host and device [Deprecated].

hipMemcpyFromArray

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

Copies data between host and device [Deprecated].

hipMemAllocHost

hipError_t hipMemAllocHost(void **ptr, size_t size)

Allocate pinned host memory [Deprecated].

hipMemcpyAtoA

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

Copies from one 1D array to another.

hipHostAlloc

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

Allocate device accessible page locked host memory.

hipMemcpy3DBatchAsync

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

Perform Batch of 3D copies.

hipMemcpy2DArrayToArray

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

Copies data between host and device.

hipMemsetD8Async

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

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

hipMemcpyAtoHAsync

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

Copies from one 1D array to host memory.

hipFreeHost

hipError_t hipFreeHost(void *ptr)

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

hipMemset2DAsync

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

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

hipMemGetInfo

hipError_t hipMemGetInfo(size_t *free, size_t *total)

Query memory info.

hipExtMallocWithFlags

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

Allocate memory on the default accelerator.

hipMemcpy3D

hipError_t hipMemcpy3D(const struct hipMemcpy3DParms *p)

Copies data between host and device.

hipMalloc3DArray

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

Allocate an array on the device.

hipArrayCreate

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

Create an array memory pointer on the device.

hipMemset3D

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

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

hipMemsetD16

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

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

hipMemcpyAtoD

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

Copies from one 1D array to device memory.

hipMalloc

hipError_t hipMalloc(void **ptr, size_t size)

Allocate memory on the default accelerator.

hipHostUnregister

hipError_t hipHostUnregister(void *hostPtr)

Un-register host pointer.

hipHostGetFlags

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

Return flags associated with host pointer.

hipMemcpyFromSymbolAsync

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

Copies data from the given symbol on the device asynchronously.

hipMemsetD2D32

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

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

hipMemsetD32

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

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

hipMemset3DAsync

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

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

hipMemcpyFromSymbol

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

Copies data from the given symbol on the device.

hipDrvMemcpy3DAsync

hipError_t hipDrvMemcpy3DAsync(const HIP_MEMCPY3D *pCopy, hipStream_t stream)

Copies data between host and device asynchronously.

hipMemsetD2D32Async

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

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

hipArray3DGetDescriptor

hipError_t hipArray3DGetDescriptor(HIP_ARRAY3D_DESCRIPTOR *pArrayDescriptor, hipArray_t array)

Gets a 3D array descriptor.

hipMemcpy2DAsync

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

Copies data between host and device asynchronously.

hipArrayGetDescriptor

hipError_t hipArrayGetDescriptor(HIP_ARRAY_DESCRIPTOR *pArrayDescriptor, hipArray_t array)

Gets a 1D or 2D array descriptor.

hipFree

hipError_t hipFree(void *ptr)

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

hipMemcpyHtoAAsync

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

Copies from host memory to a 1D array.

hipMemsetD16Async

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

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

hipGetProcAddress

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

Gets the pointer of requested HIP driver function.

hipPointerGetAttributes

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

Returns attributes for the specified pointer.

hipMallocPitch

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

hipMemcpy3DPeer

hipError_t hipMemcpy3DPeer(hipMemcpy3DPeerParms *p)

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

hipMemcpyDtoD

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

Copy data from Device to Device.

hipMallocArray

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

Allocate an array on the device.

hipMemcpy2D

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

Copies data between host and device.

hipHostGetDevicePointer

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

Get Device pointer from Host Pointer allocated through hipHostMalloc.

hipMemcpyDtoA

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

Copies from device memory to a 1D array.

hipMemcpy2DFromArrayAsync

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

Copies data between host and device asynchronously.

hipMemsetD2D16Async

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

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

hipMemcpy2DFromArray

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

Copies data between host and device.

hipMemcpy3DAsync

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

Copies data between host and device asynchronously.

hipArray3DCreate

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

Create a 3D array memory pointer on the device.

hipArrayGetInfo

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

Gets info about the specified array.

hipDrvMemcpy3D

hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D *pCopy)

Copies data between host and device.

hipMemcpyParam2D

hipError_t hipMemcpyParam2D(const hip_Memcpy2D *pCopy)

Copies memory for 2D arrays.

hipMemcpyHtoA

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

Copies data between host and device.

hipMemcpyToSymbolAsync

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

Copies data to the given symbol on the device asynchronously.

hipHostMalloc

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

Allocates device accessible page locked (pinned) host memory.

hipMemsetD2D8

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

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

hipMemcpy2DToArrayAsync

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

Copies data between host and device.

hipHostRegister

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

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

hipMipmappedArrayGetMemoryRequirements

hipError_t hipMipmappedArrayGetMemoryRequirements(hipArrayMemoryRequirements *memoryRequirements, hipMipmappedArray_t mipmap, hipDevice_t device)

Returns the memory requirements of a HIP mipmapped array.

hipMemsetD2D16

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

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

hipMemcpyBatchAsync

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

Perform Batch of 1D copies.

hipMemcpyAtoH

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

Copies data between host and device.

hipMemcpyToSymbol

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

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

hipMemcpy

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

Copy data from src to dst.

hipMemset

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

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

hipMemGetAddressRange

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

Get information on memory allocations.

hipMemcpy2DToArray

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

Copies data between host and device.

hipMemcpyParam2DAsync

hipError_t hipMemcpyParam2DAsync(const hip_Memcpy2D *pCopy, hipStream_t stream)

Copies memory for 2D arrays.

hipDrvPointerGetAttributes

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

Returns information about the specified pointer.[BETA].

hipMalloc3D

hipError_t hipMalloc3D(hipPitchedPtr *pitchedDevPtr, hipExtent extent)

Create a 3D memory pointer on the device.

hipPointerSetAttribute

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

Sets information on the specified pointer.[BETA].

hipMemcpyDtoDAsync

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

Copy data from Device to Device asynchronously.

hipMemAllocPitch

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

hipMemsetD8

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

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

hipMemcpyAsync

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

Copies data from src to dst asynchronously.

hipMemcpyDtoHAsync

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

Copy data from Device to Host asynchronously.

hipFreeArray

hipError_t hipFreeArray(hipArray_t array)

Frees an array on the device.

hipMemcpyHtoD

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

Copy data from Host to Device.

hipMemsetD32Async

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

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

hipMemset2D

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

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

hipGetSymbolSize

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

Gets the size of the given symbol on the device.

hipMemcpyDtoH

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

Copy data from Device to Host.

hipMemcpyHtoDAsync

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

Copy data from Host to Device asynchronously.

hipMemsetAsync

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

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

hipMemcpyWithStream

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

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

hipGetSymbolAddress

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

Gets device pointer associated with symbol on the device.

hipPointerGetAttribute

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

Returns information about the specified pointer.[BETA].

hipMemsetD2D8Async

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

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

hipMemcpy3DPeerAsync

hipError_t hipMemcpy3DPeerAsync(hipMemcpy3DPeerParms *p, hipStream_t stream)

Performs 3D memory copies between devices asynchronously.

hipMemPtrGetInfo

hipError_t hipMemPtrGetInfo(void *ptr, size_t *size)

Get allocated memory size via memory pointer.

hipArrayDestroy

hipError_t hipArrayDestroy(hipArray_t array)

Destroy an array memory pointer on the device.

hipMemPrefetchAsync

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

Prefetches memory to the specified destination device using HIP.

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

hipLibraryUnload

hipError_t hipLibraryUnload(hipLibrary_t library)

Unload HIP Library.

hipLinkAddFile

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

Adds a file with bitcode to be linked with options.

hipGetFuncBySymbol

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

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

hipLinkDestroy

hipError_t hipLinkDestroy(hipLinkState_t state)

Deletes the linker instance.

hipLibraryLoadFromFile

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

Load hip Library from file.

hipMemGetHandleForAddressRange

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

Returns a handle for the address range requested.

hipLibraryEnumerateKernels

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

Retrieve kernel handles within a library.

hipLibraryGetKernel

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

Get Kernel object from library.

hipKernelGetName

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

Returns a Kernel Name.

hipModuleGetFunction

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

Function with kname will be extracted if present in module.

hipLinkCreate

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

Creates a linker instance with options.

hipGetDriverEntryPoint

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

Gets function pointer of a requested HIP API.

hipModuleLoadData

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

builds module from code object data which resides in host memory.

hipLibraryGetKernelCount

hipError_t hipLibraryGetKernelCount(unsigned int *count, hipLibrary_t library)

Get Kernel count in library.

hipKernelGetParamInfo

hipError_t hipKernelGetParamInfo(hipKernel_t kernel, size_t paramIndex, size_t *paramOffset, size_t *paramSize)

Returns the offset and size of a kernel parameter.

hipKernelGetAttribute

hipError_t hipKernelGetAttribute(int *pi, hipFunction_attribute attrib, hipKernel_t kernel, hipDevice_t dev)

Returns information about a kernel.

hipModuleLoadFatBinary

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

Loads fatbin object.

hipLibraryLoadData

hipError_t hipLibraryLoadData(hipLibrary_t *library, const void *code, hipJitOption *jitOptions, void **jitOptionsValues, unsigned int numJitOptions, hipLibraryOption *libraryOptions, void **libraryOptionValues, unsigned int numLibraryOptions)

Load hip Library from inmemory object.

hipModuleUnload

hipError_t hipModuleUnload(hipModule_t module)

Frees the module.

hipKernelGetLibrary

hipError_t hipKernelGetLibrary(hipLibrary_t *library, hipKernel_t kernel)

Returns a Library Handle.

hipLinkAddData

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

Adds bitcode data to be linked with options.

hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags

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

Returns occupancy for a device function.

hipOccupancyAvailableDynamicSMemPerBlock

hipError_t hipOccupancyAvailableDynamicSMemPerBlock(size_t *dynamicSmemSize, const void *f, int numBlocks, int blockSize)

Returns dynamic shared memory available per block when launching numBlocks blocks on SM.

hipModuleOccupancyMaxPotentialBlockSize

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

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

hipOccupancyMaxActiveBlocksPerMultiprocessor

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

Returns occupancy for a device function.

hipOccupancyMaxPotentialBlockSize

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

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

hipModuleOccupancyMaxActiveBlocksPerMultiprocessor

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

Returns occupancy for a device function.

hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags

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

Returns occupancy for a device function.

hipModuleOccupancyMaxPotentialBlockSizeWithFlags

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

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

hipDeviceCanAccessPeer

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

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

hipDeviceEnablePeerAccess

hipError_t hipDeviceEnablePeerAccess(int peerDeviceId, unsigned int flags)

Enables direct access to memory allocations on a peer device.

hipMemcpyPeer

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

Copies memory between two peer accessible devices.

hipMemcpyPeerAsync

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

Copies memory between two peer accessible devices asynchronously.

hipDeviceDisablePeerAccess

hipError_t hipDeviceDisablePeerAccess(int peerDeviceId)

Disables direct access to memory allocations on a peer device.

hipProfilerStart

hipError_t hipProfilerStart()

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

hipProfilerStop

hipError_t hipProfilerStop()

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

hipStreamGetId

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

Queries the Id of a stream.

hipDeviceGetStreamPriorityRange

hipError_t hipDeviceGetStreamPriorityRange(int *leastPriority, int *greatestPriority)

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

hipStreamDestroy

hipError_t hipStreamDestroy(hipStream_t stream)

Destroys the specified stream.

hipStreamGetFlags

hipError_t hipStreamGetFlags(hipStream_t stream, unsigned int *flags)

Returns flags associated with this stream.

hipStreamAddCallback

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

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

hipStreamCopyAttributes

hipError_t hipStreamCopyAttributes(hipStream_t dst, hipStream_t src)

Copies attributes from source stream to destination stream.

hipStreamCallback_t

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

Definition hip_runtime_api.h:3055

hipStreamGetDevice

hipError_t hipStreamGetDevice(hipStream_t stream, hipDevice_t *device)

Gets the device associated with the stream.

hipStreamQuery

hipError_t hipStreamQuery(hipStream_t stream)

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

hipStreamSynchronize

hipError_t hipStreamSynchronize(hipStream_t stream)

Waits for all commands in the stream to complete.

hipStreamSetAttribute

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

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

hipStreamWaitEvent

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

Makes the specified compute stream wait for the specified event.

hipStreamCreateWithPriority

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

Creates an asynchronous stream with the specified priority.

hipExtStreamCreateWithCUMask

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

Creates an asynchronous stream with the specified CU mask.

hipStreamGetPriority

hipError_t hipStreamGetPriority(hipStream_t stream, int *priority)

Queries the priority of a stream.

hipExtStreamGetCUMask

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

Gets CU mask associated with an asynchronous stream.

hipStreamGetAttribute

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

queries stream attribute.

hipStreamCreateWithFlags

hipError_t hipStreamCreateWithFlags(hipStream_t *stream, unsigned int flags)

Creates an asynchronous stream with flag.

hipStreamCreate

hipError_t hipStreamCreate(hipStream_t *stream)

Creates an asynchronous stream.

hipStreamWriteValue64

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

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

hipStreamWriteValue32

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

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

hipGraphExecBatchMemOpNodeSetParams

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

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

hipGraphAddBatchMemOpNode

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

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

hipStreamWaitValue64

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

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

hipGraphBatchMemOpNodeGetParams

hipError_t hipGraphBatchMemOpNodeGetParams(hipGraphNode_t hNode, hipBatchMemOpNodeParams *nodeParams_out)

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

hipStreamBatchMemOp

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

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

hipGraphBatchMemOpNodeSetParams

hipError_t hipGraphBatchMemOpNodeSetParams(hipGraphNode_t hNode, hipBatchMemOpNodeParams *nodeParams)

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

hipStreamWaitValue32

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

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

hipMemPoolImportPointer

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

Import a memory pool allocation from another process.

hipMemPoolImportFromShareableHandle

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

Imports a memory pool from a shared handle.

hipMallocFromPoolAsync

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

Allocates memory from a specified pool with stream ordered semantics.

hipMemSetMemPool

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

Sets memory pool for memory location and allocation type.

hipFreeAsync

hipError_t hipFreeAsync(void *dev_ptr, hipStream_t stream)

Frees memory with stream ordered semantics.

hipMemPoolTrimTo

hipError_t hipMemPoolTrimTo(hipMemPool_t mem_pool, size_t min_bytes_to_hold)

Releases freed memory back to the OS.

hipMemPoolCreate

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

Creates a memory pool.

hipMemPoolSetAccess

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

Controls visibility of the specified pool between devices.

hipMemPoolDestroy

hipError_t hipMemPoolDestroy(hipMemPool_t mem_pool)

Destroys the specified memory pool.

hipMemPoolSetAttribute

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

Sets attributes of a memory pool.

hipMemPoolGetAttribute

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

Gets attributes of a memory pool.

hipMemPoolExportToShareableHandle

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

Exports a memory pool to the requested handle type.

hipMemPoolExportPointer

hipError_t hipMemPoolExportPointer(hipMemPoolPtrExportData *export_data, void *dev_ptr)

Export data to share a memory pool allocation between processes.

hipMallocAsync

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

Allocates memory with stream ordered semantics.

hipMemPoolGetAccess

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

Returns the accessibility of a pool from a device.

hipMemGetMemPool

hipError_t hipMemGetMemPool(hipMemPool_t *pool, hipMemLocation *location, hipMemAllocationType type)

Retrieves memory pool for memory location and allocation type.

hipDestroySurfaceObject

hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject)

Destroy a surface object.

hipCreateSurfaceObject

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

Create a surface object.

hipTexRefGetFilterMode

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

Gets filter mode for a texture reference [Deprecated].

hipBindTextureToMipmappedArray

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

Binds a mipmapped array to a texture [Deprecated].

hipTexRefGetMipmapLevelClamp

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

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

hipTexRefGetAddressMode

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

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

hipTexRefGetFlags

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

Gets flags for a texture reference [Deprecated].

hipTexRefSetAddress

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

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

hipTexRefSetFilterMode

hipError_t hipTexRefSetFilterMode(textureReference *texRef, enum hipTextureFilterMode fm)

Set filter mode for a texture reference [Deprecated].

hipTexRefSetMipmappedArray

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

Binds mipmapped array to a texture reference [Deprecated].

hipTexRefGetMipmapFilterMode

hipError_t hipTexRefGetMipmapFilterMode(enum hipTextureFilterMode *pfm, const textureReference *texRef)

Gets the mipmap filter mode for a texture reference [Deprecated].

hipGetTextureAlignmentOffset

hipError_t hipGetTextureAlignmentOffset(size_t *offset, const textureReference *texref)

Get the offset of the alignment in a texture [Deprecated].

hipBindTexture2D

hipError_t hipBindTexture2D(size_t *offset, const textureReference *tex, const void *devPtr, const hipChannelFormatDesc *desc, size_t width, size_t height, size_t pitch)

Binds a 2D memory area to a texture [Deprecated].

hipTexRefGetMaxAnisotropy

hipError_t hipTexRefGetMaxAnisotropy(int *pmaxAnsio, const textureReference *texRef)

Gets the maximum anisotropy for a texture reference [Deprecated].

hipBindTexture

hipError_t hipBindTexture(size_t *offset, const textureReference *tex, const void *devPtr, const hipChannelFormatDesc *desc, size_t size)

Binds a memory area to a texture [Deprecated].

hipUnbindTexture

hipError_t hipUnbindTexture(const textureReference *tex)

Unbinds a texture [Deprecated].

hipTexRefGetBorderColor

hipError_t hipTexRefGetBorderColor(float *pBorderColor, const textureReference *texRef)

Gets the border color used by a texture reference [Deprecated].

hipTexRefSetFormat

hipError_t hipTexRefSetFormat(textureReference *texRef, hipArray_Format fmt, int NumPackedComponents)

Set format for a texture reference [Deprecated].

hipTexRefGetAddress

hipError_t hipTexRefGetAddress(hipDeviceptr_t *dev_ptr, const textureReference *texRef)

Gets the address for a texture reference [Deprecated].

hipTexRefGetArray

hipError_t hipTexRefGetArray(hipArray_t *pArray, const textureReference *texRef)

Gets the array bound to a texture reference [Deprecated].

hipTexRefSetFlags

hipError_t hipTexRefSetFlags(textureReference *texRef, unsigned int Flags)

Set flags for a texture reference [Deprecated].

hipTexRefSetAddressMode

hipError_t hipTexRefSetAddressMode(textureReference *texRef, int dim, enum hipTextureAddressMode am)

Sets address mode for a texture reference [Deprecated].

hipTexRefGetMipMappedArray

hipError_t hipTexRefGetMipMappedArray(hipMipmappedArray_t *pArray, const textureReference *texRef)

Gets the mipmapped array bound to a texture reference [Deprecated].

hipTexRefSetMaxAnisotropy

hipError_t hipTexRefSetMaxAnisotropy(textureReference *texRef, unsigned int maxAniso)

Sets the maximum anisotropy for a texture reference [Deprecated].

hipTexRefSetMipmapLevelClamp

hipError_t hipTexRefSetMipmapLevelClamp(textureReference *texRef, float minMipMapLevelClamp, float maxMipMapLevelClamp)

Sets mipmap level clamp for a texture reference [Deprecated].

hipTexRefSetBorderColor

hipError_t hipTexRefSetBorderColor(textureReference *texRef, float *pBorderColor)

Sets border color for a texture reference [Deprecated].

hipTexRefSetArray

hipError_t hipTexRefSetArray(textureReference *tex, hipArray_const_t array, unsigned int flags)

Binds an array as a texture reference [Deprecated].

hipTexRefSetMipmapLevelBias

hipError_t hipTexRefSetMipmapLevelBias(textureReference *texRef, float bias)

Sets mipmap level bias for a texture reference [Deprecated].

hipTexRefGetMipmapLevelBias

hipError_t hipTexRefGetMipmapLevelBias(float *pbias, const textureReference *texRef)

Gets the mipmap level bias for a texture reference [Deprecated].

hipBindTextureToArray

hipError_t hipBindTextureToArray(const textureReference *tex, hipArray_const_t array, const hipChannelFormatDesc *desc)

Binds a memory area to a texture [Deprecated].

hipGetTextureReference

hipError_t hipGetTextureReference(const textureReference **texref, const void *symbol)

Gets the texture reference related with the symbol [Deprecated].

hipTexRefSetAddress2D

hipError_t hipTexRefSetAddress2D(textureReference *texRef, const HIP_ARRAY_DESCRIPTOR *desc, hipDeviceptr_t dptr, size_t Pitch)

Set a bind an address as a 2D texture reference [Deprecated].

hipTexRefSetMipmapFilterMode

hipError_t hipTexRefSetMipmapFilterMode(textureReference *texRef, enum hipTextureFilterMode fm)

Sets mipmap filter mode for a texture reference [Deprecated].

hipTexRefGetFormat

hipError_t hipTexRefGetFormat(hipArray_Format *pFormat, int *pNumChannels, const textureReference *texRef)

Gets texture format for a texture reference [Deprecated].

hipFreeMipmappedArray

hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray)

Frees a mipmapped array on the device.

hipGetMipmappedArrayLevel

hipError_t hipGetMipmappedArrayLevel(hipArray_t *levelArray, hipMipmappedArray_const_t mipmappedArray, unsigned int level)

Gets a mipmap level of a HIP mipmapped array.

hipMipmappedArrayGetLevel

hipError_t hipMipmappedArrayGetLevel(hipArray_t *pLevelArray, hipMipmappedArray_t hMipMappedArray, unsigned int level)

Get a mipmapped array on a mipmapped level.

hipMipmappedArrayDestroy

hipError_t hipMipmappedArrayDestroy(hipMipmappedArray_t hMipmappedArray)

Destroy a mipmapped array.

hipTexObjectCreate

hipError_t hipTexObjectCreate(hipTextureObject_t *pTexObject, const HIP_RESOURCE_DESC *pResDesc, const HIP_TEXTURE_DESC *pTexDesc, const HIP_RESOURCE_VIEW_DESC *pResViewDesc)

Creates a texture object.

hipGetTextureObjectResourceDesc

hipError_t hipGetTextureObjectResourceDesc(hipResourceDesc *pResDesc, hipTextureObject_t textureObject)

Gets resource descriptor for the texture object.

hipGetTextureObjectResourceViewDesc

hipError_t hipGetTextureObjectResourceViewDesc(struct hipResourceViewDesc *pResViewDesc, hipTextureObject_t textureObject)

Gets resource view descriptor for the texture object.

hipTexObjectGetTextureDesc

hipError_t hipTexObjectGetTextureDesc(HIP_TEXTURE_DESC *pTexDesc, hipTextureObject_t texObject)

Gets texture descriptor of a texture object.

hipCreateTextureObject

hipError_t hipCreateTextureObject(hipTextureObject_t *pTexObject, const hipResourceDesc *pResDesc, const hipTextureDesc *pTexDesc, const struct hipResourceViewDesc *pResViewDesc)

Creates a texture object.

hipTexObjectDestroy

hipError_t hipTexObjectDestroy(hipTextureObject_t texObject)

Destroys a texture object.

hipMipmappedArrayCreate

hipError_t hipMipmappedArrayCreate(hipMipmappedArray_t *pHandle, HIP_ARRAY3D_DESCRIPTOR *pMipmappedArrayDesc, unsigned int numMipmapLevels)

Create a mipmapped array.

hipGetChannelDesc

hipError_t hipGetChannelDesc(hipChannelFormatDesc *desc, hipArray_const_t array)

Gets the channel descriptor in an array.

hipTexObjectGetResourceDesc

hipError_t hipTexObjectGetResourceDesc(HIP_RESOURCE_DESC *pResDesc, hipTextureObject_t texObject)

Gets resource descriptor of a texture object.

hipTexObjectGetResourceViewDesc

hipError_t hipTexObjectGetResourceViewDesc(HIP_RESOURCE_VIEW_DESC *pResViewDesc, hipTextureObject_t texObject)

Gets resource view descriptor of a texture object.

hipMallocMipmappedArray

hipError_t hipMallocMipmappedArray(hipMipmappedArray_t *mipmappedArray, const struct hipChannelFormatDesc *desc, struct hipExtent extent, unsigned int numLevels, unsigned int flags)

Allocate a mipmapped array on the device.

hipDestroyTextureObject

hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject)

Destroys a texture object.

hipGetTextureObjectTextureDesc

hipError_t hipGetTextureObjectTextureDesc(hipTextureDesc *pTexDesc, hipTextureObject_t textureObject)

Gets texture descriptor for the texture object.

hipMemAddressFree

hipError_t hipMemAddressFree(void *devPtr, size_t size)

Frees an address range reservation made via hipMemAddressReserve.

hipMemExportToShareableHandle

hipError_t hipMemExportToShareableHandle(void *shareableHandle, hipMemGenericAllocationHandle_t handle, hipMemAllocationHandleType handleType, unsigned long long flags)

Exports an allocation to a requested shareable handle type.

hipMemGetAccess

hipError_t hipMemGetAccess(unsigned long long *flags, const hipMemLocation *location, void *ptr)

Get the access flags set for the given location and ptr.

hipMemSetAccess

hipError_t hipMemSetAccess(void *ptr, size_t size, const hipMemAccessDesc *desc, size_t count)

Set the access flags for each location specified in desc for the given virtual address range.

hipMemRelease

hipError_t hipMemRelease(hipMemGenericAllocationHandle_t handle)

Release a memory handle representing a memory allocation which was previously allocated through hipMe...

hipMemUnmap

hipError_t hipMemUnmap(void *ptr, size_t size)

Unmap memory allocation of a given address range.

hipMemGetAllocationGranularity

hipError_t hipMemGetAllocationGranularity(size_t *granularity, const hipMemAllocationProp *prop, hipMemAllocationGranularity_flags option)

Calculates either the minimal or recommended granularity.

hipMemRetainAllocationHandle

hipError_t hipMemRetainAllocationHandle(hipMemGenericAllocationHandle_t *handle, void *addr)

Returns the allocation handle of the backing memory allocation given the address.

hipMemCreate

hipError_t hipMemCreate(hipMemGenericAllocationHandle_t *handle, size_t size, const hipMemAllocationProp *prop, unsigned long long flags)

Creates a memory allocation described by the properties and size.

hipMemMap

hipError_t hipMemMap(void *ptr, size_t size, size_t offset, hipMemGenericAllocationHandle_t handle, unsigned long long flags)

Maps an allocation handle to a reserved virtual address range.

hipMemAddressReserve

hipError_t hipMemAddressReserve(void **ptr, size_t size, size_t alignment, void *addr, unsigned long long flags)

Reserves an address range.

hipMemGetAllocationPropertiesFromHandle

hipError_t hipMemGetAllocationPropertiesFromHandle(hipMemAllocationProp *prop, hipMemGenericAllocationHandle_t handle)

Retrieve the property structure of the given handle.

hipMemMapArrayAsync

hipError_t hipMemMapArrayAsync(hipArrayMapInfo *mapInfoList, unsigned int count, hipStream_t stream)

Maps or unmaps subregions of sparse HIP arrays and sparse HIP mipmapped arrays.

hipMemImportFromShareableHandle

hipError_t hipMemImportFromShareableHandle(hipMemGenericAllocationHandle_t *handle, void *osHandle, hipMemAllocationHandleType shHandleType)

Imports an allocation from a requested shareable handle type.

hip_common.h

hipErrorIllegalAddress

hipErrorIllegalAddress

Definition hip_runtime_api.h:349

hipErrorMemoryAllocation

hipErrorMemoryAllocation

Memory allocation error.

Definition hip_runtime_api.h:295

hipErrorNotFound

hipErrorNotFound

Not found.

Definition hip_runtime_api.h:344

hipErrorProfilerDisabled

hipErrorProfilerDisabled

Definition hip_runtime_api.h:300

hipErrorInvalidDevicePointer

hipErrorInvalidDevicePointer

Invalid Device Pointer.

Definition hip_runtime_api.h:307

HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

@ HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

Definition hip_runtime_api.h:37

HIP_ERROR_INVALID_VALUE

@ HIP_ERROR_INVALID_VALUE

Definition hip_runtime_api.h:35

HIP_SUCCESS

@ HIP_SUCCESS

Definition hip_runtime_api.h:34

HIP_ERROR_NOT_INITIALIZED

@ HIP_ERROR_NOT_INITIALIZED

Definition hip_runtime_api.h:36

hipErrorRuntimeMemory

hipErrorRuntimeMemory

Definition hip_runtime_api.h:398

hipErrorInvalidImage

hipErrorInvalidImage

Invalid image.

Definition hip_runtime_api.h:315

hipErrorPeerAccessUnsupported

hipErrorPeerAccessUnsupported

Definition hip_runtime_api.h:332

hipErrorArrayIsMapped

hipErrorArrayIsMapped

Definition hip_runtime_api.h:322

hipErrorStreamCaptureIsolation

hipErrorStreamCaptureIsolation

Definition hip_runtime_api.h:377

hipErrorInvalidKernelFile

hipErrorInvalidKernelFile

In CUDA DRV, it is CUDA_ERROR_INVALID_PTX.

Definition hip_runtime_api.h:333

hipErrorNotMapped

hipErrorNotMapped

Definition hip_runtime_api.h:326

hipErrorGraphExecUpdateFailure

hipErrorGraphExecUpdateFailure

Definition hip_runtime_api.h:390

hipErrorNotInitialized

hipErrorNotInitialized

Invalid not initialized.

Definition hip_runtime_api.h:296

hipErrorInvalidResourceHandle

hipErrorInvalidResourceHandle

Resource handle (hipEvent_t or hipStream_t) invalid.

Definition hip_runtime_api.h:342

hipErrorSharedObjectInitFailed

hipErrorSharedObjectInitFailed

Failed to initialize shared object.

Definition hip_runtime_api.h:338

hipErrorInvalidPitchValue

hipErrorInvalidPitchValue

Invalid pitch value.

Definition hip_runtime_api.h:305

hipErrorNoBinaryForGpu

hipErrorNoBinaryForGpu

Definition hip_runtime_api.h:324

hipErrorInvalidContext

hipErrorInvalidContext

Produced when input context is invalid.

Definition hip_runtime_api.h:316

hipErrorStreamCaptureUnsupported

hipErrorStreamCaptureUnsupported

Definition hip_runtime_api.h:368

hipErrorPeerAccessNotEnabled

hipErrorPeerAccessNotEnabled

Peer access was never enabled from the current device.

Definition hip_runtime_api.h:354

hipErrorOperatingSystem

hipErrorOperatingSystem

Not the correct operating system.

Definition hip_runtime_api.h:339

hipErrorStreamCaptureUnjoined

hipErrorStreamCaptureUnjoined

Definition hip_runtime_api.h:375

hipErrorInitializationError

hipErrorInitializationError

Definition hip_runtime_api.h:298

hipErrorNotMappedAsPointer

hipErrorNotMappedAsPointer

Definition hip_runtime_api.h:328

hipErrorPriorLaunchFailure

hipErrorPriorLaunchFailure

Definition hip_runtime_api.h:311

hipErrorContextIsDestroyed

hipErrorContextIsDestroyed

The context is already destroyed.

Definition hip_runtime_api.h:356

hipErrorInvalidValue

hipErrorInvalidValue

Definition hip_runtime_api.h:291

hipErrorLaunchTimeOut

hipErrorLaunchTimeOut

Timeout for the launch.

Definition hip_runtime_api.h:351

hipErrorUnmapFailed

hipErrorUnmapFailed

Definition hip_runtime_api.h:321

hipErrorSetOnActiveProcess

hipErrorSetOnActiveProcess

The process is active.

Definition hip_runtime_api.h:355

hipErrorFileNotFound

hipErrorFileNotFound

the file is not found.

Definition hip_runtime_api.h:336

hipErrorLaunchFailure

hipErrorLaunchFailure

An exception occurred on the device while executing a kernel.

Definition hip_runtime_api.h:362

hipErrorInvalidDevice

hipErrorInvalidDevice

DeviceID must be in range from 0 to compute-devices.

Definition hip_runtime_api.h:314

hipErrorUnsupportedLimit

hipErrorUnsupportedLimit

Unsupported limit.

Definition hip_runtime_api.h:330

hipErrorMapBufferObjectFailed

hipErrorMapBufferObjectFailed

Produced when the IPC memory attach failed from ROCr.

Definition hip_runtime_api.h:320

hipErrorHostMemoryAlreadyRegistered

hipErrorHostMemoryAlreadyRegistered

Definition hip_runtime_api.h:358

hipErrorMissingConfiguration

hipErrorMissingConfiguration

Definition hip_runtime_api.h:310

hipErrorSharedObjectSymbolNotFound

hipErrorSharedObjectSymbolNotFound

Definition hip_runtime_api.h:337

hipErrorECCNotCorrectable

hipErrorECCNotCorrectable

Definition hip_runtime_api.h:329

hipErrorStreamCaptureWrongThread

hipErrorStreamCaptureWrongThread

Definition hip_runtime_api.h:386

hipErrorAssert

hipErrorAssert

Produced when the kernel calls assert.

Definition hip_runtime_api.h:357

hipErrorContextAlreadyInUse

hipErrorContextAlreadyInUse

The context is already in use.

Definition hip_runtime_api.h:331

hipErrorNotReady

hipErrorNotReady

Definition hip_runtime_api.h:345

hipErrorInvalidSource

hipErrorInvalidSource

Invalid source.

Definition hip_runtime_api.h:335

hipErrorLaunchOutOfResources

hipErrorLaunchOutOfResources

Out of resources error.

Definition hip_runtime_api.h:350

hipErrorInvalidDeviceFunction

hipErrorInvalidDeviceFunction

Invalid device function.

Definition hip_runtime_api.h:312

hipErrorCooperativeLaunchTooLarge

hipErrorCooperativeLaunchTooLarge

Definition hip_runtime_api.h:363

hipErrorAlreadyMapped

hipErrorAlreadyMapped

Definition hip_runtime_api.h:323

hipErrorProfilerNotInitialized

hipErrorProfilerNotInitialized

Definition hip_runtime_api.h:301

hipErrorProfilerAlreadyStarted

hipErrorProfilerAlreadyStarted

Definition hip_runtime_api.h:302

hipErrorInvalidChannelDescriptor

hipErrorInvalidChannelDescriptor

Invalid channel descriptor.

Definition hip_runtime_api.h:394

hipErrorNoDevice

hipErrorNoDevice

Call to hipGetDeviceCount returned 0 devices.

Definition hip_runtime_api.h:313

hipErrorMapFailed

hipErrorMapFailed

Definition hip_runtime_api.h:318

hipErrorStreamCaptureInvalidated

hipErrorStreamCaptureInvalidated

Definition hip_runtime_api.h:370

hipErrorProfilerAlreadyStopped

hipErrorProfilerAlreadyStopped

Definition hip_runtime_api.h:303

hipErrorDeinitialized

hipErrorDeinitialized

Deinitialized.

Definition hip_runtime_api.h:299

hipErrorPeerAccessAlreadyEnabled

hipErrorPeerAccessAlreadyEnabled

Definition hip_runtime_api.h:352

hipErrorNotMappedAsArray

hipErrorNotMappedAsArray

Definition hip_runtime_api.h:327

hipErrorNotSupported

hipErrorNotSupported

Produced when the hip API is not supported/implemented.

Definition hip_runtime_api.h:367

hipErrorInvalidConfiguration

hipErrorInvalidConfiguration

Invalide configuration.

Definition hip_runtime_api.h:304

hipErrorStreamCaptureImplicit

hipErrorStreamCaptureImplicit

Definition hip_runtime_api.h:381

hipErrorStreamCaptureMerge

hipErrorStreamCaptureMerge

Definition hip_runtime_api.h:372

hipErrorInvalidGraphicsContext

hipErrorInvalidGraphicsContext

Definition hip_runtime_api.h:334

hipErrorIllegalState

hipErrorIllegalState

Resource required is not in a valid state to perform operation.

Definition hip_runtime_api.h:343

hipErrorOutOfMemory

hipErrorOutOfMemory

out of memory range.

Definition hip_runtime_api.h:293

hipErrorInvalidSymbol

hipErrorInvalidSymbol

Invalid symbol.

Definition hip_runtime_api.h:306

hipSuccess

hipSuccess

Successful completion.

Definition hip_runtime_api.h:290

hipErrorUnknown

hipErrorUnknown

Unknown error.

Definition hip_runtime_api.h:396

hipErrorInvalidHandle

hipErrorInvalidHandle

Invalide handle.

Definition hip_runtime_api.h:340

hipErrorStreamCaptureUnmatched

hipErrorStreamCaptureUnmatched

The capture was not initiated in this stream.

Definition hip_runtime_api.h:374

hipErrorCapturedEvent

hipErrorCapturedEvent

Definition hip_runtime_api.h:384

hipErrorAlreadyAcquired

hipErrorAlreadyAcquired

Definition hip_runtime_api.h:325

hipErrorInsufficientDriver

hipErrorInsufficientDriver

Definition hip_runtime_api.h:309

hipErrorHostMemoryNotRegistered

hipErrorHostMemoryNotRegistered

Definition hip_runtime_api.h:360

hipErrorInvalidTexture

hipErrorInvalidTexture

Invalid texture.

Definition hip_runtime_api.h:395

hipErrorRuntimeOther

hipErrorRuntimeOther

Definition hip_runtime_api.h:400

hipErrorContextAlreadyCurrent

hipErrorContextAlreadyCurrent

Definition hip_runtime_api.h:317

hipErrorInvalidMemcpyDirection

hipErrorInvalidMemcpyDirection

Invalid memory copy direction.

Definition hip_runtime_api.h:308

linker_types.h

hip_impl

Definition hip_runtime_api.h:661

hip_impl::hip_init

hipError_t hip_init()

HIP_ARRAY3D_DESCRIPTOR

Definition driver_types.h:87

HIP_ARRAY_DESCRIPTOR

Definition driver_types.h:77

HIP_LAUNCH_CONFIG

Definition hip_runtime_api.h:1992

HIP_LAUNCH_CONFIG::gridDimZ

unsigned int gridDimZ

Grid depth in blocks.

Definition hip_runtime_api.h:1995

HIP_LAUNCH_CONFIG::sharedMemBytes

unsigned int sharedMemBytes

Dynamic shared-memory size in bytes per block.

Definition hip_runtime_api.h:1999

HIP_LAUNCH_CONFIG::blockDimY

unsigned int blockDimY

Thread block dimension in Y.

Definition hip_runtime_api.h:1997

HIP_LAUNCH_CONFIG::hStream

hipStream_t hStream

HIP stream identifier.

Definition hip_runtime_api.h:2000

HIP_LAUNCH_CONFIG::attrs

hipLaunchAttribute * attrs

Attribute list.

Definition hip_runtime_api.h:2001

HIP_LAUNCH_CONFIG::blockDimZ

unsigned int blockDimZ

Thread block dimension in Z.

Definition hip_runtime_api.h:1998

HIP_LAUNCH_CONFIG::numAttrs

unsigned int numAttrs

Number of attributes.

Definition hip_runtime_api.h:2002

HIP_LAUNCH_CONFIG::gridDimX

unsigned int gridDimX

Grid width in blocks.

Definition hip_runtime_api.h:1993

HIP_LAUNCH_CONFIG::gridDimY

unsigned int gridDimY

Grid height in blocks.

Definition hip_runtime_api.h:1994

HIP_LAUNCH_CONFIG::blockDimX

unsigned int blockDimX

Thread block dimension in X.

Definition hip_runtime_api.h:1996

HIP_MEMCPY3D

Definition driver_types.h:408

HIP_RESOURCE_DESC

Definition driver_types.h:297

HIP_RESOURCE_VIEW_DESC

Definition driver_types.h:342

HIP_TEXTURE_DESC

Definition driver_types.h:175

dim3

Definition hip_runtime_api.h:1284

dim3::y

uint32_t y

y

Definition hip_runtime_api.h:1286

dim3::z

uint32_t z

z

Definition hip_runtime_api.h:1287

dim3::x

uint32_t x

x

Definition hip_runtime_api.h:1285

dim3::dim3

constexpr dim3(uint32_t _x=1, uint32_t _y=1, uint32_t _z=1)

Definition hip_runtime_api.h:1289

hip_Memcpy2D

Definition driver_types.h:99

hipAccessPolicyWindow

Definition hip_runtime_api.h:1533

hipAccessPolicyWindow::hitProp

hipAccessProperty hitProp

hipAccessProperty set for hit

Definition hip_runtime_api.h:1535

hipAccessPolicyWindow::missProp

hipAccessProperty missProp

hipAccessProperty set for miss

Definition hip_runtime_api.h:1537

hipAccessPolicyWindow::hitRatio

float hitRatio

hitRatio specifies percentage of lines assigned hitProp

Definition hip_runtime_api.h:1536

hipAccessPolicyWindow::base_ptr

void * base_ptr

Starting address of the access policy window.

Definition hip_runtime_api.h:1534

hipAccessPolicyWindow::num_bytes

size_t num_bytes

Size in bytes of the window policy.

Definition hip_runtime_api.h:1538

hipArrayMapInfo

Definition hip_runtime_api.h:1827

hipArrayMapInfo::level

unsigned int level

For mipmapped arrays must be a valid mipmap level. For arrays must be zero.

Definition hip_runtime_api.h:1837

hipArrayMapInfo::flags

unsigned int flags

flags for future use, must be zero now.

Definition hip_runtime_api.h:1861

hipArrayMapInfo::subresourceType

hipArraySparseSubresourceType subresourceType

Sparse subresource type.

Definition hip_runtime_api.h:1833

hipArrayMapInfo::extentDepth

unsigned int extentDepth

Depth in elements.

Definition hip_runtime_api.h:1845

hipArrayMapInfo::offsetX

unsigned int offsetX

X offset in elements.

Definition hip_runtime_api.h:1840

hipArrayMapInfo::array

hipArray_t array

Definition hip_runtime_api.h:1831

hipArrayMapInfo::resourceType

hipResourceType resourceType

Resource type.

Definition hip_runtime_api.h:1828

hipArrayMapInfo::memOperationType

hipMemOperationType memOperationType

Memory operation type.

Definition hip_runtime_api.h:1854

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:1862

hipArrayMapInfo::extentWidth

unsigned int extentWidth

Width in elements.

Definition hip_runtime_api.h:1843

hipArrayMapInfo::sparseLevel

struct hipArrayMapInfo::@35::@37 sparseLevel

hipArrayMapInfo::extentHeight

unsigned int extentHeight

Height in elements.

Definition hip_runtime_api.h:1844

hipArrayMapInfo::offsetY

unsigned int offsetY

Y offset in elements.

Definition hip_runtime_api.h:1841

hipArrayMapInfo::memHandleType

hipMemHandleType memHandleType

Memory handle type.

Definition hip_runtime_api.h:1855

hipArrayMapInfo::memHandle

hipMemGenericAllocationHandle_t memHandle

Definition hip_runtime_api.h:1857

hipArrayMapInfo::mipmap

hipMipmappedArray mipmap

Definition hip_runtime_api.h:1830

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:1839

hipArrayMapInfo::deviceBitMask

unsigned int deviceBitMask

Device ordinal bit mask.

Definition hip_runtime_api.h:1860

hipArrayMapInfo::size

unsigned long long size

Extent in bytes.

Definition hip_runtime_api.h:1851

hipArrayMapInfo::offset

unsigned long long offset

Offset within mip tail.

Definition hip_runtime_api.h:1850

hipArrayMapInfo::offsetZ

unsigned int offsetZ

Z offset in elements.

Definition hip_runtime_api.h:1842

hipArrayMapInfo::resource

union hipArrayMapInfo::@34 resource

hipArrayMemoryRequirements

Definition hip_runtime_api.h:2008

hipArrayMemoryRequirements::size

size_t size

Definition hip_runtime_api.h:2010

hipArrayMemoryRequirements::alignment

size_t alignment

Definition hip_runtime_api.h:2009

hipBatchMemOpNodeParams

Structure representing node parameters for batch memory operations in HIP graphs.

Definition hip_runtime_api.h:1062

hipBatchMemOpNodeParams::paramArray

hipStreamBatchMemOpParams * paramArray

Definition hip_runtime_api.h:1065

hipBatchMemOpNodeParams::count

unsigned int count

Definition hip_runtime_api.h:1064

hipBatchMemOpNodeParams::flags

unsigned int flags

Definition hip_runtime_api.h:1066

hipBatchMemOpNodeParams::ctx

hipCtx_t ctx

Definition hip_runtime_api.h:1063

hipChannelFormatDesc

Definition driver_types.h:43

hipChildGraphNodeParams

Definition hip_runtime_api.h:1877

hipChildGraphNodeParams::graph

hipGraph_t graph

Definition hip_runtime_api.h:1878

hipDeviceArch_t

Definition hip_runtime_api.h:49

hipDeviceArch_t::hasSharedInt64Atomics

unsigned hasSharedInt64Atomics

64-bit integer atomics for shared memory.

Definition hip_runtime_api.h:59

hipDeviceArch_t::hasSharedInt32Atomics

unsigned hasSharedInt32Atomics

32-bit integer atomics for shared memory.

Definition hip_runtime_api.h:53

hipDeviceArch_t::hasFloatAtomicAdd

unsigned hasFloatAtomicAdd

32-bit float atomic add in global and shared memory.

Definition hip_runtime_api.h:55

hipDeviceArch_t::hasDoubles

unsigned hasDoubles

Double-precision floating point.

Definition hip_runtime_api.h:62

hipDeviceArch_t::hasWarpVote

unsigned hasWarpVote

Warp vote instructions (__any, __all).

Definition hip_runtime_api.h:65

hipDeviceArch_t::hasWarpShuffle

unsigned hasWarpShuffle

Warp shuffle operations. (__shfl_*).

Definition hip_runtime_api.h:67

hipDeviceArch_t::hasGlobalInt32Atomics

unsigned hasGlobalInt32Atomics

32-bit integer atomics for global memory.

Definition hip_runtime_api.h:51

hipDeviceArch_t::hasGlobalFloatAtomicExch

unsigned hasGlobalFloatAtomicExch

32-bit float atomic exch for global memory.

Definition hip_runtime_api.h:52

hipDeviceArch_t::hasDynamicParallelism

unsigned hasDynamicParallelism

Dynamic parallelism.

Definition hip_runtime_api.h:77

hipDeviceArch_t::hasSurfaceFuncs

unsigned hasSurfaceFuncs

Surface functions.

Definition hip_runtime_api.h:75

hipDeviceArch_t::has3dGrid

unsigned has3dGrid

Grid and group dims are 3D (rather than 2D).

Definition hip_runtime_api.h:76

hipDeviceArch_t::hasFunnelShift

unsigned hasFunnelShift

Funnel two words into one with shift&mask caps.

Definition hip_runtime_api.h:68

hipDeviceArch_t::hasThreadFenceSystem

unsigned hasThreadFenceSystem

__threadfence_system.

Definition hip_runtime_api.h:71

hipDeviceArch_t::hasGlobalInt64Atomics

unsigned hasGlobalInt64Atomics

64-bit integer atomics for global memory.

Definition hip_runtime_api.h:58

hipDeviceArch_t::hasSyncThreadsExt

unsigned hasSyncThreadsExt

__syncthreads_count, syncthreads_and, syncthreads_or.

Definition hip_runtime_api.h:72

hipDeviceArch_t::hasWarpBallot

unsigned hasWarpBallot

Warp ballot instructions (__ballot).

Definition hip_runtime_api.h:66

hipDeviceArch_t::hasSharedFloatAtomicExch

unsigned hasSharedFloatAtomicExch

32-bit float atomic exch for shared memory.

Definition hip_runtime_api.h:54

hipDeviceProp_t

Definition hip_runtime_api.h:95

hipDeviceProp_t::ECCEnabled

int ECCEnabled

Device has ECC support enabled.

Definition hip_runtime_api.h:155

hipDeviceProp_t::ipcEventSupported

int ipcEventSupported

Device supports IPC events.

Definition hip_runtime_api.h:209

hipDeviceProp_t::computePreemptionSupported

int computePreemptionSupported

Is compute preemption supported on the device.

Definition hip_runtime_api.h:181

hipDeviceProp_t::maxTexture1DLinear

int maxTexture1DLinear

Maximum size for 1D textures bound to linear memory.

Definition hip_runtime_api.h:134

hipDeviceProp_t::timelineSemaphoreInteropSupported

int timelineSemaphoreInteropSupported

Indicates external timeline semaphore support.

Definition hip_runtime_api.h:199

hipDeviceProp_t::pciBusID

int pciBusID

PCI Bus ID.

Definition hip_runtime_api.h:156

hipDeviceProp_t::maxTexture1D

int maxTexture1D

Maximum number of elements in 1D images.

Definition hip_runtime_api.h:132

hipDeviceProp_t::memoryBusWidth

int memoryBusWidth

Global memory bus width in bits.

Definition hip_runtime_api.h:163

hipDeviceProp_t::maxTexture2DMipmap

int maxTexture2DMipmap[2]

Maximum number of elements in 2D array mipmap of images.

Definition hip_runtime_api.h:136

hipDeviceProp_t::clockRate

int clockRate

Max clock frequency of the multiProcessors in khz.

Definition hip_runtime_api.h:109

hipDeviceProp_t::maxThreadsPerMultiProcessor

int maxThreadsPerMultiProcessor

Maximum resident threads per multi-processor.

Definition hip_runtime_api.h:166

hipDeviceProp_t::l2CacheSize

int l2CacheSize

L2 cache size.

Definition hip_runtime_api.h:164

hipDeviceProp_t::deferredMappingHipArraySupported

int deferredMappingHipArraySupported

Definition hip_runtime_api.h:207

hipDeviceProp_t::asyncEngineCount

int asyncEngineCount

Number of async engines.

Definition hip_runtime_api.h:160

hipDeviceProp_t::accessPolicyMaxWindowSize

int accessPolicyMaxWindowSize

Max value of access policy window.

Definition hip_runtime_api.h:193

hipDeviceProp_t::totalConstMem

size_t totalConstMem

Definition hip_runtime_api.h:110

hipDeviceProp_t::memoryPoolsSupported

int memoryPoolsSupported

Indicates if device supports hipMallocAsync and hipMemPool APIs.

Definition hip_runtime_api.h:200

hipDeviceProp_t::unifiedFunctionPointers

int unifiedFunctionPointers

Indicates device supports unified function pointers.

Definition hip_runtime_api.h:211

hipDeviceProp_t::maxTexture2DGather

int maxTexture2DGather[2]

Maximum 2D tex dimensions if gather has to be performed.

Definition hip_runtime_api.h:138

hipDeviceProp_t::memPitch

size_t memPitch

Definition hip_runtime_api.h:104

hipDeviceProp_t::gpuDirectRDMAWritesOrdering

int gpuDirectRDMAWritesOrdering

value of hipGPUDirectRDMAWritesOrdering

Definition hip_runtime_api.h:204

hipDeviceProp_t::uuid

hipUUID uuid

UUID of a device.

Definition hip_runtime_api.h:97

hipDeviceProp_t::sharedMemPerBlock

size_t sharedMemPerBlock

Size of shared memory per block (in bytes).

Definition hip_runtime_api.h:101

hipDeviceProp_t::gpuDirectRDMAFlushWritesOptions

unsigned int gpuDirectRDMAFlushWritesOptions

Definition hip_runtime_api.h:202

hipDeviceProp_t::surfaceAlignment

size_t surfaceAlignment

Alignment requirement for surface.

Definition hip_runtime_api.h:153

hipDeviceProp_t::reserved

int reserved[63]

CUDA Reserved.

Definition hip_runtime_api.h:212

hipDeviceProp_t::maxTexture2DLayered

int maxTexture2DLayered[3]

Maximum number of elements in 2D array images.

Definition hip_runtime_api.h:144

hipDeviceProp_t::streamPrioritiesSupported

int streamPrioritiesSupported

Device supports stream priority.

Definition hip_runtime_api.h:167

hipDeviceProp_t::cooperativeMultiDeviceLaunch

int cooperativeMultiDeviceLaunch

Definition hip_runtime_api.h:185

hipDeviceProp_t::hostRegisterSupported

int hostRegisterSupported

Device supports hipHostRegister.

Definition hip_runtime_api.h:195

hipDeviceProp_t::pageableMemoryAccess

int pageableMemoryAccess

Definition hip_runtime_api.h:177

hipDeviceProp_t::name

char name[256]

Device name.

Definition hip_runtime_api.h:96

hipDeviceProp_t::textureAlignment

size_t textureAlignment

Alignment requirement for textures.

Definition hip_runtime_api.h:121

hipDeviceProp_t::globalL1CacheSupported

int globalL1CacheSupported

Indicates globals are cached in L1.

Definition hip_runtime_api.h:168

hipDeviceProp_t::hostNativeAtomicSupported

int hostNativeAtomicSupported

Link between host and device supports native atomics.

Definition hip_runtime_api.h:175

hipDeviceProp_t::maxSurfaceCubemapLayered

int maxSurfaceCubemapLayered[2]

Maximum cubemap layered surface size.

Definition hip_runtime_api.h:152

hipDeviceProp_t::maxTextureCubemapLayered

int maxTextureCubemapLayered[2]

Maximum cubemaps layered texture dims.

Definition hip_runtime_api.h:145

hipDeviceProp_t::sharedMemPerBlockOptin

size_t sharedMemPerBlockOptin

Per device m ax shared mem per block usable by special opt in.

Definition hip_runtime_api.h:187

hipDeviceProp_t::sharedMemPerMultiprocessor

size_t sharedMemPerMultiprocessor

Amount of shared memory available per multiprocessor.

Definition hip_runtime_api.h:170

hipDeviceProp_t::singleToDoublePrecisionPerfRatio

int singleToDoublePrecisionPerfRatio

Deprecated. CUDA only.

Definition hip_runtime_api.h:176

hipDeviceProp_t::maxSurface2D

int maxSurface2D[2]

Maximum 2D surface size.

Definition hip_runtime_api.h:147

hipDeviceProp_t::memoryClockRate

int memoryClockRate

Max global memory clock frequency in khz.

Definition hip_runtime_api.h:162

hipDeviceProp_t::maxTexture2DLinear

int maxTexture2DLinear[3]

Maximum 2D tex dimensions if tex are bound to pitched memory.

Definition hip_runtime_api.h:137

hipDeviceProp_t::sparseHipArraySupported

int sparseHipArraySupported

Indicates if device supports sparse hip arrays.

Definition hip_runtime_api.h:196

hipDeviceProp_t::clockInstructionRate

int clockInstructionRate

Definition hip_runtime_api.h:219

hipDeviceProp_t::localL1CacheSupported

int localL1CacheSupported

Locals are cahced in L1.

Definition hip_runtime_api.h:169

hipDeviceProp_t::regsPerMultiprocessor

int regsPerMultiprocessor

registers available per multiprocessor

Definition hip_runtime_api.h:171

hipDeviceProp_t::regsPerBlock

int regsPerBlock

Registers per block.

Definition hip_runtime_api.h:102

hipDeviceProp_t::maxTexture2D

int maxTexture2D[2]

Maximum dimensions (width, height) of 2D images, in image elements.

Definition hip_runtime_api.h:135

hipDeviceProp_t::cooperativeLaunch

int cooperativeLaunch

HIP device supports cooperative launch.

Definition hip_runtime_api.h:184

hipDeviceProp_t::maxTexture3D

int maxTexture3D[3]

Definition hip_runtime_api.h:139

hipDeviceProp_t::directManagedMemAccessFromHost

int directManagedMemAccessFromHost

Definition hip_runtime_api.h:190

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedFunc

int cooperativeMultiDeviceUnmatchedFunc

Definition hip_runtime_api.h:224

hipDeviceProp_t::deviceOverlap

int deviceOverlap

Deprecated. Use asyncEngineCount instead.

Definition hip_runtime_api.h:123

hipDeviceProp_t::pageableMemoryAccessUsesHostPageTables

int pageableMemoryAccessUsesHostPageTables

Definition hip_runtime_api.h:188

hipDeviceProp_t::hdpRegFlushCntl

unsigned int * hdpRegFlushCntl

Addres of HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:223

hipDeviceProp_t::maxThreadsDim

int maxThreadsDim[3]

Max number of threads in each dimension (XYZ) of a block.

Definition hip_runtime_api.h:107

hipDeviceProp_t::unifiedAddressing

int unifiedAddressing

Does device and host share unified address space.

Definition hip_runtime_api.h:161

hipDeviceProp_t::multiGpuBoardGroupID

int multiGpuBoardGroupID

Unique identifier for a group of devices on same multiboard GPU.

Definition hip_runtime_api.h:174

hipDeviceProp_t::isMultiGpuBoard

int isMultiGpuBoard

1 if device is on a multi-GPU board, 0 if not.

Definition hip_runtime_api.h:173

hipDeviceProp_t::canUseHostPointerForRegisteredMem

int canUseHostPointerForRegisteredMem

Definition hip_runtime_api.h:182

hipDeviceProp_t::maxTexture1DLayered

int maxTexture1DLayered[2]

Maximum number of elements in 1D array images.

Definition hip_runtime_api.h:143

hipDeviceProp_t::pciDomainID

int pciDomainID

PCI Domain ID.

Definition hip_runtime_api.h:158

hipDeviceProp_t::maxSharedMemoryPerMultiProcessor

size_t maxSharedMemoryPerMultiProcessor

Maximum Shared Memory Per CU. HIP Only.

Definition hip_runtime_api.h:218

hipDeviceProp_t::maxTextureCubemap

int maxTextureCubemap

Maximum cubemap texture dims.

Definition hip_runtime_api.h:142

hipDeviceProp_t::hipReserved

int hipReserved[32]

Reserved for adding new entries for HIP/CUDA.

Definition hip_runtime_api.h:214

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedGridDim

int cooperativeMultiDeviceUnmatchedGridDim

Definition hip_runtime_api.h:227

hipDeviceProp_t::gpuDirectRDMASupported

int gpuDirectRDMASupported

Indicates device support of RDMA APIs.

Definition hip_runtime_api.h:201

hipDeviceProp_t::minor

int minor

Definition hip_runtime_api.h:116

hipDeviceProp_t::gcnArchName

char gcnArchName[256]

AMD GCN Arch Name. HIP Only.

Definition hip_runtime_api.h:217

hipDeviceProp_t::luid

char luid[8]

8-byte unique identifier. Only valid on windows

Definition hip_runtime_api.h:98

hipDeviceProp_t::kernelExecTimeoutEnabled

int kernelExecTimeoutEnabled

Run time limit for kernels executed on the device.

Definition hip_runtime_api.h:128

hipDeviceProp_t::memoryPoolSupportedHandleTypes

unsigned int memoryPoolSupportedHandleTypes

Bitmask of handle types support with mempool based IPC.

Definition hip_runtime_api.h:206

hipDeviceProp_t::hdpMemFlushCntl

unsigned int * hdpMemFlushCntl

Addres of HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:222

hipDeviceProp_t::concurrentManagedAccess

int concurrentManagedAccess

Definition hip_runtime_api.h:179

hipDeviceProp_t::integrated

int integrated

APU vs dGPU.

Definition hip_runtime_api.h:129

hipDeviceProp_t::canMapHostMemory

int canMapHostMemory

Check whether HIP can map host memory.

Definition hip_runtime_api.h:130

hipDeviceProp_t::reservedSharedMemPerBlock

size_t reservedSharedMemPerBlock

Shared memory reserved by driver per block.

Definition hip_runtime_api.h:194

hipDeviceProp_t::maxSurfaceCubemap

int maxSurfaceCubemap

Maximum cubemap surface size.

Definition hip_runtime_api.h:151

hipDeviceProp_t::maxSurface3D

int maxSurface3D[3]

Maximum 3D surface size.

Definition hip_runtime_api.h:148

hipDeviceProp_t::asicRevision

int asicRevision

Revision of the GPU in this device.

Definition hip_runtime_api.h:237

hipDeviceProp_t::totalGlobalMem

size_t totalGlobalMem

Size of global memory region (in bytes).

Definition hip_runtime_api.h:100

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedBlockDim

int cooperativeMultiDeviceUnmatchedBlockDim

Definition hip_runtime_api.h:230

hipDeviceProp_t::maxSurface1DLayered

int maxSurface1DLayered[2]

Maximum 1D layered surface size.

Definition hip_runtime_api.h:149

hipDeviceProp_t::persistingL2CacheMaxSize

int persistingL2CacheMaxSize

Device's max L2 persisting lines in bytes.

Definition hip_runtime_api.h:165

hipDeviceProp_t::maxSurface1D

int maxSurface1D

Maximum 1D surface size.

Definition hip_runtime_api.h:146

hipDeviceProp_t::concurrentKernels

int concurrentKernels

Device can possibly execute multiple kernels concurrently.

Definition hip_runtime_api.h:154

hipDeviceProp_t::isLargeBar

int isLargeBar

1: if it is a large PCI bar device, else 0

Definition hip_runtime_api.h:236

hipDeviceProp_t::clusterLaunch

int clusterLaunch

Device supports cluster launch.

Definition hip_runtime_api.h:210

hipDeviceProp_t::maxTexture1DMipmap

int maxTexture1DMipmap

Maximum 1D mipmap texture size.

Definition hip_runtime_api.h:133

hipDeviceProp_t::multiProcessorCount

int multiProcessorCount

Definition hip_runtime_api.h:124

hipDeviceProp_t::maxTexture3DAlt

int maxTexture3DAlt[3]

Maximum alternate 3D texture dims.

Definition hip_runtime_api.h:141

hipDeviceProp_t::maxGridSize

int maxGridSize[3]

Max grid dimensions (XYZ).

Definition hip_runtime_api.h:108

hipDeviceProp_t::pciDeviceID

int pciDeviceID

PCI Device ID.

Definition hip_runtime_api.h:157

hipDeviceProp_t::maxBlocksPerMultiProcessor

int maxBlocksPerMultiProcessor

Max number of blocks on CU.

Definition hip_runtime_api.h:192

hipDeviceProp_t::computeMode

int computeMode

Compute mode.

Definition hip_runtime_api.h:131

hipDeviceProp_t::maxSurface2DLayered

int maxSurface2DLayered[3]

Maximum 2D layared surface size.

Definition hip_runtime_api.h:150

hipDeviceProp_t::major

int major

Definition hip_runtime_api.h:112

hipDeviceProp_t::warpSize

int warpSize

Warp size.

Definition hip_runtime_api.h:103

hipDeviceProp_t::tccDriver

int tccDriver

1:If device is Tesla device using TCC driver, else 0

Definition hip_runtime_api.h:159

hipDeviceProp_t::luidDeviceNodeMask

unsigned int luidDeviceNodeMask

LUID node mask.

Definition hip_runtime_api.h:99

hipDeviceProp_t::hostRegisterReadOnlySupported

int hostRegisterReadOnlySupported

Definition hip_runtime_api.h:197

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedSharedMem

int cooperativeMultiDeviceUnmatchedSharedMem

Definition hip_runtime_api.h:233

hipDeviceProp_t::maxThreadsPerBlock

int maxThreadsPerBlock

Max work items per work group or workgroup max size.

Definition hip_runtime_api.h:106

hipDeviceProp_t::arch

hipDeviceArch_t arch

Architectural feature flags. New for HIP.

Definition hip_runtime_api.h:221

hipDeviceProp_t::managedMemory

int managedMemory

Device supports allocating managed memory on this system.

Definition hip_runtime_api.h:172

hipDeviceProp_t::texturePitchAlignment

size_t texturePitchAlignment

Pitch alignment requirement for texture references bound to.

Definition hip_runtime_api.h:122

hipEventRecordNodeParams

Definition hip_runtime_api.h:1892

hipEventRecordNodeParams::event

hipEvent_t event

The event to be recorded when node executes.

Definition hip_runtime_api.h:1893

hipEventWaitNodeParams

Definition hip_runtime_api.h:1885

hipEventWaitNodeParams::event

hipEvent_t event

Event to wait on.

Definition hip_runtime_api.h:1886

hipExtent

Definition driver_types.h:378

hipExternalMemoryBufferDesc

Definition hip_runtime_api.h:1343

hipExternalMemoryBufferDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1346

hipExternalMemoryBufferDesc::offset

unsigned long long offset

Definition hip_runtime_api.h:1344

hipExternalMemoryBufferDesc::size

unsigned long long size

Definition hip_runtime_api.h:1345

hipExternalMemoryHandleDesc

Definition hip_runtime_api.h:1329

hipExternalMemoryHandleDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1340

hipExternalMemoryHandleDesc::name

const void * name

Definition hip_runtime_api.h:1335

hipExternalMemoryHandleDesc::fd

int fd

Definition hip_runtime_api.h:1332

hipExternalMemoryHandleDesc::size

unsigned long long size

Definition hip_runtime_api.h:1339

hipExternalMemoryHandleDesc::type

hipExternalMemoryHandleType type

Definition hip_runtime_api.h:1330

hipExternalMemoryHandleDesc::nvSciBufObject

const void * nvSciBufObject

Definition hip_runtime_api.h:1337

hipExternalMemoryHandleDesc::handle

void * handle

Definition hip_runtime_api.h:1334

hipExternalMemoryMipmappedArrayDesc

Definition hip_runtime_api.h:1349

hipExternalMemoryMipmappedArrayDesc::extent

hipExtent extent

Definition hip_runtime_api.h:1352

hipExternalMemoryMipmappedArrayDesc::numLevels

unsigned int numLevels

Definition hip_runtime_api.h:1354

hipExternalMemoryMipmappedArrayDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1353

hipExternalMemoryMipmappedArrayDesc::offset

unsigned long long offset

Definition hip_runtime_api.h:1350

hipExternalMemoryMipmappedArrayDesc::formatDesc

hipChannelFormatDesc formatDesc

Definition hip_runtime_api.h:1351

hipExternalSemaphoreHandleDesc

Definition hip_runtime_api.h:1369

hipExternalSemaphoreHandleDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1379

hipExternalSemaphoreHandleDesc::name

const void * name

Definition hip_runtime_api.h:1375

hipExternalSemaphoreHandleDesc::NvSciSyncObj

const void * NvSciSyncObj

Definition hip_runtime_api.h:1377

hipExternalSemaphoreHandleDesc::type

hipExternalSemaphoreHandleType type

Definition hip_runtime_api.h:1370

hipExternalSemaphoreHandleDesc::handle

void * handle

Definition hip_runtime_api.h:1374

hipExternalSemaphoreHandleDesc::fd

int fd

Definition hip_runtime_api.h:1372

hipExternalSemaphoreSignalNodeParams

Definition hip_runtime_api.h:1767

hipExternalSemaphoreSignalNodeParams::paramsArray

const hipExternalSemaphoreSignalParams * paramsArray

Total number of handles and parameters contained in extSemArray and paramsArray.

Definition hip_runtime_api.h:1771

hipExternalSemaphoreSignalNodeParams::extSemArray

hipExternalSemaphore_t * extSemArray

< Array containing external semaphore handles.

Definition hip_runtime_api.h:1769

hipExternalSemaphoreSignalNodeParams::numExtSems

unsigned int numExtSems

Definition hip_runtime_api.h:1773

hipExternalSemaphoreSignalParams

Definition hip_runtime_api.h:1383

hipExternalSemaphoreSignalParams::reserved

unsigned long long reserved

Definition hip_runtime_api.h:1390

hipExternalSemaphoreSignalParams::value

unsigned long long value

Definition hip_runtime_api.h:1386

hipExternalSemaphoreSignalParams::fence

void * fence

Definition hip_runtime_api.h:1389

hipExternalSemaphoreSignalParams::flags

unsigned int flags

Definition hip_runtime_api.h:1397

hipExternalSemaphoreSignalParams::key

unsigned long long key

Definition hip_runtime_api.h:1393

hipExternalSemaphoreWaitNodeParams

Definition hip_runtime_api.h:1779

hipExternalSemaphoreWaitNodeParams::numExtSems

unsigned int numExtSems

Definition hip_runtime_api.h:1785

hipExternalSemaphoreWaitNodeParams::paramsArray

const hipExternalSemaphoreWaitParams * paramsArray

Total number of handles and parameters contained in extSemArray and paramsArray.

Definition hip_runtime_api.h:1783

hipExternalSemaphoreWaitNodeParams::extSemArray

hipExternalSemaphore_t * extSemArray

< Array containing external semaphore handles.

Definition hip_runtime_api.h:1781

hipExternalSemaphoreWaitParams

Definition hip_runtime_api.h:1403

hipExternalSemaphoreWaitParams::value

unsigned long long value

Definition hip_runtime_api.h:1406

hipExternalSemaphoreWaitParams::fence

void * fence

Definition hip_runtime_api.h:1409

hipExternalSemaphoreWaitParams::timeoutMs

unsigned int timeoutMs

Definition hip_runtime_api.h:1414

hipExternalSemaphoreWaitParams::key

unsigned long long key

Definition hip_runtime_api.h:1413

hipExternalSemaphoreWaitParams::flags

unsigned int flags

Definition hip_runtime_api.h:1418

hipExternalSemaphoreWaitParams::reserved

unsigned long long reserved

Definition hip_runtime_api.h:1410

hipFuncAttributes

Definition hip_runtime_api.h:704

hipFuncAttributes::cacheModeCA

int cacheModeCA

Definition hip_runtime_api.h:706

hipFuncAttributes::binaryVersion

int binaryVersion

Definition hip_runtime_api.h:705

hipFuncAttributes::constSizeBytes

size_t constSizeBytes

Definition hip_runtime_api.h:707

hipFuncAttributes::preferredShmemCarveout

int preferredShmemCarveout

Definition hip_runtime_api.h:712

hipFuncAttributes::sharedSizeBytes

size_t sharedSizeBytes

Definition hip_runtime_api.h:714

hipFuncAttributes::maxDynamicSharedSizeBytes

int maxDynamicSharedSizeBytes

Definition hip_runtime_api.h:709

hipFuncAttributes::ptxVersion

int ptxVersion

Definition hip_runtime_api.h:713

hipFuncAttributes::numRegs

int numRegs

Definition hip_runtime_api.h:711

hipFuncAttributes::localSizeBytes

size_t localSizeBytes

Definition hip_runtime_api.h:708

hipFuncAttributes::maxThreadsPerBlock

int maxThreadsPerBlock

Definition hip_runtime_api.h:710

hipFunctionLaunchParams

Definition hip_runtime_api.h:1307

hipFunctionLaunchParams::gridDimX

unsigned int gridDimX

Width(X) of grid in blocks.

Definition hip_runtime_api.h:1309

hipFunctionLaunchParams::blockDimX

unsigned int blockDimX

X dimension of each thread block.

Definition hip_runtime_api.h:1312

hipFunctionLaunchParams::function

hipFunction_t function

Kernel to launch.

Definition hip_runtime_api.h:1308

hipFunctionLaunchParams::hStream

hipStream_t hStream

Stream identifier.

Definition hip_runtime_api.h:1316

hipFunctionLaunchParams::blockDimY

unsigned int blockDimY

Y dimension of each thread block.

Definition hip_runtime_api.h:1313

hipFunctionLaunchParams::gridDimY

unsigned int gridDimY

Height(Y) of grid in blocks.

Definition hip_runtime_api.h:1310

hipFunctionLaunchParams::gridDimZ

unsigned int gridDimZ

Depth(Z) of grid in blocks.

Definition hip_runtime_api.h:1311

hipFunctionLaunchParams::sharedMemBytes

unsigned int sharedMemBytes

Shared memory.

Definition hip_runtime_api.h:1315

hipFunctionLaunchParams::blockDimZ

unsigned int blockDimZ

Z dimension of each thread block.

Definition hip_runtime_api.h:1314

hipFunctionLaunchParams::kernelParams

void ** kernelParams

Kernel parameters.

Definition hip_runtime_api.h:1317

hipGraphEdgeData

Definition hip_runtime_api.h:1949

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:1960

hipGraphEdgeData::reserved

unsigned char reserved[5]

These bytes are unused and must be zeroed.

Definition hip_runtime_api.h:1958

hipGraphEdgeData::type

unsigned char type

This should be populated with a value from hipGraphDependencyType.

Definition hip_runtime_api.h:1961

hipGraphEdgeData::from_port

unsigned char from_port

Definition hip_runtime_api.h:1951

hipGraphInstantiateParams

Definition hip_runtime_api.h:1737

hipGraphInstantiateParams::result_out

hipGraphInstantiateResult result_out

Definition hip_runtime_api.h:1740

hipGraphInstantiateParams::uploadStream

hipStream_t uploadStream

Definition hip_runtime_api.h:1742

hipGraphInstantiateParams::errNode_out

hipGraphNode_t errNode_out

Definition hip_runtime_api.h:1738

hipGraphInstantiateParams::flags

unsigned long long flags

Definition hip_runtime_api.h:1739

hipGraphNodeParams

Definition hip_runtime_api.h:1906

hipGraphNodeParams::type

hipGraphNodeType type

Definition hip_runtime_api.h:1907

hipGraphNodeParams::reserved0

int reserved0[3]

Definition hip_runtime_api.h:1908

hipGraphNodeParams::alloc

hipMemAllocNodeParams alloc

Definition hip_runtime_api.h:1920

hipGraphNodeParams::reserved1

long long reserved1[29]

Definition hip_runtime_api.h:1910

hipGraphNodeParams::eventRecord

hipEventRecordNodeParams eventRecord

Definition hip_runtime_api.h:1917

hipGraphNodeParams::extSemSignal

hipExternalSemaphoreSignalNodeParams extSemSignal

Definition hip_runtime_api.h:1918

hipGraphNodeParams::free

hipMemFreeNodeParams free

Definition hip_runtime_api.h:1921

hipGraphNodeParams::graph

hipChildGraphNodeParams graph

Definition hip_runtime_api.h:1915

hipGraphNodeParams::extSemWait

hipExternalSemaphoreWaitNodeParams extSemWait

Definition hip_runtime_api.h:1919

hipGraphNodeParams::memset

hipMemsetParams memset

Definition hip_runtime_api.h:1913

hipGraphNodeParams::host

hipHostNodeParams host

Definition hip_runtime_api.h:1914

hipGraphNodeParams::reserved2

long long reserved2

Definition hip_runtime_api.h:1924

hipGraphNodeParams::kernel

hipKernelNodeParams kernel

Definition hip_runtime_api.h:1911

hipGraphNodeParams::eventWait

hipEventWaitNodeParams eventWait

Definition hip_runtime_api.h:1916

hipGraphNodeParams::memcpy

hipMemcpyNodeParams memcpy

Definition hip_runtime_api.h:1912

hipHostNodeParams

Definition hip_runtime_api.h:1489

hipHostNodeParams::fn

hipHostFn_t fn

Definition hip_runtime_api.h:1490

hipHostNodeParams::userData

void * userData

Definition hip_runtime_api.h:1491

hipIpcEventHandle_t

Definition hip_runtime_api.h:691

hipIpcMemHandle_t

Definition hip_runtime_api.h:688

hipKernelNodeParams

Definition hip_runtime_api.h:1493

hipKernelNodeParams::gridDim

dim3 gridDim

Definition hip_runtime_api.h:1497

hipKernelNodeParams::sharedMemBytes

unsigned int sharedMemBytes

Definition hip_runtime_api.h:1499

hipKernelNodeParams::blockDim

dim3 blockDim

Definition hip_runtime_api.h:1494

hipKernelNodeParams::kernelParams

void ** kernelParams

Definition hip_runtime_api.h:1498

hipKernelNodeParams::extra

void ** extra

Definition hip_runtime_api.h:1495

hipKernelNodeParams::func

void * func

Definition hip_runtime_api.h:1496

hipLaunchAttribute

Definition hip_runtime_api.h:1968

hipLaunchAttribute::val

hipLaunchAttributeValue val

Value associated with the launch attribute.

Definition hip_runtime_api.h:1972

hipLaunchAttribute::id

hipLaunchAttributeID id

Identifier of the launch attribute.

Definition hip_runtime_api.h:1969

hipLaunchAttribute::value

hipLaunchAttributeValue value

Value associated with the launch attribute.

Definition hip_runtime_api.h:1973

hipLaunchConfig_t

Definition hip_runtime_api.h:1980

hipLaunchConfig_t::blockDim

dim3 blockDim

Block dimensions.

Definition hip_runtime_api.h:1982

hipLaunchConfig_t::gridDim

dim3 gridDim

Grid dimensions.

Definition hip_runtime_api.h:1981

hipLaunchConfig_t::numAttrs

unsigned int numAttrs

Number of attributes.

Definition hip_runtime_api.h:1986

hipLaunchConfig_t::stream

hipStream_t stream

Stream identifier.

Definition hip_runtime_api.h:1984

hipLaunchConfig_t::dynamicSmemBytes

size_t dynamicSmemBytes

Dynamic shared-memory size per thread block.

Definition hip_runtime_api.h:1983

hipLaunchConfig_t::attrs

hipLaunchAttribute * attrs

Attributes list.

Definition hip_runtime_api.h:1985

hipLaunchMemSyncDomainMap

Definition hip_runtime_api.h:1544

hipLaunchMemSyncDomainMap::remote

unsigned char remote

Definition hip_runtime_api.h:1546

hipLaunchMemSyncDomainMap::default_

unsigned char default_

Definition hip_runtime_api.h:1545

hipLaunchParams

Definition hip_runtime_api.h:1296

hipLaunchParams::sharedMem

size_t sharedMem

Shared memory.

Definition hip_runtime_api.h:1301

hipLaunchParams::args

void ** args

Arguments.

Definition hip_runtime_api.h:1300

hipLaunchParams::blockDim

dim3 blockDim

Block dimensions.

Definition hip_runtime_api.h:1299

hipLaunchParams::gridDim

dim3 gridDim

Grid dimensions.

Definition hip_runtime_api.h:1298

hipLaunchParams::func

void * func

Device function symbol.

Definition hip_runtime_api.h:1297

hipLaunchParams::stream

hipStream_t stream

Stream identifier.

Definition hip_runtime_api.h:1302

hipMemAccessDesc

Definition hip_runtime_api.h:1201

hipMemAccessDesc::flags

hipMemAccessFlags flags

Accessibility flags to set.

Definition hip_runtime_api.h:1203

hipMemAccessDesc::location

hipMemLocation location

Location on which the accessibility has to change.

Definition hip_runtime_api.h:1202

hipMemAllocNodeParams

Definition hip_runtime_api.h:1510

hipMemAllocNodeParams::accessDescs

const hipMemAccessDesc * accessDescs

The number of memory access descriptors.

Definition hip_runtime_api.h:1513

hipMemAllocNodeParams::bytesize

size_t bytesize

The size of the requested allocation in bytes.

Definition hip_runtime_api.h:1516

hipMemAllocNodeParams::poolProps

hipMemPoolProps poolProps

Definition hip_runtime_api.h:1511

hipMemAllocNodeParams::accessDescCount

size_t accessDescCount

Definition hip_runtime_api.h:1514

hipMemAllocNodeParams::dptr

void * dptr

Returned device address of the allocation.

Definition hip_runtime_api.h:1517

hipMemAllocationProp

Definition hip_runtime_api.h:1749

hipMemAllocationProp::win32HandleMetaData

void * win32HandleMetaData

Metadata for Win32 handles.

Definition hip_runtime_api.h:1756

hipMemAllocationProp::type

hipMemAllocationType type

Memory allocation type.

Definition hip_runtime_api.h:1750

hipMemAllocationProp::allocFlags

struct hipMemAllocationProp::@33 allocFlags

hipMemAllocationProp::gpuDirectRDMACapable

unsigned char gpuDirectRDMACapable

RDMA capable.

Definition hip_runtime_api.h:1759

hipMemAllocationProp::requestedHandleTypes

hipMemAllocationHandleType requestedHandleTypes

Requested handle types.

Definition hip_runtime_api.h:1753

hipMemAllocationProp::usage

unsigned short usage

Usage.

Definition hip_runtime_api.h:1760

hipMemAllocationProp::requestedHandleType

hipMemAllocationHandleType requestedHandleType

Requested handle type.

Definition hip_runtime_api.h:1752

hipMemAllocationProp::location

hipMemLocation location

Memory location.

Definition hip_runtime_api.h:1755

hipMemAllocationProp::compressionType

unsigned char compressionType

Compression type.

Definition hip_runtime_api.h:1758

hipMemFreeNodeParams

Definition hip_runtime_api.h:1899

hipMemFreeNodeParams::dptr

void * dptr

the pointer to be freed

Definition hip_runtime_api.h:1900

hipMemLocation

Definition driver_types.h:450

hipMemPoolProps

Definition hip_runtime_api.h:1232

hipMemPoolProps::maxSize

size_t maxSize

Maximum pool size. When set to 0, defaults to a system dependent value.

Definition hip_runtime_api.h:1242

hipMemPoolProps::reserved

unsigned char reserved[56]

Reserved for future use, must be 0.

Definition hip_runtime_api.h:1243

hipMemPoolProps::location

hipMemLocation location

Location where allocations should reside.

Definition hip_runtime_api.h:1237

hipMemPoolProps::handleTypes

hipMemAllocationHandleType handleTypes

Handle types that will be supported by allocations from the pool.

Definition hip_runtime_api.h:1236

hipMemPoolProps::allocType

hipMemAllocationType allocType

Allocation type. Currently must be specified as hipMemAllocationTypePinned.

Definition hip_runtime_api.h:1234

hipMemPoolProps::win32SecurityAttributes

void * win32SecurityAttributes

Definition hip_runtime_api.h:1241

hipMemPoolPtrExportData

Definition hip_runtime_api.h:1248

hipMemPoolPtrExportData::reserved

unsigned char reserved[64]

Definition hip_runtime_api.h:1249

hipMemcpy3DBatchOp

Definition driver_types.h:538

hipMemcpy3DParms

Definition driver_types.h:395

hipMemcpy3DPeerParms

Definition driver_types.h:546

hipMemcpyAttributes

Definition driver_types.h:492

hipMemcpyNodeParams

Definition hip_runtime_api.h:1868

hipMemcpyNodeParams::reserved

int reserved[3]

Must be zero.

Definition hip_runtime_api.h:1870

hipMemcpyNodeParams::flags

int flags

Must be zero.

Definition hip_runtime_api.h:1869

hipMemcpyNodeParams::copyParams

hipMemcpy3DParms copyParams

Params set for the memory copy.

Definition hip_runtime_api.h:1871

hipMemsetParams

Definition hip_runtime_api.h:1501

hipMemsetParams::dst

void * dst

Definition hip_runtime_api.h:1502

hipMemsetParams::value

unsigned int value

Definition hip_runtime_api.h:1506

hipMemsetParams::elementSize

unsigned int elementSize

Definition hip_runtime_api.h:1503

hipMemsetParams::width

size_t width

Definition hip_runtime_api.h:1507

hipMemsetParams::pitch

size_t pitch

Definition hip_runtime_api.h:1505

hipMemsetParams::height

size_t height

Definition hip_runtime_api.h:1504

hipMipmappedArray

Definition driver_types.h:121

hipPitchedPtr

Definition driver_types.h:369

hipPointerAttribute_t

Definition hip_runtime_api.h:264

hipPointerAttribute_t::device

int device

Definition hip_runtime_api.h:266

hipPointerAttribute_t::hostPointer

void * hostPointer

Definition hip_runtime_api.h:268

hipPointerAttribute_t::type

enum hipMemoryType type

Definition hip_runtime_api.h:265

hipPointerAttribute_t::isManaged

int isManaged

Definition hip_runtime_api.h:269

hipPointerAttribute_t::devicePointer

void * devicePointer

Definition hip_runtime_api.h:267

hipPointerAttribute_t::allocationFlags

unsigned allocationFlags

Definition hip_runtime_api.h:270

hipResourceDesc

Definition driver_types.h:270

hipResourceViewDesc

Definition driver_types.h:329

hipStreamBatchMemOpParams::hipStreamMemOpFlushRemoteWritesParams_t

Definition hip_runtime_api.h:1024

hipStreamBatchMemOpParams::hipStreamMemOpFlushRemoteWritesParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:1026

hipStreamBatchMemOpParams::hipStreamMemOpFlushRemoteWritesParams_t::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:1025

hipStreamBatchMemOpParams::hipStreamMemOpMemoryBarrierParams_t

Definition hip_runtime_api.h:1028

hipStreamBatchMemOpParams::hipStreamMemOpMemoryBarrierParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:1030

hipStreamBatchMemOpParams::hipStreamMemOpMemoryBarrierParams_t::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:1029

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t

Definition hip_runtime_api.h:1004

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:1005

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::value64

uint64_t value64

Definition hip_runtime_api.h:1009

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::address

hipDeviceptr_t address

Definition hip_runtime_api.h:1006

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::alias

hipDeviceptr_t alias

Not valid for AMD backend. Initial value is unimportant.

Definition hip_runtime_api.h:1012

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::value

uint32_t value

Definition hip_runtime_api.h:1008

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:1011

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t

Definition hip_runtime_api.h:1014

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::address

hipDeviceptr_t address

Definition hip_runtime_api.h:1016

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::alias

hipDeviceptr_t alias

Not valid for AMD backend. Initial value is unimportant.

Definition hip_runtime_api.h:1022

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::value

uint32_t value

Definition hip_runtime_api.h:1018

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:1015

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:1021

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::value64

uint64_t value64

Definition hip_runtime_api.h:1019

hipTextureDesc

Definition texture_types.h:100

hipUUID

Definition hip_runtime_api.h:80

texture

Definition texture_types.h:131

textureReference

Definition texture_types.h:79

surface_types.h

Defines surface types for HIP runtime.

hipSurfaceObject_t

struct __hip_surface * hipSurfaceObject_t

Definition surface_types.h:28

texture_types.h

hipTextureObject_t

struct __hip_texture * hipTextureObject_t

Definition texture_types.h:54

hipTextureAddressMode

hipTextureAddressMode

Definition texture_types.h:59

hipTextureFilterMode

hipTextureFilterMode

Definition texture_types.h:69

hipLaunchAttributeValue

Definition hip_runtime_api.h:1585

hipLaunchAttributeValue::priority

int priority

Definition hip_runtime_api.h:1591

hipLaunchAttributeValue::pad

char pad[64]

64 byte padding

Definition hip_runtime_api.h:1586

hipLaunchAttributeValue::memSyncDomain

hipLaunchMemSyncDomain memSyncDomain

Value of launch attribute hipLaunchAttributeMemSyncDomain.

Definition hip_runtime_api.h:1599

hipLaunchAttributeValue::cooperative

int cooperative

Definition hip_runtime_api.h:1589

hipLaunchAttributeValue::accessPolicyWindow

hipAccessPolicyWindow accessPolicyWindow

Value of launch attribute hipLaunchAttributeAccessPolicyWindow.

Definition hip_runtime_api.h:1588

hipLaunchAttributeValue::syncPolicy

hipSynchronizationPolicy syncPolicy

Definition hip_runtime_api.h:1594

hipLaunchAttributeValue::memSyncDomainMap

hipLaunchMemSyncDomainMap memSyncDomainMap

Value of launch attribute hipLaunchAttributeMemSyncDomainMap.

Definition hip_runtime_api.h:1597

hipStreamBatchMemOpParams

Union representing batch memory operation parameters for HIP streams.

Definition hip_runtime_api.h:1002

hipStreamBatchMemOpParams::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:1003