include/hip/hip_runtime_api.h Source File

• include
• hip

hip_runtime_api.h

Go to the documentation of this file.

1/*

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

3

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

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

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

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

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

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

10

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

12all copies or substantial portions of the Software.

13

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

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

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

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

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

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

20THE SOFTWARE.

21*/

22

31#ifndef HIP_INCLUDE_HIP_HIP_RUNTIME_API_H

32#define HIP_INCLUDE_HIP_HIP_RUNTIME_API_H

33

34#if __cplusplus

35#include <climits>

36#include <cstdint>

37#include <cstdlib>

38#include <utility>

39#else

40#include <limits.h>

41#include <stdint.h>

42#include <stdlib.h>

43#endif

44

45#include <hip/hip_version.h>

46#include <hip/hip_common.h>

47#include <hip/linker_types.h>

48

49enum {

50 HIP_SUCCESS = 0,

51 HIP_ERROR_INVALID_VALUE,

52 HIP_ERROR_NOT_INITIALIZED,

53 HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

54};

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

65typedef struct {

66 // 32-bit Atomics

67 unsigned hasGlobalInt32Atomics : 1;

68 unsigned hasGlobalFloatAtomicExch : 1;

69 unsigned hasSharedInt32Atomics : 1;

70 unsigned hasSharedFloatAtomicExch : 1;

71 unsigned hasFloatAtomicAdd : 1;

72

73 // 64-bit Atomics

74 unsigned hasGlobalInt64Atomics : 1;

75 unsigned hasSharedInt64Atomics : 1;

76

77 // Doubles

78 unsigned hasDoubles : 1;

79

80 // Warp cross-lane operations

81 unsigned hasWarpVote : 1;

82 unsigned hasWarpBallot : 1;

83 unsigned hasWarpShuffle : 1;

84 unsigned hasFunnelShift : 1;

85

86 // Sync

87 unsigned hasThreadFenceSystem : 1;

88 unsigned hasSyncThreadsExt : 1;

89

90 // Misc

91 unsigned hasSurfaceFuncs : 1;

92 unsigned has3dGrid : 1;

93 unsigned hasDynamicParallelism : 1;

94} hipDeviceArch_t;

95

96typedef struct hipUUID_t {

97 char bytes[16];

98} hipUUID;

99

100//---

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

102

103#define hipGetDeviceProperties hipGetDevicePropertiesR0600

104#define hipDeviceProp_t hipDeviceProp_tR0600

105#define hipChooseDevice hipChooseDeviceR0600

106

111typedef struct hipDeviceProp_t {

112 char name[256];

113 hipUUID uuid;

114 char luid[8];

115 unsigned int luidDeviceNodeMask;

116 size_t totalGlobalMem;

117 size_t sharedMemPerBlock;

118 int regsPerBlock;

119 int warpSize;

120 size_t memPitch;

122 int maxThreadsPerBlock;

123 int maxThreadsDim[3];

124 int maxGridSize[3];

125 int clockRate;

126 size_t totalConstMem;

128 int major;

132 int minor;

137 size_t textureAlignment;

138 size_t texturePitchAlignment;

139 int deviceOverlap;

140 int multiProcessorCount;

144 int kernelExecTimeoutEnabled;

145 int integrated;

146 int canMapHostMemory;

147 int computeMode;

148 int maxTexture1D;

149 int maxTexture1DMipmap;

150 int maxTexture1DLinear;

151 int maxTexture2D[2];

152 int maxTexture2DMipmap[2];

153 int maxTexture2DLinear[3];

154 int maxTexture2DGather[2];

155 int maxTexture3D[3];

157 int maxTexture3DAlt[3];

158 int maxTextureCubemap;

159 int maxTexture1DLayered[2];

160 int maxTexture2DLayered[3];

161 int maxTextureCubemapLayered[2];

162 int maxSurface1D;

163 int maxSurface2D[2];

164 int maxSurface3D[3];

165 int maxSurface1DLayered[2];

166 int maxSurface2DLayered[3];

167 int maxSurfaceCubemap;

168 int maxSurfaceCubemapLayered[2];

169 size_t surfaceAlignment;

170 int concurrentKernels;

171 int ECCEnabled;

172 int pciBusID;

173 int pciDeviceID;

174 int pciDomainID;

175 int tccDriver;

176 int asyncEngineCount;

177 int unifiedAddressing;

178 int memoryClockRate;

179 int memoryBusWidth;

180 int l2CacheSize;

181 int persistingL2CacheMaxSize;

182 int maxThreadsPerMultiProcessor;

183 int streamPrioritiesSupported;

184 int globalL1CacheSupported;

185 int localL1CacheSupported;

186 size_t sharedMemPerMultiprocessor;

187 int regsPerMultiprocessor;

188 int managedMemory;

189 int isMultiGpuBoard;

190 int multiGpuBoardGroupID;

191 int hostNativeAtomicSupported;

192 int singleToDoublePrecisionPerfRatio;

193 int pageableMemoryAccess;

195 int concurrentManagedAccess;

197 int computePreemptionSupported;

198 int canUseHostPointerForRegisteredMem;

200 int cooperativeLaunch;

201 int cooperativeMultiDeviceLaunch;

203 size_t sharedMemPerBlockOptin;

204 int pageableMemoryAccessUsesHostPageTables;

206 int directManagedMemAccessFromHost;

208 int maxBlocksPerMultiProcessor;

209 int accessPolicyMaxWindowSize;

210 size_t reservedSharedMemPerBlock;

211 int hostRegisterSupported;

212 int sparseHipArraySupported;

213 int hostRegisterReadOnlySupported;

215 int timelineSemaphoreInteropSupported;

216 int memoryPoolsSupported;

217 int gpuDirectRDMASupported;

218 unsigned int gpuDirectRDMAFlushWritesOptions;

220 int gpuDirectRDMAWritesOrdering;

221 unsigned int

222 memoryPoolSupportedHandleTypes;

223 int deferredMappingHipArraySupported;

225 int ipcEventSupported;

226 int clusterLaunch;

227 int unifiedFunctionPointers;

228 int reserved[63];

229

230 int hipReserved[32];

231

232 /* HIP Only struct members */

233 char gcnArchName[256];

234 size_t maxSharedMemoryPerMultiProcessor;

235 int clockInstructionRate;

237 hipDeviceArch_t arch;

238 unsigned int* hdpMemFlushCntl;

239 unsigned int* hdpRegFlushCntl;

240 int cooperativeMultiDeviceUnmatchedFunc;

243 int cooperativeMultiDeviceUnmatchedGridDim;

246 int cooperativeMultiDeviceUnmatchedBlockDim;

249 int cooperativeMultiDeviceUnmatchedSharedMem;

252 int isLargeBar;

253 int asicRevision;

254} hipDeviceProp_t;

255

263typedef enum hipMemoryType {

264 hipMemoryTypeUnregistered = 0,

265 hipMemoryTypeHost = 1,

266 hipMemoryTypeDevice = 2,

268 hipMemoryTypeManaged = 3,

271 hipMemoryTypeArray = 10,

273 hipMemoryTypeUnified = 11

274

275} hipMemoryType;

276

280typedef struct hipPointerAttribute_t {

281 enum hipMemoryType type;

282 int device;

283 void* devicePointer;

284 void* hostPointer;

285 int isManaged;

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

287 /* peers? */

288} hipPointerAttribute_t;

289

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

291// we can make that yield a warning

292#if __cplusplus >= 201703L

293#define __HIP_NODISCARD [[nodiscard]]

294#else

295#define __HIP_NODISCARD

296#endif

297

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

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

304

305typedef enum __HIP_NODISCARD hipError_t {

306 hipSuccess = 0,

307 hipErrorInvalidValue = 1,

309 hipErrorOutOfMemory = 2,

310 // Deprecated

311 hipErrorMemoryAllocation = 2,

312 hipErrorNotInitialized = 3,

313 // Deprecated

314 hipErrorInitializationError = 3,

315 hipErrorDeinitialized = 4,

316 hipErrorProfilerDisabled = 5,

317 hipErrorProfilerNotInitialized = 6,

318 hipErrorProfilerAlreadyStarted = 7,

319 hipErrorProfilerAlreadyStopped = 8,

320 hipErrorInvalidConfiguration = 9,

321 hipErrorInvalidPitchValue = 12,

322 hipErrorInvalidSymbol = 13,

323 hipErrorInvalidDevicePointer = 17,

324 hipErrorInvalidMemcpyDirection = 21,

325 hipErrorInsufficientDriver = 35,

326 hipErrorMissingConfiguration = 52,

327 hipErrorPriorLaunchFailure = 53,

328 hipErrorInvalidDeviceFunction = 98,

329 hipErrorNoDevice = 100,

330 hipErrorInvalidDevice = 101,

331 hipErrorInvalidImage = 200,

332 hipErrorInvalidContext = 201,

333 hipErrorContextAlreadyCurrent = 202,

334 hipErrorMapFailed = 205,

335 // Deprecated

336 hipErrorMapBufferObjectFailed = 205,

337 hipErrorUnmapFailed = 206,

338 hipErrorArrayIsMapped = 207,

339 hipErrorAlreadyMapped = 208,

340 hipErrorNoBinaryForGpu = 209,

341 hipErrorAlreadyAcquired = 210,

342 hipErrorNotMapped = 211,

343 hipErrorNotMappedAsArray = 212,

344 hipErrorNotMappedAsPointer = 213,

345 hipErrorECCNotCorrectable = 214,

346 hipErrorUnsupportedLimit = 215,

347 hipErrorContextAlreadyInUse = 216,

348 hipErrorPeerAccessUnsupported = 217,

349 hipErrorInvalidKernelFile = 218,

350 hipErrorInvalidGraphicsContext = 219,

351 hipErrorInvalidSource = 300,

352 hipErrorFileNotFound = 301,

353 hipErrorSharedObjectSymbolNotFound = 302,

354 hipErrorSharedObjectInitFailed = 303,

355 hipErrorOperatingSystem = 304,

356 hipErrorInvalidHandle = 400,

357 // Deprecated

358 hipErrorInvalidResourceHandle = 400,

359 hipErrorIllegalState = 401,

360 hipErrorNotFound = 500,

361 hipErrorNotReady = 600,

365 hipErrorIllegalAddress = 700,

366 hipErrorLaunchOutOfResources = 701,

367 hipErrorLaunchTimeOut = 702,

368 hipErrorPeerAccessAlreadyEnabled = 704,

370 hipErrorPeerAccessNotEnabled = 705,

371 hipErrorSetOnActiveProcess = 708,

372 hipErrorContextIsDestroyed = 709,

373 hipErrorAssert = 710,

374 hipErrorHostMemoryAlreadyRegistered = 712,

376 hipErrorHostMemoryNotRegistered = 713,

378 hipErrorLaunchFailure = 719,

379 hipErrorCooperativeLaunchTooLarge = 720,

383 hipErrorNotSupported = 801,

384 hipErrorStreamCaptureUnsupported = 900,

386 hipErrorStreamCaptureInvalidated = 901,

388 hipErrorStreamCaptureMerge = 902,

390 hipErrorStreamCaptureUnmatched = 903,

391 hipErrorStreamCaptureUnjoined = 904,

393 hipErrorStreamCaptureIsolation = 905,

397 hipErrorStreamCaptureImplicit = 906,

400 hipErrorCapturedEvent = 907,

402 hipErrorStreamCaptureWrongThread = 908,

406 hipErrorGraphExecUpdateFailure = 910,

410 hipErrorInvalidChannelDescriptor = 911,

411 hipErrorInvalidTexture = 912,

412 hipErrorUnknown = 999,

413 // HSA Runtime Error Codes start here.

414 hipErrorRuntimeMemory = 1052,

416 hipErrorRuntimeOther = 1053,

418 hipErrorTbd

419} hipError_t;

420

421#undef __HIP_NODISCARD

422

427typedef enum hipDeviceAttribute_t {

428 hipDeviceAttributeCudaCompatibleBegin = 0,

429

430 hipDeviceAttributeEccEnabled =

431 hipDeviceAttributeCudaCompatibleBegin,

432 hipDeviceAttributeAccessPolicyMaxWindowSize,

434 hipDeviceAttributeAsyncEngineCount,

435 hipDeviceAttributeCanMapHostMemory,

437 hipDeviceAttributeCanUseHostPointerForRegisteredMem,

440 hipDeviceAttributeClockRate,

441 hipDeviceAttributeComputeMode,

442 hipDeviceAttributeComputePreemptionSupported,

443 hipDeviceAttributeConcurrentKernels,

445 hipDeviceAttributeConcurrentManagedAccess,

447 hipDeviceAttributeCooperativeLaunch,

448 hipDeviceAttributeCooperativeMultiDeviceLaunch,

450 hipDeviceAttributeDeviceOverlap,

452 hipDeviceAttributeDirectManagedMemAccessFromHost,

454 hipDeviceAttributeGlobalL1CacheSupported,

455 hipDeviceAttributeHostNativeAtomicSupported,

457 hipDeviceAttributeIntegrated,

458 hipDeviceAttributeIsMultiGpuBoard,

459 hipDeviceAttributeKernelExecTimeout,

460 hipDeviceAttributeL2CacheSize,

462 hipDeviceAttributeLocalL1CacheSupported,

463 hipDeviceAttributeLuid,

465 hipDeviceAttributeLuidDeviceNodeMask,

467 hipDeviceAttributeComputeCapabilityMajor,

468 hipDeviceAttributeManagedMemory,

469 hipDeviceAttributeMaxBlocksPerMultiProcessor,

470 hipDeviceAttributeMaxBlockDimX,

471 hipDeviceAttributeMaxBlockDimY,

472 hipDeviceAttributeMaxBlockDimZ,

473 hipDeviceAttributeMaxGridDimX,

474 hipDeviceAttributeMaxGridDimY,

475 hipDeviceAttributeMaxGridDimZ,

476 hipDeviceAttributeMaxSurface1D,

477 hipDeviceAttributeMaxSurface1DLayered,

478 hipDeviceAttributeMaxSurface2D,

479 hipDeviceAttributeMaxSurface2DLayered,

480 hipDeviceAttributeMaxSurface3D,

481 hipDeviceAttributeMaxSurfaceCubemap,

482 hipDeviceAttributeMaxSurfaceCubemapLayered,

484 hipDeviceAttributeMaxTexture1DWidth,

485 hipDeviceAttributeMaxTexture1DLayered,

486 hipDeviceAttributeMaxTexture1DLinear,

489 hipDeviceAttributeMaxTexture1DMipmap,

490 hipDeviceAttributeMaxTexture2DWidth,

491 hipDeviceAttributeMaxTexture2DHeight,

492 hipDeviceAttributeMaxTexture2DGather,

494 hipDeviceAttributeMaxTexture2DLayered,

495 hipDeviceAttributeMaxTexture2DLinear,

497 hipDeviceAttributeMaxTexture2DMipmap,

498 hipDeviceAttributeMaxTexture3DWidth,

499 hipDeviceAttributeMaxTexture3DHeight,

500 hipDeviceAttributeMaxTexture3DDepth,

501 hipDeviceAttributeMaxTexture3DAlt,

502 hipDeviceAttributeMaxTextureCubemap,

503 hipDeviceAttributeMaxTextureCubemapLayered,

504 hipDeviceAttributeMaxThreadsDim,

505 hipDeviceAttributeMaxThreadsPerBlock,

506 hipDeviceAttributeMaxThreadsPerMultiProcessor,

507 hipDeviceAttributeMaxPitch,

508 hipDeviceAttributeMemoryBusWidth,

509 hipDeviceAttributeMemoryClockRate,

510 hipDeviceAttributeComputeCapabilityMinor,

511 hipDeviceAttributeMultiGpuBoardGroupID,

513 hipDeviceAttributeMultiprocessorCount,

517 hipDeviceAttributeUnused1,

518 hipDeviceAttributePageableMemoryAccess,

520 hipDeviceAttributePageableMemoryAccessUsesHostPageTables,

522 hipDeviceAttributePciBusId,

523 hipDeviceAttributePciDeviceId,

524 hipDeviceAttributePciDomainId,

525 hipDeviceAttributePciDomainID =

526 hipDeviceAttributePciDomainId,

527 hipDeviceAttributePersistingL2CacheMaxSize,

528 hipDeviceAttributeMaxRegistersPerBlock,

531 hipDeviceAttributeMaxRegistersPerMultiprocessor,

532 hipDeviceAttributeReservedSharedMemPerBlock,

534 hipDeviceAttributeMaxSharedMemoryPerBlock,

536 hipDeviceAttributeSharedMemPerBlockOptin,

538 hipDeviceAttributeSharedMemPerMultiprocessor,

539 hipDeviceAttributeSingleToDoublePrecisionPerfRatio,

541 hipDeviceAttributeStreamPrioritiesSupported,

542 hipDeviceAttributeSurfaceAlignment,

543 hipDeviceAttributeTccDriver,

544 hipDeviceAttributeTextureAlignment,

545 hipDeviceAttributeTexturePitchAlignment,

547 hipDeviceAttributeTotalConstantMemory,

548 hipDeviceAttributeTotalGlobalMem,

549 hipDeviceAttributeUnifiedAddressing,

551 hipDeviceAttributeUnused2,

552 hipDeviceAttributeWarpSize,

553 hipDeviceAttributeMemoryPoolsSupported,

554 hipDeviceAttributeVirtualMemoryManagementSupported,

556 hipDeviceAttributeHostRegisterSupported,

558 hipDeviceAttributeMemoryPoolSupportedHandleTypes,

560

561 hipDeviceAttributeCudaCompatibleEnd = 9999,

562 hipDeviceAttributeAmdSpecificBegin = 10000,

563

564 hipDeviceAttributeClockInstructionRate =

565 hipDeviceAttributeAmdSpecificBegin,

567 hipDeviceAttributeUnused3,

568 hipDeviceAttributeMaxSharedMemoryPerMultiprocessor,

569 hipDeviceAttributeUnused4,

570 hipDeviceAttributeUnused5,

571 hipDeviceAttributeHdpMemFlushCntl,

572 hipDeviceAttributeHdpRegFlushCntl,

573 hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc,

576 hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim,

579 hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim,

582 hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem,

585 hipDeviceAttributeIsLargeBar,

586 hipDeviceAttributeAsicRevision,

587 hipDeviceAttributeCanUseStreamWaitValue,

589 hipDeviceAttributeImageSupport,

590 hipDeviceAttributePhysicalMultiProcessorCount,

592 hipDeviceAttributeFineGrainSupport,

593 hipDeviceAttributeWallClockRate,

594 hipDeviceAttributeNumberOfXccs,

595 hipDeviceAttributeMaxAvailableVgprsPerThread,

598 hipDeviceAttributePciChipId,

599

600 hipDeviceAttributeAmdSpecificEnd = 19999,

601 hipDeviceAttributeVendorSpecificBegin = 20000,

602 // Extended attributes for vendors

603} hipDeviceAttribute_t;

604

605typedef enum hipDriverProcAddressQueryResult {

606 HIP_GET_PROC_ADDRESS_SUCCESS = 0,

607 HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND = 1,

608 HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT = 2

609} hipDriverProcAddressQueryResult;

610

611enum hipComputeMode {

612 hipComputeModeDefault = 0,

613 hipComputeModeExclusive = 1,

614 hipComputeModeProhibited = 2,

615 hipComputeModeExclusiveProcess = 3

616};

617

618enum hipFlushGPUDirectRDMAWritesOptions {

619 hipFlushGPUDirectRDMAWritesOptionHost = 1 << 0,

620 hipFlushGPUDirectRDMAWritesOptionMemOps = 1 << 1

621};

622

623enum hipGPUDirectRDMAWritesOrdering {

624 hipGPUDirectRDMAWritesOrderingNone = 0,

625 hipGPUDirectRDMAWritesOrderingOwner = 100,

626 hipGPUDirectRDMAWritesOrderingAllDevices = 200

627};

628

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

630

631#ifndef GENERIC_GRID_LAUNCH

632#define GENERIC_GRID_LAUNCH 1

633#endif

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

635#include <hip/driver_types.h>

636#include <hip/texture_types.h>

637#include <hip/surface_types.h>

638#if defined(_MSC_VER)

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

640#else // !defined(_MSC_VER)

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

642#endif // !defined(_MSC_VER)

643#define HIP_DEPRECATED_MSG \

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

645 "details please refer " \

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

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

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

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

650#ifdef __cplusplus

651#define __dparm(x) = x

652#else

653#define __dparm(x)

654#endif

655#ifdef __GNUC__

656#pragma GCC visibility push(default)

657#endif

658#ifdef __cplusplus

659namespace hip_impl {

660hipError_t hip_init();

661} // namespace hip_impl

662#endif

663// Structure definitions:

664#ifdef __cplusplus

665extern "C" {

666#endif

667//---

668// API-visible structures

669typedef struct ihipCtx_t* hipCtx_t;

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

671typedef int hipDevice_t;

672typedef enum hipDeviceP2PAttr {

673 hipDevP2PAttrPerformanceRank = 0,

674 hipDevP2PAttrAccessSupported,

675 hipDevP2PAttrNativeAtomicSupported,

676 hipDevP2PAttrHipArrayAccessSupported

677} hipDeviceP2PAttr;

678typedef enum hipDriverEntryPointQueryResult {

679 hipDriverEntryPointSuccess = 0,

680 hipDriverEntryPointSymbolNotFound = 1,

681 hipDriverEntryPointVersionNotSufficent = 2

682} hipDriverEntryPointQueryResult;

683typedef struct ihipStream_t* hipStream_t;

684#define hipIpcMemLazyEnablePeerAccess 0x01

685#define HIP_IPC_HANDLE_SIZE 64

686typedef struct hipIpcMemHandle_st {

687 char reserved[HIP_IPC_HANDLE_SIZE];

688} hipIpcMemHandle_t;

689typedef struct hipIpcEventHandle_st {

690 char reserved[HIP_IPC_HANDLE_SIZE];

691} hipIpcEventHandle_t;

692typedef struct ihipModule_t* hipModule_t;

693typedef struct ihipModuleSymbol_t* hipFunction_t;

694typedef struct ihipLinkState_t* hipLinkState_t;

695typedef struct ihipLibrary_t* hipLibrary_t;

696typedef struct ihipKernel_t* hipKernel_t;

700typedef struct ihipMemPoolHandle_t* hipMemPool_t;

701

702typedef struct hipFuncAttributes {

703 int binaryVersion;

704 int cacheModeCA;

705 size_t constSizeBytes;

706 size_t localSizeBytes;

707 int maxDynamicSharedSizeBytes;

708 int maxThreadsPerBlock;

709 int numRegs;

710 int preferredShmemCarveout;

711 int ptxVersion;

712 size_t sharedSizeBytes;

713} hipFuncAttributes;

714typedef struct ihipEvent_t* hipEvent_t;

715

722enum hipLimit_t {

723 hipLimitStackSize = 0x0,

726 hipLimitPrintfFifoSize = 0x01,

728 hipLimitMallocHeapSize = 0x02,

730 hipExtLimitScratchMin = 0x1000,

732 hipExtLimitScratchMax = 0x1001,

734 hipExtLimitScratchCurrent = 0x1002,

738 hipLimitRange

739};

740

744// Flags that can be used with hipStreamCreateWithFlags.

746#define hipStreamDefault 0x00

747

749#define hipStreamNonBlocking 0x01

750

751// Flags that can be used with hipEventCreateWithFlags.

753#define hipEventDefault 0x0

754

756#define hipEventBlockingSync 0x1

757

759#define hipEventDisableTiming 0x2

760

762#define hipEventInterprocess 0x4

763

764// Flags that can be used with hipEventRecordWithFlags.

766#define hipEventRecordDefault 0x00

767

769#define hipEventRecordExternal 0x01

770

771//Flags that can be used with hipStreamWaitEvent.

773#define hipEventWaitDefault 0x00

774

776#define hipEventWaitExternal 0x01

777

786#define hipEventDisableSystemFence 0x20000000

787

790#define hipEventReleaseToDevice 0x40000000

791

794#define hipEventReleaseToSystem 0x80000000

795

796// Flags that can be used with hipGetDriverEntryPoint.

800#define hipEnableDefault 0x0

801

803#define hipEnableLegacyStream 0x1

804

807#define hipEnablePerThreadDefaultStream 0x2

808

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

811#define hipHostAllocDefault 0x0

812

815#define hipHostMallocDefault 0x0

816

818#define hipHostAllocPortable 0x1

819

822#define hipHostMallocPortable 0x1

823

826#define hipHostAllocMapped 0x2

827

831#define hipHostMallocMapped 0x2

832

838#define hipHostAllocWriteCombined 0x4

839

846#define hipHostMallocWriteCombined 0x4

847

853#define hipHostMallocUncached 0x10000000

854#define hipHostAllocUncached hipHostMallocUncached

855

860#define hipHostMallocNumaUser 0x20000000

861

863#define hipHostMallocCoherent 0x40000000

864

866#define hipHostMallocNonCoherent 0x80000000

867

869#define hipMemAttachGlobal 0x01

870

872#define hipMemAttachHost 0x02

873

875#define hipMemAttachSingle 0x04

876

877#define hipDeviceMallocDefault 0x0

878

880#define hipDeviceMallocFinegrained 0x1

881

883#define hipMallocSignalMemory 0x2

884

886#define hipDeviceMallocUncached 0x3

887

889#define hipDeviceMallocContiguous 0x4

890

891// Flags that can be used with hipHostRegister.

893#define hipHostRegisterDefault 0x0

894

896#define hipHostRegisterPortable 0x1

897

900#define hipHostRegisterMapped 0x2

901

906#define hipHostRegisterIoMemory 0x4

907

909#define hipHostRegisterReadOnly 0x08

910

912#define hipExtHostRegisterCoarseGrained 0x8

913

917#define hipExtHostRegisterUncached 0x80000000

918

920#define hipDeviceScheduleAuto 0x0

921

924#define hipDeviceScheduleSpin 0x1

925

928#define hipDeviceScheduleYield 0x2

929#define hipDeviceScheduleBlockingSync 0x4

930#define hipDeviceScheduleMask 0x7

931#define hipDeviceMapHost 0x8

932#define hipDeviceLmemResizeToMax 0x10

934#define hipArrayDefault 0x00

935#define hipArrayLayered 0x01

936#define hipArraySurfaceLoadStore 0x02

937#define hipArrayCubemap 0x04

938#define hipArrayTextureGather 0x08

939#define hipOccupancyDefault 0x00

940#define hipOccupancyDisableCachingOverride 0x01

941#define hipCooperativeLaunchMultiDeviceNoPreSync 0x01

942#define hipCooperativeLaunchMultiDeviceNoPostSync 0x02

943#define hipCpuDeviceId ((int)-1)

944#define hipInvalidDeviceId ((int)-2)

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

947#define hipExtAnyOrderLaunch 0x01

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

949#define hipStreamWaitValueGte 0x0

950#define hipStreamWaitValueEq 0x1

951#define hipStreamWaitValueAnd 0x2

952#define hipStreamWaitValueNor 0x3

953

955typedef enum hipStreamBatchMemOpType {

956 hipStreamMemOpWaitValue32 = 0x1,

957 hipStreamMemOpWriteValue32 = 0x2,

958 hipStreamMemOpWaitValue64 = 0x4,

959 hipStreamMemOpWriteValue64 = 0x5,

960 hipStreamMemOpBarrier = 0x6,

961 hipStreamMemOpFlushRemoteWrites = 0x3

962} hipStreamBatchMemOpType;

963

1000typedef union hipStreamBatchMemOpParams_union {

1001 hipStreamBatchMemOpType operation;

1002 struct hipStreamMemOpWaitValueParams_t {

1003 hipStreamBatchMemOpType operation;

1004 hipDeviceptr_t address;

1005 union {

1006 uint32_t value;

1007 uint64_t value64;

1008 };

1009 unsigned int flags;

1010 hipDeviceptr_t alias;

1011 } waitValue;

1012 struct hipStreamMemOpWriteValueParams_t {

1013 hipStreamBatchMemOpType operation;

1014 hipDeviceptr_t address;

1015 union {

1016 uint32_t value;

1017 uint64_t value64;

1018 };

1019 unsigned int flags;

1020 hipDeviceptr_t alias;

1021 } writeValue;

1022 struct hipStreamMemOpFlushRemoteWritesParams_t {

1023 hipStreamBatchMemOpType operation;

1024 unsigned int flags;

1025 } flushRemoteWrites;

1026 struct hipStreamMemOpMemoryBarrierParams_t {

1027 hipStreamBatchMemOpType operation;

1028 unsigned int flags;

1029 } memoryBarrier;

1030 uint64_t pad[6];

1031} hipStreamBatchMemOpParams;

1032

1060typedef struct hipBatchMemOpNodeParams {

1061 hipCtx_t ctx;

1062 unsigned int count;

1063 hipStreamBatchMemOpParams* paramArray;

1064 unsigned int flags;

1065} hipBatchMemOpNodeParams;

1066

1067// Stream per thread

1069#define hipStreamPerThread ((hipStream_t)2)

1070

1071#define hipStreamLegacy ((hipStream_t)1)

1072

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

1074#define hipExternalMemoryDedicated 0x1

1080typedef enum hipMemoryAdvise {

1081 hipMemAdviseSetReadMostly = 1,

1083 hipMemAdviseUnsetReadMostly = 2,

1084 hipMemAdviseSetPreferredLocation = 3,

1086 hipMemAdviseUnsetPreferredLocation = 4,

1087 hipMemAdviseSetAccessedBy = 5,

1089 hipMemAdviseUnsetAccessedBy = 6,

1091 hipMemAdviseSetCoarseGrain = 100,

1096 hipMemAdviseUnsetCoarseGrain = 101

1097} hipMemoryAdvise;

1101typedef enum hipMemRangeCoherencyMode {

1102 hipMemRangeCoherencyModeFineGrain = 0,

1104 hipMemRangeCoherencyModeCoarseGrain = 1,

1106 hipMemRangeCoherencyModeIndeterminate = 2

1109} hipMemRangeCoherencyMode;

1113typedef enum hipMemRangeAttribute {

1114 hipMemRangeAttributeReadMostly = 1,

1116 hipMemRangeAttributePreferredLocation = 2,

1117 hipMemRangeAttributeAccessedBy = 3,

1119 hipMemRangeAttributeLastPrefetchLocation = 4,

1121 hipMemRangeAttributeCoherencyMode = 100,

1123} hipMemRangeAttribute;

1124

1128typedef enum hipMemPoolAttr {

1137 hipMemPoolReuseFollowEventDependencies = 0x1,

1143 hipMemPoolReuseAllowOpportunistic = 0x2,

1150 hipMemPoolReuseAllowInternalDependencies = 0x3,

1159 hipMemPoolAttrReleaseThreshold = 0x4,

1164 hipMemPoolAttrReservedMemCurrent = 0x5,

1170 hipMemPoolAttrReservedMemHigh = 0x6,

1175 hipMemPoolAttrUsedMemCurrent = 0x7,

1181 hipMemPoolAttrUsedMemHigh = 0x8

1182} hipMemPoolAttr;

1183

1188typedef enum hipMemAccessFlags {

1189 hipMemAccessFlagsProtNone = 0,

1190 hipMemAccessFlagsProtRead = 1,

1191 hipMemAccessFlagsProtReadWrite = 3

1192} hipMemAccessFlags;

1199typedef struct hipMemAccessDesc {

1200 hipMemLocation location;

1201 hipMemAccessFlags flags;

1202} hipMemAccessDesc;

1206typedef enum hipMemAllocationType {

1207 hipMemAllocationTypeInvalid = 0x0,

1211 hipMemAllocationTypePinned = 0x1,

1212 hipMemAllocationTypeUncached = 0x40000000,

1213 hipMemAllocationTypeMax = 0x7FFFFFFF

1214} hipMemAllocationType;

1219typedef enum hipMemAllocationHandleType {

1220 hipMemHandleTypeNone = 0x0,

1221 hipMemHandleTypePosixFileDescriptor =

1222 0x1,

1223 hipMemHandleTypeWin32 = 0x2,

1224 hipMemHandleTypeWin32Kmt = 0x4

1225} hipMemAllocationHandleType;

1229typedef struct hipMemPoolProps {

1230 hipMemAllocationType

1231 allocType;

1232 hipMemAllocationHandleType

1233 handleTypes;

1234 hipMemLocation location;

1238 void* win32SecurityAttributes;

1239 size_t maxSize;

1240 unsigned char reserved[56];

1241} hipMemPoolProps;

1245typedef struct hipMemPoolPtrExportData {

1246 unsigned char reserved[64];

1247} hipMemPoolPtrExportData;

1248

1252typedef enum hipFuncAttribute {

1253 hipFuncAttributeMaxDynamicSharedMemorySize =

1254 8,

1255 hipFuncAttributePreferredSharedMemoryCarveout =

1256 9,

1257 hipFuncAttributeMax

1258} hipFuncAttribute;

1262typedef enum hipFuncCache_t {

1263 hipFuncCachePreferNone,

1264 hipFuncCachePreferShared,

1265 hipFuncCachePreferL1,

1266 hipFuncCachePreferEqual,

1267} hipFuncCache_t;

1271typedef enum hipSharedMemConfig {

1272 hipSharedMemBankSizeDefault,

1273 hipSharedMemBankSizeFourByte,

1275 hipSharedMemBankSizeEightByte

1277} hipSharedMemConfig;

1281typedef struct dim3 {

1282 uint32_t x;

1283 uint32_t y;

1284 uint32_t z;

1285#ifdef __cplusplus

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

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

1288#endif

1289} dim3;

1293typedef struct hipLaunchParams_t {

1294 void* func;

1295 dim3 gridDim;

1296 dim3 blockDim;

1297 void** args;

1298 size_t sharedMem;

1299 hipStream_t stream;

1300} hipLaunchParams;

1304typedef struct hipFunctionLaunchParams_t {

1305 hipFunction_t function;

1306 unsigned int gridDimX;

1307 unsigned int gridDimY;

1308 unsigned int gridDimZ;

1309 unsigned int blockDimX;

1310 unsigned int blockDimY;

1311 unsigned int blockDimZ;

1312 unsigned int sharedMemBytes;

1313 hipStream_t hStream;

1314 void** kernelParams;

1315} hipFunctionLaunchParams;

1316typedef enum hipExternalMemoryHandleType_enum {

1317 hipExternalMemoryHandleTypeOpaqueFd = 1,

1318 hipExternalMemoryHandleTypeOpaqueWin32 = 2,

1319 hipExternalMemoryHandleTypeOpaqueWin32Kmt = 3,

1320 hipExternalMemoryHandleTypeD3D12Heap = 4,

1321 hipExternalMemoryHandleTypeD3D12Resource = 5,

1322 hipExternalMemoryHandleTypeD3D11Resource = 6,

1323 hipExternalMemoryHandleTypeD3D11ResourceKmt = 7,

1324 hipExternalMemoryHandleTypeNvSciBuf = 8

1325} hipExternalMemoryHandleType;

1326typedef struct hipExternalMemoryHandleDesc_st {

1327 hipExternalMemoryHandleType type;

1328 union {

1329 int fd;

1330 struct {

1331 void* handle;

1332 const void* name;

1333 } win32;

1334 const void* nvSciBufObject;

1335 } handle;

1336 unsigned long long size;

1337 unsigned int flags;

1338 unsigned int reserved[16];

1339} hipExternalMemoryHandleDesc;

1340typedef struct hipExternalMemoryBufferDesc_st {

1341 unsigned long long offset;

1342 unsigned long long size;

1343 unsigned int flags;

1344 unsigned int reserved[16];

1345} hipExternalMemoryBufferDesc;

1346typedef struct hipExternalMemoryMipmappedArrayDesc_st {

1347 unsigned long long offset;

1348 hipChannelFormatDesc formatDesc;

1349 hipExtent extent;

1350 unsigned int flags;

1351 unsigned int numLevels;

1352} hipExternalMemoryMipmappedArrayDesc;

1353typedef void* hipExternalMemory_t;

1354typedef enum hipExternalSemaphoreHandleType_enum {

1355 hipExternalSemaphoreHandleTypeOpaqueFd = 1,

1356 hipExternalSemaphoreHandleTypeOpaqueWin32 = 2,

1357 hipExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3,

1358 hipExternalSemaphoreHandleTypeD3D12Fence = 4,

1359 hipExternalSemaphoreHandleTypeD3D11Fence = 5,

1360 hipExternalSemaphoreHandleTypeNvSciSync = 6,

1361 hipExternalSemaphoreHandleTypeKeyedMutex = 7,

1362 hipExternalSemaphoreHandleTypeKeyedMutexKmt = 8,

1363 hipExternalSemaphoreHandleTypeTimelineSemaphoreFd = 9,

1364 hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = 10

1365} hipExternalSemaphoreHandleType;

1366typedef struct hipExternalSemaphoreHandleDesc_st {

1367 hipExternalSemaphoreHandleType type;

1368 union {

1369 int fd;

1370 struct {

1371 void* handle;

1372 const void* name;

1373 } win32;

1374 const void* NvSciSyncObj;

1375 } handle;

1376 unsigned int flags;

1377 unsigned int reserved[16];

1378} hipExternalSemaphoreHandleDesc;

1379typedef void* hipExternalSemaphore_t;

1380typedef struct hipExternalSemaphoreSignalParams_st {

1381 struct {

1382 struct {

1383 unsigned long long value;

1384 } fence;

1385 union {

1386 void* fence;

1387 unsigned long long reserved;

1388 } nvSciSync;

1389 struct {

1390 unsigned long long key;

1391 } keyedMutex;

1392 unsigned int reserved[12];

1393 } params;

1394 unsigned int flags;

1395 unsigned int reserved[16];

1396} hipExternalSemaphoreSignalParams;

1400typedef struct hipExternalSemaphoreWaitParams_st {

1401 struct {

1402 struct {

1403 unsigned long long value;

1404 } fence;

1405 union {

1406 void* fence;

1407 unsigned long long reserved;

1408 } nvSciSync;

1409 struct {

1410 unsigned long long key;

1411 unsigned int timeoutMs;

1412 } keyedMutex;

1413 unsigned int reserved[10];

1414 } params;

1415 unsigned int flags;

1416 unsigned int reserved[16];

1417} hipExternalSemaphoreWaitParams;

1418

1419#if __HIP_HAS_GET_PCH

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

1425#endif

1426

1430typedef enum hipGraphicsRegisterFlags {

1431 hipGraphicsRegisterFlagsNone = 0,

1432 hipGraphicsRegisterFlagsReadOnly = 1,

1433 hipGraphicsRegisterFlagsWriteDiscard =

1434 2,

1435 hipGraphicsRegisterFlagsSurfaceLoadStore = 4,

1436 hipGraphicsRegisterFlagsTextureGather =

1437 8

1438} hipGraphicsRegisterFlags;

1439

1440typedef struct _hipGraphicsResource hipGraphicsResource;

1441

1442typedef hipGraphicsResource* hipGraphicsResource_t;

1443

1447typedef struct ihipGraph* hipGraph_t;

1451typedef struct hipGraphNode* hipGraphNode_t;

1455typedef struct hipGraphExec* hipGraphExec_t;

1456

1460typedef struct hipUserObject* hipUserObject_t;

1461

1462

1466typedef enum hipGraphNodeType {

1467 hipGraphNodeTypeKernel = 0,

1468 hipGraphNodeTypeMemcpy = 1,

1469 hipGraphNodeTypeMemset = 2,

1470 hipGraphNodeTypeHost = 3,

1471 hipGraphNodeTypeGraph = 4,

1472 hipGraphNodeTypeEmpty = 5,

1473 hipGraphNodeTypeWaitEvent = 6,

1474 hipGraphNodeTypeEventRecord = 7,

1475 hipGraphNodeTypeExtSemaphoreSignal = 8,

1476 hipGraphNodeTypeExtSemaphoreWait = 9,

1477 hipGraphNodeTypeMemAlloc = 10,

1478 hipGraphNodeTypeMemFree = 11,

1479 hipGraphNodeTypeMemcpyFromSymbol = 12,

1480 hipGraphNodeTypeMemcpyToSymbol = 13,

1481 hipGraphNodeTypeBatchMemOp = 14,

1482 hipGraphNodeTypeCount

1483} hipGraphNodeType;

1484

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

1486typedef struct hipHostNodeParams {

1487 hipHostFn_t fn;

1488 void* userData;

1489} hipHostNodeParams;

1490typedef struct hipKernelNodeParams {

1491 dim3 blockDim;

1492 void** extra;

1493 void* func;

1494 dim3 gridDim;

1495 void** kernelParams;

1496 unsigned int sharedMemBytes;

1497} hipKernelNodeParams;

1498typedef struct hipMemsetParams {

1499 void* dst;

1500 unsigned int elementSize;

1501 size_t height;

1502 size_t pitch;

1503 unsigned int value;

1504 size_t width;

1505} hipMemsetParams;

1506

1507typedef struct hipMemAllocNodeParams {

1508 hipMemPoolProps poolProps;

1510 const hipMemAccessDesc* accessDescs;

1511 size_t accessDescCount;

1513 size_t bytesize;

1514 void* dptr;

1515} hipMemAllocNodeParams;

1516

1520typedef enum hipAccessProperty {

1521 hipAccessPropertyNormal = 0,

1522 hipAccessPropertyStreaming = 1,

1523 hipAccessPropertyPersisting = 2,

1524} hipAccessProperty;

1525

1526/***

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

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

1529 */

1530typedef struct hipAccessPolicyWindow {

1531 void* base_ptr;

1532 hipAccessProperty hitProp;

1533 float hitRatio;

1534 hipAccessProperty missProp;

1535 size_t num_bytes;

1536} hipAccessPolicyWindow;

1537

1541typedef struct hipLaunchMemSyncDomainMap {

1542 unsigned char default_;

1543 unsigned char remote;

1544} hipLaunchMemSyncDomainMap;

1545

1549typedef enum hipLaunchMemSyncDomain {

1550 hipLaunchMemSyncDomainDefault = 0,

1551 hipLaunchMemSyncDomainRemote = 1

1552} hipLaunchMemSyncDomain;

1553

1558typedef enum hipSynchronizationPolicy {

1559 hipSyncPolicyAuto = 1,

1560 hipSyncPolicySpin = 2,

1561 hipSyncPolicyYield = 3,

1562 hipSyncPolicyBlockingSync = 4

1563} hipSynchronizationPolicy;

1564

1568typedef enum hipLaunchAttributeID {

1569 hipLaunchAttributeAccessPolicyWindow = 1,

1570 hipLaunchAttributeCooperative = 2,

1571 hipLaunchAttributeSynchronizationPolicy = 3,

1572 hipLaunchAttributePriority = 8,

1573 hipLaunchAttributeMemSyncDomainMap = 9,

1574 hipLaunchAttributeMemSyncDomain = 10,

1575 hipLaunchAttributeMax

1576} hipLaunchAttributeID;

1577

1578

1582typedef union hipLaunchAttributeValue {

1583 char pad[64];

1584 hipAccessPolicyWindow

1585 accessPolicyWindow;

1586 int cooperative;

1588 int priority;

1590 hipSynchronizationPolicy

1591 syncPolicy;

1593 hipLaunchMemSyncDomainMap

1594 memSyncDomainMap;

1595 hipLaunchMemSyncDomain

1596 memSyncDomain;

1597} hipLaunchAttributeValue;

1598

1602#define hipStreamAttrID hipLaunchAttributeID

1603#define hipStreamAttributeAccessPolicyWindow hipLaunchAttributeAccessPolicyWindow

1604#define hipStreamAttributeSynchronizationPolicy hipLaunchAttributeSynchronizationPolicy

1605#define hipStreamAttributeMemSyncDomainMap hipLaunchAttributeMemSyncDomainMap

1606#define hipStreamAttributeMemSyncDomain hipLaunchAttributeMemSyncDomain

1607#define hipStreamAttributePriority hipLaunchAttributePriority

1608

1609#define hipStreamAttrValue hipLaunchAttributeValue

1610

1614#define hipKernelNodeAttrID hipLaunchAttributeID

1615#define hipKernelNodeAttributeAccessPolicyWindow hipLaunchAttributeAccessPolicyWindow

1616#define hipKernelNodeAttributeCooperative hipLaunchAttributeCooperative

1617#define hipKernelNodeAttributePriority hipLaunchAttributePriority

1618

1622#define hipKernelNodeAttrValue hipLaunchAttributeValue

1623

1627#define hipDrvLaunchAttributeCooperative hipLaunchAttributeCooperative

1628

1629#define hipDrvLaunchAttributeID hipLaunchAttributeID

1630#define hipDrvLaunchAttributeValue hipLaunchAttributeValue

1631#define hipDrvLaunchAttribute hipLaunchAttribute

1632

1636typedef enum hipGraphExecUpdateResult {

1637 hipGraphExecUpdateSuccess = 0x0,

1638 hipGraphExecUpdateError = 0x1,

1640 hipGraphExecUpdateErrorTopologyChanged = 0x2,

1641 hipGraphExecUpdateErrorNodeTypeChanged = 0x3,

1642 hipGraphExecUpdateErrorFunctionChanged =

1643 0x4,

1644 hipGraphExecUpdateErrorParametersChanged =

1645 0x5,

1646 hipGraphExecUpdateErrorNotSupported =

1647 0x6,

1648 hipGraphExecUpdateErrorUnsupportedFunctionChange = 0x7

1649} hipGraphExecUpdateResult;

1650

1651typedef enum hipStreamCaptureMode {

1652 hipStreamCaptureModeGlobal = 0,

1653 hipStreamCaptureModeThreadLocal,

1654 hipStreamCaptureModeRelaxed

1655} hipStreamCaptureMode;

1656typedef enum hipStreamCaptureStatus {

1657 hipStreamCaptureStatusNone = 0,

1658 hipStreamCaptureStatusActive,

1659 hipStreamCaptureStatusInvalidated

1661} hipStreamCaptureStatus;

1662

1663typedef enum hipStreamUpdateCaptureDependenciesFlags {

1664 hipStreamAddCaptureDependencies = 0,

1665 hipStreamSetCaptureDependencies,

1666} hipStreamUpdateCaptureDependenciesFlags;

1667

1668typedef enum hipGraphMemAttributeType {

1669 hipGraphMemAttrUsedMemCurrent =

1670 0,

1671 hipGraphMemAttrUsedMemHigh,

1673 hipGraphMemAttrReservedMemCurrent,

1675 hipGraphMemAttrReservedMemHigh,

1677} hipGraphMemAttributeType;

1678typedef enum hipUserObjectFlags {

1679 hipUserObjectNoDestructorSync = 0x1,

1680} hipUserObjectFlags;

1681

1682typedef enum hipUserObjectRetainFlags {

1683 hipGraphUserObjectMove = 0x1,

1684} hipUserObjectRetainFlags;

1685

1686typedef enum hipGraphInstantiateFlags {

1687 hipGraphInstantiateFlagAutoFreeOnLaunch =

1688 1,

1689 hipGraphInstantiateFlagUpload = 2,

1690 hipGraphInstantiateFlagDeviceLaunch =

1691 4,

1692 hipGraphInstantiateFlagUseNodePriority =

1693 8,

1695} hipGraphInstantiateFlags;

1696

1697enum hipGraphDebugDotFlags {

1698 hipGraphDebugDotFlagsVerbose =

1699 1 << 0,

1700 hipGraphDebugDotFlagsKernelNodeParams = 1 << 2,

1701 hipGraphDebugDotFlagsMemcpyNodeParams = 1 << 3,

1702 hipGraphDebugDotFlagsMemsetNodeParams = 1 << 4,

1703 hipGraphDebugDotFlagsHostNodeParams = 1 << 5,

1704 hipGraphDebugDotFlagsEventNodeParams =

1705 1 << 6,

1706 hipGraphDebugDotFlagsExtSemasSignalNodeParams =

1707 1 << 7,

1708 hipGraphDebugDotFlagsExtSemasWaitNodeParams =

1709 1 << 8,

1710 hipGraphDebugDotFlagsKernelNodeAttributes =

1711 1 << 9,

1712 hipGraphDebugDotFlagsHandles =

1713 1 << 10

1714};

1715

1719typedef enum hipGraphInstantiateResult {

1720 hipGraphInstantiateSuccess = 0,

1721 hipGraphInstantiateError = 1,

1723 hipGraphInstantiateInvalidStructure = 2,

1725 hipGraphInstantiateNodeOperationNotSupported = 3,

1727 hipGraphInstantiateMultipleDevicesNotSupported = 4,

1729} hipGraphInstantiateResult;

1730

1734typedef struct hipGraphInstantiateParams {

1735 hipGraphNode_t errNode_out;

1736 unsigned long long flags;

1737 hipGraphInstantiateResult result_out;

1739 hipStream_t uploadStream;

1740} hipGraphInstantiateParams;

1741

1742

1746typedef struct hipMemAllocationProp {

1747 hipMemAllocationType type;

1748 union {

1749 hipMemAllocationHandleType requestedHandleType;

1750 hipMemAllocationHandleType requestedHandleTypes;

1751 };

1752 hipMemLocation location;

1753 void* win32HandleMetaData;

1754 struct {

1755 unsigned char compressionType;

1756 unsigned char gpuDirectRDMACapable;

1757 unsigned short usage;

1758 } allocFlags;

1759} hipMemAllocationProp;

1760

1764typedef struct hipExternalSemaphoreSignalNodeParams {

1766 hipExternalSemaphore_t* extSemArray;

1768 const hipExternalSemaphoreSignalParams* paramsArray;

1770 unsigned int numExtSems;

1771} hipExternalSemaphoreSignalNodeParams;

1772

1776typedef struct hipExternalSemaphoreWaitNodeParams {

1778 hipExternalSemaphore_t* extSemArray;

1780 const hipExternalSemaphoreWaitParams* paramsArray;

1782 unsigned int numExtSems;

1783} hipExternalSemaphoreWaitNodeParams;

1784

1788typedef struct ihipMemGenericAllocationHandle* hipMemGenericAllocationHandle_t;

1789

1793typedef enum hipMemAllocationGranularity_flags {

1794 hipMemAllocationGranularityMinimum = 0x0,

1795 hipMemAllocationGranularityRecommended = 0x1

1796} hipMemAllocationGranularity_flags;

1797

1801typedef enum hipMemHandleType {

1802 hipMemHandleTypeGeneric = 0x0

1803} hipMemHandleType;

1804

1808typedef enum hipMemOperationType {

1809 hipMemOperationTypeMap = 0x1,

1810 hipMemOperationTypeUnmap = 0x2

1811} hipMemOperationType;

1812

1816typedef enum hipArraySparseSubresourceType {

1817 hipArraySparseSubresourceTypeSparseLevel = 0x0,

1818 hipArraySparseSubresourceTypeMiptail = 0x1

1819} hipArraySparseSubresourceType;

1820

1824typedef struct hipArrayMapInfo {

1825 hipResourceType resourceType;

1826 union {

1827 hipMipmappedArray mipmap;

1828 hipArray_t array;

1829 } resource;

1830 hipArraySparseSubresourceType subresourceType;

1831 union {

1832 struct {

1833 unsigned int

1834 level;

1835 unsigned int

1836 layer;

1837 unsigned int offsetX;

1838 unsigned int offsetY;

1839 unsigned int offsetZ;

1840 unsigned int extentWidth;

1841 unsigned int extentHeight;

1842 unsigned int extentDepth;

1843 } sparseLevel;

1844 struct {

1845 unsigned int

1846 layer;

1847 unsigned long long offset;

1848 unsigned long long size;

1849 } miptail;

1850 } subresource;

1851 hipMemOperationType memOperationType;

1852 hipMemHandleType memHandleType;

1853 union {

1854 hipMemGenericAllocationHandle_t memHandle;

1855 } memHandle;

1856 unsigned long long offset;

1857 unsigned int deviceBitMask;

1858 unsigned int flags;

1859 unsigned int reserved[2];

1860} hipArrayMapInfo;

1861

1865typedef struct hipMemcpyNodeParams {

1866 int flags;

1867 int reserved[3];

1868 hipMemcpy3DParms copyParams;

1869} hipMemcpyNodeParams;

1870

1874typedef struct hipChildGraphNodeParams {

1875 hipGraph_t graph;

1877} hipChildGraphNodeParams;

1878

1882typedef struct hipEventWaitNodeParams {

1883 hipEvent_t event;

1884} hipEventWaitNodeParams;

1885

1889typedef struct hipEventRecordNodeParams {

1890 hipEvent_t event;

1891} hipEventRecordNodeParams;

1892

1896typedef struct hipMemFreeNodeParams {

1897 void* dptr;

1898} hipMemFreeNodeParams;

1899

1903typedef struct hipGraphNodeParams {

1904 hipGraphNodeType type;

1905 int reserved0[3];

1906 union {

1907 long long reserved1[29];

1908 hipKernelNodeParams kernel;

1909 hipMemcpyNodeParams memcpy;

1910 hipMemsetParams memset;

1911 hipHostNodeParams host;

1912 hipChildGraphNodeParams graph;

1913 hipEventWaitNodeParams eventWait;

1914 hipEventRecordNodeParams eventRecord;

1915 hipExternalSemaphoreSignalNodeParams extSemSignal;

1916 hipExternalSemaphoreWaitNodeParams extSemWait;

1917 hipMemAllocNodeParams alloc;

1918 hipMemFreeNodeParams free;

1919 };

1920

1921 long long reserved2;

1922} hipGraphNodeParams;

1923

1927#define hipGraphKernelNodePortDefault 0

1928

1932#define hipGraphKernelNodePortLaunchCompletion 2

1933

1939#define hipGraphKernelNodePortProgrammatic 1

1940

1941typedef enum hipGraphDependencyType {

1942 hipGraphDependencyTypeDefault = 0,

1943 hipGraphDependencyTypeProgrammatic = 1

1944} hipGraphDependencyType;

1945

1946typedef struct hipGraphEdgeData {

1947 unsigned char

1948 from_port;

1955 unsigned char reserved[5];

1956 unsigned char

1957 to_port;

1958 unsigned char type;

1959} hipGraphEdgeData;

1960

1961

1965typedef struct hipLaunchAttribute_st {

1966 hipLaunchAttributeID id;

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

1968 union {

1969 hipLaunchAttributeValue val;

1970 hipLaunchAttributeValue value;

1971 };

1972} hipLaunchAttribute;

1973

1977typedef struct hipLaunchConfig_st {

1978 dim3 gridDim;

1979 dim3 blockDim;

1980 size_t dynamicSmemBytes;

1981 hipStream_t stream;

1982 hipLaunchAttribute* attrs;

1983 unsigned int numAttrs;

1984} hipLaunchConfig_t;

1985

1989typedef struct HIP_LAUNCH_CONFIG_st {

1990 unsigned int gridDimX;

1991 unsigned int gridDimY;

1992 unsigned int gridDimZ;

1993 unsigned int blockDimX;

1994 unsigned int blockDimY;

1995 unsigned int blockDimZ;

1996 unsigned int sharedMemBytes;

1997 hipStream_t hStream;

1998 hipLaunchAttribute* attrs;

1999 unsigned int numAttrs;

2000} HIP_LAUNCH_CONFIG;

2001

2005typedef enum hipMemRangeHandleType {

2006 hipMemRangeHandleTypeDmaBufFd = 0x1,

2007 hipMemRangeHandleTypeMax = 0x7fffffff

2008} hipMemRangeHandleType;

2009

2013typedef enum hipMemRangeFlags {

2014 hipMemRangeFlagDmaBufMappingTypePcie = 0x1,

2015 hipMemRangeFlagsMax = 0x7fffffff

2016} hipMemRangeFlags;

2017

2018// Doxygen end group GlobalDefs

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

2045hipError_t hipInit(unsigned int flags);

2046

2064hipError_t hipDriverGetVersion(int* driverVersion);

2079hipError_t hipRuntimeGetVersion(int* runtimeVersion);

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

2088

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

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

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

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

2129 int dstDevice);

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

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

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

2155// doxygen end initialization

2174hipError_t hipDeviceSynchronize(void);

2186hipError_t hipDeviceReset(void);

2218hipError_t hipSetDevice(int deviceId);

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

2245hipError_t hipGetDevice(int* deviceId);

2258hipError_t hipGetDeviceCount(int* count);

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

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

2305hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool);

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

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

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

2357 int device);

2369hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig);

2380hipError_t hipDeviceGetCacheConfig(hipFuncCache_t* cacheConfig);

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

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

2426hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig* pConfig);

2434hipError_t hipGetDeviceFlags(unsigned int* flags);

2446hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config);

2478hipError_t hipSetDeviceFlags(unsigned flags);

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

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

2502 uint32_t* hopcount);

2503// TODO: implement IPC apis

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

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

2581hipError_t hipIpcCloseMemHandle(void* devPtr);

2582

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

2600

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

2620

2621// end doxygen Device

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

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

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

2671// doxygen end execution

2693hipError_t hipGetLastError(void);

2694

2706hipError_t hipExtGetLastError(void);

2707

2718hipError_t hipPeekAtLastError(void);

2727const char* hipGetErrorName(hipError_t hip_error);

2736const char* hipGetErrorString(hipError_t hipError);

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

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

2757// end doxygen Error

2790hipError_t hipStreamCreate(hipStream_t* stream);

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

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

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

2870hipError_t hipStreamDestroy(hipStream_t stream);

2886hipError_t hipStreamQuery(hipStream_t stream);

2908hipError_t hipStreamSynchronize(hipStream_t stream);

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

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

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

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

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

2997hipError_t hipExtStreamCreateWithCUMask(hipStream_t* stream, uint32_t cuMaskSize,

2998 const uint32_t* cuMask);

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

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

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

3032 unsigned int flags);

3033

3041hipError_t hipStreamSetAttribute(hipStream_t stream, hipStreamAttrID attr,

3042 const hipStreamAttrValue* value);

3043

3051hipError_t hipStreamGetAttribute(hipStream_t stream, hipStreamAttrID attr,

3052 hipStreamAttrValue* value_out);

3053

3054// end doxygen Stream

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

3103 uint32_t mask __dparm(0xFFFFFFFF));

3104

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

3142 uint64_t mask __dparm(0xFFFFFFFFFFFFFFFF));

3143

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

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

3186

3206hipError_t hipStreamBatchMemOp(hipStream_t stream, unsigned int count,

3207 hipStreamBatchMemOpParams* paramArray, unsigned int flags);

3208

3226hipError_t hipGraphAddBatchMemOpNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

3227 const hipGraphNode_t* dependencies, size_t numDependencies,

3228 const hipBatchMemOpNodeParams* nodeParams);

3229

3250hipError_t hipGraphBatchMemOpNodeGetParams(hipGraphNode_t hNode,

3251 hipBatchMemOpNodeParams* nodeParams_out);

3252

3270hipError_t hipGraphBatchMemOpNodeSetParams(hipGraphNode_t hNode,

3271 hipBatchMemOpNodeParams* nodeParams);

3272

3292hipError_t hipGraphExecBatchMemOpNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

3293 const hipBatchMemOpNodeParams* nodeParams);

3294

3295// end doxygen Stream Memory Operations

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

3343hipError_t hipEventCreate(hipEvent_t* event);

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

3381 unsigned int flags __dparm(0));

3412#ifdef __cplusplus

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

3414#else

3415hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream);

3416#endif

3433hipError_t hipEventDestroy(hipEvent_t event);

3452hipError_t hipEventSynchronize(hipEvent_t event);

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

3498hipError_t hipEventQuery(hipEvent_t event);

3499// end doxygen Events

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

3531 hipDeviceptr_t ptr);

3532

3533

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

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

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

3586 void** data, hipDeviceptr_t ptr);

3610hipError_t hipImportExternalSemaphore(hipExternalSemaphore_t* extSem_out,

3611 const hipExternalSemaphoreHandleDesc* semHandleDesc);

3627hipError_t hipSignalExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

3628 const hipExternalSemaphoreSignalParams* paramsArray,

3629 unsigned int numExtSems, hipStream_t stream);

3645hipError_t hipWaitExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

3646 const hipExternalSemaphoreWaitParams* paramsArray,

3647 unsigned int numExtSems, hipStream_t stream);

3661hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem);

3662

3674hipError_t hipImportExternalMemory(hipExternalMemory_t* extMem_out,

3675 const hipExternalMemoryHandleDesc* memHandleDesc);

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

3688 const hipExternalMemoryBufferDesc* bufferDesc);

3698hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem);

3713hipError_t hipExternalMemoryGetMappedMipmappedArray(

3714 hipMipmappedArray_t* mipmap, hipExternalMemory_t extMem,

3715 const hipExternalMemoryMipmappedArrayDesc* mipmapDesc);

3716// end of external resource

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

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

3754

3755

3778HIP_DEPRECATED("use hipHostMalloc instead")

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

3792HIP_DEPRECATED("use hipHostMalloc instead")

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

3794// end doxygen deprecated management memory

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

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

3867 unsigned int flags __dparm(hipMemAttachGlobal));

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

3881 hipStream_t stream __dparm(0));

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

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

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

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

3937 hipMemLocation location);

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

3953 const void* dev_ptr, size_t count);

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

3971 hipMemRangeAttribute* attributes, size_t num_attributes,

3972 const void* dev_ptr, size_t count);

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

3989 unsigned int flags __dparm(hipMemAttachSingle));

3990// end doxygen Managed Memory

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

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

4103hipError_t hipMemPoolTrimTo(hipMemPool_t mem_pool, size_t min_bytes_to_hold);

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

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

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

4202 size_t count);

4222hipError_t hipMemPoolGetAccess(hipMemAccessFlags* flags, hipMemPool_t mem_pool,

4223 hipMemLocation* location);

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

4276hipError_t hipMemPoolDestroy(hipMemPool_t mem_pool);

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

4313 hipStream_t stream);

4340hipError_t hipMemPoolExportToShareableHandle(void* shared_handle, hipMemPool_t mem_pool,

4341 hipMemAllocationHandleType handle_type,

4342 unsigned int flags);

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

4367 hipMemAllocationHandleType handle_type,

4368 unsigned int flags);

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

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

4418 hipMemPoolPtrExportData* export_data);

4419// Doxygen end of ordered memory allocator

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

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

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

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

4512hipError_t hipHostUnregister(void* hostPtr);

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

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

4555 unsigned int elementSizeBytes);

4569hipError_t hipFree(void* ptr);

4581hipError_t hipFreeHost(void* ptr);

4598hipError_t hipHostFree(void* ptr);

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

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

4645 hipStream_t stream);

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

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

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

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

4719 size_t ByteCount);

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

4739 size_t ByteCount);

4740

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

4761 size_t srcOffset, size_t ByteCount);

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

4781 hipStream_t stream);

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

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

4820 hipStream_t stream);

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

4841 size_t ByteCount, hipStream_t stream);

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

4862 size_t ByteCount, hipStream_t stream);

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

4880 const char* name);

4881

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

4892

4893

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

4904

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

4925 hipDriverProcAddressQueryResult* symbolStatus);

4926

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

4949 size_t offset __dparm(0),

4950 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice));

4951

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

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

4967

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

4981 size_t offset __dparm(0),

4982 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost));

4983

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

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

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

5028 hipStream_t stream __dparm(0));

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

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

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

5065 hipStream_t stream __dparm(0));

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

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

5092 hipStream_t stream __dparm(0));

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

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

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

5135 hipStream_t stream __dparm(0));

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

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

5159 hipStream_t stream __dparm(0));

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

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

5179 hipStream_t stream __dparm(0));

5180

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

5193 size_t height);

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

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

5208

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

5221 size_t height);

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

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

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

5248 size_t height);

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

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

5263

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

5281

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

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

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

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

5328hipError_t hipArrayDestroy(hipArray_t array);

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

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

5359hipError_t hipFreeArray(hipArray_t array);

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

5372 struct hipExtent extent, unsigned int flags);

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

5386 hipArray_t array);

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

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

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

5458 size_t height, hipMemcpyKind kind);

5468hipError_t hipMemcpyParam2D(const hip_Memcpy2D* pCopy);

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

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

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

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

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

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

5560 size_t spitch, size_t width, size_t height, hipMemcpyKind kind,

5561 hipStream_t stream __dparm(0));

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

5581 hipArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc,

5582 size_t width, size_t height, hipMemcpyKind kind);

5601HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5603 size_t count, hipMemcpyKind kind);

5622HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5624 size_t count, hipMemcpyKind kind);

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

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

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

5663 size_t hOffset, size_t width, size_t height,

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

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

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

5703hipError_t hipMemcpy3D(const struct hipMemcpy3DParms* p);

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

5726hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D* pCopy);

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

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

5752

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

5769 hipMemcpyAttributes* attrs, size_t* attrsIdxs, size_t numAttrs,

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

5771

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

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

5786

5795hipError_t hipMemcpy3DPeer(hipMemcpy3DPeerParms* p);

5796

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

5806// doxygen end Memory

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

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

5867hipError_t hipDeviceDisablePeerAccess(int peerDeviceId);

5868

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

5881 size_t sizeBytes);

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

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

5896

5897// doxygen end PeerToPeer

5938HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5953HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5954hipError_t hipCtxDestroy(hipCtx_t ctx);

5968HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5969hipError_t hipCtxPopCurrent(hipCtx_t* ctx);

5983HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5984hipError_t hipCtxPushCurrent(hipCtx_t ctx);

5998HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5999hipError_t hipCtxSetCurrent(hipCtx_t ctx);

6013HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6014hipError_t hipCtxGetCurrent(hipCtx_t* ctx);

6028HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6029hipError_t hipCtxGetDevice(hipDevice_t* device);

6050HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6068HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6069hipError_t hipCtxGetCacheConfig(hipFuncCache_t* cacheConfig);

6086HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6087hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig);

6104HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6105hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config);

6122HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6123hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig* pConfig);

6138HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6139hipError_t hipCtxSynchronize(void);

6153HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6154hipError_t hipCtxGetFlags(unsigned int* flags);

6177HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6198HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6199hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx);

6200

6216HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6233HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6234hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev);

6249HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6264HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6265hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev);

6280HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6282// doxygen end Context Management

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

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

6330hipError_t hipModuleUnload(hipModule_t module);

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

6342

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

6353

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

6368 void** jitOptionsValues, unsigned int numJitOptions,

6369 hipLibraryOption* libraryOptions, void** libraryOptionValues,

6370 unsigned int numLibraryOptions);

6371

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

6386 hipJitOption* jitOptions, void** jitOptionsValues,

6387 unsigned int numJitOptions, hipLibraryOption* libraryOptions,

6388 void** libraryOptionValues, unsigned int numLibraryOptions);

6389

6396hipError_t hipLibraryUnload(hipLibrary_t library);

6397

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

6407

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

6416

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

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

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

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

6458 hipDriverEntryPointQueryResult* driverStatus);

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

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

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

6506 hipJitOption* options, void** optionValues);

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

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

6527 void** optionValues);

6528

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

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

6547

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

6563

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

6576 hipLinkState_t* stateOut);

6585hipError_t hipLinkDestroy(hipLinkState_t state);

6586

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

6616 unsigned int gridDimZ, unsigned int blockDimX,

6617 unsigned int blockDimY, unsigned int blockDimZ,

6618 unsigned int sharedMemBytes, hipStream_t stream,

6619 void** kernelParams, void** extra);

6648hipError_t hipModuleLaunchCooperativeKernel(hipFunction_t f, unsigned int gridDimX,

6649 unsigned int gridDimY, unsigned int gridDimZ,

6650 unsigned int blockDimX, unsigned int blockDimY,

6651 unsigned int blockDimZ, unsigned int sharedMemBytes,

6652 hipStream_t stream, void** kernelParams);

6667hipError_t hipModuleLaunchCooperativeKernelMultiDevice(hipFunctionLaunchParams* launchParamsList,

6668 unsigned int numDevices, unsigned int flags);

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

6690 void** kernelParams, unsigned int sharedMemBytes,

6691 hipStream_t stream);

6703hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList, int numDevices,

6704 unsigned int flags);

6705

6706// Doxygen end group ModuleCooperativeG

6720hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList, int numDevices,

6721 unsigned int flags);

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

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

6752 void** extra);

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

6768 hipMemRangeHandleType handleType,

6769 unsigned long long flags);

6770// doxygen end Module

6798// TODO - Match CUoccupancyB2DSize

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

6800 size_t dynSharedMemPerBlk, int blockSizeLimit);

6816// TODO - Match CUoccupancyB2DSize

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

6818 hipFunction_t f,

6819 size_t dynSharedMemPerBlk,

6820 int blockSizeLimit, unsigned int flags);

6830hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, hipFunction_t f,

6831 int blockSize,

6832 size_t dynSharedMemPerBlk);

6843hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

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

6855 int blockSize, size_t dynSharedMemPerBlk);

6866hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

6868 unsigned int flags __dparm(hipOccupancyDefault));

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

6884 size_t dynSharedMemPerBlk, int blockSizeLimit);

6885// doxygen end Occupancy

6899// TODO - expand descriptions:

6906HIP_DEPRECATED("use roctracer/rocTX instead")

6907hipError_t hipProfilerStart();

6914HIP_DEPRECATED("use roctracer/rocTX instead")

6915hipError_t hipProfilerStop();

6916// doxygen end profiler

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

6944 hipStream_t stream __dparm(0));

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

6964hipError_t hipLaunchByPtr(const void* func);

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

6982 hipStream_t stream __dparm(0));

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

7003 hipStream_t* stream);

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

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

7022 hipStream_t stream __dparm(0));

7023

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

7051

7059hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D* pCopy);

7060// TODO: Move this to hip_ext.h

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

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

7084 hipEvent_t startEvent, hipEvent_t stopEvent, int flags);

7085// doxygen end Clang launch

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

7112 const hipTextureDesc* pTexDesc,

7113 const struct hipResourceViewDesc* pResViewDesc);

7114

7123hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject);

7124

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

7135

7145hipError_t hipGetTextureObjectResourceDesc(hipResourceDesc* pResDesc,

7146 hipTextureObject_t textureObject);

7147

7157hipError_t hipGetTextureObjectResourceViewDesc(struct hipResourceViewDesc* pResViewDesc,

7158 hipTextureObject_t textureObject);

7159

7169hipError_t hipGetTextureObjectTextureDesc(hipTextureDesc* pTexDesc,

7170 hipTextureObject_t textureObject);

7171

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

7184 const HIP_TEXTURE_DESC* pTexDesc,

7185 const HIP_RESOURCE_VIEW_DESC* pResViewDesc);

7186

7195hipError_t hipTexObjectDestroy(hipTextureObject_t texObject);

7196

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

7207

7217hipError_t hipTexObjectGetResourceViewDesc(HIP_RESOURCE_VIEW_DESC* pResViewDesc,

7218 hipTextureObject_t texObject);

7219

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

7230

7245hipError_t hipMallocMipmappedArray(hipMipmappedArray_t* mipmappedArray,

7246 const struct hipChannelFormatDesc* desc, struct hipExtent extent,

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

7248

7259hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray);

7260

7273hipError_t hipGetMipmappedArrayLevel(hipArray_t* levelArray,

7274 hipMipmappedArray_const_t mipmappedArray, unsigned int level);

7275

7287hipError_t hipMipmappedArrayCreate(hipMipmappedArray_t* pHandle,

7288 HIP_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc,

7289 unsigned int numMipmapLevels);

7290

7301hipError_t hipMipmappedArrayDestroy(hipMipmappedArray_t hMipmappedArray);

7302

7315hipError_t hipMipmappedArrayGetLevel(hipArray_t* pLevelArray, hipMipmappedArray_t hMipMappedArray,

7316 unsigned int level);

7317

7336HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7337hipError_t hipBindTextureToMipmappedArray(const textureReference* tex,

7338 hipMipmappedArray_const_t mipmappedArray,

7339 const hipChannelFormatDesc* desc);

7340

7351HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7353

7364HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7366

7378HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7380

7392HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7393hipError_t hipTexRefSetAddressMode(textureReference* texRef, int dim,

7394 enum hipTextureAddressMode am);

7407HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7420HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7433HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7447HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7448hipError_t hipTexRefSetFormat(textureReference* texRef, hipArray_Format fmt,

7449 int NumPackedComponents);

7464HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

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

7483HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

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

7486 size_t pitch);

7499HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7501 const hipChannelFormatDesc* desc);

7513HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7525HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7526hipError_t hipUnbindTexture(const textureReference* tex);

7538HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7552HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7554 int dim);

7566HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7579HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7593HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7595 const textureReference* texRef);

7607HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7620HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7621hipError_t hipTexRefGetMipmapFilterMode(enum hipTextureFilterMode* pfm,

7622 const textureReference* texRef);

7634HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7648HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7650 const textureReference* texRef);

7662HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7677HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7679 size_t bytes);

7693HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7695 hipDeviceptr_t dptr, size_t Pitch);

7707HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7720HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7733HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7746HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

7760HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7761hipError_t hipTexRefSetMipmapLevelClamp(textureReference* texRef, float minMipMapLevelClamp,

7762 float maxMipMapLevelClamp);

7775HIP_DEPRECATED(HIP_DEPRECATED_MSG)

7776hipError_t hipTexRefSetMipmappedArray(textureReference* texRef,

7777 struct hipMipmappedArray* mipmappedArray, unsigned int Flags);

7778

7779// doxygen end deprecated texture management

7784// doxygen end Texture management

7796// This group is for HIPrtc

7797

7798// doxygen end Runtime

7817const char* hipApiName(uint32_t id);

7826const char* hipKernelNameRef(const hipFunction_t f);

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

7845int hipGetStreamDeviceId(hipStream_t stream);

7846

7847// doxygen end Callback

7869hipError_t hipStreamBeginCapture(hipStream_t stream, hipStreamCaptureMode mode);

7870

7890hipError_t hipStreamBeginCaptureToGraph(hipStream_t stream, hipGraph_t graph,

7891 const hipGraphNode_t* dependencies,

7892 const hipGraphEdgeData* dependencyData,

7893 size_t numDependencies, hipStreamCaptureMode mode);

7894

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

7905

7916hipError_t hipStreamGetCaptureInfo(hipStream_t stream, hipStreamCaptureStatus* pCaptureStatus,

7917 unsigned long long* pId);

7918

7933hipError_t hipStreamGetCaptureInfo_v2(hipStream_t stream, hipStreamCaptureStatus* captureStatus_out,

7934 unsigned long long* id_out __dparm(0),

7935 hipGraph_t* graph_out __dparm(0),

7936 const hipGraphNode_t** dependencies_out __dparm(0),

7937 size_t* numDependencies_out __dparm(0));

7938

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

7949

7961hipError_t hipStreamUpdateCaptureDependencies(hipStream_t stream, hipGraphNode_t* dependencies,

7962 size_t numDependencies,

7963 unsigned int flags __dparm(0));

7964

7972hipError_t hipThreadExchangeStreamCaptureMode(hipStreamCaptureMode* mode);

7973

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

7984

7993hipError_t hipGraphDestroy(hipGraph_t graph);

7994

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

8006 const hipGraphNode_t* to, size_t numDependencies);

8007

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

8019 const hipGraphNode_t* to, size_t numDependencies);

8020

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

8037 size_t* numEdges);

8038

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

8054

8069hipError_t hipGraphGetRootNodes(hipGraph_t graph, hipGraphNode_t* pRootNodes,

8070 size_t* pNumRootNodes);

8071

8086hipError_t hipGraphNodeGetDependencies(hipGraphNode_t node, hipGraphNode_t* pDependencies,

8087 size_t* pNumDependencies);

8088

8104hipError_t hipGraphNodeGetDependentNodes(hipGraphNode_t node, hipGraphNode_t* pDependentNodes,

8105 size_t* pNumDependentNodes);

8106

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

8116

8124hipError_t hipGraphDestroyNode(hipGraphNode_t node);

8125

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

8135

8145hipError_t hipGraphNodeFindInClone(hipGraphNode_t* pNode, hipGraphNode_t originalNode,

8146 hipGraph_t clonedGraph);

8147

8161hipError_t hipGraphInstantiate(hipGraphExec_t* pGraphExec, hipGraph_t graph,

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

8163

8174hipError_t hipGraphInstantiateWithFlags(hipGraphExec_t* pGraphExec, hipGraph_t graph,

8175 unsigned long long flags);

8176

8186hipError_t hipGraphInstantiateWithParams(hipGraphExec_t* pGraphExec, hipGraph_t graph,

8187 hipGraphInstantiateParams* instantiateParams);

8196hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream);

8197

8206hipError_t hipGraphUpload(hipGraphExec_t graphExec, hipStream_t stream);

8207

8219hipError_t hipGraphAddNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8220 const hipGraphNode_t* pDependencies, size_t numDependencies,

8221 hipGraphNodeParams* nodeParams);

8222

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

8232

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

8243

8254hipError_t hipGraphExecNodeSetParams(hipGraphExec_t graphExec, hipGraphNode_t node,

8255 hipGraphNodeParams* nodeParams);

8256

8265hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec);

8266

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

8279hipError_t hipGraphExecUpdate(hipGraphExec_t hGraphExec, hipGraph_t hGraph,

8280 hipGraphNode_t* hErrorNode_out,

8281 hipGraphExecUpdateResult* updateResult_out);

8282

8294hipError_t hipGraphAddKernelNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8295 const hipGraphNode_t* pDependencies, size_t numDependencies,

8296 const hipKernelNodeParams* pNodeParams);

8297

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

8307

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

8317

8327hipError_t hipGraphExecKernelNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8328 const hipKernelNodeParams* pNodeParams);

8329

8342hipError_t hipDrvGraphAddMemcpyNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

8343 const hipGraphNode_t* dependencies, size_t numDependencies,

8344 const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);

8356hipError_t hipGraphAddMemcpyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8357 const hipGraphNode_t* pDependencies, size_t numDependencies,

8358 const hipMemcpy3DParms* pCopyParams);

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

8368

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

8378

8388hipError_t hipGraphKernelNodeSetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

8389 const hipKernelNodeAttrValue* value);

8399hipError_t hipGraphKernelNodeGetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

8400 hipKernelNodeAttrValue* value);

8410hipError_t hipGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8411 hipMemcpy3DParms* pNodeParams);

8412

8427hipError_t hipGraphAddMemcpyNode1D(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8428 const hipGraphNode_t* pDependencies, size_t numDependencies,

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

8430

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

8443 size_t count, hipMemcpyKind kind);

8444

8458hipError_t hipGraphExecMemcpyNodeSetParams1D(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

8460 hipMemcpyKind kind);

8461

8477hipError_t hipGraphAddMemcpyNodeFromSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8478 const hipGraphNode_t* pDependencies,

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

8480 size_t count, size_t offset, hipMemcpyKind kind);

8481

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

8495 size_t count, size_t offset, hipMemcpyKind kind);

8496

8511hipError_t hipGraphExecMemcpyNodeSetParamsFromSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

8513 size_t offset, hipMemcpyKind kind);

8514

8530hipError_t hipGraphAddMemcpyNodeToSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8531 const hipGraphNode_t* pDependencies,

8532 size_t numDependencies, const void* symbol,

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

8534 hipMemcpyKind kind);

8535

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

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

8550 hipMemcpyKind kind);

8551

8552

8566hipError_t hipGraphExecMemcpyNodeSetParamsToSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8567 const void* symbol, const void* src,

8568 size_t count, size_t offset, hipMemcpyKind kind);

8569

8581hipError_t hipGraphAddMemsetNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8582 const hipGraphNode_t* pDependencies, size_t numDependencies,

8583 const hipMemsetParams* pMemsetParams);

8584

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

8594

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

8604

8614hipError_t hipGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8615 const hipMemsetParams* pNodeParams);

8616

8628hipError_t hipGraphAddHostNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8629 const hipGraphNode_t* pDependencies, size_t numDependencies,

8630 const hipHostNodeParams* pNodeParams);

8631

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

8641

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

8651

8661hipError_t hipGraphExecHostNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8662 const hipHostNodeParams* pNodeParams);

8663

8675hipError_t hipGraphAddChildGraphNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8676 const hipGraphNode_t* pDependencies, size_t numDependencies,

8677 hipGraph_t childGraph);

8678

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

8688

8698hipError_t hipGraphExecChildGraphNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

8699 hipGraph_t childGraph);

8700

8711hipError_t hipGraphAddEmptyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8712 const hipGraphNode_t* pDependencies, size_t numDependencies);

8713

8714

8726hipError_t hipGraphAddEventRecordNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8727 const hipGraphNode_t* pDependencies, size_t numDependencies,

8728 hipEvent_t event);

8729

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

8739

8748hipError_t hipGraphEventRecordNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

8749

8759hipError_t hipGraphExecEventRecordNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8760 hipEvent_t event);

8761

8773hipError_t hipGraphAddEventWaitNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8774 const hipGraphNode_t* pDependencies, size_t numDependencies,

8775 hipEvent_t event);

8776

8777

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

8787

8796hipError_t hipGraphEventWaitNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

8797

8807hipError_t hipGraphExecEventWaitNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8808 hipEvent_t event);

8809

8822hipError_t hipGraphAddMemAllocNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8823 const hipGraphNode_t* pDependencies, size_t numDependencies,

8824 hipMemAllocNodeParams* pNodeParams);

8825

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

8835

8847hipError_t hipGraphAddMemFreeNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8848 const hipGraphNode_t* pDependencies, size_t numDependencies,

8849 void* dev_ptr);

8850

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

8860

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

8871

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

8882

8890hipError_t hipDeviceGraphMemTrim(int device);

8891

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

8904 unsigned int initialRefcount, unsigned int flags);

8905

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

8915

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

8925

8936hipError_t hipGraphRetainUserObject(hipGraph_t graph, hipUserObject_t object,

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

8938

8948hipError_t hipGraphReleaseUserObject(hipGraph_t graph, hipUserObject_t object,

8949 unsigned int count __dparm(1));

8950

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

8961

8975hipError_t hipGraphKernelNodeCopyAttributes(hipGraphNode_t hSrc, hipGraphNode_t hDst);

8976

8998hipError_t hipGraphNodeSetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8999 unsigned int isEnabled);

9019hipError_t hipGraphNodeGetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9020 unsigned int* isEnabled);

9021

9033hipError_t hipGraphAddExternalSemaphoresWaitNode(

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

9035 size_t numDependencies, const hipExternalSemaphoreWaitNodeParams* nodeParams);

9036

9048hipError_t hipGraphAddExternalSemaphoresSignalNode(

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

9050 size_t numDependencies, const hipExternalSemaphoreSignalNodeParams* nodeParams);

9059hipError_t hipGraphExternalSemaphoresSignalNodeSetParams(

9060 hipGraphNode_t hNode, const hipExternalSemaphoreSignalNodeParams* nodeParams);

9069hipError_t hipGraphExternalSemaphoresWaitNodeSetParams(

9070 hipGraphNode_t hNode, const hipExternalSemaphoreWaitNodeParams* nodeParams);

9079hipError_t hipGraphExternalSemaphoresSignalNodeGetParams(

9080 hipGraphNode_t hNode, hipExternalSemaphoreSignalNodeParams* params_out);

9089hipError_t hipGraphExternalSemaphoresWaitNodeGetParams(

9090 hipGraphNode_t hNode, hipExternalSemaphoreWaitNodeParams* params_out);

9100hipError_t hipGraphExecExternalSemaphoresSignalNodeSetParams(

9101 hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9102 const hipExternalSemaphoreSignalNodeParams* nodeParams);

9112hipError_t hipGraphExecExternalSemaphoresWaitNodeSetParams(

9113 hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9114 const hipExternalSemaphoreWaitNodeParams* nodeParams);

9115

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

9125

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

9135

9148hipError_t hipDrvGraphAddMemsetNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

9149 const hipGraphNode_t* dependencies, size_t numDependencies,

9150 const hipMemsetParams* memsetParams, hipCtx_t ctx);

9151

9163hipError_t hipDrvGraphAddMemFreeNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

9164 const hipGraphNode_t* dependencies, size_t numDependencies,

9165 hipDeviceptr_t dptr);

9166

9177hipError_t hipDrvGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9178 const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);

9179

9190hipError_t hipDrvGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

9191 const hipMemsetParams* memsetParams, hipCtx_t ctx);

9192

9193// doxygen end graph API

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

9225

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

9241 unsigned long long flags);

9242

9256hipError_t hipMemCreate(hipMemGenericAllocationHandle_t* handle, size_t size,

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

9258

9272hipError_t hipMemExportToShareableHandle(void* shareableHandle,

9273 hipMemGenericAllocationHandle_t handle,

9274 hipMemAllocationHandleType handleType,

9275 unsigned long long flags);

9276

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

9290

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

9305 hipMemAllocationGranularity_flags option);

9306

9318hipError_t hipMemGetAllocationPropertiesFromHandle(hipMemAllocationProp* prop,

9319 hipMemGenericAllocationHandle_t handle);

9320

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

9334 hipMemAllocationHandleType shHandleType);

9335

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

9351 unsigned long long flags);

9352

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

9364 hipStream_t stream);

9365

9377hipError_t hipMemRelease(hipMemGenericAllocationHandle_t handle);

9378

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

9391

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

9407

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

9420

9421// doxygen end virtual memory management API

9443hipError_t hipGraphicsMapResources(int count, hipGraphicsResource_t* resources,

9444 hipStream_t stream __dparm(0));

9458hipError_t hipGraphicsSubResourceGetMappedArray(hipArray_t* array, hipGraphicsResource_t resource,

9459 unsigned int arrayIndex, unsigned int mipLevel);

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

9471 hipGraphicsResource_t resource);

9482hipError_t hipGraphicsUnmapResources(int count, hipGraphicsResource_t* resources,

9483 hipStream_t stream __dparm(0));

9492hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource);

9493// doxygen end GraphicsInterop

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

9527hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject);

9528// end of surface

9532#ifdef __cplusplus

9533} /* extern "c" */

9534#endif

9535#ifdef __cplusplus

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

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

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

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

9540 dynSharedMemPerBlk, blockSizeLimit);

9541}

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

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

9544 unsigned int flags = 0) {

9545 (void)flags;

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

9547 dynSharedMemPerBlk, blockSizeLimit);

9548}

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

9550

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

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

9562}

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

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

9575}

9576

9585template <typename T>

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

9587 size_t offset __dparm(0),

9588 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice)) {

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

9590}

9599template <typename T>

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

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

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

9603}

9611template <typename T>

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

9613 size_t offset __dparm(0),

9614 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost)) {

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

9616}

9624template <typename T>

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

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

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

9628}

9629

9641template <class T>

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

9643 size_t dynSharedMemPerBlk) {

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

9645 blockSize, dynSharedMemPerBlk);

9646}

9660template <class T> inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

9662 return hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

9664}

9687template <typename UnaryFunction, class T>

9688static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(

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

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

9691 if (min_grid_size == nullptr || block_size == nullptr ||

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

9693 return hipErrorInvalidValue;

9694 }

9695

9696 int dev;

9697 hipError_t status;

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

9699 return status;

9700 }

9701

9702 int max_threads_per_cu;

9703 if ((status = hipDeviceGetAttribute(&max_threads_per_cu,

9704 hipDeviceAttributeMaxThreadsPerMultiProcessor, dev)) !=

9705 hipSuccess) {

9706 return status;

9707 }

9708

9709 int warp_size;

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

9711 return status;

9712 }

9713

9714 int max_cu_count;

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

9716 hipSuccess) {

9717 return status;

9718 }

9719

9720 struct hipFuncAttributes attr;

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

9722 return status;

9723 }

9724

9725 // Initial limits for the execution

9726 const int func_max_threads_per_block = attr.maxThreadsPerBlock;

9727 if (block_size_limit == 0) {

9728 block_size_limit = func_max_threads_per_block;

9729 }

9730

9731 if (func_max_threads_per_block < block_size_limit) {

9732 block_size_limit = func_max_threads_per_block;

9733 }

9734

9735 const int block_size_limit_aligned =

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

9737

9738 // For maximum search

9739 int max_threads = 0;

9740 int max_block_size{};

9741 int max_num_blocks{};

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

9743 block_size_check_aligned -= warp_size) {

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

9745 int block_size_check =

9746 (block_size_limit < block_size_check_aligned) ? block_size_limit : block_size_check_aligned;

9747

9748 size_t dyn_smem_size = block_size_to_dynamic_smem_size(block_size_check);

9749 int optimal_blocks;

9750 if ((status = hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

9752 return status;

9753 }

9754

9755 int total_threads = block_size_check * optimal_blocks;

9756 if (total_threads > max_threads) {

9757 max_block_size = block_size_check;

9758 max_num_blocks = optimal_blocks;

9759 max_threads = total_threads;

9760 }

9761

9762 // Break if the logic reached possible maximum

9763 if (max_threads_per_cu == max_threads) {

9764 break;

9765 }

9766 }

9767

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

9769 *min_grid_size = max_num_blocks * max_cu_count;

9770 *block_size = max_block_size;

9771

9772 return status;

9773}

9774

9796template <typename UnaryFunction, class T>

9797static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMem(

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

9799 int block_size_limit = 0) {

9800 return hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(

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

9802}

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

9819 int* blockSize, F kernel,

9820 size_t dynSharedMemPerBlk,

9821 uint32_t blockSizeLimit) {

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

9823 dynSharedMemPerBlk, blockSizeLimit);

9824}

9846template <class T>

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

9848 unsigned int sharedMemBytes, hipStream_t stream) {

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

9850 kernelParams, sharedMemBytes, stream);

9851}

9867template <class T>

9868inline hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

9869 unsigned int numDevices,

9870 unsigned int flags = 0) {

9871 return hipLaunchCooperativeKernelMultiDevice(launchParamsList, numDevices, flags);

9872}

9885template <class T>

9886inline hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

9887 unsigned int numDevices,

9888 unsigned int flags = 0) {

9889 return hipExtLaunchMultiKernelMultiDevice(launchParamsList, numDevices, flags);

9890}

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

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

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

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

9908}

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

9924static inline hipError_t

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

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

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

9928}

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

9945static inline hipError_t

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

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

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

9949}

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

9967static inline hipError_t

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

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

9970 size_t height, size_t pitch) {

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

9972}

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

9985static inline hipError_t

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

9987 struct hipChannelFormatDesc desc;

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

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

9990}

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

10004static inline hipError_t

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

10006 const struct hipChannelFormatDesc& desc) {

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

10008}

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

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

10022 hipMipmappedArray_const_t mipmappedArray) {

10023 struct hipChannelFormatDesc desc;

10024 hipArray_t levelArray;

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

10026 if (err != hipSuccess) {

10027 return err;

10028 }

10029 err = hipGetChannelDesc(&desc, levelArray);

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

10031}

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

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

10046 hipMipmappedArray_const_t mipmappedArray,

10047 const struct hipChannelFormatDesc& desc) {

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

10049}

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

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

10062 return hipUnbindTexture(&tex);

10063}

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

10088 hipStream_t stream) {

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

10090}

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

10102 hipMemPool_t mem_pool,

10103 hipStream_t stream) {

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

10105}

10116template <class T>

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

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

10119}

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

10131 hipMemPool_t mem_pool,

10132 hipStream_t stream) {

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

10134}

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

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

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

10151 Params&&... args) {

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

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

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

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

10156}

10162#endif // __cplusplus

10163

10164#ifdef __GNUC__

10165#pragma GCC visibility pop

10166#endif

10167

10168

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

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

10171#else

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

10173#endif

10174

10175

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

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

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

10190}

10202template <class T>

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

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

10205}

10218template <class T>

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

10220 unsigned int flags = hipHostMallocDefault) {

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

10222}

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

10236 unsigned int flags = hipHostAllocDefault) {

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

10238}

10253template <class T>

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

10255 unsigned int flags = hipMemAttachGlobal) {

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

10257}

10258

10259

10260#endif

10261#endif

10262// doxygen end HIP API

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

10267

10268#if USE_PROF_API

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

10270#endif

driver_types.h

err

hipError_t err

Definition hip_runtime_api.h:9988

tex

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

Definition hip_runtime_api.h:9905

size

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

Definition hip_runtime_api.h:9906

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

levelArray

hipArray_t levelArray

Definition hip_runtime_api.h:10024

dim

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

Definition hip_runtime_api.h:9923

mipmappedArray

readMode hipMipmappedArray_const_t mipmappedArray

Definition hip_runtime_api.h:10022

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

devPtr

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

Definition hip_runtime_api.h:9906

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

array

readMode hipArray_const_t array

Definition hip_runtime_api.h:9986

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

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

hipPointer_attribute

hipPointer_attribute

Definition driver_types.h:634

hipArray_t

struct hipArray * hipArray_t

Definition driver_types.h:75

hipDeviceptr_t

void * hipDeviceptr_t

Definition driver_types.h:46

hipFunction_attribute

hipFunction_attribute

Definition driver_types.h:613

hipArray_const_t

const struct hipArray * hipArray_const_t

Definition driver_types.h:76

hipArray_Format

hipArray_Format

Definition driver_types.h:80

hipResourceType

hipResourceType

Definition driver_types.h:159

hipMemcpyDeviceToHost

@ hipMemcpyDeviceToHost

Device-to-Host Copy.

Definition driver_types.h:376

hipMemcpyHostToDevice

@ hipMemcpyHostToDevice

Host-to-Device Copy.

Definition driver_types.h:375

hipGetErrorString

const char * hipGetErrorString(hipError_t hipError)

Return handy text string message to explain the error which occurred.

hipPeekAtLastError

hipError_t hipPeekAtLastError(void)

Return last error returned by any HIP runtime API call.

hipDrvGetErrorString

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

Return handy text string message to explain the error which occurred.

hipGetLastError

hipError_t hipGetLastError(void)

Return last error returned by any HIP runtime API call and resets the stored error code to hipSuccess...

hipExtGetLastError

hipError_t hipExtGetLastError(void)

Return last error returned by any HIP runtime API call and resets the stored error code to hipSuccess...

hipDrvGetErrorName

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

Return hip error as text string form.

hipGetErrorName

const char * hipGetErrorName(hipError_t hip_error)

Return hip error as text string form.

hipEventSynchronize

hipError_t hipEventSynchronize(hipEvent_t event)

Wait for an event to complete.

hipEventQuery

hipError_t hipEventQuery(hipEvent_t event)

Query event status.

hipEventCreate

hipError_t hipEventCreate(hipEvent_t *event)

hipEventDestroy

hipError_t hipEventDestroy(hipEvent_t event)

Destroy the specified event.

hipEventRecordWithFlags

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

Record an event in the specified stream.

hipEventRecord

hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream=NULL)

Record an event in the specified stream.

hipEventElapsedTime

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

Return the elapsed time between two events.

hipEventCreateWithFlags

hipError_t hipEventCreateWithFlags(hipEvent_t *event, unsigned flags)

Create an event with the specified flags.

hipFuncGetAttributes

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

Find out attributes for a given function.

hipLaunchKernelExC

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

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

hipExtLaunchMultiKernelMultiDevice

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

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

hipModuleLaunchKernel

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

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

hipFuncSetSharedMemConfig

hipError_t hipFuncSetSharedMemConfig(const void *func, hipSharedMemConfig config)

Set shared memory configuation for a specific function.

hipFuncGetAttribute

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

Find out a specific attribute for a given function.

hipFuncSetAttribute

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

Set attribute for a specific function.

hipDrvLaunchKernelEx

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

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

hipFuncSetCacheConfig

hipError_t hipFuncSetCacheConfig(const void *func, hipFuncCache_t config)

Set Cache configuration for a specific function.

hipDestroyExternalMemory

hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem)

Destroys an external memory object.

hipImportExternalSemaphore

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

Imports an external semaphore.

hipImportExternalMemory

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

Imports an external memory object.

hipDestroyExternalSemaphore

hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem)

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

hipWaitExternalSemaphoresAsync

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

Waits on a set of external semaphore objects.

hipSignalExternalSemaphoresAsync

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

Signals a set of external semaphore objects.

hipExternalMemoryGetMappedMipmappedArray

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

Maps a mipmapped array onto an external memory object.

hipExternalMemoryGetMappedBuffer

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

Maps a buffer onto an imported memory object.

hipLimit_t

hipLimit_t

Definition hip_runtime_api.h:722

hipMemRangeHandleType

hipMemRangeHandleType

Definition hip_runtime_api.h:2005

hipMemAllocationHandleType

hipMemAllocationHandleType

Definition hip_runtime_api.h:1219

hipGraphicsResource_t

hipGraphicsResource * hipGraphicsResource_t

Definition hip_runtime_api.h:1442

hipCtx_t

struct ihipCtx_t * hipCtx_t

Definition hip_runtime_api.h:669

__dparm

#define __dparm(x)

Definition hip_runtime_api.h:651

hipStream_t

struct ihipStream_t * hipStream_t

Definition hip_runtime_api.h:683

hipGraphInstantiateResult

hipGraphInstantiateResult

Definition hip_runtime_api.h:1719

hipDevice_t

int hipDevice_t

Definition hip_runtime_api.h:671

hipAccessProperty

hipAccessProperty

Definition hip_runtime_api.h:1520

hipLinkState_t

struct ihipLinkState_t * hipLinkState_t

Definition hip_runtime_api.h:694

hipGraphDependencyType

hipGraphDependencyType

Definition hip_runtime_api.h:1941

hipMemRangeAttribute

hipMemRangeAttribute

Definition hip_runtime_api.h:1113

hipMemAttachSingle

#define hipMemAttachSingle

Definition hip_runtime_api.h:875

hipMemoryAdvise

hipMemoryAdvise

Definition hip_runtime_api.h:1080

hipArrayDefault

#define hipArrayDefault

Definition hip_runtime_api.h:934

hipSharedMemConfig

hipSharedMemConfig

Definition hip_runtime_api.h:1271

hipKernelNodeAttrValue

#define hipKernelNodeAttrValue

Definition hip_runtime_api.h:1622

hipComputeMode

hipComputeMode

Definition hip_runtime_api.h:611

hipEvent_t

struct ihipEvent_t * hipEvent_t

Definition hip_runtime_api.h:714

hipStreamCaptureMode

hipStreamCaptureMode

Definition hip_runtime_api.h:1651

hipStreamBatchMemOpType

hipStreamBatchMemOpType

Definition hip_runtime_api.h:955

hipDriverProcAddressQueryResult

hipDriverProcAddressQueryResult

Definition hip_runtime_api.h:605

HIP_DEPRECATED_MSG

#define HIP_DEPRECATED_MSG

Definition hip_runtime_api.h:643

hipLaunchAttributeID

hipLaunchAttributeID

Definition hip_runtime_api.h:1568

hipKernel_t

struct ihipKernel_t * hipKernel_t

Definition hip_runtime_api.h:696

hipSynchronizationPolicy

hipSynchronizationPolicy

Definition hip_runtime_api.h:1558

hipGraphNodeType

hipGraphNodeType

Definition hip_runtime_api.h:1466

hipExternalMemoryHandleType

hipExternalMemoryHandleType

Definition hip_runtime_api.h:1316

hipMemAttachGlobal

#define hipMemAttachGlobal

Definition hip_runtime_api.h:869

hipLibrary_t

struct ihipLibrary_t * hipLibrary_t

Definition hip_runtime_api.h:695

hipFuncAttribute

hipFuncAttribute

Definition hip_runtime_api.h:1252

hipExternalSemaphoreHandleType

hipExternalSemaphoreHandleType

Definition hip_runtime_api.h:1354

hipLaunchMemSyncDomain

hipLaunchMemSyncDomain

Definition hip_runtime_api.h:1549

hipDeviceP2PAttr

hipDeviceP2PAttr

Definition hip_runtime_api.h:672

hipGraphDebugDotFlags

hipGraphDebugDotFlags

Definition hip_runtime_api.h:1697

hipUserObjectRetainFlags

hipUserObjectRetainFlags

Definition hip_runtime_api.h:1682

hipStreamAttrID

#define hipStreamAttrID

Definition hip_runtime_api.h:1602

hipError_t

enum __HIP_NODISCARD hipError_t hipError_t

Definition hip_runtime_api.h:305

hipHostAllocDefault

#define hipHostAllocDefault

Definition hip_runtime_api.h:811

hipHostFn_t

void(* hipHostFn_t)(void *userData)

Definition hip_runtime_api.h:1485

hipOccupancyDefault

#define hipOccupancyDefault

Definition hip_runtime_api.h:939

hipStreamUpdateCaptureDependenciesFlags

hipStreamUpdateCaptureDependenciesFlags

Definition hip_runtime_api.h:1663

hipGraph_t

struct ihipGraph * hipGraph_t

Definition hip_runtime_api.h:1447

hipChooseDevice

#define hipChooseDevice

Definition hip_runtime_api.h:105

hipMemHandleType

hipMemHandleType

Definition hip_runtime_api.h:1801

hipFlushGPUDirectRDMAWritesOptions

hipFlushGPUDirectRDMAWritesOptions

Definition hip_runtime_api.h:618

hipFuncCache_t

hipFuncCache_t

Definition hip_runtime_api.h:1262

hipUserObjectFlags

hipUserObjectFlags

Definition hip_runtime_api.h:1678

__HIP_NODISCARD

#define __HIP_NODISCARD

Definition hip_runtime_api.h:295

hipGraphMemAttributeType

hipGraphMemAttributeType

Definition hip_runtime_api.h:1668

hipMemPoolAttr

hipMemPoolAttr

Definition hip_runtime_api.h:1128

hipDriverEntryPointQueryResult

hipDriverEntryPointQueryResult

Definition hip_runtime_api.h:678

hipMemRangeFlags

hipMemRangeFlags

Definition hip_runtime_api.h:2013

hipDeviceProp_t

#define hipDeviceProp_t

Definition hip_runtime_api.h:104

hipModule_t

struct ihipModule_t * hipModule_t

Definition hip_runtime_api.h:692

hipUserObject_t

struct hipUserObject * hipUserObject_t

Definition hip_runtime_api.h:1460

hipMemOperationType

hipMemOperationType

Definition hip_runtime_api.h:1808

hipExternalSemaphore_t

void * hipExternalSemaphore_t

Definition hip_runtime_api.h:1379

hipGraphicsRegisterFlags

hipGraphicsRegisterFlags

Definition hip_runtime_api.h:1430

hipStreamAttrValue

#define hipStreamAttrValue

Definition hip_runtime_api.h:1609

hipMemRangeCoherencyMode

hipMemRangeCoherencyMode

Definition hip_runtime_api.h:1101

hipMemAccessFlags

hipMemAccessFlags

Definition hip_runtime_api.h:1188

hipMemAllocationGranularity_flags

hipMemAllocationGranularity_flags

Definition hip_runtime_api.h:1793

hipGraphExec_t

struct hipGraphExec * hipGraphExec_t

Definition hip_runtime_api.h:1455

hipGraphExecUpdateResult

hipGraphExecUpdateResult

Definition hip_runtime_api.h:1636

hipFunction_t

struct ihipModuleSymbol_t * hipFunction_t

Definition hip_runtime_api.h:693

hipKernelNodeAttrID

#define hipKernelNodeAttrID

Definition hip_runtime_api.h:1614

hipExternalMemory_t

void * hipExternalMemory_t

Definition hip_runtime_api.h:1353

hipStreamCaptureStatus

hipStreamCaptureStatus

Definition hip_runtime_api.h:1656

hipDeviceAttribute_t

hipDeviceAttribute_t

Definition hip_runtime_api.h:427

hipGPUDirectRDMAWritesOrdering

hipGPUDirectRDMAWritesOrdering

Definition hip_runtime_api.h:623

hipGetDeviceProperties

#define hipGetDeviceProperties

Definition hip_runtime_api.h:103

hipHostMallocDefault

#define hipHostMallocDefault

Definition hip_runtime_api.h:815

HIP_DEPRECATED

#define HIP_DEPRECATED(msg)

Definition hip_runtime_api.h:641

hipGraphicsResource

struct _hipGraphicsResource hipGraphicsResource

Definition hip_runtime_api.h:1440

hipMemAllocationType

hipMemAllocationType

Definition hip_runtime_api.h:1206

hipGraphNode_t

struct hipGraphNode * hipGraphNode_t

Definition hip_runtime_api.h:1451

hipMemGenericAllocationHandle_t

struct ihipMemGenericAllocationHandle * hipMemGenericAllocationHandle_t

Definition hip_runtime_api.h:1788

hipMemoryType

hipMemoryType

Definition hip_runtime_api.h:263

hipGraphInstantiateFlags

hipGraphInstantiateFlags

Definition hip_runtime_api.h:1686

HIP_IPC_HANDLE_SIZE

#define HIP_IPC_HANDLE_SIZE

Definition hip_runtime_api.h:685

hipMemPool_t

struct ihipMemPoolHandle_t * hipMemPool_t

Definition hip_runtime_api.h:700

hipArraySparseSubresourceType

hipArraySparseSubresourceType

Definition hip_runtime_api.h:1816

hipExtLimitScratchMin

@ hipExtLimitScratchMin

Definition hip_runtime_api.h:730

hipLimitMallocHeapSize

@ hipLimitMallocHeapSize

Definition hip_runtime_api.h:728

hipLimitStackSize

@ hipLimitStackSize

Definition hip_runtime_api.h:723

hipLimitRange

@ hipLimitRange

Supported limit range.

Definition hip_runtime_api.h:738

hipLimitPrintfFifoSize

@ hipLimitPrintfFifoSize

Definition hip_runtime_api.h:726

hipExtLimitScratchMax

@ hipExtLimitScratchMax

Definition hip_runtime_api.h:732

hipExtLimitScratchCurrent

@ hipExtLimitScratchCurrent

Definition hip_runtime_api.h:734

hipMemRangeHandleTypeMax

@ hipMemRangeHandleTypeMax

Definition hip_runtime_api.h:2007

hipMemRangeHandleTypeDmaBufFd

@ hipMemRangeHandleTypeDmaBufFd

Definition hip_runtime_api.h:2006

hipMemHandleTypeWin32

@ hipMemHandleTypeWin32

Allows a Win32 NT handle for exporting. (HANDLE)

Definition hip_runtime_api.h:1223

hipMemHandleTypeWin32Kmt

@ hipMemHandleTypeWin32Kmt

Allows a Win32 KMT handle for exporting. (D3DKMT_HANDLE)

Definition hip_runtime_api.h:1224

hipMemHandleTypeNone

@ hipMemHandleTypeNone

Does not allow any export mechanism.

Definition hip_runtime_api.h:1220

hipMemHandleTypePosixFileDescriptor

@ hipMemHandleTypePosixFileDescriptor

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

Definition hip_runtime_api.h:1221

hipGraphInstantiateNodeOperationNotSupported

@ hipGraphInstantiateNodeOperationNotSupported

Definition hip_runtime_api.h:1725

hipGraphInstantiateMultipleDevicesNotSupported

@ hipGraphInstantiateMultipleDevicesNotSupported

Definition hip_runtime_api.h:1727

hipGraphInstantiateError

@ hipGraphInstantiateError

Definition hip_runtime_api.h:1721

hipGraphInstantiateInvalidStructure

@ hipGraphInstantiateInvalidStructure

Definition hip_runtime_api.h:1723

hipGraphInstantiateSuccess

@ hipGraphInstantiateSuccess

Definition hip_runtime_api.h:1720

hipAccessPropertyNormal

@ hipAccessPropertyNormal

Normal cache persistence.

Definition hip_runtime_api.h:1521

hipAccessPropertyPersisting

@ hipAccessPropertyPersisting

Persisting access is more likely to persist in cache.

Definition hip_runtime_api.h:1523

hipAccessPropertyStreaming

@ hipAccessPropertyStreaming

Streaming access is less likely to persist from cache.

Definition hip_runtime_api.h:1522

hipGraphDependencyTypeDefault

@ hipGraphDependencyTypeDefault

Definition hip_runtime_api.h:1942

hipGraphDependencyTypeProgrammatic

@ hipGraphDependencyTypeProgrammatic

Definition hip_runtime_api.h:1943

hipMemRangeAttributeLastPrefetchLocation

@ hipMemRangeAttributeLastPrefetchLocation

Definition hip_runtime_api.h:1119

hipMemRangeAttributePreferredLocation

@ hipMemRangeAttributePreferredLocation

The preferred location of the range.

Definition hip_runtime_api.h:1116

hipMemRangeAttributeAccessedBy

@ hipMemRangeAttributeAccessedBy

Definition hip_runtime_api.h:1117

hipMemRangeAttributeReadMostly

@ hipMemRangeAttributeReadMostly

Definition hip_runtime_api.h:1114

hipMemRangeAttributeCoherencyMode

@ hipMemRangeAttributeCoherencyMode

Definition hip_runtime_api.h:1121

hipMemAdviseUnsetAccessedBy

@ hipMemAdviseUnsetAccessedBy

Definition hip_runtime_api.h:1089

hipMemAdviseUnsetCoarseGrain

@ hipMemAdviseUnsetCoarseGrain

Restores cache coherency policy back to fine-grain.

Definition hip_runtime_api.h:1096

hipMemAdviseSetCoarseGrain

@ hipMemAdviseSetCoarseGrain

Definition hip_runtime_api.h:1091

hipMemAdviseUnsetPreferredLocation

@ hipMemAdviseUnsetPreferredLocation

Clear the preferred location for the data.

Definition hip_runtime_api.h:1086

hipMemAdviseSetAccessedBy

@ hipMemAdviseSetAccessedBy

Definition hip_runtime_api.h:1087

hipMemAdviseSetPreferredLocation

@ hipMemAdviseSetPreferredLocation

Definition hip_runtime_api.h:1084

hipMemAdviseSetReadMostly

@ hipMemAdviseSetReadMostly

Definition hip_runtime_api.h:1081

hipMemAdviseUnsetReadMostly

@ hipMemAdviseUnsetReadMostly

Undo the effect of hipMemAdviseSetReadMostly.

Definition hip_runtime_api.h:1083

hipSharedMemBankSizeFourByte

@ hipSharedMemBankSizeFourByte

Definition hip_runtime_api.h:1273

hipSharedMemBankSizeEightByte

@ hipSharedMemBankSizeEightByte

Definition hip_runtime_api.h:1275

hipSharedMemBankSizeDefault

@ hipSharedMemBankSizeDefault

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

Definition hip_runtime_api.h:1272

hipComputeModeProhibited

@ hipComputeModeProhibited

Definition hip_runtime_api.h:614

hipComputeModeExclusive

@ hipComputeModeExclusive

Definition hip_runtime_api.h:613

hipComputeModeDefault

@ hipComputeModeDefault

Definition hip_runtime_api.h:612

hipComputeModeExclusiveProcess

@ hipComputeModeExclusiveProcess

Definition hip_runtime_api.h:615

hipStreamCaptureModeRelaxed

@ hipStreamCaptureModeRelaxed

Definition hip_runtime_api.h:1654

hipStreamCaptureModeThreadLocal

@ hipStreamCaptureModeThreadLocal

Definition hip_runtime_api.h:1653

hipStreamCaptureModeGlobal

@ hipStreamCaptureModeGlobal

Definition hip_runtime_api.h:1652

hipStreamMemOpWriteValue64

@ hipStreamMemOpWriteValue64

Definition hip_runtime_api.h:959

hipStreamMemOpBarrier

@ hipStreamMemOpBarrier

Currently not supported.

Definition hip_runtime_api.h:960

hipStreamMemOpWriteValue32

@ hipStreamMemOpWriteValue32

Definition hip_runtime_api.h:957

hipStreamMemOpWaitValue32

@ hipStreamMemOpWaitValue32

Definition hip_runtime_api.h:956

hipStreamMemOpWaitValue64

@ hipStreamMemOpWaitValue64

Definition hip_runtime_api.h:958

hipStreamMemOpFlushRemoteWrites

@ hipStreamMemOpFlushRemoteWrites

Currently not supported.

Definition hip_runtime_api.h:961

HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND

@ HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND

Definition hip_runtime_api.h:607

HIP_GET_PROC_ADDRESS_SUCCESS

@ HIP_GET_PROC_ADDRESS_SUCCESS

Definition hip_runtime_api.h:606

HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT

@ HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT

Definition hip_runtime_api.h:608

hipLaunchAttributePriority

@ hipLaunchAttributePriority

Valid for graph node, streams, launches.

Definition hip_runtime_api.h:1572

hipLaunchAttributeMax

@ hipLaunchAttributeMax

Definition hip_runtime_api.h:1575

hipLaunchAttributeMemSyncDomain

@ hipLaunchAttributeMemSyncDomain

Valid for streams, graph nodes, launches.

Definition hip_runtime_api.h:1574

hipLaunchAttributeMemSyncDomainMap

@ hipLaunchAttributeMemSyncDomainMap

Valid for streams, graph nodes, launches.

Definition hip_runtime_api.h:1573

hipLaunchAttributeSynchronizationPolicy

@ hipLaunchAttributeSynchronizationPolicy

Valid for streams.

Definition hip_runtime_api.h:1571

hipLaunchAttributeAccessPolicyWindow

@ hipLaunchAttributeAccessPolicyWindow

Valid for Streams, graph nodes, launches.

Definition hip_runtime_api.h:1569

hipLaunchAttributeCooperative

@ hipLaunchAttributeCooperative

Valid for graph nodes, launches.

Definition hip_runtime_api.h:1570

hipSyncPolicyYield

@ hipSyncPolicyYield

Definition hip_runtime_api.h:1561

hipSyncPolicyBlockingSync

@ hipSyncPolicyBlockingSync

Definition hip_runtime_api.h:1562

hipSyncPolicyAuto

@ hipSyncPolicyAuto

Definition hip_runtime_api.h:1559

hipSyncPolicySpin

@ hipSyncPolicySpin

Definition hip_runtime_api.h:1560

hipGraphNodeTypeBatchMemOp

@ hipGraphNodeTypeBatchMemOp

BatchMemOp node.

Definition hip_runtime_api.h:1481

hipGraphNodeTypeGraph

@ hipGraphNodeTypeGraph

Node which executes an embedded graph.

Definition hip_runtime_api.h:1471

hipGraphNodeTypeMemset

@ hipGraphNodeTypeMemset

Memset node.

Definition hip_runtime_api.h:1469

hipGraphNodeTypeEventRecord

@ hipGraphNodeTypeEventRecord

External event record node.

Definition hip_runtime_api.h:1474

hipGraphNodeTypeExtSemaphoreSignal

@ hipGraphNodeTypeExtSemaphoreSignal

External Semaphore signal node.

Definition hip_runtime_api.h:1475

hipGraphNodeTypeMemcpy

@ hipGraphNodeTypeMemcpy

Memcpy node.

Definition hip_runtime_api.h:1468

hipGraphNodeTypeWaitEvent

@ hipGraphNodeTypeWaitEvent

External event wait node.

Definition hip_runtime_api.h:1473

hipGraphNodeTypeCount

@ hipGraphNodeTypeCount

Definition hip_runtime_api.h:1482

hipGraphNodeTypeKernel

@ hipGraphNodeTypeKernel

GPU kernel node.

Definition hip_runtime_api.h:1467

hipGraphNodeTypeHost

@ hipGraphNodeTypeHost

Host (executable) node.

Definition hip_runtime_api.h:1470

hipGraphNodeTypeMemAlloc

@ hipGraphNodeTypeMemAlloc

Memory alloc node.

Definition hip_runtime_api.h:1477

hipGraphNodeTypeMemFree

@ hipGraphNodeTypeMemFree

Memory free node.

Definition hip_runtime_api.h:1478

hipGraphNodeTypeMemcpyFromSymbol

@ hipGraphNodeTypeMemcpyFromSymbol

MemcpyFromSymbol node.

Definition hip_runtime_api.h:1479

hipGraphNodeTypeMemcpyToSymbol

@ hipGraphNodeTypeMemcpyToSymbol

MemcpyToSymbol node.

Definition hip_runtime_api.h:1480

hipGraphNodeTypeEmpty

@ hipGraphNodeTypeEmpty

Empty (no-op) node.

Definition hip_runtime_api.h:1472

hipGraphNodeTypeExtSemaphoreWait

@ hipGraphNodeTypeExtSemaphoreWait

External Semaphore wait node.

Definition hip_runtime_api.h:1476

hipExternalMemoryHandleTypeD3D11Resource

@ hipExternalMemoryHandleTypeD3D11Resource

Definition hip_runtime_api.h:1322

hipExternalMemoryHandleTypeD3D12Resource

@ hipExternalMemoryHandleTypeD3D12Resource

Definition hip_runtime_api.h:1321

hipExternalMemoryHandleTypeNvSciBuf

@ hipExternalMemoryHandleTypeNvSciBuf

Definition hip_runtime_api.h:1324

hipExternalMemoryHandleTypeOpaqueFd

@ hipExternalMemoryHandleTypeOpaqueFd

Definition hip_runtime_api.h:1317

hipExternalMemoryHandleTypeD3D12Heap

@ hipExternalMemoryHandleTypeD3D12Heap

Definition hip_runtime_api.h:1320

hipExternalMemoryHandleTypeOpaqueWin32Kmt

@ hipExternalMemoryHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:1319

hipExternalMemoryHandleTypeOpaqueWin32

@ hipExternalMemoryHandleTypeOpaqueWin32

Definition hip_runtime_api.h:1318

hipExternalMemoryHandleTypeD3D11ResourceKmt

@ hipExternalMemoryHandleTypeD3D11ResourceKmt

Definition hip_runtime_api.h:1323

hipFuncAttributePreferredSharedMemoryCarveout

@ hipFuncAttributePreferredSharedMemoryCarveout

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

Definition hip_runtime_api.h:1255

hipFuncAttributeMaxDynamicSharedMemorySize

@ hipFuncAttributeMaxDynamicSharedMemorySize

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

Definition hip_runtime_api.h:1253

hipFuncAttributeMax

@ hipFuncAttributeMax

Definition hip_runtime_api.h:1257

hipExternalSemaphoreHandleTypeNvSciSync

@ hipExternalSemaphoreHandleTypeNvSciSync

Definition hip_runtime_api.h:1360

hipExternalSemaphoreHandleTypeKeyedMutexKmt

@ hipExternalSemaphoreHandleTypeKeyedMutexKmt

Definition hip_runtime_api.h:1362

hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

@ hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:1357

hipExternalSemaphoreHandleTypeKeyedMutex

@ hipExternalSemaphoreHandleTypeKeyedMutex

Definition hip_runtime_api.h:1361

hipExternalSemaphoreHandleTypeD3D11Fence

@ hipExternalSemaphoreHandleTypeD3D11Fence

Definition hip_runtime_api.h:1359

hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

@ hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

Definition hip_runtime_api.h:1364

hipExternalSemaphoreHandleTypeOpaqueFd

@ hipExternalSemaphoreHandleTypeOpaqueFd

Definition hip_runtime_api.h:1355

hipExternalSemaphoreHandleTypeOpaqueWin32

@ hipExternalSemaphoreHandleTypeOpaqueWin32

Definition hip_runtime_api.h:1356

hipExternalSemaphoreHandleTypeTimelineSemaphoreFd

@ hipExternalSemaphoreHandleTypeTimelineSemaphoreFd

Definition hip_runtime_api.h:1363

hipExternalSemaphoreHandleTypeD3D12Fence

@ hipExternalSemaphoreHandleTypeD3D12Fence

Definition hip_runtime_api.h:1358

hipLaunchMemSyncDomainRemote

@ hipLaunchMemSyncDomainRemote

Definition hip_runtime_api.h:1551

hipLaunchMemSyncDomainDefault

@ hipLaunchMemSyncDomainDefault

Definition hip_runtime_api.h:1550

hipDevP2PAttrAccessSupported

@ hipDevP2PAttrAccessSupported

Definition hip_runtime_api.h:674

hipDevP2PAttrHipArrayAccessSupported

@ hipDevP2PAttrHipArrayAccessSupported

Definition hip_runtime_api.h:676

hipDevP2PAttrNativeAtomicSupported

@ hipDevP2PAttrNativeAtomicSupported

Definition hip_runtime_api.h:675

hipDevP2PAttrPerformanceRank

@ hipDevP2PAttrPerformanceRank

Definition hip_runtime_api.h:673

hipGraphDebugDotFlagsKernelNodeAttributes

@ hipGraphDebugDotFlagsKernelNodeAttributes

Definition hip_runtime_api.h:1710

hipGraphDebugDotFlagsMemsetNodeParams

@ hipGraphDebugDotFlagsMemsetNodeParams

Definition hip_runtime_api.h:1702

hipGraphDebugDotFlagsKernelNodeParams

@ hipGraphDebugDotFlagsKernelNodeParams

Definition hip_runtime_api.h:1700

hipGraphDebugDotFlagsExtSemasWaitNodeParams

@ hipGraphDebugDotFlagsExtSemasWaitNodeParams

Definition hip_runtime_api.h:1708

hipGraphDebugDotFlagsHandles

@ hipGraphDebugDotFlagsHandles

Definition hip_runtime_api.h:1712

hipGraphDebugDotFlagsExtSemasSignalNodeParams

@ hipGraphDebugDotFlagsExtSemasSignalNodeParams

Definition hip_runtime_api.h:1706

hipGraphDebugDotFlagsHostNodeParams

@ hipGraphDebugDotFlagsHostNodeParams

Definition hip_runtime_api.h:1703

hipGraphDebugDotFlagsEventNodeParams

@ hipGraphDebugDotFlagsEventNodeParams

Definition hip_runtime_api.h:1704

hipGraphDebugDotFlagsVerbose

@ hipGraphDebugDotFlagsVerbose

Definition hip_runtime_api.h:1698

hipGraphDebugDotFlagsMemcpyNodeParams

@ hipGraphDebugDotFlagsMemcpyNodeParams

Definition hip_runtime_api.h:1701

hipGraphUserObjectMove

@ hipGraphUserObjectMove

Add new reference or retain.

Definition hip_runtime_api.h:1683

hipStreamAddCaptureDependencies

@ hipStreamAddCaptureDependencies

Add new nodes to the dependency set.

Definition hip_runtime_api.h:1664

hipStreamSetCaptureDependencies

@ hipStreamSetCaptureDependencies

Replace the dependency set with the new nodes.

Definition hip_runtime_api.h:1665

hipMemHandleTypeGeneric

@ hipMemHandleTypeGeneric

Generic handle type.

Definition hip_runtime_api.h:1802

hipFlushGPUDirectRDMAWritesOptionHost

@ hipFlushGPUDirectRDMAWritesOptionHost

Definition hip_runtime_api.h:619

hipFlushGPUDirectRDMAWritesOptionMemOps

@ hipFlushGPUDirectRDMAWritesOptionMemOps

Definition hip_runtime_api.h:620

hipFuncCachePreferNone

@ hipFuncCachePreferNone

no preference for shared memory or L1 (default)

Definition hip_runtime_api.h:1263

hipFuncCachePreferEqual

@ hipFuncCachePreferEqual

prefer equal size L1 cache and shared memory

Definition hip_runtime_api.h:1266

hipFuncCachePreferL1

@ hipFuncCachePreferL1

prefer larger L1 cache and smaller shared memory

Definition hip_runtime_api.h:1265

hipFuncCachePreferShared

@ hipFuncCachePreferShared

prefer larger shared memory and smaller L1 cache

Definition hip_runtime_api.h:1264

hipUserObjectNoDestructorSync

@ hipUserObjectNoDestructorSync

Destructor execution is not synchronized.

Definition hip_runtime_api.h:1679

hipGraphMemAttrReservedMemHigh

@ hipGraphMemAttrReservedMemHigh

Definition hip_runtime_api.h:1675

hipGraphMemAttrUsedMemCurrent

@ hipGraphMemAttrUsedMemCurrent

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

Definition hip_runtime_api.h:1669

hipGraphMemAttrUsedMemHigh

@ hipGraphMemAttrUsedMemHigh

Definition hip_runtime_api.h:1671

hipGraphMemAttrReservedMemCurrent

@ hipGraphMemAttrReservedMemCurrent

Definition hip_runtime_api.h:1673

hipMemPoolAttrUsedMemCurrent

@ hipMemPoolAttrUsedMemCurrent

Definition hip_runtime_api.h:1175

hipMemPoolAttrReservedMemHigh

@ hipMemPoolAttrReservedMemHigh

Definition hip_runtime_api.h:1170

hipMemPoolAttrReservedMemCurrent

@ hipMemPoolAttrReservedMemCurrent

Definition hip_runtime_api.h:1164

hipMemPoolAttrReleaseThreshold

@ hipMemPoolAttrReleaseThreshold

Definition hip_runtime_api.h:1159

hipMemPoolAttrUsedMemHigh

@ hipMemPoolAttrUsedMemHigh

Definition hip_runtime_api.h:1181

hipMemPoolReuseAllowInternalDependencies

@ hipMemPoolReuseAllowInternalDependencies

Definition hip_runtime_api.h:1150

hipMemPoolReuseFollowEventDependencies

@ hipMemPoolReuseFollowEventDependencies

Definition hip_runtime_api.h:1137

hipMemPoolReuseAllowOpportunistic

@ hipMemPoolReuseAllowOpportunistic

Definition hip_runtime_api.h:1143

hipDriverEntryPointSuccess

@ hipDriverEntryPointSuccess

Definition hip_runtime_api.h:679

hipDriverEntryPointSymbolNotFound

@ hipDriverEntryPointSymbolNotFound

Definition hip_runtime_api.h:680

hipDriverEntryPointVersionNotSufficent

@ hipDriverEntryPointVersionNotSufficent

Definition hip_runtime_api.h:681

hipMemRangeFlagsMax

@ hipMemRangeFlagsMax

Definition hip_runtime_api.h:2015

hipMemRangeFlagDmaBufMappingTypePcie

@ hipMemRangeFlagDmaBufMappingTypePcie

Definition hip_runtime_api.h:2014

hipMemOperationTypeMap

@ hipMemOperationTypeMap

Map operation.

Definition hip_runtime_api.h:1809

hipMemOperationTypeUnmap

@ hipMemOperationTypeUnmap

Unmap operation.

Definition hip_runtime_api.h:1810

hipGraphicsRegisterFlagsReadOnly

@ hipGraphicsRegisterFlagsReadOnly

HIP will not write to this registered resource.

Definition hip_runtime_api.h:1432

hipGraphicsRegisterFlagsTextureGather

@ hipGraphicsRegisterFlagsTextureGather

HIP will perform texture gather operations on this registered resource.

Definition hip_runtime_api.h:1436

hipGraphicsRegisterFlagsWriteDiscard

@ hipGraphicsRegisterFlagsWriteDiscard

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

Definition hip_runtime_api.h:1433

hipGraphicsRegisterFlagsNone

@ hipGraphicsRegisterFlagsNone

Definition hip_runtime_api.h:1431

hipGraphicsRegisterFlagsSurfaceLoadStore

@ hipGraphicsRegisterFlagsSurfaceLoadStore

HIP will bind this resource to a surface.

Definition hip_runtime_api.h:1435

hipMemRangeCoherencyModeFineGrain

@ hipMemRangeCoherencyModeFineGrain

Definition hip_runtime_api.h:1102

hipMemRangeCoherencyModeIndeterminate

@ hipMemRangeCoherencyModeIndeterminate

Definition hip_runtime_api.h:1106

hipMemRangeCoherencyModeCoarseGrain

@ hipMemRangeCoherencyModeCoarseGrain

Definition hip_runtime_api.h:1104

hipMemAccessFlagsProtRead

@ hipMemAccessFlagsProtRead

Set the address range read accessible.

Definition hip_runtime_api.h:1190

hipMemAccessFlagsProtNone

@ hipMemAccessFlagsProtNone

Default, make the address range not accessible.

Definition hip_runtime_api.h:1189

hipMemAccessFlagsProtReadWrite

@ hipMemAccessFlagsProtReadWrite

Set the address range read-write accessible.

Definition hip_runtime_api.h:1191

hipMemAllocationGranularityMinimum

@ hipMemAllocationGranularityMinimum

Minimum granularity.

Definition hip_runtime_api.h:1794

hipMemAllocationGranularityRecommended

@ hipMemAllocationGranularityRecommended

Recommended granularity for performance.

Definition hip_runtime_api.h:1795

hipGraphExecUpdateErrorNotSupported

@ hipGraphExecUpdateErrorNotSupported

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

Definition hip_runtime_api.h:1646

hipGraphExecUpdateErrorNodeTypeChanged

@ hipGraphExecUpdateErrorNodeTypeChanged

The update failed because a node type changed.

Definition hip_runtime_api.h:1641

hipGraphExecUpdateErrorTopologyChanged

@ hipGraphExecUpdateErrorTopologyChanged

The update failed because the topology changed.

Definition hip_runtime_api.h:1640

hipGraphExecUpdateErrorUnsupportedFunctionChange

@ hipGraphExecUpdateErrorUnsupportedFunctionChange

Definition hip_runtime_api.h:1648

hipGraphExecUpdateError

@ hipGraphExecUpdateError

Definition hip_runtime_api.h:1638

hipGraphExecUpdateErrorFunctionChanged

@ hipGraphExecUpdateErrorFunctionChanged

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

Definition hip_runtime_api.h:1642

hipGraphExecUpdateSuccess

@ hipGraphExecUpdateSuccess

The update succeeded.

Definition hip_runtime_api.h:1637

hipGraphExecUpdateErrorParametersChanged

@ hipGraphExecUpdateErrorParametersChanged

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

Definition hip_runtime_api.h:1644

hipStreamCaptureStatusInvalidated

@ hipStreamCaptureStatusInvalidated

Definition hip_runtime_api.h:1659

hipStreamCaptureStatusNone

@ hipStreamCaptureStatusNone

Stream is not capturing.

Definition hip_runtime_api.h:1657

hipStreamCaptureStatusActive

@ hipStreamCaptureStatusActive

Stream is actively capturing.

Definition hip_runtime_api.h:1658

hipDeviceAttributeDirectManagedMemAccessFromHost

@ hipDeviceAttributeDirectManagedMemAccessFromHost

Definition hip_runtime_api.h:452

hipDeviceAttributeSurfaceAlignment

@ hipDeviceAttributeSurfaceAlignment

Alignment requirement for surfaces.

Definition hip_runtime_api.h:542

hipDeviceAttributeMaxGridDimX

@ hipDeviceAttributeMaxGridDimX

Max grid size in width.

Definition hip_runtime_api.h:473

hipDeviceAttributeMaxSurfaceCubemapLayered

@ hipDeviceAttributeMaxSurfaceCubemapLayered

Definition hip_runtime_api.h:482

hipDeviceAttributeMaxSurface3D

@ hipDeviceAttributeMaxSurface3D

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

Definition hip_runtime_api.h:480

hipDeviceAttributeMaxPitch

@ hipDeviceAttributeMaxPitch

Maximum pitch in bytes allowed by memory copies.

Definition hip_runtime_api.h:507

hipDeviceAttributeTccDriver

@ hipDeviceAttributeTccDriver

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

Definition hip_runtime_api.h:543

hipDeviceAttributeHostNativeAtomicSupported

@ hipDeviceAttributeHostNativeAtomicSupported

Definition hip_runtime_api.h:455

hipDeviceAttributePageableMemoryAccessUsesHostPageTables

@ hipDeviceAttributePageableMemoryAccessUsesHostPageTables

Definition hip_runtime_api.h:520

hipDeviceAttributeUnused5

@ hipDeviceAttributeUnused5

Previously hipDeviceAttributeGcnArchName.

Definition hip_runtime_api.h:570

hipDeviceAttributeMaxBlockDimY

@ hipDeviceAttributeMaxBlockDimY

Max block size in height.

Definition hip_runtime_api.h:471

hipDeviceAttributeMaxSurfaceCubemap

@ hipDeviceAttributeMaxSurfaceCubemap

Cuda only. Maximum dimensions of Cubemap surface.

Definition hip_runtime_api.h:481

hipDeviceAttributePageableMemoryAccess

@ hipDeviceAttributePageableMemoryAccess

Definition hip_runtime_api.h:518

hipDeviceAttributeClockRate

@ hipDeviceAttributeClockRate

Peak clock frequency in kilohertz.

Definition hip_runtime_api.h:440

hipDeviceAttributeCudaCompatibleEnd

@ hipDeviceAttributeCudaCompatibleEnd

Definition hip_runtime_api.h:561

hipDeviceAttributeMaxTexture1DMipmap

@ hipDeviceAttributeMaxTexture1DMipmap

Maximum size of 1D mipmapped texture.

Definition hip_runtime_api.h:489

hipDeviceAttributeComputeCapabilityMajor

@ hipDeviceAttributeComputeCapabilityMajor

Major compute capability version number.

Definition hip_runtime_api.h:467

hipDeviceAttributeGlobalL1CacheSupported

@ hipDeviceAttributeGlobalL1CacheSupported

Device supports caching globals in L1.

Definition hip_runtime_api.h:454

hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

Definition hip_runtime_api.h:582

hipDeviceAttributeAccessPolicyMaxWindowSize

@ hipDeviceAttributeAccessPolicyMaxWindowSize

Definition hip_runtime_api.h:432

hipDeviceAttributeMaxTexture3DHeight

@ hipDeviceAttributeMaxTexture3DHeight

Maximum dimension height of 3D texture.

Definition hip_runtime_api.h:499

hipDeviceAttributeComputeCapabilityMinor

@ hipDeviceAttributeComputeCapabilityMinor

Minor compute capability version number.

Definition hip_runtime_api.h:510

hipDeviceAttributeNumberOfXccs

@ hipDeviceAttributeNumberOfXccs

The number of XCC(s) on the device.

Definition hip_runtime_api.h:594

hipDeviceAttributeMaxTextureCubemap

@ hipDeviceAttributeMaxTextureCubemap

Maximum dimensions of Cubemap texture.

Definition hip_runtime_api.h:502

hipDeviceAttributeDeviceOverlap

@ hipDeviceAttributeDeviceOverlap

Definition hip_runtime_api.h:450

hipDeviceAttributeMaxTexture2DLinear

@ hipDeviceAttributeMaxTexture2DLinear

Definition hip_runtime_api.h:495

hipDeviceAttributeMaxSurface2D

@ hipDeviceAttributeMaxSurface2D

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

Definition hip_runtime_api.h:478

hipDeviceAttributeMaxSurface1DLayered

@ hipDeviceAttributeMaxSurface1DLayered

Cuda only. Maximum dimensions of 1D layered surface.

Definition hip_runtime_api.h:477

hipDeviceAttributeHdpRegFlushCntl

@ hipDeviceAttributeHdpRegFlushCntl

Address of the HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:572

hipDeviceAttributeMaxAvailableVgprsPerThread

@ hipDeviceAttributeMaxAvailableVgprsPerThread

Definition hip_runtime_api.h:595

hipDeviceAttributeComputeMode

@ hipDeviceAttributeComputeMode

Compute mode that device is currently in.

Definition hip_runtime_api.h:441

hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

Definition hip_runtime_api.h:573

hipDeviceAttributeAsicRevision

@ hipDeviceAttributeAsicRevision

Revision of the GPU in this device.

Definition hip_runtime_api.h:586

hipDeviceAttributeUnused4

@ hipDeviceAttributeUnused4

Previously hipDeviceAttributeGcnArch.

Definition hip_runtime_api.h:569

hipDeviceAttributeCooperativeMultiDeviceLaunch

@ hipDeviceAttributeCooperativeMultiDeviceLaunch

Definition hip_runtime_api.h:448

hipDeviceAttributeMaxTexture2DHeight

@ hipDeviceAttributeMaxTexture2DHeight

Maximum dimension hight of 2D texture.

Definition hip_runtime_api.h:491

hipDeviceAttributePersistingL2CacheMaxSize

@ hipDeviceAttributePersistingL2CacheMaxSize

Maximum l2 persisting lines capacity in bytes.

Definition hip_runtime_api.h:527

hipDeviceAttributeEccEnabled

@ hipDeviceAttributeEccEnabled

Whether ECC support is enabled.

Definition hip_runtime_api.h:430

hipDeviceAttributeCanUseHostPointerForRegisteredMem

@ hipDeviceAttributeCanUseHostPointerForRegisteredMem

Definition hip_runtime_api.h:437

hipDeviceAttributePciBusId

@ hipDeviceAttributePciBusId

PCI Bus ID.

Definition hip_runtime_api.h:522

hipDeviceAttributeL2CacheSize

@ hipDeviceAttributeL2CacheSize

Definition hip_runtime_api.h:460

hipDeviceAttributeKernelExecTimeout

@ hipDeviceAttributeKernelExecTimeout

Run time limit for kernels executed on the device.

Definition hip_runtime_api.h:459

hipDeviceAttributeMaxThreadsDim

@ hipDeviceAttributeMaxThreadsDim

Maximum dimension of a block.

Definition hip_runtime_api.h:504

hipDeviceAttributeSingleToDoublePrecisionPerfRatio

@ hipDeviceAttributeSingleToDoublePrecisionPerfRatio

Definition hip_runtime_api.h:539

hipDeviceAttributeMaxGridDimY

@ hipDeviceAttributeMaxGridDimY

Max grid size in height.

Definition hip_runtime_api.h:474

hipDeviceAttributeMultiprocessorCount

@ hipDeviceAttributeMultiprocessorCount

Definition hip_runtime_api.h:513

hipDeviceAttributeAmdSpecificBegin

@ hipDeviceAttributeAmdSpecificBegin

Definition hip_runtime_api.h:562

hipDeviceAttributeMaxRegistersPerMultiprocessor

@ hipDeviceAttributeMaxRegistersPerMultiprocessor

32-bit registers available per block.

Definition hip_runtime_api.h:531

hipDeviceAttributeIsMultiGpuBoard

@ hipDeviceAttributeIsMultiGpuBoard

Multiple GPU devices.

Definition hip_runtime_api.h:458

hipDeviceAttributeSharedMemPerBlockOptin

@ hipDeviceAttributeSharedMemPerBlockOptin

Definition hip_runtime_api.h:536

hipDeviceAttributeMaxSurface2DLayered

@ hipDeviceAttributeMaxSurface2DLayered

Cuda only. Maximum dimensions of 2D layered surface.

Definition hip_runtime_api.h:479

hipDeviceAttributeAmdSpecificEnd

@ hipDeviceAttributeAmdSpecificEnd

Definition hip_runtime_api.h:600

hipDeviceAttributeMemoryClockRate

@ hipDeviceAttributeMemoryClockRate

Peak memory clock frequency in kilohertz.

Definition hip_runtime_api.h:509

hipDeviceAttributeMaxGridDimZ

@ hipDeviceAttributeMaxGridDimZ

Max grid size in depth.

Definition hip_runtime_api.h:475

hipDeviceAttributeHdpMemFlushCntl

@ hipDeviceAttributeHdpMemFlushCntl

Address of the HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:571

hipDeviceAttributeUnused2

@ hipDeviceAttributeUnused2

Previously hipDeviceAttributeUuid.

Definition hip_runtime_api.h:551

hipDeviceAttributeFineGrainSupport

@ hipDeviceAttributeFineGrainSupport

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

Definition hip_runtime_api.h:592

hipDeviceAttributeCooperativeLaunch

@ hipDeviceAttributeCooperativeLaunch

Support cooperative launch.

Definition hip_runtime_api.h:447

hipDeviceAttributeUnifiedAddressing

@ hipDeviceAttributeUnifiedAddressing

Definition hip_runtime_api.h:549

hipDeviceAttributeAsyncEngineCount

@ hipDeviceAttributeAsyncEngineCount

Asynchronous engines number.

Definition hip_runtime_api.h:434

hipDeviceAttributeMultiGpuBoardGroupID

@ hipDeviceAttributeMultiGpuBoardGroupID

Definition hip_runtime_api.h:511

hipDeviceAttributeStreamPrioritiesSupported

@ hipDeviceAttributeStreamPrioritiesSupported

Whether to support stream priorities.

Definition hip_runtime_api.h:541

hipDeviceAttributeMaxSharedMemoryPerBlock

@ hipDeviceAttributeMaxSharedMemoryPerBlock

Definition hip_runtime_api.h:534

hipDeviceAttributeLocalL1CacheSupported

@ hipDeviceAttributeLocalL1CacheSupported

caching locals in L1 is supported

Definition hip_runtime_api.h:462

hipDeviceAttributeCanUseStreamWaitValue

@ hipDeviceAttributeCanUseStreamWaitValue

Definition hip_runtime_api.h:587

hipDeviceAttributeMaxRegistersPerBlock

@ hipDeviceAttributeMaxRegistersPerBlock

Definition hip_runtime_api.h:528

hipDeviceAttributeMaxThreadsPerBlock

@ hipDeviceAttributeMaxThreadsPerBlock

Maximum number of threads per block.

Definition hip_runtime_api.h:505

hipDeviceAttributePciDomainId

@ hipDeviceAttributePciDomainId

PCI Domain Id.

Definition hip_runtime_api.h:524

hipDeviceAttributeMemoryBusWidth

@ hipDeviceAttributeMemoryBusWidth

Global memory bus width in bits.

Definition hip_runtime_api.h:508

hipDeviceAttributeMemoryPoolSupportedHandleTypes

@ hipDeviceAttributeMemoryPoolSupportedHandleTypes

Definition hip_runtime_api.h:558

hipDeviceAttributeComputePreemptionSupported

@ hipDeviceAttributeComputePreemptionSupported

Device supports Compute Preemption.

Definition hip_runtime_api.h:442

hipDeviceAttributeMaxSurface1D

@ hipDeviceAttributeMaxSurface1D

Maximum size of 1D surface.

Definition hip_runtime_api.h:476

hipDeviceAttributeUnused1

@ hipDeviceAttributeUnused1

Previously hipDeviceAttributeName.

Definition hip_runtime_api.h:517

hipDeviceAttributeMaxTexture3DAlt

@ hipDeviceAttributeMaxTexture3DAlt

Maximum dimensions of alternate 3D texture.

Definition hip_runtime_api.h:501

hipDeviceAttributeMaxTexture1DLinear

@ hipDeviceAttributeMaxTexture1DLinear

Definition hip_runtime_api.h:486

hipDeviceAttributeMaxTexture2DGather

@ hipDeviceAttributeMaxTexture2DGather

Definition hip_runtime_api.h:492

hipDeviceAttributeWallClockRate

@ hipDeviceAttributeWallClockRate

Constant frequency of wall clock in kilohertz.

Definition hip_runtime_api.h:593

hipDeviceAttributePciDeviceId

@ hipDeviceAttributePciDeviceId

PCI Device ID. Returns pcie slot id.

Definition hip_runtime_api.h:523

hipDeviceAttributeCanMapHostMemory

@ hipDeviceAttributeCanMapHostMemory

Definition hip_runtime_api.h:435

hipDeviceAttributeMaxTexture1DWidth

@ hipDeviceAttributeMaxTexture1DWidth

Maximum size of 1D texture.

Definition hip_runtime_api.h:484

hipDeviceAttributeConcurrentManagedAccess

@ hipDeviceAttributeConcurrentManagedAccess

Definition hip_runtime_api.h:445

hipDeviceAttributeVendorSpecificBegin

@ hipDeviceAttributeVendorSpecificBegin

Definition hip_runtime_api.h:601

hipDeviceAttributeManagedMemory

@ hipDeviceAttributeManagedMemory

Device supports allocating managed memory on this system.

Definition hip_runtime_api.h:468

hipDeviceAttributeIntegrated

@ hipDeviceAttributeIntegrated

Device is integrated GPU.

Definition hip_runtime_api.h:457

hipDeviceAttributeMaxTexture2DLayered

@ hipDeviceAttributeMaxTexture2DLayered

Maximum dimensions of 2D layered texture.

Definition hip_runtime_api.h:494

hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

Definition hip_runtime_api.h:576

hipDeviceAttributeMaxTexture3DDepth

@ hipDeviceAttributeMaxTexture3DDepth

Maximum dimension depth of 3D texture.

Definition hip_runtime_api.h:500

hipDeviceAttributePciChipId

@ hipDeviceAttributePciChipId

GPU Manufacturer device id.

Definition hip_runtime_api.h:598

hipDeviceAttributeImageSupport

@ hipDeviceAttributeImageSupport

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

Definition hip_runtime_api.h:589

hipDeviceAttributeTotalGlobalMem

@ hipDeviceAttributeTotalGlobalMem

Global memory available on devicice.

Definition hip_runtime_api.h:548

hipDeviceAttributeMaxBlocksPerMultiProcessor

@ hipDeviceAttributeMaxBlocksPerMultiProcessor

Max block size per multiprocessor.

Definition hip_runtime_api.h:469

hipDeviceAttributeIsLargeBar

@ hipDeviceAttributeIsLargeBar

Whether it is LargeBar.

Definition hip_runtime_api.h:585

hipDeviceAttributeMaxTexture2DWidth

@ hipDeviceAttributeMaxTexture2DWidth

Maximum dimension width of 2D texture.

Definition hip_runtime_api.h:490

hipDeviceAttributeMaxBlockDimX

@ hipDeviceAttributeMaxBlockDimX

Max block size in width.

Definition hip_runtime_api.h:470

hipDeviceAttributeMaxTexture3DWidth

@ hipDeviceAttributeMaxTexture3DWidth

Maximum dimension width of 3D texture.

Definition hip_runtime_api.h:498

hipDeviceAttributeUnused3

@ hipDeviceAttributeUnused3

Previously hipDeviceAttributeArch.

Definition hip_runtime_api.h:567

hipDeviceAttributeTotalConstantMemory

@ hipDeviceAttributeTotalConstantMemory

Constant memory size in bytes.

Definition hip_runtime_api.h:547

hipDeviceAttributeTextureAlignment

@ hipDeviceAttributeTextureAlignment

Alignment requirement for textures.

Definition hip_runtime_api.h:544

hipDeviceAttributeMaxTexture1DLayered

@ hipDeviceAttributeMaxTexture1DLayered

Maximum dimensions of 1D layered texture.

Definition hip_runtime_api.h:485

hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

@ hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

Maximum Shared Memory PerMultiprocessor.

Definition hip_runtime_api.h:568

hipDeviceAttributeReservedSharedMemPerBlock

@ hipDeviceAttributeReservedSharedMemPerBlock

Definition hip_runtime_api.h:532

hipDeviceAttributeCudaCompatibleBegin

@ hipDeviceAttributeCudaCompatibleBegin

Definition hip_runtime_api.h:428

hipDeviceAttributeConcurrentKernels

@ hipDeviceAttributeConcurrentKernels

Definition hip_runtime_api.h:443

hipDeviceAttributeLuid

@ hipDeviceAttributeLuid

Definition hip_runtime_api.h:463

hipDeviceAttributePciDomainID

@ hipDeviceAttributePciDomainID

PCI Domain ID, for backward compatibility.

Definition hip_runtime_api.h:525

hipDeviceAttributeMaxThreadsPerMultiProcessor

@ hipDeviceAttributeMaxThreadsPerMultiProcessor

Maximum resident threads per multiprocessor.

Definition hip_runtime_api.h:506

hipDeviceAttributeTexturePitchAlignment

@ hipDeviceAttributeTexturePitchAlignment

Definition hip_runtime_api.h:545

hipDeviceAttributePhysicalMultiProcessorCount

@ hipDeviceAttributePhysicalMultiProcessorCount

Definition hip_runtime_api.h:590

hipDeviceAttributeHostRegisterSupported

@ hipDeviceAttributeHostRegisterSupported

Definition hip_runtime_api.h:556

hipDeviceAttributeSharedMemPerMultiprocessor

@ hipDeviceAttributeSharedMemPerMultiprocessor

Shared memory available per multiprocessor.

Definition hip_runtime_api.h:538

hipDeviceAttributeLuidDeviceNodeMask

@ hipDeviceAttributeLuidDeviceNodeMask

Definition hip_runtime_api.h:465

hipDeviceAttributeMaxTextureCubemapLayered

@ hipDeviceAttributeMaxTextureCubemapLayered

Maximum dimensions of Cubemap layered texture.

Definition hip_runtime_api.h:503

hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

Definition hip_runtime_api.h:579

hipDeviceAttributeVirtualMemoryManagementSupported

@ hipDeviceAttributeVirtualMemoryManagementSupported

Definition hip_runtime_api.h:554

hipDeviceAttributeMemoryPoolsSupported

@ hipDeviceAttributeMemoryPoolsSupported

Device supports HIP Stream Ordered Memory Allocator.

Definition hip_runtime_api.h:553

hipDeviceAttributeClockInstructionRate

@ hipDeviceAttributeClockInstructionRate

Definition hip_runtime_api.h:564

hipDeviceAttributeMaxTexture2DMipmap

@ hipDeviceAttributeMaxTexture2DMipmap

Maximum dimensions of 2D mipmapped texture.

Definition hip_runtime_api.h:497

hipDeviceAttributeMaxBlockDimZ

@ hipDeviceAttributeMaxBlockDimZ

Max block size in depth.

Definition hip_runtime_api.h:472

hipDeviceAttributeWarpSize

@ hipDeviceAttributeWarpSize

Warp size in threads.

Definition hip_runtime_api.h:552

hipGPUDirectRDMAWritesOrderingOwner

@ hipGPUDirectRDMAWritesOrderingOwner

Definition hip_runtime_api.h:625

hipGPUDirectRDMAWritesOrderingNone

@ hipGPUDirectRDMAWritesOrderingNone

Definition hip_runtime_api.h:624

hipGPUDirectRDMAWritesOrderingAllDevices

@ hipGPUDirectRDMAWritesOrderingAllDevices

Definition hip_runtime_api.h:626

hipMemAllocationTypeMax

@ hipMemAllocationTypeMax

Definition hip_runtime_api.h:1213

hipMemAllocationTypePinned

@ hipMemAllocationTypePinned

Definition hip_runtime_api.h:1211

hipMemAllocationTypeUncached

@ hipMemAllocationTypeUncached

Definition hip_runtime_api.h:1212

hipMemAllocationTypeInvalid

@ hipMemAllocationTypeInvalid

Definition hip_runtime_api.h:1207

hipMemoryTypeDevice

@ hipMemoryTypeDevice

Definition hip_runtime_api.h:266

hipMemoryTypeHost

@ hipMemoryTypeHost

Memory is physically located on host.

Definition hip_runtime_api.h:265

hipMemoryTypeUnregistered

@ hipMemoryTypeUnregistered

Unregistered memory.

Definition hip_runtime_api.h:264

hipMemoryTypeArray

@ hipMemoryTypeArray

Definition hip_runtime_api.h:271

hipMemoryTypeManaged

@ hipMemoryTypeManaged

Definition hip_runtime_api.h:268

hipMemoryTypeUnified

@ hipMemoryTypeUnified

unified address space

Definition hip_runtime_api.h:273

hipGraphInstantiateFlagAutoFreeOnLaunch

@ hipGraphInstantiateFlagAutoFreeOnLaunch

Automatically free memory allocated in a graph before relaunching.

Definition hip_runtime_api.h:1687

hipGraphInstantiateFlagUseNodePriority

@ hipGraphInstantiateFlagUseNodePriority

Definition hip_runtime_api.h:1692

hipGraphInstantiateFlagUpload

@ hipGraphInstantiateFlagUpload

Automatically upload the graph after instantiation.

Definition hip_runtime_api.h:1689

hipGraphInstantiateFlagDeviceLaunch

@ hipGraphInstantiateFlagDeviceLaunch

Instantiate the graph to be launched from the device.

Definition hip_runtime_api.h:1690

hipArraySparseSubresourceTypeSparseLevel

@ hipArraySparseSubresourceTypeSparseLevel

Sparse level.

Definition hip_runtime_api.h:1817

hipArraySparseSubresourceTypeMiptail

@ hipArraySparseSubresourceTypeMiptail

Miptail.

Definition hip_runtime_api.h:1818

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

hipJitOption

hipJitOption

Definition linker_types.h:47

hipJitInputType

hipJitInputType

Definition linker_types.h:92

hipHostFree

hipError_t hipHostFree(void *ptr)

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

hipMallocHost

hipError_t hipMallocHost(void **ptr, size_t size)

Allocate pinned host memory [Deprecated].

hipMemcpyToArray

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

Copies data between host and device [Deprecated].

hipMemcpyFromArray

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

Copies data between host and device [Deprecated].

hipMemAllocHost

hipError_t hipMemAllocHost(void **ptr, size_t size)

Allocate pinned host memory [Deprecated].

hipMemcpyAtoA

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

Copies from one 1D array to another.

hipHostAlloc

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

Allocate device accessible page locked host memory.

hipMemcpy3DBatchAsync

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

Perform Batch of 3D copies.

hipMemcpy2DArrayToArray

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

Copies data between host and device.

hipMemsetD8Async

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

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

hipMemcpyAtoHAsync

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

Copies from one 1D array to host memory.

hipFreeHost

hipError_t hipFreeHost(void *ptr)

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

hipMemset2DAsync

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

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

hipMemGetInfo

hipError_t hipMemGetInfo(size_t *free, size_t *total)

Query memory info.

hipExtMallocWithFlags

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

Allocate memory on the default accelerator.

hipMemcpy3D

hipError_t hipMemcpy3D(const struct hipMemcpy3DParms *p)

Copies data between host and device.

hipMalloc3DArray

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

Allocate an array on the device.

hipArrayCreate

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

Create an array memory pointer on the device.

hipMemset3D

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

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

hipMemsetD16

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

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

hipMemcpyAtoD

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

Copies from one 1D array to device memory.

hipMalloc

hipError_t hipMalloc(void **ptr, size_t size)

Allocate memory on the default accelerator.

hipHostUnregister

hipError_t hipHostUnregister(void *hostPtr)

Un-register host pointer.

hipHostGetFlags

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

Return flags associated with host pointer.

hipMemcpyFromSymbolAsync

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

Copies data from the given symbol on the device asynchronously.

hipMemsetD2D32

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

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

hipMemsetD32

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

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

hipMemset3DAsync

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

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

hipMemcpyFromSymbol

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

Copies data from the given symbol on the device.

hipDrvMemcpy3DAsync

hipError_t hipDrvMemcpy3DAsync(const HIP_MEMCPY3D *pCopy, hipStream_t stream)

Copies data between host and device asynchronously.

hipMemsetD2D32Async

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

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

hipArray3DGetDescriptor

hipError_t hipArray3DGetDescriptor(HIP_ARRAY3D_DESCRIPTOR *pArrayDescriptor, hipArray_t array)

Gets a 3D array descriptor.

hipMemcpy2DAsync

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

Copies data between host and device asynchronously.

hipArrayGetDescriptor

hipError_t hipArrayGetDescriptor(HIP_ARRAY_DESCRIPTOR *pArrayDescriptor, hipArray_t array)

Gets a 1D or 2D array descriptor.

hipFree

hipError_t hipFree(void *ptr)

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

hipMemcpyHtoAAsync

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

Copies from host memory to a 1D array.

hipMemsetD16Async

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

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

hipGetProcAddress

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

Gets the pointer of requested HIP driver function.

hipPointerGetAttributes

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

Returns attributes for the specified pointer.

hipMallocPitch

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

hipMemcpy3DPeer

hipError_t hipMemcpy3DPeer(hipMemcpy3DPeerParms *p)

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

hipMemcpyDtoD

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

Copy data from Device to Device.

hipMallocArray

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

Allocate an array on the device.

hipMemcpy2D

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

Copies data between host and device.

hipHostGetDevicePointer

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

Get Device pointer from Host Pointer allocated through hipHostMalloc.

hipMemcpyDtoA

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

Copies from device memory to a 1D array.

hipMemcpy2DFromArrayAsync

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

Copies data between host and device asynchronously.

hipMemsetD2D16Async

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

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

hipMemcpy2DFromArray

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

Copies data between host and device.

hipMemcpy3DAsync

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

Copies data between host and device asynchronously.

hipArray3DCreate

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

Create a 3D array memory pointer on the device.

hipArrayGetInfo

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

Gets info about the specified array.

hipDrvMemcpy3D

hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D *pCopy)

Copies data between host and device.

hipMemcpyParam2D

hipError_t hipMemcpyParam2D(const hip_Memcpy2D *pCopy)

Copies memory for 2D arrays.

hipMemcpyHtoA

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

Copies data between host and device.

hipMemcpyToSymbolAsync

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

Copies data to the given symbol on the device asynchronously.

hipHostMalloc

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

Allocates device accessible page locked (pinned) host memory.

hipMemsetD2D8

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

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

hipMemcpy2DToArrayAsync

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

Copies data between host and device.

hipHostRegister

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

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

hipMemsetD2D16

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

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

hipMemcpyBatchAsync

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

Perform Batch of 1D copies.

hipMemcpyAtoH

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

Copies data between host and device.

hipMemcpyToSymbol

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

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

hipMemcpy

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

Copy data from src to dst.

hipMemset

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

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

hipMemGetAddressRange

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

Get information on memory allocations.

hipMemcpy2DToArray

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

Copies data between host and device.

hipMemcpyParam2DAsync

hipError_t hipMemcpyParam2DAsync(const hip_Memcpy2D *pCopy, hipStream_t stream)

Copies memory for 2D arrays.

hipDrvPointerGetAttributes

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

Returns information about the specified pointer.[BETA].

hipMalloc3D

hipError_t hipMalloc3D(hipPitchedPtr *pitchedDevPtr, hipExtent extent)

Create a 3D memory pointer on the device.

hipPointerSetAttribute

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

Sets information on the specified pointer.[BETA].

hipMemcpyDtoDAsync

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

Copy data from Device to Device asynchronously.

hipMemAllocPitch

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

hipMemsetD8

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

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

hipMemcpyAsync

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

Copies data from src to dst asynchronously.

hipMemcpyDtoHAsync

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

Copy data from Device to Host asynchronously.

hipFreeArray

hipError_t hipFreeArray(hipArray_t array)

Frees an array on the device.

hipMemcpyHtoD

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

Copy data from Host to Device.

hipMemsetD32Async

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

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

hipMemset2D

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

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

hipGetSymbolSize

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

Gets the size of the given symbol on the device.

hipMemcpyDtoH

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

Copy data from Device to Host.

hipMemcpyHtoDAsync

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

Copy data from Host to Device asynchronously.

hipMemsetAsync

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

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

hipMemcpyWithStream

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

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

hipGetSymbolAddress

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

Gets device pointer associated with symbol on the device.

hipPointerGetAttribute

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

Returns information about the specified pointer.[BETA].

hipMemsetD2D8Async

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

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

hipMemcpy3DPeerAsync

hipError_t hipMemcpy3DPeerAsync(hipMemcpy3DPeerParms *p, hipStream_t stream)

Performs 3D memory copies between devices asynchronously.

hipMemPtrGetInfo

hipError_t hipMemPtrGetInfo(void *ptr, size_t *size)

Get allocated memory size via memory pointer.

hipArrayDestroy

hipError_t hipArrayDestroy(hipArray_t array)

Destroy an array memory pointer on the device.

hipMemPrefetchAsync

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

Prefetches memory to the specified destination device using HIP.

hipMemPrefetchAsync_v2

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

Prefetches memory to the specified destination device using HIP.

hipMemRangeGetAttributes

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

Query attributes of a given memory range in HIP.

hipMemAdvise

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

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

hipMemRangeGetAttribute

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

Query an attribute of a given memory range in HIP.

hipMallocManaged

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

Allocates memory that will be automatically managed by HIP.

hipStreamAttachMemAsync

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

Attach memory to a stream asynchronously in HIP.

hipMemAdvise_v2

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

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

hipModuleLaunchCooperativeKernelMultiDevice

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

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

hipLaunchCooperativeKernelMultiDevice

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

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

hipModuleLaunchCooperativeKernel

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

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

hipLaunchCooperativeKernel

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

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

hipModuleGetTexRef

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

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

hipLinkComplete

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

Completes the linking of the given program.

hipModuleGetFunctionCount

hipError_t hipModuleGetFunctionCount(unsigned int *count, hipModule_t mod)

Returns the number of functions within a module.

hipModuleLoad

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

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

hipModuleGetGlobal

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

Returns a global pointer from a module.

hipModuleLoadDataEx

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

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

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.

hipLibraryGetKernel

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

Get Kernel object from library.

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.

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.

hipLinkAddData

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

Adds bitcode data to be linked with options.

hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags

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

Returns occupancy for a device function.

hipModuleOccupancyMaxPotentialBlockSize

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

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

hipOccupancyMaxActiveBlocksPerMultiprocessor

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

Returns occupancy for a device function.

hipOccupancyMaxPotentialBlockSize

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

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

hipModuleOccupancyMaxActiveBlocksPerMultiprocessor

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

Returns occupancy for a device function.

hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags

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

Returns occupancy for a device function.

hipModuleOccupancyMaxPotentialBlockSizeWithFlags

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

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

hipDeviceCanAccessPeer

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

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

hipDeviceEnablePeerAccess

hipError_t hipDeviceEnablePeerAccess(int peerDeviceId, unsigned int flags)

Enables direct access to memory allocations on a peer device.

hipMemcpyPeer

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

Copies memory between two peer accessible devices.

hipMemcpyPeerAsync

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

Copies memory between two peer accessible devices asynchronously.

hipDeviceDisablePeerAccess

hipError_t hipDeviceDisablePeerAccess(int peerDeviceId)

Disables direct access to memory allocations on a peer device.

hipProfilerStart

hipError_t hipProfilerStart()

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

hipProfilerStop

hipError_t hipProfilerStop()

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

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

hipStreamCallback_t

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

Definition hip_runtime_api.h:3015

hipStreamGetDevice

hipError_t hipStreamGetDevice(hipStream_t stream, hipDevice_t *device)

Gets the device associated with the stream.

hipStreamQuery

hipError_t hipStreamQuery(hipStream_t stream)

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

hipStreamSynchronize

hipError_t hipStreamSynchronize(hipStream_t stream)

Waits for all commands in the stream to complete.

hipStreamSetAttribute

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

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

hipStreamWaitEvent

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

Makes the specified compute stream wait for the specified event.

hipStreamCreateWithPriority

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

Creates an asynchronous stream with the specified priority.

hipExtStreamCreateWithCUMask

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

Creates an asynchronous stream with the specified CU mask.

hipStreamGetPriority

hipError_t hipStreamGetPriority(hipStream_t stream, int *priority)

Queries the priority of a stream.

hipExtStreamGetCUMask

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

Gets CU mask associated with an asynchronous stream.

hipStreamGetAttribute

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

queries stream attribute.

hipStreamCreateWithFlags

hipError_t hipStreamCreateWithFlags(hipStream_t *stream, unsigned int flags)

Creates an asynchronous stream with flag.

hipStreamCreate

hipError_t hipStreamCreate(hipStream_t *stream)

Creates an asynchronous stream.

hipStreamWriteValue64

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

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

hipStreamWriteValue32

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

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

hipGraphExecBatchMemOpNodeSetParams

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

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

hipGraphAddBatchMemOpNode

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

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

hipStreamWaitValue64

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

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

hipGraphBatchMemOpNodeGetParams

hipError_t hipGraphBatchMemOpNodeGetParams(hipGraphNode_t hNode, hipBatchMemOpNodeParams *nodeParams_out)

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

hipStreamBatchMemOp

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

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

hipGraphBatchMemOpNodeSetParams

hipError_t hipGraphBatchMemOpNodeSetParams(hipGraphNode_t hNode, hipBatchMemOpNodeParams *nodeParams)

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

hipStreamWaitValue32

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

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

hipMemPoolImportPointer

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

Import a memory pool allocation from another process.

hipMemPoolImportFromShareableHandle

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

Imports a memory pool from a shared handle.

hipMallocFromPoolAsync

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

Allocates memory from a specified pool with stream ordered semantics.

hipFreeAsync

hipError_t hipFreeAsync(void *dev_ptr, hipStream_t stream)

Frees memory with stream ordered semantics.

hipMemPoolTrimTo

hipError_t hipMemPoolTrimTo(hipMemPool_t mem_pool, size_t min_bytes_to_hold)

Releases freed memory back to the OS.

hipMemPoolCreate

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

Creates a memory pool.

hipMemPoolSetAccess

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

Controls visibility of the specified pool between devices.

hipMemPoolDestroy

hipError_t hipMemPoolDestroy(hipMemPool_t mem_pool)

Destroys the specified memory pool.

hipMemPoolSetAttribute

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

Sets attributes of a memory pool.

hipMemPoolGetAttribute

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

Gets attributes of a memory pool.

hipMemPoolExportToShareableHandle

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

Exports a memory pool to the requested handle type.

hipMemPoolExportPointer

hipError_t hipMemPoolExportPointer(hipMemPoolPtrExportData *export_data, void *dev_ptr)

Export data to share a memory pool allocation between processes.

hipMallocAsync

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

Allocates memory with stream ordered semantics.

hipMemPoolGetAccess

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

Returns the accessibility of a pool from a device.

hipDestroySurfaceObject

hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject)

Destroy a surface object.

hipCreateSurfaceObject

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

Create a surface object.

hipTexRefGetFilterMode

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

Gets filter mode for a texture reference [Deprecated].

hipBindTextureToMipmappedArray

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

Binds a mipmapped array to a texture [Deprecated].

hipTexRefGetMipmapLevelClamp

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

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

hipTexRefGetAddressMode

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

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

hipTexRefGetFlags

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

Gets flags for a texture reference [Deprecated].

hipTexRefSetAddress

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

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

hipTexRefSetFilterMode

hipError_t hipTexRefSetFilterMode(textureReference *texRef, enum hipTextureFilterMode fm)

Set filter mode for a texture reference [Deprecated].

hipTexRefSetMipmappedArray

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

Binds mipmapped array to a texture reference [Deprecated].

hipTexRefGetMipmapFilterMode

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

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

hipGetTextureAlignmentOffset

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

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

hipBindTexture2D

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

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

hipTexRefGetMaxAnisotropy

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

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

hipBindTexture

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

Binds a memory area to a texture [Deprecated].

hipUnbindTexture

hipError_t hipUnbindTexture(const textureReference *tex)

Unbinds a texture [Deprecated].

hipTexRefGetBorderColor

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

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

hipTexRefSetFormat

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

Set format for a texture reference [Deprecated].

hipTexRefGetAddress

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

Gets the address for a texture reference [Deprecated].

hipTexRefGetArray

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

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

hipTexRefSetFlags

hipError_t hipTexRefSetFlags(textureReference *texRef, unsigned int Flags)

Set flags for a texture reference [Deprecated].

hipTexRefSetAddressMode

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

Sets address mode for a texture reference [Deprecated].

hipTexRefGetMipMappedArray

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

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

hipTexRefSetMaxAnisotropy

hipError_t hipTexRefSetMaxAnisotropy(textureReference *texRef, unsigned int maxAniso)

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

hipTexRefSetMipmapLevelClamp

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

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

hipTexRefSetBorderColor

hipError_t hipTexRefSetBorderColor(textureReference *texRef, float *pBorderColor)

Sets border color for a texture reference [Deprecated].

hipTexRefSetArray

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

Binds an array as a texture reference [Deprecated].

hipTexRefSetMipmapLevelBias

hipError_t hipTexRefSetMipmapLevelBias(textureReference *texRef, float bias)

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

hipTexRefGetMipmapLevelBias

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

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

hipBindTextureToArray

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

Binds a memory area to a texture [Deprecated].

hipGetTextureReference

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

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

hipTexRefSetAddress2D

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

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

hipTexRefSetMipmapFilterMode

hipError_t hipTexRefSetMipmapFilterMode(textureReference *texRef, enum hipTextureFilterMode fm)

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

hipTexRefGetFormat

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

Gets texture format for a texture reference [Deprecated].

hipFreeMipmappedArray

hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray)

Frees a mipmapped array on the device.

hipGetMipmappedArrayLevel

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

Gets a mipmap level of a HIP mipmapped array.

hipMipmappedArrayGetLevel

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

Get a mipmapped array on a mipmapped level.

hipMipmappedArrayDestroy

hipError_t hipMipmappedArrayDestroy(hipMipmappedArray_t hMipmappedArray)

Destroy a mipmapped array.

hipTexObjectCreate

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

Creates a texture object.

hipGetTextureObjectResourceDesc

hipError_t hipGetTextureObjectResourceDesc(hipResourceDesc *pResDesc, hipTextureObject_t textureObject)

Gets resource descriptor for the texture object.

hipGetTextureObjectResourceViewDesc

hipError_t hipGetTextureObjectResourceViewDesc(struct hipResourceViewDesc *pResViewDesc, hipTextureObject_t textureObject)

Gets resource view descriptor for the texture object.

hipTexObjectGetTextureDesc

hipError_t hipTexObjectGetTextureDesc(HIP_TEXTURE_DESC *pTexDesc, hipTextureObject_t texObject)

Gets texture descriptor of a texture object.

hipCreateTextureObject

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

Creates a texture object.

hipTexObjectDestroy

hipError_t hipTexObjectDestroy(hipTextureObject_t texObject)

Destroys a texture object.

hipMipmappedArrayCreate

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

Create a mipmapped array.

hipGetChannelDesc

hipError_t hipGetChannelDesc(hipChannelFormatDesc *desc, hipArray_const_t array)

Gets the channel descriptor in an array.

hipTexObjectGetResourceDesc

hipError_t hipTexObjectGetResourceDesc(HIP_RESOURCE_DESC *pResDesc, hipTextureObject_t texObject)

Gets resource descriptor of a texture object.

hipTexObjectGetResourceViewDesc

hipError_t hipTexObjectGetResourceViewDesc(HIP_RESOURCE_VIEW_DESC *pResViewDesc, hipTextureObject_t texObject)

Gets resource view descriptor of a texture object.

hipMallocMipmappedArray

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

Allocate a mipmapped array on the device.

hipDestroyTextureObject

hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject)

Destroys a texture object.

hipGetTextureObjectTextureDesc

hipError_t hipGetTextureObjectTextureDesc(hipTextureDesc *pTexDesc, hipTextureObject_t textureObject)

Gets texture descriptor for the texture object.

hipMemAddressFree

hipError_t hipMemAddressFree(void *devPtr, size_t size)

Frees an address range reservation made via hipMemAddressReserve.

hipMemExportToShareableHandle

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

Exports an allocation to a requested shareable handle type.

hipMemGetAccess

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

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

hipMemSetAccess

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

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

hipMemRelease

hipError_t hipMemRelease(hipMemGenericAllocationHandle_t handle)

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

hipMemUnmap

hipError_t hipMemUnmap(void *ptr, size_t size)

Unmap memory allocation of a given address range.

hipMemGetAllocationGranularity

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

Calculates either the minimal or recommended granularity.

hipMemRetainAllocationHandle

hipError_t hipMemRetainAllocationHandle(hipMemGenericAllocationHandle_t *handle, void *addr)

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

hipMemCreate

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

Creates a memory allocation described by the properties and size.

hipMemMap

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

Maps an allocation handle to a reserved virtual address range.

hipMemAddressReserve

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

Reserves an address range.

hipMemGetAllocationPropertiesFromHandle

hipError_t hipMemGetAllocationPropertiesFromHandle(hipMemAllocationProp *prop, hipMemGenericAllocationHandle_t handle)

Retrieve the property structure of the given handle.

hipMemMapArrayAsync

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

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

hipMemImportFromShareableHandle

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

Imports an allocation from a requested shareable handle type.

hip_common.h

hipErrorIllegalAddress

hipErrorIllegalAddress

Definition hip_runtime_api.h:365

hipErrorMemoryAllocation

hipErrorMemoryAllocation

Memory allocation error.

Definition hip_runtime_api.h:311

hipErrorNotFound

hipErrorNotFound

Not found.

Definition hip_runtime_api.h:360

hipErrorProfilerDisabled

hipErrorProfilerDisabled

Definition hip_runtime_api.h:316

hipErrorInvalidDevicePointer

hipErrorInvalidDevicePointer

Invalid Device Pointer.

Definition hip_runtime_api.h:323

HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

@ HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

Definition hip_runtime_api.h:53

HIP_ERROR_INVALID_VALUE

@ HIP_ERROR_INVALID_VALUE

Definition hip_runtime_api.h:51

HIP_SUCCESS

@ HIP_SUCCESS

Definition hip_runtime_api.h:50

HIP_ERROR_NOT_INITIALIZED

@ HIP_ERROR_NOT_INITIALIZED

Definition hip_runtime_api.h:52

hipErrorRuntimeMemory

hipErrorRuntimeMemory

Definition hip_runtime_api.h:414

hipErrorInvalidImage

hipErrorInvalidImage

Invalid image.

Definition hip_runtime_api.h:331

hipErrorPeerAccessUnsupported

hipErrorPeerAccessUnsupported

Definition hip_runtime_api.h:348

hipErrorArrayIsMapped

hipErrorArrayIsMapped

Definition hip_runtime_api.h:338

hipErrorStreamCaptureIsolation

hipErrorStreamCaptureIsolation

Definition hip_runtime_api.h:393

hipErrorInvalidKernelFile

hipErrorInvalidKernelFile

In CUDA DRV, it is CUDA_ERROR_INVALID_PTX.

Definition hip_runtime_api.h:349

hipErrorNotMapped

hipErrorNotMapped

Definition hip_runtime_api.h:342

hipErrorGraphExecUpdateFailure

hipErrorGraphExecUpdateFailure

Definition hip_runtime_api.h:406

hipErrorNotInitialized

hipErrorNotInitialized

Invalid not initialized.

Definition hip_runtime_api.h:312

hipErrorInvalidResourceHandle

hipErrorInvalidResourceHandle

Resource handle (hipEvent_t or hipStream_t) invalid.

Definition hip_runtime_api.h:358

hipErrorSharedObjectInitFailed

hipErrorSharedObjectInitFailed

Failed to initialize shared object.

Definition hip_runtime_api.h:354

hipErrorInvalidPitchValue

hipErrorInvalidPitchValue

Invalid pitch value.

Definition hip_runtime_api.h:321

hipErrorNoBinaryForGpu

hipErrorNoBinaryForGpu

Definition hip_runtime_api.h:340

hipErrorInvalidContext

hipErrorInvalidContext

Produced when input context is invalid.

Definition hip_runtime_api.h:332

hipErrorStreamCaptureUnsupported

hipErrorStreamCaptureUnsupported

Definition hip_runtime_api.h:384

hipErrorPeerAccessNotEnabled

hipErrorPeerAccessNotEnabled

Peer access was never enabled from the current device.

Definition hip_runtime_api.h:370

hipErrorOperatingSystem

hipErrorOperatingSystem

Not the correct operating system.

Definition hip_runtime_api.h:355

hipErrorStreamCaptureUnjoined

hipErrorStreamCaptureUnjoined

Definition hip_runtime_api.h:391

hipErrorInitializationError

hipErrorInitializationError

Definition hip_runtime_api.h:314

hipErrorNotMappedAsPointer

hipErrorNotMappedAsPointer

Definition hip_runtime_api.h:344

hipErrorPriorLaunchFailure

hipErrorPriorLaunchFailure

Definition hip_runtime_api.h:327

hipErrorContextIsDestroyed

hipErrorContextIsDestroyed

The context is already destroyed.

Definition hip_runtime_api.h:372

hipErrorInvalidValue

hipErrorInvalidValue

Definition hip_runtime_api.h:307

hipErrorLaunchTimeOut

hipErrorLaunchTimeOut

Timeout for the launch.

Definition hip_runtime_api.h:367

hipErrorUnmapFailed

hipErrorUnmapFailed

Definition hip_runtime_api.h:337

hipErrorSetOnActiveProcess

hipErrorSetOnActiveProcess

The process is active.

Definition hip_runtime_api.h:371

hipErrorFileNotFound

hipErrorFileNotFound

the file is not found.

Definition hip_runtime_api.h:352

hipErrorLaunchFailure

hipErrorLaunchFailure

An exception occurred on the device while executing a kernel.

Definition hip_runtime_api.h:378

hipErrorInvalidDevice

hipErrorInvalidDevice

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

Definition hip_runtime_api.h:330

hipErrorUnsupportedLimit

hipErrorUnsupportedLimit

Unsupported limit.

Definition hip_runtime_api.h:346

hipErrorMapBufferObjectFailed

hipErrorMapBufferObjectFailed

Produced when the IPC memory attach failed from ROCr.

Definition hip_runtime_api.h:336

hipErrorHostMemoryAlreadyRegistered

hipErrorHostMemoryAlreadyRegistered

Definition hip_runtime_api.h:374

hipErrorMissingConfiguration

hipErrorMissingConfiguration

Definition hip_runtime_api.h:326

hipErrorSharedObjectSymbolNotFound

hipErrorSharedObjectSymbolNotFound

Definition hip_runtime_api.h:353

hipErrorECCNotCorrectable

hipErrorECCNotCorrectable

Definition hip_runtime_api.h:345

hipErrorStreamCaptureWrongThread

hipErrorStreamCaptureWrongThread

Definition hip_runtime_api.h:402

hipErrorAssert

hipErrorAssert

Produced when the kernel calls assert.

Definition hip_runtime_api.h:373

hipErrorContextAlreadyInUse

hipErrorContextAlreadyInUse

The context is already in use.

Definition hip_runtime_api.h:347

hipErrorNotReady

hipErrorNotReady

Definition hip_runtime_api.h:361

hipErrorInvalidSource

hipErrorInvalidSource

Invalid source.

Definition hip_runtime_api.h:351

hipErrorLaunchOutOfResources

hipErrorLaunchOutOfResources

Out of resources error.

Definition hip_runtime_api.h:366

hipErrorInvalidDeviceFunction

hipErrorInvalidDeviceFunction

Invalid device function.

Definition hip_runtime_api.h:328

hipErrorCooperativeLaunchTooLarge

hipErrorCooperativeLaunchTooLarge

Definition hip_runtime_api.h:379

hipErrorAlreadyMapped

hipErrorAlreadyMapped

Definition hip_runtime_api.h:339

hipErrorProfilerNotInitialized

hipErrorProfilerNotInitialized

Definition hip_runtime_api.h:317

hipErrorProfilerAlreadyStarted

hipErrorProfilerAlreadyStarted

Definition hip_runtime_api.h:318

hipErrorInvalidChannelDescriptor

hipErrorInvalidChannelDescriptor

Invalid channel descriptor.

Definition hip_runtime_api.h:410

hipErrorNoDevice

hipErrorNoDevice

Call to hipGetDeviceCount returned 0 devices.

Definition hip_runtime_api.h:329

hipErrorMapFailed

hipErrorMapFailed

Definition hip_runtime_api.h:334

hipErrorStreamCaptureInvalidated

hipErrorStreamCaptureInvalidated

Definition hip_runtime_api.h:386

hipErrorProfilerAlreadyStopped

hipErrorProfilerAlreadyStopped

Definition hip_runtime_api.h:319

hipErrorDeinitialized

hipErrorDeinitialized

Deinitialized.

Definition hip_runtime_api.h:315

hipErrorPeerAccessAlreadyEnabled

hipErrorPeerAccessAlreadyEnabled

Definition hip_runtime_api.h:368

hipErrorNotMappedAsArray

hipErrorNotMappedAsArray

Definition hip_runtime_api.h:343

hipErrorNotSupported

hipErrorNotSupported

Produced when the hip API is not supported/implemented.

Definition hip_runtime_api.h:383

hipErrorInvalidConfiguration

hipErrorInvalidConfiguration

Invalide configuration.

Definition hip_runtime_api.h:320

hipErrorStreamCaptureImplicit

hipErrorStreamCaptureImplicit

Definition hip_runtime_api.h:397

hipErrorStreamCaptureMerge

hipErrorStreamCaptureMerge

Definition hip_runtime_api.h:388

hipErrorInvalidGraphicsContext

hipErrorInvalidGraphicsContext

Definition hip_runtime_api.h:350

hipErrorIllegalState

hipErrorIllegalState

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

Definition hip_runtime_api.h:359

hipErrorOutOfMemory

hipErrorOutOfMemory

out of memory range.

Definition hip_runtime_api.h:309

hipErrorInvalidSymbol

hipErrorInvalidSymbol

Invalid symbol.

Definition hip_runtime_api.h:322

hipSuccess

hipSuccess

Successful completion.

Definition hip_runtime_api.h:306

hipErrorUnknown

hipErrorUnknown

Unknown error.

Definition hip_runtime_api.h:412

hipErrorInvalidHandle

hipErrorInvalidHandle

Invalide handle.

Definition hip_runtime_api.h:356

hipErrorStreamCaptureUnmatched

hipErrorStreamCaptureUnmatched

The capture was not initiated in this stream.

Definition hip_runtime_api.h:390

hipErrorCapturedEvent

hipErrorCapturedEvent

Definition hip_runtime_api.h:400

hipErrorAlreadyAcquired

hipErrorAlreadyAcquired

Definition hip_runtime_api.h:341

hipErrorInsufficientDriver

hipErrorInsufficientDriver

Definition hip_runtime_api.h:325

hipErrorHostMemoryNotRegistered

hipErrorHostMemoryNotRegistered

Definition hip_runtime_api.h:376

hipErrorInvalidTexture

hipErrorInvalidTexture

Invalid texture.

Definition hip_runtime_api.h:411

hipErrorRuntimeOther

hipErrorRuntimeOther

Definition hip_runtime_api.h:416

hipErrorContextAlreadyCurrent

hipErrorContextAlreadyCurrent

Definition hip_runtime_api.h:333

hipErrorInvalidMemcpyDirection

hipErrorInvalidMemcpyDirection

Invalid memory copy direction.

Definition hip_runtime_api.h:324

linker_types.h

hip_impl

Definition hip_runtime_api.h:659

hip_impl::hip_init

hipError_t hip_init()

HIP_ARRAY3D_DESCRIPTOR

Definition driver_types.h:103

HIP_ARRAY_DESCRIPTOR

Definition driver_types.h:93

HIP_LAUNCH_CONFIG

Definition hip_runtime_api.h:1989

HIP_LAUNCH_CONFIG::gridDimZ

unsigned int gridDimZ

Grid depth in blocks.

Definition hip_runtime_api.h:1992

HIP_LAUNCH_CONFIG::sharedMemBytes

unsigned int sharedMemBytes

Dynamic shared-memory size in bytes per block.

Definition hip_runtime_api.h:1996

HIP_LAUNCH_CONFIG::blockDimY

unsigned int blockDimY

Thread block dimension in Y.

Definition hip_runtime_api.h:1994

HIP_LAUNCH_CONFIG::hStream

hipStream_t hStream

HIP stream identifier.

Definition hip_runtime_api.h:1997

HIP_LAUNCH_CONFIG::attrs

hipLaunchAttribute * attrs

Attribute list.

Definition hip_runtime_api.h:1998

HIP_LAUNCH_CONFIG::blockDimZ

unsigned int blockDimZ

Thread block dimension in Z.

Definition hip_runtime_api.h:1995

HIP_LAUNCH_CONFIG::numAttrs

unsigned int numAttrs

Number of attributes.

Definition hip_runtime_api.h:1999

HIP_LAUNCH_CONFIG::gridDimX

unsigned int gridDimX

Grid width in blocks.

Definition hip_runtime_api.h:1990

HIP_LAUNCH_CONFIG::gridDimY

unsigned int gridDimY

Grid height in blocks.

Definition hip_runtime_api.h:1991

HIP_LAUNCH_CONFIG::blockDimX

unsigned int blockDimX

Thread block dimension in X.

Definition hip_runtime_api.h:1993

HIP_MEMCPY3D

Definition driver_types.h:424

HIP_RESOURCE_DESC

Definition driver_types.h:313

HIP_RESOURCE_VIEW_DESC

Definition driver_types.h:358

HIP_TEXTURE_DESC

Definition driver_types.h:191

dim3

Definition hip_runtime_api.h:1281

dim3::y

uint32_t y

y

Definition hip_runtime_api.h:1283

dim3::z

uint32_t z

z

Definition hip_runtime_api.h:1284

dim3::x

uint32_t x

x

Definition hip_runtime_api.h:1282

dim3::dim3

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

Definition hip_runtime_api.h:1286

hip_Memcpy2D

Definition driver_types.h:115

hipAccessPolicyWindow

Definition hip_runtime_api.h:1530

hipAccessPolicyWindow::hitProp

hipAccessProperty hitProp

hipAccessProperty set for hit

Definition hip_runtime_api.h:1532

hipAccessPolicyWindow::missProp

hipAccessProperty missProp

hipAccessProperty set for miss

Definition hip_runtime_api.h:1534

hipAccessPolicyWindow::hitRatio

float hitRatio

hitRatio specifies percentage of lines assigned hitProp

Definition hip_runtime_api.h:1533

hipAccessPolicyWindow::base_ptr

void * base_ptr

Starting address of the access policy window.

Definition hip_runtime_api.h:1531

hipAccessPolicyWindow::num_bytes

size_t num_bytes

Size in bytes of the window policy.

Definition hip_runtime_api.h:1535

hipArrayMapInfo

Definition hip_runtime_api.h:1824

hipArrayMapInfo::level

unsigned int level

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

Definition hip_runtime_api.h:1834

hipArrayMapInfo::flags

unsigned int flags

flags for future use, must be zero now.

Definition hip_runtime_api.h:1858

hipArrayMapInfo::subresourceType

hipArraySparseSubresourceType subresourceType

Sparse subresource type.

Definition hip_runtime_api.h:1830

hipArrayMapInfo::extentDepth

unsigned int extentDepth

Depth in elements.

Definition hip_runtime_api.h:1842

hipArrayMapInfo::offsetX

unsigned int offsetX

X offset in elements.

Definition hip_runtime_api.h:1837

hipArrayMapInfo::array

hipArray_t array

Definition hip_runtime_api.h:1828

hipArrayMapInfo::resourceType

hipResourceType resourceType

Resource type.

Definition hip_runtime_api.h:1825

hipArrayMapInfo::memOperationType

hipMemOperationType memOperationType

Memory operation type.

Definition hip_runtime_api.h:1851

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

hipArrayMapInfo::extentWidth

unsigned int extentWidth

Width in elements.

Definition hip_runtime_api.h:1840

hipArrayMapInfo::sparseLevel

struct hipArrayMapInfo::@35::@37 sparseLevel

hipArrayMapInfo::extentHeight

unsigned int extentHeight

Height in elements.

Definition hip_runtime_api.h:1841

hipArrayMapInfo::offsetY

unsigned int offsetY

Y offset in elements.

Definition hip_runtime_api.h:1838

hipArrayMapInfo::memHandleType

hipMemHandleType memHandleType

Memory handle type.

Definition hip_runtime_api.h:1852

hipArrayMapInfo::memHandle

hipMemGenericAllocationHandle_t memHandle

Definition hip_runtime_api.h:1854

hipArrayMapInfo::mipmap

hipMipmappedArray mipmap

Definition hip_runtime_api.h:1827

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

hipArrayMapInfo::deviceBitMask

unsigned int deviceBitMask

Device ordinal bit mask.

Definition hip_runtime_api.h:1857

hipArrayMapInfo::size

unsigned long long size

Extent in bytes.

Definition hip_runtime_api.h:1848

hipArrayMapInfo::offset

unsigned long long offset

Offset within mip tail.

Definition hip_runtime_api.h:1847

hipArrayMapInfo::offsetZ

unsigned int offsetZ

Z offset in elements.

Definition hip_runtime_api.h:1839

hipArrayMapInfo::resource

union hipArrayMapInfo::@34 resource

hipBatchMemOpNodeParams

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

Definition hip_runtime_api.h:1060

hipBatchMemOpNodeParams::paramArray

hipStreamBatchMemOpParams * paramArray

Definition hip_runtime_api.h:1063

hipBatchMemOpNodeParams::count

unsigned int count

Definition hip_runtime_api.h:1062

hipBatchMemOpNodeParams::flags

unsigned int flags

Definition hip_runtime_api.h:1064

hipBatchMemOpNodeParams::ctx

hipCtx_t ctx

Definition hip_runtime_api.h:1061

hipChannelFormatDesc

Definition driver_types.h:59

hipChildGraphNodeParams

Definition hip_runtime_api.h:1874

hipChildGraphNodeParams::graph

hipGraph_t graph

Definition hip_runtime_api.h:1875

hipDeviceArch_t

Definition hip_runtime_api.h:65

hipDeviceArch_t::hasSharedInt64Atomics

unsigned hasSharedInt64Atomics

64-bit integer atomics for shared memory.

Definition hip_runtime_api.h:75

hipDeviceArch_t::hasSharedInt32Atomics

unsigned hasSharedInt32Atomics

32-bit integer atomics for shared memory.

Definition hip_runtime_api.h:69

hipDeviceArch_t::hasFloatAtomicAdd

unsigned hasFloatAtomicAdd

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

Definition hip_runtime_api.h:71

hipDeviceArch_t::hasDoubles

unsigned hasDoubles

Double-precision floating point.

Definition hip_runtime_api.h:78

hipDeviceArch_t::hasWarpVote

unsigned hasWarpVote

Warp vote instructions (__any, __all).

Definition hip_runtime_api.h:81

hipDeviceArch_t::hasWarpShuffle

unsigned hasWarpShuffle

Warp shuffle operations. (__shfl_*).

Definition hip_runtime_api.h:83

hipDeviceArch_t::hasGlobalInt32Atomics

unsigned hasGlobalInt32Atomics

32-bit integer atomics for global memory.

Definition hip_runtime_api.h:67

hipDeviceArch_t::hasGlobalFloatAtomicExch

unsigned hasGlobalFloatAtomicExch

32-bit float atomic exch for global memory.

Definition hip_runtime_api.h:68

hipDeviceArch_t::hasDynamicParallelism

unsigned hasDynamicParallelism

Dynamic parallelism.

Definition hip_runtime_api.h:93

hipDeviceArch_t::hasSurfaceFuncs

unsigned hasSurfaceFuncs

Surface functions.

Definition hip_runtime_api.h:91

hipDeviceArch_t::has3dGrid

unsigned has3dGrid

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

Definition hip_runtime_api.h:92

hipDeviceArch_t::hasFunnelShift

unsigned hasFunnelShift

Funnel two words into one with shift&mask caps.

Definition hip_runtime_api.h:84

hipDeviceArch_t::hasThreadFenceSystem

unsigned hasThreadFenceSystem

__threadfence_system.

Definition hip_runtime_api.h:87

hipDeviceArch_t::hasGlobalInt64Atomics

unsigned hasGlobalInt64Atomics

64-bit integer atomics for global memory.

Definition hip_runtime_api.h:74

hipDeviceArch_t::hasSyncThreadsExt

unsigned hasSyncThreadsExt

__syncthreads_count, syncthreads_and, syncthreads_or.

Definition hip_runtime_api.h:88

hipDeviceArch_t::hasWarpBallot

unsigned hasWarpBallot

Warp ballot instructions (__ballot).

Definition hip_runtime_api.h:82

hipDeviceArch_t::hasSharedFloatAtomicExch

unsigned hasSharedFloatAtomicExch

32-bit float atomic exch for shared memory.

Definition hip_runtime_api.h:70

hipDeviceProp_t

Definition hip_runtime_api.h:111

hipDeviceProp_t::ECCEnabled

int ECCEnabled

Device has ECC support enabled.

Definition hip_runtime_api.h:171

hipDeviceProp_t::ipcEventSupported

int ipcEventSupported

Device supports IPC events.

Definition hip_runtime_api.h:225

hipDeviceProp_t::computePreemptionSupported

int computePreemptionSupported

Is compute preemption supported on the device.

Definition hip_runtime_api.h:197

hipDeviceProp_t::maxTexture1DLinear

int maxTexture1DLinear

Maximum size for 1D textures bound to linear memory.

Definition hip_runtime_api.h:150

hipDeviceProp_t::timelineSemaphoreInteropSupported

int timelineSemaphoreInteropSupported

Indicates external timeline semaphore support.

Definition hip_runtime_api.h:215

hipDeviceProp_t::pciBusID

int pciBusID

PCI Bus ID.

Definition hip_runtime_api.h:172

hipDeviceProp_t::maxTexture1D

int maxTexture1D

Maximum number of elements in 1D images.

Definition hip_runtime_api.h:148

hipDeviceProp_t::memoryBusWidth

int memoryBusWidth

Global memory bus width in bits.

Definition hip_runtime_api.h:179

hipDeviceProp_t::maxTexture2DMipmap

int maxTexture2DMipmap[2]

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

Definition hip_runtime_api.h:152

hipDeviceProp_t::clockRate

int clockRate

Max clock frequency of the multiProcessors in khz.

Definition hip_runtime_api.h:125

hipDeviceProp_t::maxThreadsPerMultiProcessor

int maxThreadsPerMultiProcessor

Maximum resident threads per multi-processor.

Definition hip_runtime_api.h:182

hipDeviceProp_t::l2CacheSize

int l2CacheSize

L2 cache size.

Definition hip_runtime_api.h:180

hipDeviceProp_t::deferredMappingHipArraySupported

int deferredMappingHipArraySupported

Definition hip_runtime_api.h:223

hipDeviceProp_t::asyncEngineCount

int asyncEngineCount

Number of async engines.

Definition hip_runtime_api.h:176

hipDeviceProp_t::accessPolicyMaxWindowSize

int accessPolicyMaxWindowSize

Max value of access policy window.

Definition hip_runtime_api.h:209

hipDeviceProp_t::totalConstMem

size_t totalConstMem

Definition hip_runtime_api.h:126

hipDeviceProp_t::memoryPoolsSupported

int memoryPoolsSupported

Indicates if device supports hipMallocAsync and hipMemPool APIs.

Definition hip_runtime_api.h:216

hipDeviceProp_t::unifiedFunctionPointers

int unifiedFunctionPointers

Indicates device supports unified function pointers.

Definition hip_runtime_api.h:227

hipDeviceProp_t::maxTexture2DGather

int maxTexture2DGather[2]

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

Definition hip_runtime_api.h:154

hipDeviceProp_t::memPitch

size_t memPitch

Definition hip_runtime_api.h:120

hipDeviceProp_t::gpuDirectRDMAWritesOrdering

int gpuDirectRDMAWritesOrdering

value of hipGPUDirectRDMAWritesOrdering

Definition hip_runtime_api.h:220

hipDeviceProp_t::uuid

hipUUID uuid

UUID of a device.

Definition hip_runtime_api.h:113

hipDeviceProp_t::sharedMemPerBlock

size_t sharedMemPerBlock

Size of shared memory per block (in bytes).

Definition hip_runtime_api.h:117

hipDeviceProp_t::gpuDirectRDMAFlushWritesOptions

unsigned int gpuDirectRDMAFlushWritesOptions

Definition hip_runtime_api.h:218

hipDeviceProp_t::surfaceAlignment

size_t surfaceAlignment

Alignment requirement for surface.

Definition hip_runtime_api.h:169

hipDeviceProp_t::reserved

int reserved[63]

CUDA Reserved.

Definition hip_runtime_api.h:228

hipDeviceProp_t::maxTexture2DLayered

int maxTexture2DLayered[3]

Maximum number of elements in 2D array images.

Definition hip_runtime_api.h:160

hipDeviceProp_t::streamPrioritiesSupported

int streamPrioritiesSupported

Device supports stream priority.

Definition hip_runtime_api.h:183

hipDeviceProp_t::cooperativeMultiDeviceLaunch

int cooperativeMultiDeviceLaunch

Definition hip_runtime_api.h:201

hipDeviceProp_t::hostRegisterSupported

int hostRegisterSupported

Device supports hipHostRegister.

Definition hip_runtime_api.h:211

hipDeviceProp_t::pageableMemoryAccess

int pageableMemoryAccess

Definition hip_runtime_api.h:193

hipDeviceProp_t::name

char name[256]

Device name.

Definition hip_runtime_api.h:112

hipDeviceProp_t::textureAlignment

size_t textureAlignment

Alignment requirement for textures.

Definition hip_runtime_api.h:137

hipDeviceProp_t::globalL1CacheSupported

int globalL1CacheSupported

Indicates globals are cached in L1.

Definition hip_runtime_api.h:184

hipDeviceProp_t::hostNativeAtomicSupported

int hostNativeAtomicSupported

Link between host and device supports native atomics.

Definition hip_runtime_api.h:191

hipDeviceProp_t::maxSurfaceCubemapLayered

int maxSurfaceCubemapLayered[2]

Maximum cubemap layered surface size.

Definition hip_runtime_api.h:168

hipDeviceProp_t::maxTextureCubemapLayered

int maxTextureCubemapLayered[2]

Maximum cubemaps layered texture dims.

Definition hip_runtime_api.h:161

hipDeviceProp_t::sharedMemPerBlockOptin

size_t sharedMemPerBlockOptin

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

Definition hip_runtime_api.h:203

hipDeviceProp_t::sharedMemPerMultiprocessor

size_t sharedMemPerMultiprocessor

Amount of shared memory available per multiprocessor.

Definition hip_runtime_api.h:186

hipDeviceProp_t::singleToDoublePrecisionPerfRatio

int singleToDoublePrecisionPerfRatio

Deprecated. CUDA only.

Definition hip_runtime_api.h:192

hipDeviceProp_t::maxSurface2D

int maxSurface2D[2]

Maximum 2D surface size.

Definition hip_runtime_api.h:163

hipDeviceProp_t::memoryClockRate

int memoryClockRate

Max global memory clock frequency in khz.

Definition hip_runtime_api.h:178

hipDeviceProp_t::maxTexture2DLinear

int maxTexture2DLinear[3]

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

Definition hip_runtime_api.h:153

hipDeviceProp_t::sparseHipArraySupported

int sparseHipArraySupported

Indicates if device supports sparse hip arrays.

Definition hip_runtime_api.h:212

hipDeviceProp_t::clockInstructionRate

int clockInstructionRate

Definition hip_runtime_api.h:235

hipDeviceProp_t::localL1CacheSupported

int localL1CacheSupported

Locals are cahced in L1.

Definition hip_runtime_api.h:185

hipDeviceProp_t::regsPerMultiprocessor

int regsPerMultiprocessor

registers available per multiprocessor

Definition hip_runtime_api.h:187

hipDeviceProp_t::regsPerBlock

int regsPerBlock

Registers per block.

Definition hip_runtime_api.h:118

hipDeviceProp_t::maxTexture2D

int maxTexture2D[2]

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

Definition hip_runtime_api.h:151

hipDeviceProp_t::cooperativeLaunch

int cooperativeLaunch

HIP device supports cooperative launch.

Definition hip_runtime_api.h:200

hipDeviceProp_t::maxTexture3D

int maxTexture3D[3]

Definition hip_runtime_api.h:155

hipDeviceProp_t::directManagedMemAccessFromHost

int directManagedMemAccessFromHost

Definition hip_runtime_api.h:206

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedFunc

int cooperativeMultiDeviceUnmatchedFunc

Definition hip_runtime_api.h:240

hipDeviceProp_t::deviceOverlap

int deviceOverlap

Deprecated. Use asyncEngineCount instead.

Definition hip_runtime_api.h:139

hipDeviceProp_t::pageableMemoryAccessUsesHostPageTables

int pageableMemoryAccessUsesHostPageTables

Definition hip_runtime_api.h:204

hipDeviceProp_t::hdpRegFlushCntl

unsigned int * hdpRegFlushCntl

Addres of HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:239

hipDeviceProp_t::maxThreadsDim

int maxThreadsDim[3]

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

Definition hip_runtime_api.h:123

hipDeviceProp_t::unifiedAddressing

int unifiedAddressing

Does device and host share unified address space.

Definition hip_runtime_api.h:177

hipDeviceProp_t::multiGpuBoardGroupID

int multiGpuBoardGroupID

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

Definition hip_runtime_api.h:190

hipDeviceProp_t::isMultiGpuBoard

int isMultiGpuBoard

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

Definition hip_runtime_api.h:189

hipDeviceProp_t::canUseHostPointerForRegisteredMem

int canUseHostPointerForRegisteredMem

Definition hip_runtime_api.h:198

hipDeviceProp_t::maxTexture1DLayered

int maxTexture1DLayered[2]

Maximum number of elements in 1D array images.

Definition hip_runtime_api.h:159

hipDeviceProp_t::pciDomainID

int pciDomainID

PCI Domain ID.

Definition hip_runtime_api.h:174

hipDeviceProp_t::maxSharedMemoryPerMultiProcessor

size_t maxSharedMemoryPerMultiProcessor

Maximum Shared Memory Per CU. HIP Only.

Definition hip_runtime_api.h:234

hipDeviceProp_t::maxTextureCubemap

int maxTextureCubemap

Maximum cubemap texture dims.

Definition hip_runtime_api.h:158

hipDeviceProp_t::hipReserved

int hipReserved[32]

Reserved for adding new entries for HIP/CUDA.

Definition hip_runtime_api.h:230

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedGridDim

int cooperativeMultiDeviceUnmatchedGridDim

Definition hip_runtime_api.h:243

hipDeviceProp_t::gpuDirectRDMASupported

int gpuDirectRDMASupported

Indicates device support of RDMA APIs.

Definition hip_runtime_api.h:217

hipDeviceProp_t::minor

int minor

Definition hip_runtime_api.h:132

hipDeviceProp_t::gcnArchName

char gcnArchName[256]

AMD GCN Arch Name. HIP Only.

Definition hip_runtime_api.h:233

hipDeviceProp_t::luid

char luid[8]

8-byte unique identifier. Only valid on windows

Definition hip_runtime_api.h:114

hipDeviceProp_t::kernelExecTimeoutEnabled

int kernelExecTimeoutEnabled

Run time limit for kernels executed on the device.

Definition hip_runtime_api.h:144

hipDeviceProp_t::memoryPoolSupportedHandleTypes

unsigned int memoryPoolSupportedHandleTypes

Bitmask of handle types support with mempool based IPC.

Definition hip_runtime_api.h:222

hipDeviceProp_t::hdpMemFlushCntl

unsigned int * hdpMemFlushCntl

Addres of HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:238

hipDeviceProp_t::concurrentManagedAccess

int concurrentManagedAccess

Definition hip_runtime_api.h:195

hipDeviceProp_t::integrated

int integrated

APU vs dGPU.

Definition hip_runtime_api.h:145

hipDeviceProp_t::canMapHostMemory

int canMapHostMemory

Check whether HIP can map host memory.

Definition hip_runtime_api.h:146

hipDeviceProp_t::reservedSharedMemPerBlock

size_t reservedSharedMemPerBlock

Shared memory reserved by driver per block.

Definition hip_runtime_api.h:210

hipDeviceProp_t::maxSurfaceCubemap

int maxSurfaceCubemap

Maximum cubemap surface size.

Definition hip_runtime_api.h:167

hipDeviceProp_t::maxSurface3D

int maxSurface3D[3]

Maximum 3D surface size.

Definition hip_runtime_api.h:164

hipDeviceProp_t::asicRevision

int asicRevision

Revision of the GPU in this device.

Definition hip_runtime_api.h:253

hipDeviceProp_t::totalGlobalMem

size_t totalGlobalMem

Size of global memory region (in bytes).

Definition hip_runtime_api.h:116

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedBlockDim

int cooperativeMultiDeviceUnmatchedBlockDim

Definition hip_runtime_api.h:246

hipDeviceProp_t::maxSurface1DLayered

int maxSurface1DLayered[2]

Maximum 1D layered surface size.

Definition hip_runtime_api.h:165

hipDeviceProp_t::persistingL2CacheMaxSize

int persistingL2CacheMaxSize

Device's max L2 persisting lines in bytes.

Definition hip_runtime_api.h:181

hipDeviceProp_t::maxSurface1D

int maxSurface1D

Maximum 1D surface size.

Definition hip_runtime_api.h:162

hipDeviceProp_t::concurrentKernels

int concurrentKernels

Device can possibly execute multiple kernels concurrently.

Definition hip_runtime_api.h:170

hipDeviceProp_t::isLargeBar

int isLargeBar

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

Definition hip_runtime_api.h:252

hipDeviceProp_t::clusterLaunch

int clusterLaunch

Device supports cluster launch.

Definition hip_runtime_api.h:226

hipDeviceProp_t::maxTexture1DMipmap

int maxTexture1DMipmap

Maximum 1D mipmap texture size.

Definition hip_runtime_api.h:149

hipDeviceProp_t::multiProcessorCount

int multiProcessorCount

Definition hip_runtime_api.h:140

hipDeviceProp_t::maxTexture3DAlt

int maxTexture3DAlt[3]

Maximum alternate 3D texture dims.

Definition hip_runtime_api.h:157

hipDeviceProp_t::maxGridSize

int maxGridSize[3]

Max grid dimensions (XYZ).

Definition hip_runtime_api.h:124

hipDeviceProp_t::pciDeviceID

int pciDeviceID

PCI Device ID.

Definition hip_runtime_api.h:173

hipDeviceProp_t::maxBlocksPerMultiProcessor

int maxBlocksPerMultiProcessor

Max number of blocks on CU.

Definition hip_runtime_api.h:208

hipDeviceProp_t::computeMode

int computeMode

Compute mode.

Definition hip_runtime_api.h:147

hipDeviceProp_t::maxSurface2DLayered

int maxSurface2DLayered[3]

Maximum 2D layared surface size.

Definition hip_runtime_api.h:166

hipDeviceProp_t::major

int major

Definition hip_runtime_api.h:128

hipDeviceProp_t::warpSize

int warpSize

Warp size.

Definition hip_runtime_api.h:119

hipDeviceProp_t::tccDriver

int tccDriver

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

Definition hip_runtime_api.h:175

hipDeviceProp_t::luidDeviceNodeMask

unsigned int luidDeviceNodeMask

LUID node mask.

Definition hip_runtime_api.h:115

hipDeviceProp_t::hostRegisterReadOnlySupported

int hostRegisterReadOnlySupported

Definition hip_runtime_api.h:213

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedSharedMem

int cooperativeMultiDeviceUnmatchedSharedMem

Definition hip_runtime_api.h:249

hipDeviceProp_t::maxThreadsPerBlock

int maxThreadsPerBlock

Max work items per work group or workgroup max size.

Definition hip_runtime_api.h:122

hipDeviceProp_t::arch

hipDeviceArch_t arch

Architectural feature flags. New for HIP.

Definition hip_runtime_api.h:237

hipDeviceProp_t::managedMemory

int managedMemory

Device supports allocating managed memory on this system.

Definition hip_runtime_api.h:188

hipDeviceProp_t::texturePitchAlignment

size_t texturePitchAlignment

Pitch alignment requirement for texture references bound to.

Definition hip_runtime_api.h:138

hipEventRecordNodeParams

Definition hip_runtime_api.h:1889

hipEventRecordNodeParams::event

hipEvent_t event

The event to be recorded when node executes.

Definition hip_runtime_api.h:1890

hipEventWaitNodeParams

Definition hip_runtime_api.h:1882

hipEventWaitNodeParams::event

hipEvent_t event

Event to wait on.

Definition hip_runtime_api.h:1883

hipExtent

Definition driver_types.h:394

hipExternalMemoryBufferDesc

Definition hip_runtime_api.h:1340

hipExternalMemoryBufferDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1343

hipExternalMemoryBufferDesc::offset

unsigned long long offset

Definition hip_runtime_api.h:1341

hipExternalMemoryBufferDesc::size

unsigned long long size

Definition hip_runtime_api.h:1342

hipExternalMemoryHandleDesc

Definition hip_runtime_api.h:1326

hipExternalMemoryHandleDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1337

hipExternalMemoryHandleDesc::name

const void * name

Definition hip_runtime_api.h:1332

hipExternalMemoryHandleDesc::fd

int fd

Definition hip_runtime_api.h:1329

hipExternalMemoryHandleDesc::size

unsigned long long size

Definition hip_runtime_api.h:1336

hipExternalMemoryHandleDesc::type

hipExternalMemoryHandleType type

Definition hip_runtime_api.h:1327

hipExternalMemoryHandleDesc::nvSciBufObject

const void * nvSciBufObject

Definition hip_runtime_api.h:1334

hipExternalMemoryHandleDesc::handle

void * handle

Definition hip_runtime_api.h:1331

hipExternalMemoryMipmappedArrayDesc

Definition hip_runtime_api.h:1346

hipExternalMemoryMipmappedArrayDesc::extent

hipExtent extent

Definition hip_runtime_api.h:1349

hipExternalMemoryMipmappedArrayDesc::numLevels

unsigned int numLevels

Definition hip_runtime_api.h:1351

hipExternalMemoryMipmappedArrayDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1350

hipExternalMemoryMipmappedArrayDesc::offset

unsigned long long offset

Definition hip_runtime_api.h:1347

hipExternalMemoryMipmappedArrayDesc::formatDesc

hipChannelFormatDesc formatDesc

Definition hip_runtime_api.h:1348

hipExternalSemaphoreHandleDesc

Definition hip_runtime_api.h:1366

hipExternalSemaphoreHandleDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1376

hipExternalSemaphoreHandleDesc::name

const void * name

Definition hip_runtime_api.h:1372

hipExternalSemaphoreHandleDesc::NvSciSyncObj

const void * NvSciSyncObj

Definition hip_runtime_api.h:1374

hipExternalSemaphoreHandleDesc::type

hipExternalSemaphoreHandleType type

Definition hip_runtime_api.h:1367

hipExternalSemaphoreHandleDesc::handle

void * handle

Definition hip_runtime_api.h:1371

hipExternalSemaphoreHandleDesc::fd

int fd

Definition hip_runtime_api.h:1369

hipExternalSemaphoreSignalNodeParams

Definition hip_runtime_api.h:1764

hipExternalSemaphoreSignalNodeParams::paramsArray

const hipExternalSemaphoreSignalParams * paramsArray

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

Definition hip_runtime_api.h:1768

hipExternalSemaphoreSignalNodeParams::extSemArray

hipExternalSemaphore_t * extSemArray

< Array containing external semaphore handles.

Definition hip_runtime_api.h:1766

hipExternalSemaphoreSignalNodeParams::numExtSems

unsigned int numExtSems

Definition hip_runtime_api.h:1770

hipExternalSemaphoreSignalParams

Definition hip_runtime_api.h:1380

hipExternalSemaphoreSignalParams::reserved

unsigned long long reserved

Definition hip_runtime_api.h:1387

hipExternalSemaphoreSignalParams::value

unsigned long long value

Definition hip_runtime_api.h:1383

hipExternalSemaphoreSignalParams::fence

void * fence

Definition hip_runtime_api.h:1386

hipExternalSemaphoreSignalParams::flags

unsigned int flags

Definition hip_runtime_api.h:1394

hipExternalSemaphoreSignalParams::key

unsigned long long key

Definition hip_runtime_api.h:1390

hipExternalSemaphoreWaitNodeParams

Definition hip_runtime_api.h:1776

hipExternalSemaphoreWaitNodeParams::numExtSems

unsigned int numExtSems

Definition hip_runtime_api.h:1782

hipExternalSemaphoreWaitNodeParams::paramsArray

const hipExternalSemaphoreWaitParams * paramsArray

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

Definition hip_runtime_api.h:1780

hipExternalSemaphoreWaitNodeParams::extSemArray

hipExternalSemaphore_t * extSemArray

< Array containing external semaphore handles.

Definition hip_runtime_api.h:1778

hipExternalSemaphoreWaitParams

Definition hip_runtime_api.h:1400

hipExternalSemaphoreWaitParams::value

unsigned long long value

Definition hip_runtime_api.h:1403

hipExternalSemaphoreWaitParams::fence

void * fence

Definition hip_runtime_api.h:1406

hipExternalSemaphoreWaitParams::timeoutMs

unsigned int timeoutMs

Definition hip_runtime_api.h:1411

hipExternalSemaphoreWaitParams::key

unsigned long long key

Definition hip_runtime_api.h:1410

hipExternalSemaphoreWaitParams::flags

unsigned int flags

Definition hip_runtime_api.h:1415

hipExternalSemaphoreWaitParams::reserved

unsigned long long reserved

Definition hip_runtime_api.h:1407

hipFuncAttributes

Definition hip_runtime_api.h:702

hipFuncAttributes::cacheModeCA

int cacheModeCA

Definition hip_runtime_api.h:704

hipFuncAttributes::binaryVersion

int binaryVersion

Definition hip_runtime_api.h:703

hipFuncAttributes::constSizeBytes

size_t constSizeBytes

Definition hip_runtime_api.h:705

hipFuncAttributes::preferredShmemCarveout

int preferredShmemCarveout

Definition hip_runtime_api.h:710

hipFuncAttributes::sharedSizeBytes

size_t sharedSizeBytes

Definition hip_runtime_api.h:712

hipFuncAttributes::maxDynamicSharedSizeBytes

int maxDynamicSharedSizeBytes

Definition hip_runtime_api.h:707

hipFuncAttributes::ptxVersion

int ptxVersion

Definition hip_runtime_api.h:711

hipFuncAttributes::numRegs

int numRegs

Definition hip_runtime_api.h:709

hipFuncAttributes::localSizeBytes

size_t localSizeBytes

Definition hip_runtime_api.h:706

hipFuncAttributes::maxThreadsPerBlock

int maxThreadsPerBlock

Definition hip_runtime_api.h:708

hipFunctionLaunchParams

Definition hip_runtime_api.h:1304

hipFunctionLaunchParams::gridDimX

unsigned int gridDimX

Width(X) of grid in blocks.

Definition hip_runtime_api.h:1306

hipFunctionLaunchParams::blockDimX

unsigned int blockDimX

X dimension of each thread block.

Definition hip_runtime_api.h:1309

hipFunctionLaunchParams::function

hipFunction_t function

Kernel to launch.

Definition hip_runtime_api.h:1305

hipFunctionLaunchParams::hStream

hipStream_t hStream

Stream identifier.

Definition hip_runtime_api.h:1313

hipFunctionLaunchParams::blockDimY

unsigned int blockDimY

Y dimension of each thread block.

Definition hip_runtime_api.h:1310

hipFunctionLaunchParams::gridDimY

unsigned int gridDimY

Height(Y) of grid in blocks.

Definition hip_runtime_api.h:1307

hipFunctionLaunchParams::gridDimZ

unsigned int gridDimZ

Depth(Z) of grid in blocks.

Definition hip_runtime_api.h:1308

hipFunctionLaunchParams::sharedMemBytes

unsigned int sharedMemBytes

Shared memory.

Definition hip_runtime_api.h:1312

hipFunctionLaunchParams::blockDimZ

unsigned int blockDimZ

Z dimension of each thread block.

Definition hip_runtime_api.h:1311

hipFunctionLaunchParams::kernelParams

void ** kernelParams

Kernel parameters.

Definition hip_runtime_api.h:1314

hipGraphEdgeData

Definition hip_runtime_api.h:1946

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

hipGraphEdgeData::reserved

unsigned char reserved[5]

These bytes are unused and must be zeroed.

Definition hip_runtime_api.h:1955

hipGraphEdgeData::type

unsigned char type

This should be populated with a value from hipGraphDependencyType.

Definition hip_runtime_api.h:1958

hipGraphEdgeData::from_port

unsigned char from_port

Definition hip_runtime_api.h:1948

hipGraphInstantiateParams

Definition hip_runtime_api.h:1734

hipGraphInstantiateParams::result_out

hipGraphInstantiateResult result_out

Definition hip_runtime_api.h:1737

hipGraphInstantiateParams::uploadStream

hipStream_t uploadStream

Definition hip_runtime_api.h:1739

hipGraphInstantiateParams::errNode_out

hipGraphNode_t errNode_out

Definition hip_runtime_api.h:1735

hipGraphInstantiateParams::flags

unsigned long long flags

Definition hip_runtime_api.h:1736

hipGraphNodeParams

Definition hip_runtime_api.h:1903

hipGraphNodeParams::type

hipGraphNodeType type

Definition hip_runtime_api.h:1904

hipGraphNodeParams::reserved0

int reserved0[3]

Definition hip_runtime_api.h:1905

hipGraphNodeParams::alloc

hipMemAllocNodeParams alloc

Definition hip_runtime_api.h:1917

hipGraphNodeParams::reserved1

long long reserved1[29]

Definition hip_runtime_api.h:1907

hipGraphNodeParams::eventRecord

hipEventRecordNodeParams eventRecord

Definition hip_runtime_api.h:1914

hipGraphNodeParams::extSemSignal

hipExternalSemaphoreSignalNodeParams extSemSignal

Definition hip_runtime_api.h:1915

hipGraphNodeParams::free

hipMemFreeNodeParams free

Definition hip_runtime_api.h:1918

hipGraphNodeParams::graph

hipChildGraphNodeParams graph

Definition hip_runtime_api.h:1912

hipGraphNodeParams::extSemWait

hipExternalSemaphoreWaitNodeParams extSemWait

Definition hip_runtime_api.h:1916

hipGraphNodeParams::memset

hipMemsetParams memset

Definition hip_runtime_api.h:1910

hipGraphNodeParams::host

hipHostNodeParams host

Definition hip_runtime_api.h:1911

hipGraphNodeParams::reserved2

long long reserved2

Definition hip_runtime_api.h:1921

hipGraphNodeParams::kernel

hipKernelNodeParams kernel

Definition hip_runtime_api.h:1908

hipGraphNodeParams::eventWait

hipEventWaitNodeParams eventWait

Definition hip_runtime_api.h:1913

hipGraphNodeParams::memcpy

hipMemcpyNodeParams memcpy

Definition hip_runtime_api.h:1909

hipHostNodeParams

Definition hip_runtime_api.h:1486

hipHostNodeParams::fn

hipHostFn_t fn

Definition hip_runtime_api.h:1487

hipHostNodeParams::userData

void * userData

Definition hip_runtime_api.h:1488

hipIpcEventHandle_t

Definition hip_runtime_api.h:689

hipIpcMemHandle_t

Definition hip_runtime_api.h:686

hipKernelNodeParams

Definition hip_runtime_api.h:1490

hipKernelNodeParams::gridDim

dim3 gridDim

Definition hip_runtime_api.h:1494

hipKernelNodeParams::sharedMemBytes

unsigned int sharedMemBytes

Definition hip_runtime_api.h:1496

hipKernelNodeParams::blockDim

dim3 blockDim

Definition hip_runtime_api.h:1491

hipKernelNodeParams::kernelParams

void ** kernelParams

Definition hip_runtime_api.h:1495

hipKernelNodeParams::extra

void ** extra

Definition hip_runtime_api.h:1492

hipKernelNodeParams::func

void * func

Definition hip_runtime_api.h:1493

hipLaunchAttribute

Definition hip_runtime_api.h:1965

hipLaunchAttribute::val

hipLaunchAttributeValue val

Value associated with the launch attribute.

Definition hip_runtime_api.h:1969

hipLaunchAttribute::id

hipLaunchAttributeID id

Identifier of the launch attribute.

Definition hip_runtime_api.h:1966

hipLaunchAttribute::value

hipLaunchAttributeValue value

Value associated with the launch attribute.

Definition hip_runtime_api.h:1970

hipLaunchConfig_t

Definition hip_runtime_api.h:1977

hipLaunchConfig_t::blockDim

dim3 blockDim

Block dimensions.

Definition hip_runtime_api.h:1979

hipLaunchConfig_t::gridDim

dim3 gridDim

Grid dimensions.

Definition hip_runtime_api.h:1978

hipLaunchConfig_t::numAttrs

unsigned int numAttrs

Number of attributes.

Definition hip_runtime_api.h:1983

hipLaunchConfig_t::stream

hipStream_t stream

Stream identifier.

Definition hip_runtime_api.h:1981

hipLaunchConfig_t::dynamicSmemBytes

size_t dynamicSmemBytes

Dynamic shared-memory size per thread block.

Definition hip_runtime_api.h:1980

hipLaunchConfig_t::attrs

hipLaunchAttribute * attrs

Attributes list.

Definition hip_runtime_api.h:1982

hipLaunchMemSyncDomainMap

Definition hip_runtime_api.h:1541

hipLaunchMemSyncDomainMap::remote

unsigned char remote

Definition hip_runtime_api.h:1543

hipLaunchMemSyncDomainMap::default_

unsigned char default_

Definition hip_runtime_api.h:1542

hipLaunchParams

Definition hip_runtime_api.h:1293

hipLaunchParams::sharedMem

size_t sharedMem

Shared memory.

Definition hip_runtime_api.h:1298

hipLaunchParams::args

void ** args

Arguments.

Definition hip_runtime_api.h:1297

hipLaunchParams::blockDim

dim3 blockDim

Block dimensions.

Definition hip_runtime_api.h:1296

hipLaunchParams::gridDim

dim3 gridDim

Grid dimensions.

Definition hip_runtime_api.h:1295

hipLaunchParams::func

void * func

Device function symbol.

Definition hip_runtime_api.h:1294

hipLaunchParams::stream

hipStream_t stream

Stream identifier.

Definition hip_runtime_api.h:1299

hipMemAccessDesc

Definition hip_runtime_api.h:1199

hipMemAccessDesc::flags

hipMemAccessFlags flags

Accessibility flags to set.

Definition hip_runtime_api.h:1201

hipMemAccessDesc::location

hipMemLocation location

Location on which the accessibility has to change.

Definition hip_runtime_api.h:1200

hipMemAllocNodeParams

Definition hip_runtime_api.h:1507

hipMemAllocNodeParams::accessDescs

const hipMemAccessDesc * accessDescs

The number of memory access descriptors.

Definition hip_runtime_api.h:1510

hipMemAllocNodeParams::bytesize

size_t bytesize

The size of the requested allocation in bytes.

Definition hip_runtime_api.h:1513

hipMemAllocNodeParams::poolProps

hipMemPoolProps poolProps

Definition hip_runtime_api.h:1508

hipMemAllocNodeParams::accessDescCount

size_t accessDescCount

Definition hip_runtime_api.h:1511

hipMemAllocNodeParams::dptr

void * dptr

Returned device address of the allocation.

Definition hip_runtime_api.h:1514

hipMemAllocationProp

Definition hip_runtime_api.h:1746

hipMemAllocationProp::win32HandleMetaData

void * win32HandleMetaData

Metadata for Win32 handles.

Definition hip_runtime_api.h:1753

hipMemAllocationProp::type

hipMemAllocationType type

Memory allocation type.

Definition hip_runtime_api.h:1747

hipMemAllocationProp::allocFlags

struct hipMemAllocationProp::@33 allocFlags

hipMemAllocationProp::gpuDirectRDMACapable

unsigned char gpuDirectRDMACapable

RDMA capable.

Definition hip_runtime_api.h:1756

hipMemAllocationProp::requestedHandleTypes

hipMemAllocationHandleType requestedHandleTypes

Requested handle types.

Definition hip_runtime_api.h:1750

hipMemAllocationProp::usage

unsigned short usage

Usage.

Definition hip_runtime_api.h:1757

hipMemAllocationProp::requestedHandleType

hipMemAllocationHandleType requestedHandleType

Requested handle type.

Definition hip_runtime_api.h:1749

hipMemAllocationProp::location

hipMemLocation location

Memory location.

Definition hip_runtime_api.h:1752

hipMemAllocationProp::compressionType

unsigned char compressionType

Compression type.

Definition hip_runtime_api.h:1755

hipMemFreeNodeParams

Definition hip_runtime_api.h:1896

hipMemFreeNodeParams::dptr

void * dptr

the pointer to be freed

Definition hip_runtime_api.h:1897

hipMemLocation

Definition driver_types.h:466

hipMemPoolProps

Definition hip_runtime_api.h:1229

hipMemPoolProps::maxSize

size_t maxSize

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

Definition hip_runtime_api.h:1239

hipMemPoolProps::reserved

unsigned char reserved[56]

Reserved for future use, must be 0.

Definition hip_runtime_api.h:1240

hipMemPoolProps::location

hipMemLocation location

Location where allocations should reside.

Definition hip_runtime_api.h:1234

hipMemPoolProps::handleTypes

hipMemAllocationHandleType handleTypes

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

Definition hip_runtime_api.h:1233

hipMemPoolProps::allocType

hipMemAllocationType allocType

Allocation type. Currently must be specified as hipMemAllocationTypePinned.

Definition hip_runtime_api.h:1231

hipMemPoolProps::win32SecurityAttributes

void * win32SecurityAttributes

Definition hip_runtime_api.h:1238

hipMemPoolPtrExportData

Definition hip_runtime_api.h:1245

hipMemPoolPtrExportData::reserved

unsigned char reserved[64]

Definition hip_runtime_api.h:1246

hipMemcpy3DBatchOp

Definition driver_types.h:543

hipMemcpy3DParms

Definition driver_types.h:411

hipMemcpy3DPeerParms

Definition driver_types.h:551

hipMemcpyAttributes

Definition driver_types.h:497

hipMemcpyNodeParams

Definition hip_runtime_api.h:1865

hipMemcpyNodeParams::reserved

int reserved[3]

Must be zero.

Definition hip_runtime_api.h:1867

hipMemcpyNodeParams::flags

int flags

Must be zero.

Definition hip_runtime_api.h:1866

hipMemcpyNodeParams::copyParams

hipMemcpy3DParms copyParams

Params set for the memory copy.

Definition hip_runtime_api.h:1868

hipMemsetParams

Definition hip_runtime_api.h:1498

hipMemsetParams::dst

void * dst

Definition hip_runtime_api.h:1499

hipMemsetParams::value

unsigned int value

Definition hip_runtime_api.h:1503

hipMemsetParams::elementSize

unsigned int elementSize

Definition hip_runtime_api.h:1500

hipMemsetParams::width

size_t width

Definition hip_runtime_api.h:1504

hipMemsetParams::pitch

size_t pitch

Definition hip_runtime_api.h:1502

hipMemsetParams::height

size_t height

Definition hip_runtime_api.h:1501

hipMipmappedArray

Definition driver_types.h:137

hipPitchedPtr

Definition driver_types.h:385

hipPointerAttribute_t

Definition hip_runtime_api.h:280

hipPointerAttribute_t::device

int device

Definition hip_runtime_api.h:282

hipPointerAttribute_t::hostPointer

void * hostPointer

Definition hip_runtime_api.h:284

hipPointerAttribute_t::type

enum hipMemoryType type

Definition hip_runtime_api.h:281

hipPointerAttribute_t::isManaged

int isManaged

Definition hip_runtime_api.h:285

hipPointerAttribute_t::devicePointer

void * devicePointer

Definition hip_runtime_api.h:283

hipPointerAttribute_t::allocationFlags

unsigned allocationFlags

Definition hip_runtime_api.h:286

hipResourceDesc

Definition driver_types.h:286

hipResourceViewDesc

Definition driver_types.h:345

hipStreamBatchMemOpParams::hipStreamMemOpFlushRemoteWritesParams_t

Definition hip_runtime_api.h:1022

hipStreamBatchMemOpParams::hipStreamMemOpFlushRemoteWritesParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:1024

hipStreamBatchMemOpParams::hipStreamMemOpFlushRemoteWritesParams_t::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:1023

hipStreamBatchMemOpParams::hipStreamMemOpMemoryBarrierParams_t

Definition hip_runtime_api.h:1026

hipStreamBatchMemOpParams::hipStreamMemOpMemoryBarrierParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:1028

hipStreamBatchMemOpParams::hipStreamMemOpMemoryBarrierParams_t::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:1027

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t

Definition hip_runtime_api.h:1002

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:1003

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::value64

uint64_t value64

Definition hip_runtime_api.h:1007

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::address

hipDeviceptr_t address

Definition hip_runtime_api.h:1004

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::alias

hipDeviceptr_t alias

Not valid for AMD backend. Initial value is unimportant.

Definition hip_runtime_api.h:1010

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::value

uint32_t value

Definition hip_runtime_api.h:1006

hipStreamBatchMemOpParams::hipStreamMemOpWaitValueParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:1009

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t

Definition hip_runtime_api.h:1012

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::address

hipDeviceptr_t address

Definition hip_runtime_api.h:1014

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::alias

hipDeviceptr_t alias

Not valid for AMD backend. Initial value is unimportant.

Definition hip_runtime_api.h:1020

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::value

uint32_t value

Definition hip_runtime_api.h:1016

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:1013

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::flags

unsigned int flags

Definition hip_runtime_api.h:1019

hipStreamBatchMemOpParams::hipStreamMemOpWriteValueParams_t::value64

uint64_t value64

Definition hip_runtime_api.h:1017

hipTextureDesc

Definition texture_types.h:116

hipUUID

Definition hip_runtime_api.h:96

texture

Definition texture_types.h:147

textureReference

Definition texture_types.h:95

surface_types.h

Defines surface types for HIP runtime.

hipSurfaceObject_t

struct __hip_surface * hipSurfaceObject_t

Definition surface_types.h:43

texture_types.h

hipTextureObject_t

struct __hip_texture * hipTextureObject_t

Definition texture_types.h:70

hipTextureAddressMode

hipTextureAddressMode

Definition texture_types.h:75

hipTextureFilterMode

hipTextureFilterMode

Definition texture_types.h:85

hipLaunchAttributeValue

Definition hip_runtime_api.h:1582

hipLaunchAttributeValue::priority

int priority

Definition hip_runtime_api.h:1588

hipLaunchAttributeValue::pad

char pad[64]

64 byte padding

Definition hip_runtime_api.h:1583

hipLaunchAttributeValue::memSyncDomain

hipLaunchMemSyncDomain memSyncDomain

Value of launch attribute hipLaunchAttributeMemSyncDomain.

Definition hip_runtime_api.h:1596

hipLaunchAttributeValue::cooperative

int cooperative

Definition hip_runtime_api.h:1586

hipLaunchAttributeValue::accessPolicyWindow

hipAccessPolicyWindow accessPolicyWindow

Value of launch attribute hipLaunchAttributeAccessPolicyWindow.

Definition hip_runtime_api.h:1585

hipLaunchAttributeValue::syncPolicy

hipSynchronizationPolicy syncPolicy

Definition hip_runtime_api.h:1591

hipLaunchAttributeValue::memSyncDomainMap

hipLaunchMemSyncDomainMap memSyncDomainMap

Value of launch attribute hipLaunchAttributeMemSyncDomainMap.

Definition hip_runtime_api.h:1594

hipStreamBatchMemOpParams

Union representing batch memory operation parameters for HIP streams.

Definition hip_runtime_api.h:1000

hipStreamBatchMemOpParams::operation

hipStreamBatchMemOpType operation

Definition hip_runtime_api.h:1001