/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-6.1.5/include/hip/hip_runtime_api.h Source File

• include
• hip

hip_runtime_api.h

Go to the documentation of this file.

1 /*

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

3 

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

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

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

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

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

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

10 

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

12 all copies or substantial portions of the Software.

13 

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

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

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

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

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

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

20 THE SOFTWARE.

21 */

22 

30 #ifndef HIP_INCLUDE_HIP_HIP_RUNTIME_API_H

31 #define HIP_INCLUDE_HIP_HIP_RUNTIME_API_H

32 

33 #include <string.h> // for getDeviceProp

34 #include <hip/hip_version.h>

35 #include <hip/hip_common.h>

36 

37 enum {

38  HIP_SUCCESS = 0,

39  HIP_ERROR_INVALID_VALUE,

40  HIP_ERROR_NOT_INITIALIZED,

41  HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

42 };

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

53 typedef struct {

54  // 32-bit Atomics

55  unsigned hasGlobalInt32Atomics : 1;

56  unsigned hasGlobalFloatAtomicExch : 1;

57  unsigned hasSharedInt32Atomics : 1;

58  unsigned hasSharedFloatAtomicExch : 1;

59  unsigned hasFloatAtomicAdd : 1;

60 

61  // 64-bit Atomics

62  unsigned hasGlobalInt64Atomics : 1;

63  unsigned hasSharedInt64Atomics : 1;

64 

65  // Doubles

66  unsigned hasDoubles : 1;

67 

68  // Warp cross-lane operations

69  unsigned hasWarpVote : 1;

70  unsigned hasWarpBallot : 1;

71  unsigned hasWarpShuffle : 1;

72  unsigned hasFunnelShift : 1;

73 

74  // Sync

75  unsigned hasThreadFenceSystem : 1;

76  unsigned hasSyncThreadsExt : 1;

77 

78  // Misc

79  unsigned hasSurfaceFuncs : 1;

80  unsigned has3dGrid : 1;

81  unsigned hasDynamicParallelism : 1;

82 } hipDeviceArch_t;

83 

84 typedef struct hipUUID_t {

85  char bytes[16];

86 } hipUUID;

87 

88 //---

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

90 

91 #define hipGetDeviceProperties hipGetDevicePropertiesR0600

92 #define hipDeviceProp_t hipDeviceProp_tR0600

93 #define hipChooseDevice hipChooseDeviceR0600

94 

99 typedef struct hipDeviceProp_t {

100  char name[256];

101  hipUUID uuid;

102  char luid[8];

103  unsigned int luidDeviceNodeMask;

104  size_t totalGlobalMem;

105  size_t sharedMemPerBlock;

106  int regsPerBlock;

107  int warpSize;

108  size_t memPitch;

110  int maxThreadsPerBlock;

111  int maxThreadsDim[3];

112  int maxGridSize[3];

113  int clockRate;

114  size_t totalConstMem;

116  int major;

119  int minor;

122  size_t textureAlignment;

123  size_t texturePitchAlignment;

124  int deviceOverlap;

125  int multiProcessorCount;

126  int kernelExecTimeoutEnabled;

127  int integrated;

128  int canMapHostMemory;

129  int computeMode;

130  int maxTexture1D;

131  int maxTexture1DMipmap;

132  int maxTexture1DLinear;

133  int maxTexture2D[2];

134  int maxTexture2DMipmap[2];

135  int maxTexture2DLinear[3];

136  int maxTexture2DGather[2];

137  int maxTexture3D[3];

139  int maxTexture3DAlt[3];

140  int maxTextureCubemap;

141  int maxTexture1DLayered[2];

142  int maxTexture2DLayered[3];

143  int maxTextureCubemapLayered[2];

144  int maxSurface1D;

145  int maxSurface2D[2];

146  int maxSurface3D[3];

147  int maxSurface1DLayered[2];

148  int maxSurface2DLayered[3];

149  int maxSurfaceCubemap;

150  int maxSurfaceCubemapLayered[2];

151  size_t surfaceAlignment;

152  int concurrentKernels;

153  int ECCEnabled;

154  int pciBusID;

155  int pciDeviceID;

156  int pciDomainID;

157  int tccDriver;

158  int asyncEngineCount;

159  int unifiedAddressing;

160  int memoryClockRate;

161  int memoryBusWidth;

162  int l2CacheSize;

163  int persistingL2CacheMaxSize;

164  int maxThreadsPerMultiProcessor;

165  int streamPrioritiesSupported;

166  int globalL1CacheSupported;

167  int localL1CacheSupported;

168  size_t sharedMemPerMultiprocessor;

169  int regsPerMultiprocessor;

170  int managedMemory;

171  int isMultiGpuBoard;

172  int multiGpuBoardGroupID;

173  int hostNativeAtomicSupported;

174  int singleToDoublePrecisionPerfRatio;

175  int pageableMemoryAccess;

177  int concurrentManagedAccess;

179  int computePreemptionSupported;

180  int canUseHostPointerForRegisteredMem;

182  int cooperativeLaunch;

183  int cooperativeMultiDeviceLaunch;

185  size_t

186  sharedMemPerBlockOptin;

187  int pageableMemoryAccessUsesHostPageTables;

189  int directManagedMemAccessFromHost;

191  int maxBlocksPerMultiProcessor;

192  int accessPolicyMaxWindowSize;

193  size_t reservedSharedMemPerBlock;

194  int hostRegisterSupported;

195  int sparseHipArraySupported;

196  int hostRegisterReadOnlySupported;

198  int timelineSemaphoreInteropSupported;

199  int memoryPoolsSupported;

200  int gpuDirectRDMASupported;

201  unsigned int gpuDirectRDMAFlushWritesOptions;

203  int gpuDirectRDMAWritesOrdering;

204  unsigned int

205  memoryPoolSupportedHandleTypes;

206  int deferredMappingHipArraySupported;

208  int ipcEventSupported;

209  int clusterLaunch;

210  int unifiedFunctionPointers;

211  int reserved[63];

212 

213  int hipReserved[32];

214 

215  /* HIP Only struct members */

216  char gcnArchName[256];

217  size_t maxSharedMemoryPerMultiProcessor;

218  int clockInstructionRate;

220  hipDeviceArch_t arch;

221  unsigned int* hdpMemFlushCntl;

222  unsigned int* hdpRegFlushCntl;

223  int cooperativeMultiDeviceUnmatchedFunc;

226  int cooperativeMultiDeviceUnmatchedGridDim;

229  int cooperativeMultiDeviceUnmatchedBlockDim;

232  int cooperativeMultiDeviceUnmatchedSharedMem;

235  int isLargeBar;

236  int asicRevision;

237 } hipDeviceProp_t;

238 

245 typedef enum hipMemoryType {

246  hipMemoryTypeUnregistered = 0,

247  hipMemoryTypeHost = 1,

248  hipMemoryTypeDevice = 2,

250  hipMemoryTypeManaged = 3,

253  hipMemoryTypeArray = 10,

255  hipMemoryTypeUnified = 11

256 

257 } hipMemoryType;

258 

262 typedef struct hipPointerAttribute_t {

263  enum hipMemoryType type;

264  int device;

265  void* devicePointer;

266  void* hostPointer;

267  int isManaged;

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

269  /* peers? */

270 } hipPointerAttribute_t;

271 

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

273 // we can make that yield a warning

274 #if __cplusplus >= 201703L

275 #define __HIP_NODISCARD [[nodiscard]]

276 #else

277 #define __HIP_NODISCARD

278 #endif

279 

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

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

286 

287 typedef enum __HIP_NODISCARD hipError_t {

288  hipSuccess = 0,

289  hipErrorInvalidValue = 1,

291  hipErrorOutOfMemory = 2,

292  // Deprecated

293  hipErrorMemoryAllocation = 2,

294  hipErrorNotInitialized = 3,

295  // Deprecated

296  hipErrorInitializationError = 3,

297  hipErrorDeinitialized = 4,

298  hipErrorProfilerDisabled = 5,

299  hipErrorProfilerNotInitialized = 6,

300  hipErrorProfilerAlreadyStarted = 7,

301  hipErrorProfilerAlreadyStopped = 8,

302  hipErrorInvalidConfiguration = 9,

303  hipErrorInvalidPitchValue = 12,

304  hipErrorInvalidSymbol = 13,

305  hipErrorInvalidDevicePointer = 17,

306  hipErrorInvalidMemcpyDirection = 21,

307  hipErrorInsufficientDriver = 35,

308  hipErrorMissingConfiguration = 52,

309  hipErrorPriorLaunchFailure = 53,

310  hipErrorInvalidDeviceFunction = 98,

311  hipErrorNoDevice = 100,

312  hipErrorInvalidDevice = 101,

313  hipErrorInvalidImage = 200,

314  hipErrorInvalidContext = 201,

315  hipErrorContextAlreadyCurrent = 202,

316  hipErrorMapFailed = 205,

317  // Deprecated

318  hipErrorMapBufferObjectFailed = 205,

319  hipErrorUnmapFailed = 206,

320  hipErrorArrayIsMapped = 207,

321  hipErrorAlreadyMapped = 208,

322  hipErrorNoBinaryForGpu = 209,

323  hipErrorAlreadyAcquired = 210,

324  hipErrorNotMapped = 211,

325  hipErrorNotMappedAsArray = 212,

326  hipErrorNotMappedAsPointer = 213,

327  hipErrorECCNotCorrectable = 214,

328  hipErrorUnsupportedLimit = 215,

329  hipErrorContextAlreadyInUse = 216,

330  hipErrorPeerAccessUnsupported = 217,

331  hipErrorInvalidKernelFile = 218,

332  hipErrorInvalidGraphicsContext = 219,

333  hipErrorInvalidSource = 300,

334  hipErrorFileNotFound = 301,

335  hipErrorSharedObjectSymbolNotFound = 302,

336  hipErrorSharedObjectInitFailed = 303,

337  hipErrorOperatingSystem = 304,

338  hipErrorInvalidHandle = 400,

339  // Deprecated

340  hipErrorInvalidResourceHandle = 400,

341  hipErrorIllegalState = 401,

342  hipErrorNotFound = 500,

343  hipErrorNotReady = 600,

347  hipErrorIllegalAddress = 700,

348  hipErrorLaunchOutOfResources = 701,

349  hipErrorLaunchTimeOut = 702,

350  hipErrorPeerAccessAlreadyEnabled = 704,

352  hipErrorPeerAccessNotEnabled = 705,

353  hipErrorSetOnActiveProcess = 708,

354  hipErrorContextIsDestroyed = 709,

355  hipErrorAssert = 710,

356  hipErrorHostMemoryAlreadyRegistered = 712,

358  hipErrorHostMemoryNotRegistered = 713,

360  hipErrorLaunchFailure = 719,

361  hipErrorCooperativeLaunchTooLarge = 720,

365  hipErrorNotSupported = 801,

366  hipErrorStreamCaptureUnsupported = 900,

368  hipErrorStreamCaptureInvalidated = 901,

370  hipErrorStreamCaptureMerge = 902,

372  hipErrorStreamCaptureUnmatched = 903,

373  hipErrorStreamCaptureUnjoined = 904,

375  hipErrorStreamCaptureIsolation = 905,

379  hipErrorStreamCaptureImplicit = 906,

382  hipErrorCapturedEvent = 907,

384  hipErrorStreamCaptureWrongThread = 908,

388  hipErrorGraphExecUpdateFailure = 910,

392  hipErrorUnknown = 999,

393  // HSA Runtime Error Codes start here.

394  hipErrorRuntimeMemory = 1052,

396  hipErrorRuntimeOther = 1053,

398  hipErrorTbd

399 } hipError_t;

400 

401 #undef __HIP_NODISCARD

402 

407 typedef enum hipDeviceAttribute_t {

408  hipDeviceAttributeCudaCompatibleBegin = 0,

409 

410  hipDeviceAttributeEccEnabled = hipDeviceAttributeCudaCompatibleBegin,

411  hipDeviceAttributeAccessPolicyMaxWindowSize,

412  hipDeviceAttributeAsyncEngineCount,

413  hipDeviceAttributeCanMapHostMemory,

414  hipDeviceAttributeCanUseHostPointerForRegisteredMem,

416  hipDeviceAttributeClockRate,

417  hipDeviceAttributeComputeMode,

418  hipDeviceAttributeComputePreemptionSupported,

419  hipDeviceAttributeConcurrentKernels,

420  hipDeviceAttributeConcurrentManagedAccess,

421  hipDeviceAttributeCooperativeLaunch,

422  hipDeviceAttributeCooperativeMultiDeviceLaunch,

423  hipDeviceAttributeDeviceOverlap,

425  hipDeviceAttributeDirectManagedMemAccessFromHost,

427  hipDeviceAttributeGlobalL1CacheSupported,

428  hipDeviceAttributeHostNativeAtomicSupported,

429  hipDeviceAttributeIntegrated,

430  hipDeviceAttributeIsMultiGpuBoard,

431  hipDeviceAttributeKernelExecTimeout,

432  hipDeviceAttributeL2CacheSize,

433  hipDeviceAttributeLocalL1CacheSupported,

434  hipDeviceAttributeLuid,

435  hipDeviceAttributeLuidDeviceNodeMask,

436  hipDeviceAttributeComputeCapabilityMajor,

437  hipDeviceAttributeManagedMemory,

438  hipDeviceAttributeMaxBlocksPerMultiProcessor,

439  hipDeviceAttributeMaxBlockDimX,

440  hipDeviceAttributeMaxBlockDimY,

441  hipDeviceAttributeMaxBlockDimZ,

442  hipDeviceAttributeMaxGridDimX,

443  hipDeviceAttributeMaxGridDimY,

444  hipDeviceAttributeMaxGridDimZ,

445  hipDeviceAttributeMaxSurface1D,

446  hipDeviceAttributeMaxSurface1DLayered,

447  hipDeviceAttributeMaxSurface2D,

448  hipDeviceAttributeMaxSurface2DLayered,

449  hipDeviceAttributeMaxSurface3D,

450  hipDeviceAttributeMaxSurfaceCubemap,

451  hipDeviceAttributeMaxSurfaceCubemapLayered,

452  hipDeviceAttributeMaxTexture1DWidth,

453  hipDeviceAttributeMaxTexture1DLayered,

454  hipDeviceAttributeMaxTexture1DLinear,

456  hipDeviceAttributeMaxTexture1DMipmap,

457  hipDeviceAttributeMaxTexture2DWidth,

458  hipDeviceAttributeMaxTexture2DHeight,

459  hipDeviceAttributeMaxTexture2DGather,

460  hipDeviceAttributeMaxTexture2DLayered,

461  hipDeviceAttributeMaxTexture2DLinear,

462  hipDeviceAttributeMaxTexture2DMipmap,

463  hipDeviceAttributeMaxTexture3DWidth,

464  hipDeviceAttributeMaxTexture3DHeight,

465  hipDeviceAttributeMaxTexture3DDepth,

466  hipDeviceAttributeMaxTexture3DAlt,

467  hipDeviceAttributeMaxTextureCubemap,

468  hipDeviceAttributeMaxTextureCubemapLayered,

469  hipDeviceAttributeMaxThreadsDim,

470  hipDeviceAttributeMaxThreadsPerBlock,

471  hipDeviceAttributeMaxThreadsPerMultiProcessor,

472  hipDeviceAttributeMaxPitch,

473  hipDeviceAttributeMemoryBusWidth,

474  hipDeviceAttributeMemoryClockRate,

475  hipDeviceAttributeComputeCapabilityMinor,

476  hipDeviceAttributeMultiGpuBoardGroupID,

477  hipDeviceAttributeMultiprocessorCount,

478  hipDeviceAttributeUnused1,

479  hipDeviceAttributePageableMemoryAccess,

481  hipDeviceAttributePageableMemoryAccessUsesHostPageTables,

482  hipDeviceAttributePciBusId,

483  hipDeviceAttributePciDeviceId,

484  hipDeviceAttributePciDomainID,

485  hipDeviceAttributePersistingL2CacheMaxSize,

486  hipDeviceAttributeMaxRegistersPerBlock,

488  hipDeviceAttributeMaxRegistersPerMultiprocessor,

489  hipDeviceAttributeReservedSharedMemPerBlock,

490  hipDeviceAttributeMaxSharedMemoryPerBlock,

491  hipDeviceAttributeSharedMemPerBlockOptin,

492  hipDeviceAttributeSharedMemPerMultiprocessor,

493  hipDeviceAttributeSingleToDoublePrecisionPerfRatio,

494  hipDeviceAttributeStreamPrioritiesSupported,

495  hipDeviceAttributeSurfaceAlignment,

496  hipDeviceAttributeTccDriver,

497  hipDeviceAttributeTextureAlignment,

498  hipDeviceAttributeTexturePitchAlignment,

499  hipDeviceAttributeTotalConstantMemory,

500  hipDeviceAttributeTotalGlobalMem,

501  hipDeviceAttributeUnifiedAddressing,

502  hipDeviceAttributeUnused2,

503  hipDeviceAttributeWarpSize,

504  hipDeviceAttributeMemoryPoolsSupported,

505  hipDeviceAttributeVirtualMemoryManagementSupported,

506  hipDeviceAttributeHostRegisterSupported,

507  hipDeviceAttributeMemoryPoolSupportedHandleTypes,

508 

509  hipDeviceAttributeCudaCompatibleEnd = 9999,

510  hipDeviceAttributeAmdSpecificBegin = 10000,

511 

512  hipDeviceAttributeClockInstructionRate = hipDeviceAttributeAmdSpecificBegin,

513  hipDeviceAttributeUnused3,

514  hipDeviceAttributeMaxSharedMemoryPerMultiprocessor,

515  hipDeviceAttributeUnused4,

516  hipDeviceAttributeUnused5,

517  hipDeviceAttributeHdpMemFlushCntl,

518  hipDeviceAttributeHdpRegFlushCntl,

519  hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc,

521  hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim,

523  hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim,

525  hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem,

527  hipDeviceAttributeIsLargeBar,

528  hipDeviceAttributeAsicRevision,

529  hipDeviceAttributeCanUseStreamWaitValue,

531  hipDeviceAttributeImageSupport,

532  hipDeviceAttributePhysicalMultiProcessorCount,

534  hipDeviceAttributeFineGrainSupport,

535  hipDeviceAttributeWallClockRate,

536 

537  hipDeviceAttributeAmdSpecificEnd = 19999,

538  hipDeviceAttributeVendorSpecificBegin = 20000,

539  // Extended attributes for vendors

540 } hipDeviceAttribute_t;

541 

542 typedef enum hipDriverProcAddressQueryResult {

543  HIP_GET_PROC_ADDRESS_SUCCESS = 0,

544  HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND = 1,

545  HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT = 2

546 } hipDriverProcAddressQueryResult;

547 

548 enum hipComputeMode {

549  hipComputeModeDefault = 0,

550  hipComputeModeExclusive = 1,

551  hipComputeModeProhibited = 2,

552  hipComputeModeExclusiveProcess = 3

553 };

554 

555 enum hipFlushGPUDirectRDMAWritesOptions {

556  hipFlushGPUDirectRDMAWritesOptionHost = 1 << 0,

557  hipFlushGPUDirectRDMAWritesOptionMemOps = 1 << 1

558 };

559 

560 enum hipGPUDirectRDMAWritesOrdering {

561  hipGPUDirectRDMAWritesOrderingNone = 0,

562  hipGPUDirectRDMAWritesOrderingOwner = 100,

563  hipGPUDirectRDMAWritesOrderingAllDevices = 200

564 };

565 

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

567 

568 #include <stdint.h>

569 #include <stddef.h>

570 #ifndef GENERIC_GRID_LAUNCH

571 #define GENERIC_GRID_LAUNCH 1

572 #endif

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

574 #include <hip/driver_types.h>

575 #include <hip/texture_types.h>

576 #include <hip/surface_types.h>

577 #if defined(_MSC_VER)

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

579 #else // !defined(_MSC_VER)

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

581 #endif // !defined(_MSC_VER)

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

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

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

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

586 #ifdef __cplusplus

587  #define __dparm(x) \

588  = x

589 #else

590  #define __dparm(x)

591 #endif

592 #ifdef __GNUC__

593 #pragma GCC visibility push (default)

594 #endif

595 #ifdef __cplusplus

596 namespace hip_impl {

597 hipError_t hip_init();

598 } // namespace hip_impl

599 #endif

600 // Structure definitions:

601 #ifdef __cplusplus

602 extern "C" {

603 #endif

604 //---

605 // API-visible structures

606 typedef struct ihipCtx_t* hipCtx_t;

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

608 typedef int hipDevice_t;

609 typedef enum hipDeviceP2PAttr {

610  hipDevP2PAttrPerformanceRank = 0,

611  hipDevP2PAttrAccessSupported,

612  hipDevP2PAttrNativeAtomicSupported,

613  hipDevP2PAttrHipArrayAccessSupported

614 } hipDeviceP2PAttr;

615 typedef struct ihipStream_t* hipStream_t;

616 #define hipIpcMemLazyEnablePeerAccess 0x01

617 #define HIP_IPC_HANDLE_SIZE 64

618 typedef struct hipIpcMemHandle_st {

619  char reserved[HIP_IPC_HANDLE_SIZE];

620 } hipIpcMemHandle_t;

621 typedef struct hipIpcEventHandle_st {

622  char reserved[HIP_IPC_HANDLE_SIZE];

623 } hipIpcEventHandle_t;

624 typedef struct ihipModule_t* hipModule_t;

625 typedef struct ihipModuleSymbol_t* hipFunction_t;

629 typedef struct ihipMemPoolHandle_t* hipMemPool_t;

630 

631 typedef struct hipFuncAttributes {

632  int binaryVersion;

633  int cacheModeCA;

634  size_t constSizeBytes;

635  size_t localSizeBytes;

636  int maxDynamicSharedSizeBytes;

637  int maxThreadsPerBlock;

638  int numRegs;

639  int preferredShmemCarveout;

640  int ptxVersion;

641  size_t sharedSizeBytes;

642 } hipFuncAttributes;

643 typedef struct ihipEvent_t* hipEvent_t;

644 

651 enum hipLimit_t {

652  hipLimitStackSize = 0x0,

655  hipLimitPrintfFifoSize = 0x01,

657  hipLimitMallocHeapSize = 0x02,

659  hipLimitRange

660 };

664 //Flags that can be used with hipStreamCreateWithFlags.

666 #define hipStreamDefault 0x00

667 

669 #define hipStreamNonBlocking 0x01

670 

671 //Flags that can be used with hipEventCreateWithFlags.

673 #define hipEventDefault 0x0

674 

676 #define hipEventBlockingSync 0x1

677 

679 #define hipEventDisableTiming 0x2

680 

682 #define hipEventInterprocess 0x4

683 

692 #define hipEventDisableSystemFence 0x20000000

693 

696 #define hipEventReleaseToDevice 0x40000000

697 

700 #define hipEventReleaseToSystem 0x80000000

701 

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

704 #define hipHostMallocDefault 0x0

705 #define hipHostAllocDefault 0x0

706 

708 #define hipHostMallocPortable 0x1

709 #define hipHostAllocPortable 0x1

710 

713 #define hipHostMallocMapped 0x2

714 #define hipHostAllocMapped 0x2

715 

719 #define hipHostMallocWriteCombined 0x4

720 #define hipHostAllocWriteCombined 0x4

721 

726 #define hipHostMallocNumaUser 0x20000000

727 

729 #define hipHostMallocCoherent 0x40000000

730 

732 #define hipHostMallocNonCoherent 0x80000000

733 

735 #define hipMemAttachGlobal 0x01

736 

738 #define hipMemAttachHost 0x02

739 

741 #define hipMemAttachSingle 0x04

742 

743 #define hipDeviceMallocDefault 0x0

744 

746 #define hipDeviceMallocFinegrained 0x1

747 

749 #define hipMallocSignalMemory 0x2

750 

752 #define hipDeviceMallocUncached 0x3

753 

755 #define hipDeviceMallocContiguous 0x4

756 

757 //Flags that can be used with hipHostRegister.

759 #define hipHostRegisterDefault 0x0

760 

762 #define hipHostRegisterPortable 0x1

763 

766 #define hipHostRegisterMapped 0x2

767 

769 #define hipHostRegisterIoMemory 0x4

770 

772 #define hipHostRegisterReadOnly 0x08

773 

775 #define hipExtHostRegisterCoarseGrained 0x8

776 

778 #define hipDeviceScheduleAuto 0x0

779 

782 #define hipDeviceScheduleSpin 0x1

783 

786 #define hipDeviceScheduleYield 0x2

787 #define hipDeviceScheduleBlockingSync 0x4

788 #define hipDeviceScheduleMask 0x7

789 #define hipDeviceMapHost 0x8

790 #define hipDeviceLmemResizeToMax 0x10

792 #define hipArrayDefault 0x00

793 #define hipArrayLayered 0x01

794 #define hipArraySurfaceLoadStore 0x02

795 #define hipArrayCubemap 0x04

796 #define hipArrayTextureGather 0x08

797 #define hipOccupancyDefault 0x00

798 #define hipOccupancyDisableCachingOverride 0x01

799 #define hipCooperativeLaunchMultiDeviceNoPreSync 0x01

800 #define hipCooperativeLaunchMultiDeviceNoPostSync 0x02

801 #define hipCpuDeviceId ((int)-1)

802 #define hipInvalidDeviceId ((int)-2)

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

805 #define hipExtAnyOrderLaunch 0x01

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

807 #define hipStreamWaitValueGte 0x0

808 #define hipStreamWaitValueEq 0x1

809 #define hipStreamWaitValueAnd 0x2

810 #define hipStreamWaitValueNor 0x3

811 // Stream per thread

813 #define hipStreamPerThread ((hipStream_t)2)

814 

815 #define hipStreamLegacy ((hipStream_t)1)

816 

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

818 #define hipExternalMemoryDedicated 0x1

824 typedef enum hipMemoryAdvise {

825  hipMemAdviseSetReadMostly = 1,

827  hipMemAdviseUnsetReadMostly = 2,

828  hipMemAdviseSetPreferredLocation = 3,

830  hipMemAdviseUnsetPreferredLocation = 4,

831  hipMemAdviseSetAccessedBy = 5,

833  hipMemAdviseUnsetAccessedBy = 6,

835  hipMemAdviseSetCoarseGrain = 100,

840  hipMemAdviseUnsetCoarseGrain = 101

841 } hipMemoryAdvise;

845 typedef enum hipMemRangeCoherencyMode {

846  hipMemRangeCoherencyModeFineGrain = 0,

848  hipMemRangeCoherencyModeCoarseGrain = 1,

850  hipMemRangeCoherencyModeIndeterminate = 2

853 } hipMemRangeCoherencyMode;

857 typedef enum hipMemRangeAttribute {

858  hipMemRangeAttributeReadMostly = 1,

860  hipMemRangeAttributePreferredLocation = 2,

861  hipMemRangeAttributeAccessedBy = 3,

863  hipMemRangeAttributeLastPrefetchLocation = 4,

865  hipMemRangeAttributeCoherencyMode = 100,

867 } hipMemRangeAttribute;

868 

872 typedef enum hipMemPoolAttr

873 {

882  hipMemPoolReuseFollowEventDependencies = 0x1,

888  hipMemPoolReuseAllowOpportunistic = 0x2,

895  hipMemPoolReuseAllowInternalDependencies = 0x3,

904  hipMemPoolAttrReleaseThreshold = 0x4,

909  hipMemPoolAttrReservedMemCurrent = 0x5,

915  hipMemPoolAttrReservedMemHigh = 0x6,

920  hipMemPoolAttrUsedMemCurrent = 0x7,

926  hipMemPoolAttrUsedMemHigh = 0x8

927 } hipMemPoolAttr;

931  typedef enum hipMemLocationType {

932  hipMemLocationTypeInvalid = 0,

933  hipMemLocationTypeDevice = 1

934 } hipMemLocationType;

940 typedef struct hipMemLocation {

941  hipMemLocationType type;

942  int id;

943 } hipMemLocation;

948 typedef enum hipMemAccessFlags {

949  hipMemAccessFlagsProtNone = 0,

950  hipMemAccessFlagsProtRead = 1,

951  hipMemAccessFlagsProtReadWrite = 3

952 } hipMemAccessFlags;

956 typedef struct hipMemAccessDesc {

957  hipMemLocation location;

958  hipMemAccessFlags flags;

959 } hipMemAccessDesc;

963 typedef enum hipMemAllocationType {

964  hipMemAllocationTypeInvalid = 0x0,

968  hipMemAllocationTypePinned = 0x1,

969  hipMemAllocationTypeMax = 0x7FFFFFFF

970 } hipMemAllocationType;

975 typedef enum hipMemAllocationHandleType {

976  hipMemHandleTypeNone = 0x0,

977  hipMemHandleTypePosixFileDescriptor = 0x1,

978  hipMemHandleTypeWin32 = 0x2,

979  hipMemHandleTypeWin32Kmt = 0x4

980 } hipMemAllocationHandleType;

984 typedef struct hipMemPoolProps {

985  hipMemAllocationType allocType;

986  hipMemAllocationHandleType handleTypes;

987  hipMemLocation location;

991  void* win32SecurityAttributes;

992  size_t maxSize;

993  unsigned char reserved[56];

994 } hipMemPoolProps;

998 typedef struct hipMemPoolPtrExportData {

999  unsigned char reserved[64];

1000 } hipMemPoolPtrExportData;

1001 

1005 typedef enum hipJitOption {

1006  hipJitOptionMaxRegisters = 0,

1007  hipJitOptionThreadsPerBlock,

1008  hipJitOptionWallTime,

1009  hipJitOptionInfoLogBuffer,

1010  hipJitOptionInfoLogBufferSizeBytes,

1011  hipJitOptionErrorLogBuffer,

1012  hipJitOptionErrorLogBufferSizeBytes,

1013  hipJitOptionOptimizationLevel,

1014  hipJitOptionTargetFromContext,

1015  hipJitOptionTarget,

1016  hipJitOptionFallbackStrategy,

1017  hipJitOptionGenerateDebugInfo,

1018  hipJitOptionLogVerbose,

1019  hipJitOptionGenerateLineInfo,

1020  hipJitOptionCacheMode,

1021  hipJitOptionSm3xOpt,

1022  hipJitOptionFastCompile,

1023  hipJitOptionNumOptions

1024 } hipJitOption;

1028 typedef enum hipFuncAttribute {

1029  hipFuncAttributeMaxDynamicSharedMemorySize = 8,

1030  hipFuncAttributePreferredSharedMemoryCarveout = 9,

1031  hipFuncAttributeMax

1032 } hipFuncAttribute;

1036 typedef enum hipFuncCache_t {

1037  hipFuncCachePreferNone,

1038  hipFuncCachePreferShared,

1039  hipFuncCachePreferL1,

1040  hipFuncCachePreferEqual,

1041 } hipFuncCache_t;

1045 typedef enum hipSharedMemConfig {

1046  hipSharedMemBankSizeDefault,

1047  hipSharedMemBankSizeFourByte,

1049  hipSharedMemBankSizeEightByte

1051 } hipSharedMemConfig;

1055 typedef struct dim3 {

1056  uint32_t x;

1057  uint32_t y;

1058  uint32_t z;

1059 #ifdef __cplusplus

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

1061 #endif

1062 } dim3;

1066 typedef struct hipLaunchParams_t {

1067  void* func;

1068  dim3 gridDim;

1069  dim3 blockDim;

1070  void **args;

1071  size_t sharedMem;

1072  hipStream_t stream;

1073 } hipLaunchParams;

1077 typedef struct hipFunctionLaunchParams_t {

1078  hipFunction_t function;

1079  unsigned int gridDimX;

1080  unsigned int gridDimY;

1081  unsigned int gridDimZ;

1082  unsigned int blockDimX;

1083  unsigned int blockDimY;

1084  unsigned int blockDimZ;

1085  unsigned int sharedMemBytes;

1086  hipStream_t hStream;

1087  void **kernelParams;

1088 } hipFunctionLaunchParams;

1089 typedef enum hipExternalMemoryHandleType_enum {

1090  hipExternalMemoryHandleTypeOpaqueFd = 1,

1091  hipExternalMemoryHandleTypeOpaqueWin32 = 2,

1092  hipExternalMemoryHandleTypeOpaqueWin32Kmt = 3,

1093  hipExternalMemoryHandleTypeD3D12Heap = 4,

1094  hipExternalMemoryHandleTypeD3D12Resource = 5,

1095  hipExternalMemoryHandleTypeD3D11Resource = 6,

1096  hipExternalMemoryHandleTypeD3D11ResourceKmt = 7,

1097  hipExternalMemoryHandleTypeNvSciBuf = 8

1098 } hipExternalMemoryHandleType;

1099 typedef struct hipExternalMemoryHandleDesc_st {

1100  hipExternalMemoryHandleType type;

1101  union {

1102  int fd;

1103  struct {

1104  void *handle;

1105  const void *name;

1106  } win32;

1107  const void *nvSciBufObject;

1108  } handle;

1109  unsigned long long size;

1110  unsigned int flags;

1111  unsigned int reserved[16];

1112 } hipExternalMemoryHandleDesc;

1113 typedef struct hipExternalMemoryBufferDesc_st {

1114  unsigned long long offset;

1115  unsigned long long size;

1116  unsigned int flags;

1117  unsigned int reserved[16];

1118 } hipExternalMemoryBufferDesc;

1119 typedef struct hipExternalMemoryMipmappedArrayDesc_st {

1120  unsigned long long offset;

1121  hipChannelFormatDesc formatDesc;

1122  hipExtent extent;

1123  unsigned int flags;

1124  unsigned int numLevels;

1125 } hipExternalMemoryMipmappedArrayDesc;

1126 typedef void* hipExternalMemory_t;

1127 typedef enum hipExternalSemaphoreHandleType_enum {

1128  hipExternalSemaphoreHandleTypeOpaqueFd = 1,

1129  hipExternalSemaphoreHandleTypeOpaqueWin32 = 2,

1130  hipExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3,

1131  hipExternalSemaphoreHandleTypeD3D12Fence = 4,

1132  hipExternalSemaphoreHandleTypeD3D11Fence = 5,

1133  hipExternalSemaphoreHandleTypeNvSciSync = 6,

1134  hipExternalSemaphoreHandleTypeKeyedMutex = 7,

1135  hipExternalSemaphoreHandleTypeKeyedMutexKmt = 8,

1136  hipExternalSemaphoreHandleTypeTimelineSemaphoreFd = 9,

1137  hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = 10

1138 } hipExternalSemaphoreHandleType;

1139 typedef struct hipExternalSemaphoreHandleDesc_st {

1140  hipExternalSemaphoreHandleType type;

1141  union {

1142  int fd;

1143  struct {

1144  void* handle;

1145  const void* name;

1146  } win32;

1147  const void* NvSciSyncObj;

1148  } handle;

1149  unsigned int flags;

1150  unsigned int reserved[16];

1151 } hipExternalSemaphoreHandleDesc;

1152 typedef void* hipExternalSemaphore_t;

1153 typedef struct hipExternalSemaphoreSignalParams_st {

1154  struct {

1155  struct {

1156  unsigned long long value;

1157  } fence;

1158  union {

1159  void *fence;

1160  unsigned long long reserved;

1161  } nvSciSync;

1162  struct {

1163  unsigned long long key;

1164  } keyedMutex;

1165  unsigned int reserved[12];

1166  } params;

1167  unsigned int flags;

1168  unsigned int reserved[16];

1169 } hipExternalSemaphoreSignalParams;

1173 typedef struct hipExternalSemaphoreWaitParams_st {

1174  struct {

1175  struct {

1176  unsigned long long value;

1177  } fence;

1178  union {

1179  void *fence;

1180  unsigned long long reserved;

1181  } nvSciSync;

1182  struct {

1183  unsigned long long key;

1184  unsigned int timeoutMs;

1185  } keyedMutex;

1186  unsigned int reserved[10];

1187  } params;

1188  unsigned int flags;

1189  unsigned int reserved[16];

1190 } hipExternalSemaphoreWaitParams;

1191 

1192 #if __HIP_HAS_GET_PCH

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

1198 #endif

1199 

1203 typedef enum hipGraphicsRegisterFlags {

1204  hipGraphicsRegisterFlagsNone = 0,

1205  hipGraphicsRegisterFlagsReadOnly = 1,

1206  hipGraphicsRegisterFlagsWriteDiscard =

1207  2,

1208  hipGraphicsRegisterFlagsSurfaceLoadStore = 4,

1209  hipGraphicsRegisterFlagsTextureGather =

1210  8

1211 } hipGraphicsRegisterFlags;

1212 

1213 typedef struct _hipGraphicsResource hipGraphicsResource;

1214 

1215 typedef hipGraphicsResource* hipGraphicsResource_t;

1216 

1220 typedef struct ihipGraph* hipGraph_t;

1224 typedef struct hipGraphNode* hipGraphNode_t;

1228 typedef struct hipGraphExec* hipGraphExec_t;

1229 

1233 typedef struct hipUserObject* hipUserObject_t;

1234 

1235 

1239 typedef enum hipGraphNodeType {

1240  hipGraphNodeTypeKernel = 0,

1241  hipGraphNodeTypeMemcpy = 1,

1242  hipGraphNodeTypeMemset = 2,

1243  hipGraphNodeTypeHost = 3,

1244  hipGraphNodeTypeGraph = 4,

1245  hipGraphNodeTypeEmpty = 5,

1246  hipGraphNodeTypeWaitEvent = 6,

1247  hipGraphNodeTypeEventRecord = 7,

1248  hipGraphNodeTypeExtSemaphoreSignal = 8,

1249  hipGraphNodeTypeExtSemaphoreWait = 9,

1250  hipGraphNodeTypeMemAlloc = 10,

1251  hipGraphNodeTypeMemFree = 11,

1252  hipGraphNodeTypeMemcpyFromSymbol = 12,

1253  hipGraphNodeTypeMemcpyToSymbol = 13,

1254  hipGraphNodeTypeCount

1255 } hipGraphNodeType;

1256 

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

1258 typedef struct hipHostNodeParams {

1259  hipHostFn_t fn;

1260  void* userData;

1261 } hipHostNodeParams;

1262 typedef struct hipKernelNodeParams {

1263  dim3 blockDim;

1264  void** extra;

1265  void* func;

1266  dim3 gridDim;

1267  void** kernelParams;

1268  unsigned int sharedMemBytes;

1269 } hipKernelNodeParams;

1270 typedef struct hipMemsetParams {

1271  void* dst;

1272  unsigned int elementSize;

1273  size_t height;

1274  size_t pitch;

1275  unsigned int value;

1276  size_t width;

1277 } hipMemsetParams;

1278 

1279 typedef struct hipMemAllocNodeParams {

1280  hipMemPoolProps poolProps;

1282  const hipMemAccessDesc* accessDescs;

1284  size_t accessDescCount;

1285  size_t bytesize;

1286  void* dptr;

1287 } hipMemAllocNodeParams;

1288 

1289 

1290 typedef enum hipAccessProperty {

1291  hipAccessPropertyNormal = 0,

1292  hipAccessPropertyStreaming = 1,

1293  hipAccessPropertyPersisting = 2,

1294 } hipAccessProperty;

1295 typedef struct hipAccessPolicyWindow {

1296  void* base_ptr;

1297  hipAccessProperty hitProp;

1298  float hitRatio;

1299  hipAccessProperty missProp;

1300  size_t num_bytes;

1301 } hipAccessPolicyWindow;

1302 

1306 typedef enum hipLaunchAttributeID {

1307  hipLaunchAttributeAccessPolicyWindow = 1,

1308  hipLaunchAttributeCooperative = 2,

1309  hipLaunchAttributePriority = 8,

1310 } hipLaunchAttributeID;

1311 

1315 typedef union hipLaunchAttributeValue {

1316  hipAccessPolicyWindow accessPolicyWindow;

1318  int cooperative;

1319  int priority;

1321 } hipLaunchAttributeValue;

1322 

1326 #define hipKernelNodeAttrID hipLaunchAttributeID

1327 #define hipKernelNodeAttributeAccessPolicyWindow hipLaunchAttributeAccessPolicyWindow

1328 #define hipKernelNodeAttributeCooperative hipLaunchAttributeCooperative

1329 #define hipKernelNodeAttributePriority hipLaunchAttributePriority

1330 

1334 #define hipKernelNodeAttrValue hipLaunchAttributeValue

1335 

1339 typedef struct HIP_MEMSET_NODE_PARAMS {

1340  hipDeviceptr_t dst;

1341  size_t pitch;

1342  unsigned int value;

1343  unsigned int elementSize;

1344  size_t width;

1345  size_t height;

1346 } HIP_MEMSET_NODE_PARAMS;

1347 

1351 typedef enum hipGraphExecUpdateResult {

1352  hipGraphExecUpdateSuccess = 0x0,

1353  hipGraphExecUpdateError = 0x1,

1355  hipGraphExecUpdateErrorTopologyChanged = 0x2,

1356  hipGraphExecUpdateErrorNodeTypeChanged = 0x3,

1357  hipGraphExecUpdateErrorFunctionChanged =

1358  0x4,

1359  hipGraphExecUpdateErrorParametersChanged =

1360  0x5,

1361  hipGraphExecUpdateErrorNotSupported =

1362  0x6,

1363  hipGraphExecUpdateErrorUnsupportedFunctionChange = 0x7

1364 } hipGraphExecUpdateResult;

1365 

1366 typedef enum hipStreamCaptureMode {

1367  hipStreamCaptureModeGlobal = 0,

1368  hipStreamCaptureModeThreadLocal,

1369  hipStreamCaptureModeRelaxed

1370 } hipStreamCaptureMode;

1371 typedef enum hipStreamCaptureStatus {

1372  hipStreamCaptureStatusNone = 0,

1373  hipStreamCaptureStatusActive,

1374  hipStreamCaptureStatusInvalidated

1376 } hipStreamCaptureStatus;

1377 

1378 typedef enum hipStreamUpdateCaptureDependenciesFlags {

1379  hipStreamAddCaptureDependencies = 0,

1380  hipStreamSetCaptureDependencies,

1381 } hipStreamUpdateCaptureDependenciesFlags;

1382 

1383 typedef enum hipGraphMemAttributeType {

1384  hipGraphMemAttrUsedMemCurrent = 0,

1385  hipGraphMemAttrUsedMemHigh,

1386  hipGraphMemAttrReservedMemCurrent,

1387  hipGraphMemAttrReservedMemHigh,

1388 }hipGraphMemAttributeType;

1389 typedef enum hipUserObjectFlags {

1390  hipUserObjectNoDestructorSync = 0x1,

1391 } hipUserObjectFlags;

1392 

1393 typedef enum hipUserObjectRetainFlags {

1394  hipGraphUserObjectMove = 0x1,

1395 } hipUserObjectRetainFlags;

1396 

1397 typedef enum hipGraphInstantiateFlags {

1398  hipGraphInstantiateFlagAutoFreeOnLaunch =

1399  1,

1400  hipGraphInstantiateFlagUpload =

1401  2,

1402  hipGraphInstantiateFlagDeviceLaunch =

1403  4,

1404  hipGraphInstantiateFlagUseNodePriority =

1405  8,

1406 } hipGraphInstantiateFlags;

1407 

1408 enum hipGraphDebugDotFlags {

1409  hipGraphDebugDotFlagsVerbose = 1

1410  << 0,

1411  hipGraphDebugDotFlagsKernelNodeParams = 1 << 2,

1412  hipGraphDebugDotFlagsMemcpyNodeParams = 1 << 3,

1413  hipGraphDebugDotFlagsMemsetNodeParams = 1 << 4,

1414  hipGraphDebugDotFlagsHostNodeParams = 1 << 5,

1415  hipGraphDebugDotFlagsEventNodeParams = 1

1416  << 6,

1417  hipGraphDebugDotFlagsExtSemasSignalNodeParams = 1

1418  << 7,

1419  hipGraphDebugDotFlagsExtSemasWaitNodeParams = 1

1420  << 8,

1421  hipGraphDebugDotFlagsKernelNodeAttributes = 1

1422  << 9,

1423  hipGraphDebugDotFlagsHandles = 1

1424  << 10

1425 };

1426 

1430 typedef enum hipGraphInstantiateResult {

1431  hipGraphInstantiateSuccess = 0,

1432  hipGraphInstantiateError = 1,

1434  hipGraphInstantiateInvalidStructure = 2,

1436  hipGraphInstantiateNodeOperationNotSupported = 3,

1438  hipGraphInstantiateMultipleDevicesNotSupported = 4,

1440 }hipGraphInstantiateResult;

1441 

1445 typedef struct hipGraphInstantiateParams {

1446  hipGraphNode_t errNode_out;

1447  unsigned long long flags;

1448  hipGraphInstantiateResult result_out;

1450  hipStream_t uploadStream;

1451 } hipGraphInstantiateParams;

1452 

1453 

1457 typedef struct hipMemAllocationProp {

1458  hipMemAllocationType type;

1459  hipMemAllocationHandleType requestedHandleType;

1460  hipMemLocation location;

1461  void* win32HandleMetaData;

1462  struct {

1463  unsigned char compressionType;

1464  unsigned char gpuDirectRDMACapable;

1465  unsigned short usage;

1466  } allocFlags;

1467 } hipMemAllocationProp;

1468 

1472 typedef struct hipExternalSemaphoreSignalNodeParams {

1474  hipExternalSemaphore_t* extSemArray;

1476  const hipExternalSemaphoreSignalParams* paramsArray;

1478  unsigned int numExtSems;

1479 } hipExternalSemaphoreSignalNodeParams;

1480 

1484 typedef struct hipExternalSemaphoreWaitNodeParams {

1486  hipExternalSemaphore_t* extSemArray;

1488  const hipExternalSemaphoreWaitParams* paramsArray;

1490  unsigned int numExtSems;

1491 } hipExternalSemaphoreWaitNodeParams;

1492 

1496 typedef struct ihipMemGenericAllocationHandle* hipMemGenericAllocationHandle_t;

1497 

1501 typedef enum hipMemAllocationGranularity_flags {

1502  hipMemAllocationGranularityMinimum = 0x0,

1503  hipMemAllocationGranularityRecommended = 0x1

1504 } hipMemAllocationGranularity_flags;

1505 

1509 typedef enum hipMemHandleType {

1510  hipMemHandleTypeGeneric = 0x0

1511 } hipMemHandleType;

1512 

1516 typedef enum hipMemOperationType {

1517  hipMemOperationTypeMap = 0x1,

1518  hipMemOperationTypeUnmap = 0x2

1519 } hipMemOperationType;

1520 

1524 typedef enum hipArraySparseSubresourceType {

1525  hipArraySparseSubresourceTypeSparseLevel = 0x0,

1526  hipArraySparseSubresourceTypeMiptail = 0x1

1527 } hipArraySparseSubresourceType;

1528 

1532 typedef struct hipArrayMapInfo {

1533  hipResourceType resourceType;

1534  union {

1535  hipMipmappedArray mipmap;

1536  hipArray_t array;

1537  } resource;

1538  hipArraySparseSubresourceType subresourceType;

1539  union {

1540  struct {

1541  unsigned int level;

1542  unsigned int layer;

1543  unsigned int offsetX;

1544  unsigned int offsetY;

1545  unsigned int offsetZ;

1546  unsigned int extentWidth;

1547  unsigned int extentHeight;

1548  unsigned int extentDepth;

1549  } sparseLevel;

1550  struct {

1551  unsigned int layer;

1552  unsigned long long offset;

1553  unsigned long long size;

1554  } miptail;

1555  } subresource;

1556  hipMemOperationType memOperationType;

1557  hipMemHandleType memHandleType;

1558  union {

1559  hipMemGenericAllocationHandle_t memHandle;

1560  } memHandle;

1561  unsigned long long offset;

1562  unsigned int deviceBitMask;

1563  unsigned int flags;

1564  unsigned int reserved[2];

1565 } hipArrayMapInfo;

1566 

1570 typedef struct hipMemcpyNodeParams {

1571  int flags;

1572  int reserved[3];

1573  hipMemcpy3DParms copyParams;

1574 } hipMemcpyNodeParams;

1575 

1579 typedef struct hipChildGraphNodeParams {

1580  hipGraph_t graph;

1582 } hipChildGraphNodeParams;

1583 

1587 typedef struct hipEventWaitNodeParams {

1588  hipEvent_t event;

1589 } hipEventWaitNodeParams;

1590 

1594 typedef struct hipEventRecordNodeParams {

1595  hipEvent_t event;

1596 } hipEventRecordNodeParams;

1597 

1601 typedef struct hipMemFreeNodeParams {

1602  void *dptr;

1603 } hipMemFreeNodeParams;

1604 

1608 typedef struct hipGraphNodeParams {

1609  hipGraphNodeType type;

1610  int reserved0[3];

1611  union {

1612  long long reserved1[29];

1613  hipKernelNodeParams kernel;

1614  hipMemcpyNodeParams memcpy;

1615  hipMemsetParams memset;

1616  hipHostNodeParams host;

1617  hipChildGraphNodeParams graph;

1618  hipEventWaitNodeParams eventWait;

1619  hipEventRecordNodeParams eventRecord;

1620  hipExternalSemaphoreSignalNodeParams extSemSignal;

1621  hipExternalSemaphoreWaitNodeParams extSemWait;

1622  hipMemAllocNodeParams alloc;

1623  hipMemFreeNodeParams free;

1624  };

1625 

1626  long long reserved2;

1627 } hipGraphNodeParams;

1628 

1632 #define hipGraphKernelNodePortDefault 0

1633 

1637 #define hipGraphKernelNodePortLaunchCompletion 2

1638 

1644 #define hipGraphKernelNodePortProgrammatic 1

1645 

1646 typedef enum hipGraphDependencyType {

1647  hipGraphDependencyTypeDefault = 0,

1648  hipGraphDependencyTypeProgrammatic = 1

1649 }hipGraphDependencyType;

1650 

1651 typedef struct hipGraphEdgeData {

1652  unsigned char

1653  from_port;

1660  unsigned char reserved[5];

1661  unsigned char

1662  to_port;

1663  unsigned char type;

1664 } hipGraphEdgeData;

1665 

1666 // Doxygen end group GlobalDefs

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

1693 hipError_t hipInit(unsigned int flags);

1694 

1710 hipError_t hipDriverGetVersion(int* driverVersion);

1725 hipError_t hipRuntimeGetVersion(int* runtimeVersion);

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

1734 

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

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

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

1774 hipError_t hipDeviceGetP2PAttribute(int* value, hipDeviceP2PAttr attr,

1775  int srcDevice, int dstDevice);

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

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

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

1801 // doxygen end initialization

1820 hipError_t hipDeviceSynchronize(void);

1832 hipError_t hipDeviceReset(void);

1864 hipError_t hipSetDevice(int deviceId);

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

1890 hipError_t hipGetDevice(int* deviceId);

1903 hipError_t hipGetDeviceCount(int* count);

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

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

1950 hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool);

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

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

1996 hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig);

2007 hipError_t hipDeviceGetCacheConfig(hipFuncCache_t* cacheConfig);

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

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

2053 hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig* pConfig);

2061 hipError_t hipGetDeviceFlags(unsigned int* flags);

2073 hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config);

2098 hipError_t hipSetDeviceFlags(unsigned flags);

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

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

2121 // TODO: implement IPC apis

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

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

2199 hipError_t hipIpcCloseMemHandle(void* devPtr);

2200 

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

2218 

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

2237 

2238 // end doxygen Device

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

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

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

2288 //doxygen end execution

2310 hipError_t hipGetLastError(void);

2311 

2323 hipError_t hipExtGetLastError(void);

2324 

2335 hipError_t hipPeekAtLastError(void);

2344 const char* hipGetErrorName(hipError_t hip_error);

2353 const char* hipGetErrorString(hipError_t hipError);

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

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

2374 // end doxygen Error

2404 hipError_t hipStreamCreate(hipStream_t* stream);

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

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

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

2472 hipError_t hipStreamDestroy(hipStream_t stream);

2488 hipError_t hipStreamQuery(hipStream_t stream);

2509 hipError_t hipStreamSynchronize(hipStream_t stream);

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

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

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

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

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

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

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

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

2622  unsigned int flags);

2623 // end doxygen Stream

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

2667  uint32_t mask __dparm(0xFFFFFFFF));

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

2701  uint64_t mask __dparm(0xFFFFFFFFFFFFFFFF));

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

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

2742 // end doxygen Stream Memory Operations

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

2790 hipError_t hipEventCreate(hipEvent_t* event);

2821 #ifdef __cplusplus

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

2823 #else

2824 hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream);

2825 #endif

2842 hipError_t hipEventDestroy(hipEvent_t event);

2861 hipError_t hipEventSynchronize(hipEvent_t event);

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

2907 hipError_t hipEventQuery(hipEvent_t event);

2908 // end doxygen Events

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

2940  hipDeviceptr_t ptr);

2941 

2942 

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

2977 hipError_t hipPointerGetAttribute(void* data, hipPointer_attribute attribute,

2978  hipDeviceptr_t ptr);

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

2996  void** data, hipDeviceptr_t ptr);

3020 hipError_t hipImportExternalSemaphore(hipExternalSemaphore_t* extSem_out,

3021  const hipExternalSemaphoreHandleDesc* semHandleDesc);

3037 hipError_t hipSignalExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

3038  const hipExternalSemaphoreSignalParams* paramsArray,

3039  unsigned int numExtSems, hipStream_t stream);

3055 hipError_t hipWaitExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

3056  const hipExternalSemaphoreWaitParams* paramsArray,

3057  unsigned int numExtSems, hipStream_t stream);

3070 hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem);

3071 

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

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

3105 hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem);

3119 hipError_t hipExternalMemoryGetMappedMipmappedArray(hipMipmappedArray_t* mipmap, hipExternalMemory_t extMem,

3120  const hipExternalMemoryMipmappedArrayDesc* mipmapDesc);

3121  // end of external resource

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

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

3159 

3160 

3183 HIP_DEPRECATED("use hipHostMalloc instead")

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

3197 HIP_DEPRECATED("use hipHostMalloc instead")

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

3199 // end doxygen deprecated management memory

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

3268 hipError_t hipMallocManaged(void** dev_ptr,

3269  size_t size,

3270  unsigned int flags __dparm(hipMemAttachGlobal));

3283 hipError_t hipMemPrefetchAsync(const void* dev_ptr,

3284  size_t count,

3285  int device,

3286  hipStream_t stream __dparm(0));

3306 hipError_t hipMemAdvise(const void* dev_ptr,

3307  size_t count,

3308  hipMemoryAdvise advice,

3309  int device);

3324 hipError_t hipMemRangeGetAttribute(void* data,

3325  size_t data_size,

3326  hipMemRangeAttribute attribute,

3327  const void* dev_ptr,

3328  size_t count);

3345 hipError_t hipMemRangeGetAttributes(void** data,

3346  size_t* data_sizes,

3347  hipMemRangeAttribute* attributes,

3348  size_t num_attributes,

3349  const void* dev_ptr,

3350  size_t count);

3365 hipError_t hipStreamAttachMemAsync(hipStream_t stream,

3366  void* dev_ptr,

3367  size_t length __dparm(0),

3368  unsigned int flags __dparm(hipMemAttachSingle));

3369 // end doxygen Managed Memory

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

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

3482 hipError_t hipMemPoolTrimTo(hipMemPool_t mem_pool, size_t min_bytes_to_hold);

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

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

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

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

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

3649 hipError_t hipMemPoolDestroy(hipMemPool_t mem_pool);

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

3710 hipError_t hipMemPoolExportToShareableHandle(

3711  void* shared_handle,

3712  hipMemPool_t mem_pool,

3713  hipMemAllocationHandleType handle_type,

3714  unsigned int flags);

3738 hipError_t hipMemPoolImportFromShareableHandle(

3739  hipMemPool_t* mem_pool,

3740  void* shared_handle,

3741  hipMemAllocationHandleType handle_type,

3742  unsigned int flags);

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

3791 hipError_t hipMemPoolImportPointer(

3792  void** dev_ptr,

3793  hipMemPool_t mem_pool,

3794  hipMemPoolPtrExportData* export_data);

3795 // Doxygen end of ordered memory allocator

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

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

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

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

3885 hipError_t hipHostUnregister(void* hostPtr);

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

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

3928  unsigned int elementSizeBytes);

3942 hipError_t hipFree(void* ptr);

3954 hipError_t hipFreeHost(void* ptr);

3970 hipError_t hipHostFree(void* ptr);

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

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

4016  hipMemcpyKind kind, hipStream_t stream);

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

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

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

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

4090  size_t ByteCount);

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

4110  size_t ByteCount);

4111 

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

4132  size_t srcOffset, size_t ByteCount);

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

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

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

4190  hipStream_t stream);

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

4211  size_t ByteCount, hipStream_t stream);

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

4232  size_t ByteCount, hipStream_t stream);

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

4248  hipModule_t hmod, const char* name);

4249 

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

4260 

4261 

4262 

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

4273 

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

4294  hipDriverProcAddressQueryResult* symbolStatus);

4295 

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

4317  size_t sizeBytes, size_t offset __dparm(0),

4318  hipMemcpyKind kind __dparm(hipMemcpyHostToDevice));

4319 

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

4334  size_t sizeBytes, size_t offset,

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

4336 

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

4350  size_t sizeBytes, size_t offset __dparm(0),

4351  hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost));

4352 

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

4367  size_t sizeBytes, size_t offset,

4368  hipMemcpyKind kind,

4369  hipStream_t stream __dparm(0));

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

4400  hipStream_t stream __dparm(0));

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

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

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

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

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

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

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

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

4505  hipStream_t stream __dparm(0));

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

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

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

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

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

4565 

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

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

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

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

4612 hipError_t hipArrayDestroy(hipArray_t array);

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

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

4643 hipError_t hipFreeArray(hipArray_t array);

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

4656  struct hipExtent extent, unsigned int flags);

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

4670  hipArray_t array);

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

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

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

4724  size_t height, hipMemcpyKind kind);

4734 hipError_t hipMemcpyParam2D(const hip_Memcpy2D* pCopy);

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

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

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

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

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

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

4803  size_t spitch, size_t width, size_t height, hipMemcpyKind kind,

4804  hipStream_t stream __dparm(0));

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

4824  hipArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc,

4825  size_t width, size_t height, hipMemcpyKind kind);

4844 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

4846  size_t count, hipMemcpyKind kind);

4865 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

4867  size_t count, hipMemcpyKind kind);

4885 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);

4904 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 __dparm(0));

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

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

4943 hipError_t hipMemcpy3D(const struct hipMemcpy3DParms* p);

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

4966 hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D* pCopy);

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

4979 // doxygen end Memory

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

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

5036 hipError_t hipDeviceDisablePeerAccess(int peerDeviceId);

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

5050 #ifndef USE_PEER_NON_UNIFIED

5051 #define USE_PEER_NON_UNIFIED 1

5052 #endif

5053 #if USE_PEER_NON_UNIFIED == 1

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

5066  size_t sizeBytes);

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

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

5081 #endif

5082 // doxygen end PeerToPeer

5123 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5138 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5139 hipError_t hipCtxDestroy(hipCtx_t ctx);

5153 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5154 hipError_t hipCtxPopCurrent(hipCtx_t* ctx);

5168 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5169 hipError_t hipCtxPushCurrent(hipCtx_t ctx);

5183 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5184 hipError_t hipCtxSetCurrent(hipCtx_t ctx);

5198 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5199 hipError_t hipCtxGetCurrent(hipCtx_t* ctx);

5213 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5214 hipError_t hipCtxGetDevice(hipDevice_t* device);

5235 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5253 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5254 hipError_t hipCtxGetCacheConfig(hipFuncCache_t* cacheConfig);

5271 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5272 hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig);

5289 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5290 hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config);

5307 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5308 hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig* pConfig);

5323 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5324 hipError_t hipCtxSynchronize(void);

5338 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5339 hipError_t hipCtxGetFlags(unsigned int* flags);

5362 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5383 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5384 hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx);

5385 

5401 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5418 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5419 hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev);

5434 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5449 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5450 hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev);

5465 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5467 // doxygen end Context Management

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

5504 hipError_t hipModuleUnload(hipModule_t module);

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

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

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

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

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

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

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

5578  hipJitOption* options, void** optionValues);

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

5608  unsigned int gridDimZ, unsigned int blockDimX,

5609  unsigned int blockDimY, unsigned int blockDimZ,

5610  unsigned int sharedMemBytes, hipStream_t stream,

5611  void** kernelParams, void** extra);

5637 hipError_t hipModuleLaunchCooperativeKernel(hipFunction_t f, unsigned int gridDimX,

5638  unsigned int gridDimY, unsigned int gridDimZ,

5639  unsigned int blockDimX, unsigned int blockDimY,

5640  unsigned int blockDimZ, unsigned int sharedMemBytes,

5641  hipStream_t stream, void** kernelParams);

5656 hipError_t hipModuleLaunchCooperativeKernelMultiDevice(hipFunctionLaunchParams* launchParamsList,

5657  unsigned int numDevices,

5658  unsigned int flags);

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

5680  void** kernelParams, unsigned int sharedMemBytes,

5681  hipStream_t stream);

5693 hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

5694  int numDevices, unsigned int flags);

5706 hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

5707  int numDevices, unsigned int flags);

5708 // doxygen end Module

5735 //TODO - Match CUoccupancyB2DSize

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

5737  hipFunction_t f, size_t dynSharedMemPerBlk,

5738  int blockSizeLimit);

5754 //TODO - Match CUoccupancyB2DSize

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

5756  hipFunction_t f, size_t dynSharedMemPerBlk,

5757  int blockSizeLimit, unsigned int flags);

5767 hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(

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

5779 hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

5790 hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(

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

5802 hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

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

5819  const void* f, size_t dynSharedMemPerBlk,

5820  int blockSizeLimit);

5821 // doxygen end Occupancy

5835 // TODO - expand descriptions:

5842 HIP_DEPRECATED("use roctracer/rocTX instead")

5843 hipError_t hipProfilerStart();

5850 HIP_DEPRECATED("use roctracer/rocTX instead")

5851 hipError_t hipProfilerStop();

5852 // doxygen end profiler

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

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

5899 hipError_t hipLaunchByPtr(const void* func);

5916 hipError_t __hipPushCallConfiguration(dim3 gridDim,

5917  dim3 blockDim,

5918  size_t sharedMem __dparm(0),

5919  hipStream_t stream __dparm(0));

5939 hipError_t __hipPopCallConfiguration(dim3 *gridDim,

5940  dim3 *blockDim,

5941  size_t *sharedMem,

5942  hipStream_t *stream);

5959 hipError_t hipLaunchKernel(const void* function_address,

5960  dim3 numBlocks,

5961  dim3 dimBlocks,

5962  void** args,

5963  size_t sharedMemBytes __dparm(0),

5964  hipStream_t stream __dparm(0));

5965 

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

5992 

6000 hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D* pCopy);

6001 //TODO: Move this to hip_ext.h

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

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

6025  hipEvent_t startEvent, hipEvent_t stopEvent, int flags);

6026 // doxygen end Clang launch

6052 hipError_t hipCreateTextureObject(

6053  hipTextureObject_t* pTexObject,

6054  const hipResourceDesc* pResDesc,

6055  const hipTextureDesc* pTexDesc,

6056  const struct hipResourceViewDesc* pResViewDesc);

6057 

6066 hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject);

6067 

6077 hipError_t hipGetChannelDesc(

6078  hipChannelFormatDesc* desc,

6079  hipArray_const_t array);

6080 

6090 hipError_t hipGetTextureObjectResourceDesc(

6091  hipResourceDesc* pResDesc,

6092  hipTextureObject_t textureObject);

6093 

6103 hipError_t hipGetTextureObjectResourceViewDesc(

6104  struct hipResourceViewDesc* pResViewDesc,

6105  hipTextureObject_t textureObject);

6106 

6116 hipError_t hipGetTextureObjectTextureDesc(

6117  hipTextureDesc* pTexDesc,

6118  hipTextureObject_t textureObject);

6119 

6131 hipError_t hipTexObjectCreate(

6132  hipTextureObject_t* pTexObject,

6133  const HIP_RESOURCE_DESC* pResDesc,

6134  const HIP_TEXTURE_DESC* pTexDesc,

6135  const HIP_RESOURCE_VIEW_DESC* pResViewDesc);

6136 

6145 hipError_t hipTexObjectDestroy(

6146  hipTextureObject_t texObject);

6147 

6157 hipError_t hipTexObjectGetResourceDesc(

6158  HIP_RESOURCE_DESC* pResDesc,

6159  hipTextureObject_t texObject);

6160 

6170 hipError_t hipTexObjectGetResourceViewDesc(

6171  HIP_RESOURCE_VIEW_DESC* pResViewDesc,

6172  hipTextureObject_t texObject);

6173 

6183 hipError_t hipTexObjectGetTextureDesc(

6184  HIP_TEXTURE_DESC* pTexDesc,

6185  hipTextureObject_t texObject);

6186 

6201 hipError_t hipMallocMipmappedArray(

6202  hipMipmappedArray_t *mipmappedArray,

6203  const struct hipChannelFormatDesc* desc,

6204  struct hipExtent extent,

6205  unsigned int numLevels,

6206  unsigned int flags __dparm(0));

6207 

6218 hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray);

6219 

6232 hipError_t hipGetMipmappedArrayLevel(

6233  hipArray_t *levelArray,

6234  hipMipmappedArray_const_t mipmappedArray,

6235  unsigned int level);

6236 

6248 hipError_t hipMipmappedArrayCreate(

6249  hipMipmappedArray_t* pHandle,

6250  HIP_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc,

6251  unsigned int numMipmapLevels);

6252 

6263 hipError_t hipMipmappedArrayDestroy(hipMipmappedArray_t hMipmappedArray);

6264 

6277 hipError_t hipMipmappedArrayGetLevel(

6278  hipArray_t* pLevelArray,

6279  hipMipmappedArray_t hMipMappedArray,

6280  unsigned int level);

6281 

6300 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6301 hipError_t hipBindTextureToMipmappedArray(

6302  const textureReference* tex,

6303  hipMipmappedArray_const_t mipmappedArray,

6304  const hipChannelFormatDesc* desc);

6305 

6316 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6317 hipError_t hipGetTextureReference(

6318  const textureReference** texref,

6319  const void* symbol);

6320 

6331 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6333 

6345 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6347 

6359 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6360 hipError_t hipTexRefSetAddressMode(

6361  textureReference* texRef,

6362  int dim,

6363  enum hipTextureAddressMode am);

6376 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6377 hipError_t hipTexRefSetArray(

6378  textureReference* tex,

6379  hipArray_const_t array,

6380  unsigned int flags);

6392 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6393 hipError_t hipTexRefSetFilterMode(

6394  textureReference* texRef,

6395  enum hipTextureFilterMode fm);

6407 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6408 hipError_t hipTexRefSetFlags(

6409  textureReference* texRef,

6410  unsigned int Flags);

6423 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6424 hipError_t hipTexRefSetFormat(

6425  textureReference* texRef,

6426  hipArray_Format fmt,

6427  int NumPackedComponents);

6442 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6443 hipError_t hipBindTexture(

6444  size_t* offset,

6445  const textureReference* tex,

6446  const void* devPtr,

6447  const hipChannelFormatDesc* desc,

6448  size_t size __dparm(UINT_MAX));

6465 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6466 hipError_t hipBindTexture2D(

6467  size_t* offset,

6468  const textureReference* tex,

6469  const void* devPtr,

6470  const hipChannelFormatDesc* desc,

6471  size_t width,

6472  size_t height,

6473  size_t pitch);

6486 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6487 hipError_t hipBindTextureToArray(

6488  const textureReference* tex,

6489  hipArray_const_t array,

6490  const hipChannelFormatDesc* desc);

6502 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6503 hipError_t hipGetTextureAlignmentOffset(

6504  size_t* offset,

6505  const textureReference* texref);

6516 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6517 hipError_t hipUnbindTexture(const textureReference* tex);

6529 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6530 hipError_t hipTexRefGetAddress(

6531  hipDeviceptr_t* dev_ptr,

6532  const textureReference* texRef);

6545 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6546 hipError_t hipTexRefGetAddressMode(

6547  enum hipTextureAddressMode* pam,

6548  const textureReference* texRef,

6549  int dim);

6561 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6562 hipError_t hipTexRefGetFilterMode(

6563  enum hipTextureFilterMode* pfm,

6564  const textureReference* texRef);

6576 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6577 hipError_t hipTexRefGetFlags(

6578  unsigned int* pFlags,

6579  const textureReference* texRef);

6592 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6593 hipError_t hipTexRefGetFormat(

6594  hipArray_Format* pFormat,

6595  int* pNumChannels,

6596  const textureReference* texRef);

6608 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6609 hipError_t hipTexRefGetMaxAnisotropy(

6610  int* pmaxAnsio,

6611  const textureReference* texRef);

6623 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6624 hipError_t hipTexRefGetMipmapFilterMode(

6625  enum hipTextureFilterMode* pfm,

6626  const textureReference* texRef);

6638 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6639 hipError_t hipTexRefGetMipmapLevelBias(

6640  float* pbias,

6641  const textureReference* texRef);

6654 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6655 hipError_t hipTexRefGetMipmapLevelClamp(

6656  float* pminMipmapLevelClamp,

6657  float* pmaxMipmapLevelClamp,

6658  const textureReference* texRef);

6670 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6671 hipError_t hipTexRefGetMipMappedArray(

6672  hipMipmappedArray_t* pArray,

6673  const textureReference* texRef);

6687 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6688 hipError_t hipTexRefSetAddress(

6689  size_t* ByteOffset,

6690  textureReference* texRef,

6691  hipDeviceptr_t dptr,

6692  size_t bytes);

6706 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6707 hipError_t hipTexRefSetAddress2D(

6708  textureReference* texRef,

6709  const HIP_ARRAY_DESCRIPTOR* desc,

6710  hipDeviceptr_t dptr,

6711  size_t Pitch);

6723 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6724 hipError_t hipTexRefSetMaxAnisotropy(

6725  textureReference* texRef,

6726  unsigned int maxAniso);

6738 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6739 hipError_t hipTexRefSetBorderColor(

6740  textureReference* texRef,

6741  float* pBorderColor);

6753 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6754 hipError_t hipTexRefSetMipmapFilterMode(

6755  textureReference* texRef,

6756  enum hipTextureFilterMode fm);

6768 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6769 hipError_t hipTexRefSetMipmapLevelBias(

6770  textureReference* texRef,

6771  float bias);

6784 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6785 hipError_t hipTexRefSetMipmapLevelClamp(

6786  textureReference* texRef,

6787  float minMipMapLevelClamp,

6788  float maxMipMapLevelClamp);

6801 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6802 hipError_t hipTexRefSetMipmappedArray(

6803  textureReference* texRef,

6804  struct hipMipmappedArray* mipmappedArray,

6805  unsigned int Flags);

6806 

6807 // doxygen end deprecated texture management

6812 // doxygen end Texture management

6824 // This group is for HIPrtc

6825 

6826 // doxygen end Runtime

6845 const char* hipApiName(uint32_t id);

6854 const char* hipKernelNameRef(const hipFunction_t f);

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

6873 int hipGetStreamDeviceId(hipStream_t stream);

6874 

6875 // doxygen end Callback

6900 hipError_t hipStreamBeginCapture(hipStream_t stream, hipStreamCaptureMode mode);

6901 

6921 hipError_t hipStreamBeginCaptureToGraph(hipStream_t stream, hipGraph_t graph,

6922  const hipGraphNode_t* dependencies,

6923  const hipGraphEdgeData* dependencyData,

6924  size_t numDependencies, hipStreamCaptureMode mode);

6925 

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

6939 

6953 hipError_t hipStreamGetCaptureInfo(hipStream_t stream, hipStreamCaptureStatus* pCaptureStatus,

6954  unsigned long long* pId);

6955 

6972 hipError_t hipStreamGetCaptureInfo_v2(hipStream_t stream, hipStreamCaptureStatus* captureStatus_out,

6973  unsigned long long* id_out __dparm(0),

6974  hipGraph_t* graph_out __dparm(0),

6975  const hipGraphNode_t** dependencies_out __dparm(0),

6976  size_t* numDependencies_out __dparm(0));

6977 

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

6991 

7006 hipError_t hipStreamUpdateCaptureDependencies(hipStream_t stream, hipGraphNode_t* dependencies,

7007  size_t numDependencies,

7008  unsigned int flags __dparm(0));

7009 

7020 hipError_t hipThreadExchangeStreamCaptureMode(hipStreamCaptureMode* mode);

7021 

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

7035 

7047 hipError_t hipGraphDestroy(hipGraph_t graph);

7048 

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

7063  const hipGraphNode_t* to, size_t numDependencies);

7064 

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

7079  const hipGraphNode_t* to, size_t numDependencies);

7080 

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

7099  size_t* numEdges);

7100 

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

7118 

7135 hipError_t hipGraphGetRootNodes(hipGraph_t graph, hipGraphNode_t* pRootNodes,

7136  size_t* pNumRootNodes);

7137 

7154 hipError_t hipGraphNodeGetDependencies(hipGraphNode_t node, hipGraphNode_t* pDependencies,

7155  size_t* pNumDependencies);

7156 

7174 hipError_t hipGraphNodeGetDependentNodes(hipGraphNode_t node, hipGraphNode_t* pDependentNodes,

7175  size_t* pNumDependentNodes);

7176 

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

7189 

7200 hipError_t hipGraphDestroyNode(hipGraphNode_t node);

7201 

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

7214 

7227 hipError_t hipGraphNodeFindInClone(hipGraphNode_t* pNode, hipGraphNode_t originalNode,

7228  hipGraph_t clonedGraph);

7229 

7246 hipError_t hipGraphInstantiate(hipGraphExec_t* pGraphExec, hipGraph_t graph,

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

7248 

7261 hipError_t hipGraphInstantiateWithFlags(hipGraphExec_t* pGraphExec, hipGraph_t graph,

7262  unsigned long long flags);

7263 

7275 hipError_t hipGraphInstantiateWithParams(hipGraphExec_t* pGraphExec, hipGraph_t graph,

7276  hipGraphInstantiateParams *instantiateParams);

7287 hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream);

7288 

7299 hipError_t hipGraphUpload(hipGraphExec_t graphExec, hipStream_t stream);

7300 

7313 hipError_t hipGraphAddNode(hipGraphNode_t *pGraphNode, hipGraph_t graph,

7314  const hipGraphNode_t *pDependencies, size_t numDependencies,

7315  hipGraphNodeParams *nodeParams);

7316 

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

7327 

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

7338 

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

7350 

7361 hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec);

7362 

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

7377 hipError_t hipGraphExecUpdate(hipGraphExec_t hGraphExec, hipGraph_t hGraph,

7378  hipGraphNode_t* hErrorNode_out,

7379  hipGraphExecUpdateResult* updateResult_out);

7380 

7393 hipError_t hipGraphAddKernelNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7394  const hipGraphNode_t* pDependencies, size_t numDependencies,

7395  const hipKernelNodeParams* pNodeParams);

7396 

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

7407 

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

7418 

7429 hipError_t hipGraphExecKernelNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7430  const hipKernelNodeParams* pNodeParams);

7431 

7445 hipError_t hipDrvGraphAddMemcpyNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

7446  const hipGraphNode_t* dependencies,

7447  size_t numDependencies,

7448  const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);

7461 hipError_t hipGraphAddMemcpyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7462  const hipGraphNode_t* pDependencies, size_t numDependencies,

7463  const hipMemcpy3DParms* pCopyParams);

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

7474 

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

7485 

7496 hipError_t hipGraphKernelNodeSetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

7497  const hipKernelNodeAttrValue* value);

7508 hipError_t hipGraphKernelNodeGetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

7509  hipKernelNodeAttrValue* value);

7520 hipError_t hipGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7521  hipMemcpy3DParms* pNodeParams);

7522 

7538 hipError_t hipGraphAddMemcpyNode1D(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7539  const hipGraphNode_t* pDependencies, size_t numDependencies,

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

7541 

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

7555  size_t count, hipMemcpyKind kind);

7556 

7571 hipError_t hipGraphExecMemcpyNodeSetParams1D(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

7573  hipMemcpyKind kind);

7574 

7591 hipError_t hipGraphAddMemcpyNodeFromSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7592  const hipGraphNode_t* pDependencies,

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

7594  size_t count, size_t offset, hipMemcpyKind kind);

7595 

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

7610  size_t count, size_t offset, hipMemcpyKind kind);

7611 

7627 hipError_t hipGraphExecMemcpyNodeSetParamsFromSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

7629  size_t offset, hipMemcpyKind kind);

7630 

7647 hipError_t hipGraphAddMemcpyNodeToSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7648  const hipGraphNode_t* pDependencies,

7649  size_t numDependencies, const void* symbol,

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

7651  hipMemcpyKind kind);

7652 

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

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

7668  hipMemcpyKind kind);

7669 

7670 

7685 hipError_t hipGraphExecMemcpyNodeSetParamsToSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7686  const void* symbol, const void* src,

7687  size_t count, size_t offset, hipMemcpyKind kind);

7688 

7701 hipError_t hipGraphAddMemsetNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7702  const hipGraphNode_t* pDependencies, size_t numDependencies,

7703  const hipMemsetParams* pMemsetParams);

7704 

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

7715 

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

7726 

7737 hipError_t hipGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7738  const hipMemsetParams* pNodeParams);

7739 

7752 hipError_t hipGraphAddHostNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7753  const hipGraphNode_t* pDependencies, size_t numDependencies,

7754  const hipHostNodeParams* pNodeParams);

7755 

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

7766 

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

7777 

7788 hipError_t hipGraphExecHostNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7789  const hipHostNodeParams* pNodeParams);

7790 

7803 hipError_t hipGraphAddChildGraphNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7804  const hipGraphNode_t* pDependencies, size_t numDependencies,

7805  hipGraph_t childGraph);

7806 

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

7817 

7828 hipError_t hipGraphExecChildGraphNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7829  hipGraph_t childGraph);

7830 

7842 hipError_t hipGraphAddEmptyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7843  const hipGraphNode_t* pDependencies, size_t numDependencies);

7844 

7845 

7858 hipError_t hipGraphAddEventRecordNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7859  const hipGraphNode_t* pDependencies, size_t numDependencies,

7860  hipEvent_t event);

7861 

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

7872 

7882 hipError_t hipGraphEventRecordNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

7883 

7894 hipError_t hipGraphExecEventRecordNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

7895  hipEvent_t event);

7896 

7909 hipError_t hipGraphAddEventWaitNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7910  const hipGraphNode_t* pDependencies, size_t numDependencies,

7911  hipEvent_t event);

7912 

7913 

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

7924 

7934 hipError_t hipGraphEventWaitNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

7935 

7946 hipError_t hipGraphExecEventWaitNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

7947  hipEvent_t event);

7948 

7961 hipError_t hipGraphAddMemAllocNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

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

7963 

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

7974 

7987 hipError_t hipGraphAddMemFreeNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

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

7989 

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

8000 

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

8012 

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

8024 

8034 hipError_t hipDeviceGraphMemTrim(int device);

8035 

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

8049  unsigned int initialRefcount, unsigned int flags);

8050 

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

8061 

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

8072 

8084 hipError_t hipGraphRetainUserObject(hipGraph_t graph, hipUserObject_t object,

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

8086 

8097 hipError_t hipGraphReleaseUserObject(hipGraph_t graph, hipUserObject_t object,

8098  unsigned int count __dparm(1));

8099 

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

8111 

8126 hipError_t hipGraphKernelNodeCopyAttributes(hipGraphNode_t hSrc, hipGraphNode_t hDst);

8127 

8150 hipError_t hipGraphNodeSetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8151  unsigned int isEnabled);

8172 hipError_t hipGraphNodeGetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8173  unsigned int* isEnabled);

8174 

8187 hipError_t hipGraphAddExternalSemaphoresWaitNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8188  const hipGraphNode_t* pDependencies, size_t numDependencies,

8189  const hipExternalSemaphoreWaitNodeParams* nodeParams);

8190 

8203 hipError_t hipGraphAddExternalSemaphoresSignalNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8204  const hipGraphNode_t* pDependencies, size_t numDependencies,

8205  const hipExternalSemaphoreSignalNodeParams* nodeParams);

8215 hipError_t hipGraphExternalSemaphoresSignalNodeSetParams(hipGraphNode_t hNode,

8216  const hipExternalSemaphoreSignalNodeParams* nodeParams);

8226 hipError_t hipGraphExternalSemaphoresWaitNodeSetParams(hipGraphNode_t hNode,

8227  const hipExternalSemaphoreWaitNodeParams* nodeParams);

8237 hipError_t hipGraphExternalSemaphoresSignalNodeGetParams(hipGraphNode_t hNode,

8238  hipExternalSemaphoreSignalNodeParams* params_out);

8248 hipError_t hipGraphExternalSemaphoresWaitNodeGetParams(hipGraphNode_t hNode,

8249  hipExternalSemaphoreWaitNodeParams* params_out);

8260 hipError_t hipGraphExecExternalSemaphoresSignalNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8261  const hipExternalSemaphoreSignalNodeParams* nodeParams);

8272 hipError_t hipGraphExecExternalSemaphoresWaitNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8273  const hipExternalSemaphoreWaitNodeParams* nodeParams);

8274 

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

8285 

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

8296 

8310 hipError_t hipDrvGraphAddMemsetNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

8311  const hipGraphNode_t* dependencies, size_t numDependencies,

8312  const HIP_MEMSET_NODE_PARAMS* memsetParams, hipCtx_t ctx);

8313 

8326 hipError_t hipDrvGraphAddMemFreeNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

8327  const hipGraphNode_t* dependencies, size_t numDependencies,

8328  hipDeviceptr_t dptr);

8329 

8341 hipError_t hipDrvGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8342  const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);

8343 

8355 hipError_t hipDrvGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8356  const HIP_MEMSET_NODE_PARAMS* memsetParams, hipCtx_t ctx);

8357 

8358 // doxygen end graph API

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

8387 

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

8403 

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

8418 

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

8433 

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

8447 

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

8462 

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

8475 

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

8489 

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

8505 

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

8519 

8530 hipError_t hipMemRelease(hipMemGenericAllocationHandle_t handle);

8531 

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

8544 

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

8559 

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

8572 

8573 // doxygen end virtual memory management API

8595 hipError_t hipGraphicsMapResources(int count, hipGraphicsResource_t* resources,

8596  hipStream_t stream __dparm(0) );

8610 hipError_t hipGraphicsSubResourceGetMappedArray(hipArray_t* array, hipGraphicsResource_t resource,

8611  unsigned int arrayIndex, unsigned int mipLevel);

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

8623  hipGraphicsResource_t resource);

8634 hipError_t hipGraphicsUnmapResources(int count, hipGraphicsResource_t* resources,

8635  hipStream_t stream __dparm(0));

8644 hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource);

8645 // doxygen end GL Interop

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

8679 hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject);

8680 // end of surface

8684 #ifdef __cplusplus

8685 } /* extern "c" */

8686 #endif

8687 #ifdef __cplusplus

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

8689 template <typename T>

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

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

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

8693 }

8694 template <typename T>

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

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

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

8698 }

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

8700 

8710 template <typename T>

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

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

8713 }

8724 template <typename T>

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

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

8727 }

8728 

8737 template <typename T>

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

8739  size_t offset __dparm(0),

8740  hipMemcpyKind kind __dparm(hipMemcpyHostToDevice)) {

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

8742 }

8751 template <typename T>

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

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

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

8755 }

8763 template <typename T>

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

8765  size_t sizeBytes, size_t offset __dparm(0),

8766  hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost)) {

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

8768 }

8776 template <typename T>

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

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

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

8780 }

8781 

8793 template <class T>

8794 inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(

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

8796  return hipOccupancyMaxActiveBlocksPerMultiprocessor(

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

8798 }

8812 template <class T>

8813 inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

8815  return hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

8817 }

8838 template<typename UnaryFunction, class T>

8839 static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(

8840  int* min_grid_size,

8841  int* block_size,

8842  T func,

8843  UnaryFunction block_size_to_dynamic_smem_size,

8844  int block_size_limit = 0,

8845  unsigned int flags = 0) {

8846  if (min_grid_size == nullptr || block_size == nullptr ||

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

8848  return hipErrorInvalidValue;

8849  }

8850 

8851  int dev;

8852  hipError_t status;

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

8854  return status;

8855  }

8856 

8857  int max_threads_per_cu;

8858  if ((status = hipDeviceGetAttribute(&max_threads_per_cu,

8859  hipDeviceAttributeMaxThreadsPerMultiProcessor, dev)) != hipSuccess) {

8860  return status;

8861  }

8862 

8863  int warp_size;

8864  if ((status = hipDeviceGetAttribute(&warp_size,

8865  hipDeviceAttributeWarpSize, dev)) != hipSuccess) {

8866  return status;

8867  }

8868 

8869  int max_cu_count;

8870  if ((status = hipDeviceGetAttribute(&max_cu_count,

8871  hipDeviceAttributeMultiprocessorCount, dev)) != hipSuccess) {

8872  return status;

8873  }

8874 

8875  struct hipFuncAttributes attr;

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

8877  return status;

8878  }

8879 

8880  // Initial limits for the execution

8881  const int func_max_threads_per_block = attr.maxThreadsPerBlock;

8882  if (block_size_limit == 0) {

8883  block_size_limit = func_max_threads_per_block;

8884  }

8885 

8886  if (func_max_threads_per_block < block_size_limit) {

8887  block_size_limit = func_max_threads_per_block;

8888  }

8889 

8890  const int block_size_limit_aligned =

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

8892 

8893  // For maximum search

8894  int max_threads = 0;

8895  int max_block_size{};

8896  int max_num_blocks{};

8897  for (int block_size_check_aligned = block_size_limit_aligned;

8898  block_size_check_aligned > 0;

8899  block_size_check_aligned -= warp_size) {

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

8901  int block_size_check = (block_size_limit < block_size_check_aligned) ?

8902  block_size_limit : block_size_check_aligned;

8903 

8904  size_t dyn_smem_size = block_size_to_dynamic_smem_size(block_size_check);

8905  int optimal_blocks;

8906  if ((status = hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

8908  return status;

8909  }

8910 

8911  int total_threads = block_size_check * optimal_blocks;

8912  if (total_threads > max_threads) {

8913  max_block_size = block_size_check;

8914  max_num_blocks = optimal_blocks;

8915  max_threads = total_threads;

8916  }

8917 

8918  // Break if the logic reached possible maximum

8919  if (max_threads_per_cu == max_threads) {

8920  break;

8921  }

8922  }

8923 

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

8925  *min_grid_size = max_num_blocks * max_cu_count;

8926  *block_size = max_block_size;

8927 

8928  return status;

8929 }

8930 

8950 template<typename UnaryFunction, class T>

8951 static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMem(

8952  int* min_grid_size,

8953  int* block_size,

8954  T func,

8955  UnaryFunction block_size_to_dynamic_smem_size,

8956  int block_size_limit = 0)

8957 {

8958  return hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(min_grid_size, block_size, func,

8959  block_size_to_dynamic_smem_size, block_size_limit);

8960 }

8975 template <typename F>

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

8977  F kernel, size_t dynSharedMemPerBlk, uint32_t blockSizeLimit) {

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

8979 }

8996 template <class T>

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

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

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

9000  blockDim, kernelParams, sharedMemBytes, stream);

9001 }

9016 template <class T>

9017 inline hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

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

9019  return hipLaunchCooperativeKernelMultiDevice(launchParamsList, numDevices, flags);

9020 }

9035 template <class T>

9036 inline hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

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

9038  return hipExtLaunchMultiKernelMultiDevice(launchParamsList, numDevices, flags);

9039 }

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

9054 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

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

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

9058 }

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

9074 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9075 static inline hipError_t

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

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

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

9079 }

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

9096 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9097 static inline hipError_t hipBindTexture2D(

9098  size_t *offset,

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

9100  const void *devPtr,

9101  size_t width,

9102  size_t height,

9103  size_t pitch)

9104 {

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

9106 }

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

9124 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9125 static inline hipError_t hipBindTexture2D(

9126  size_t *offset,

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

9128  const void *devPtr,

9129  const struct hipChannelFormatDesc &desc,

9130  size_t width,

9131  size_t height,

9132  size_t pitch)

9133 {

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

9135 }

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

9148 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9149 static inline hipError_t hipBindTextureToArray(

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

9151  hipArray_const_t array)

9152 {

9153  struct hipChannelFormatDesc desc;

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

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

9156 }

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

9170 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9171 static inline hipError_t hipBindTextureToArray(

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

9173  hipArray_const_t array,

9174  const struct hipChannelFormatDesc &desc)

9175 {

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

9177 }

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

9190 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9191 static inline hipError_t hipBindTextureToMipmappedArray(

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

9193  hipMipmappedArray_const_t mipmappedArray)

9194 {

9195  struct hipChannelFormatDesc desc;

9196  hipArray_t levelArray;

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

9198  if (err != hipSuccess) {

9199  return err;

9200  }

9201  err = hipGetChannelDesc(&desc, levelArray);

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

9203 }

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

9217 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9218 static inline hipError_t hipBindTextureToMipmappedArray(

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

9220  hipMipmappedArray_const_t mipmappedArray,

9221  const struct hipChannelFormatDesc &desc)

9222 {

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

9224 }

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

9236 HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9237 static inline hipError_t hipUnbindTexture(

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

9239 {

9240  return hipUnbindTexture(&tex);

9241 }

9265 static inline hipError_t hipMallocAsync(

9266  void** dev_ptr,

9267  size_t size,

9268  hipMemPool_t mem_pool,

9269  hipStream_t stream) {

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

9271 }

9282 template<class T>

9283 static inline hipError_t hipMallocAsync(

9284  T** dev_ptr,

9285  size_t size,

9286  hipMemPool_t mem_pool,

9287  hipStream_t stream) {

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

9289 }

9300 template<class T>

9301 static inline hipError_t hipMallocAsync(

9302  T** dev_ptr,

9303  size_t size,

9304  hipStream_t stream) {

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

9306 }

9317 template<class T>

9318 static inline hipError_t hipMallocFromPoolAsync(

9319  T** dev_ptr,

9320  size_t size,

9321  hipMemPool_t mem_pool,

9322  hipStream_t stream) {

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

9324 }

9330 #endif // __cplusplus

9331 

9332 #ifdef __GNUC__

9333 #pragma GCC visibility pop

9334 #endif

9335 

9336 

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

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

9339 #else

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

9341 #endif

9342 

9343 

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

9356 template <class T>

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

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

9359 }

9371 template <class T>

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

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

9374 }

9387 template <class T>

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

9389  unsigned int flags = hipHostMallocDefault) {

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

9391 }

9404 template <class T>

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

9406  unsigned int flags = hipHostAllocDefault) {

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

9408 }

9423 template <class T>

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

9425  unsigned int flags = hipMemAttachGlobal) {

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

9427 }

9428 

9429 

9430 #endif

9431 #endif

9432 // doxygen end HIP API

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

9437 

9438 #if USE_PROF_API

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

9440 #endif

driver_types.h

hipMemcpyKind

hipMemcpyKind

Definition: driver_types.h:333

hipMemcpyDeviceToHost

@ hipMemcpyDeviceToHost

Device-to-Host Copy.

Definition: driver_types.h:336

hipMemcpyHostToDevice

@ hipMemcpyHostToDevice

Host-to-Device Copy.

Definition: driver_types.h:335

hipPointer_attribute

hipPointer_attribute

Definition: driver_types.h:431

hipArray_t

struct hipArray * hipArray_t

Definition: driver_types.h:58

hipDeviceptr_t

void * hipDeviceptr_t

Definition: driver_types.h:39

hipFunction_attribute

hipFunction_attribute

Definition: driver_types.h:417

hipArray_const_t

const struct hipArray * hipArray_const_t

Definition: driver_types.h:59

hipArray_Format

hipArray_Format

Definition: driver_types.h:60

hipResourceType

hipResourceType

Definition: driver_types.h:123

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.

hipApiName

const char * hipApiName(uint32_t id)

Returns HIP API name by ID.

hipGetStreamDeviceId

int hipGetStreamDeviceId(hipStream_t stream)

Returns device ID on the stream.

hipSetupArgument

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

Set a kernel argument.

__hipPopCallConfiguration

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

Pop configuration of a kernel launch.

hipLaunchHostFunc

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

Enqueues a host function call in a stream.

hipLaunchKernel

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

C compliant kernel launch API.

hipExtLaunchKernel

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

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

__hipPushCallConfiguration

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

Push configuration of a kernel launch.

hipLaunchByPtr

hipError_t hipLaunchByPtr(const void *func)

Launch a kernel.

hipDrvMemcpy2DUnaligned

hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D *pCopy)

hipConfigureCall

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

Configure a kernel launch.

hipCtxGetFlags

hipError_t hipCtxGetFlags(unsigned int *flags)

Return flags used for creating default context [Deprecated].

hipCtxPopCurrent

hipError_t hipCtxPopCurrent(hipCtx_t *ctx)

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

hipCtxGetSharedMemConfig

hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig *pConfig)

Get Shared memory bank configuration [Deprecated].

hipDevicePrimaryCtxSetFlags

hipError_t hipDevicePrimaryCtxSetFlags(hipDevice_t dev, unsigned int flags)

Set flags for the primary context [Deprecated].

hipDevicePrimaryCtxGetState

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

Get the state of the primary context [Deprecated].

hipCtxGetCurrent

hipError_t hipCtxGetCurrent(hipCtx_t *ctx)

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

hipDevicePrimaryCtxRelease

hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev)

Release the primary context on the GPU.

hipCtxSetCacheConfig

hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig)

Set L1/Shared cache partition [Deprecated].

hipCtxSetCurrent

hipError_t hipCtxSetCurrent(hipCtx_t ctx)

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

hipCtxEnablePeerAccess

hipError_t hipCtxEnablePeerAccess(hipCtx_t peerCtx, unsigned int flags)

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

hipCtxGetDevice

hipError_t hipCtxGetDevice(hipDevice_t *device)

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

hipCtxDestroy

hipError_t hipCtxDestroy(hipCtx_t ctx)

Destroy a HIP context [Deprecated].

hipCtxPushCurrent

hipError_t hipCtxPushCurrent(hipCtx_t ctx)

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

hipCtxGetCacheConfig

hipError_t hipCtxGetCacheConfig(hipFuncCache_t *cacheConfig)

Get Cache configuration for a specific function [Deprecated].

hipCtxCreate

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

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

hipDevicePrimaryCtxRetain

hipError_t hipDevicePrimaryCtxRetain(hipCtx_t *pctx, hipDevice_t dev)

Retain the primary context on the GPU [Deprecated].

hipCtxGetApiVersion

hipError_t hipCtxGetApiVersion(hipCtx_t ctx, int *apiVersion)

Returns the approximate HIP api version.

hipDevicePrimaryCtxReset

hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev)

Resets the primary context on the GPU [Deprecated].

hipCtxSynchronize

hipError_t hipCtxSynchronize(void)

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

hipCtxSetSharedMemConfig

hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config)

Set Shared memory bank configuration [Deprecated].

hipCtxDisablePeerAccess

hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx)

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

hipGetDeviceFlags

hipError_t hipGetDeviceFlags(unsigned int *flags)

Gets the flags set for current device.

hipIpcGetEventHandle

hipError_t hipIpcGetEventHandle(hipIpcEventHandle_t *handle, hipEvent_t event)

Gets an opaque interprocess handle for an event.

hipDeviceGetDefaultMemPool

hipError_t hipDeviceGetDefaultMemPool(hipMemPool_t *mem_pool, int device)

Returns the default memory pool of the specified device.

hipDeviceGetSharedMemConfig

hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig *pConfig)

Returns bank width of shared memory for current device.

hipDeviceSetMemPool

hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool)

Sets the current memory pool of a device.

hipIpcOpenMemHandle

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

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

hipDeviceGetCacheConfig

hipError_t hipDeviceGetCacheConfig(hipFuncCache_t *cacheConfig)

Get Cache configuration for a specific Device.

hipSetDevice

hipError_t hipSetDevice(int deviceId)

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

hipExtGetLinkTypeAndHopCount

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

Returns the link type and hop count between two devices.

hipSetDeviceFlags

hipError_t hipSetDeviceFlags(unsigned flags)

The current device behavior is changed according the flags passed.

hipDeviceGetAttribute

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

Query for a specific device attribute.

hipGetDevice

hipError_t hipGetDevice(int *deviceId)

Return the default device id for the calling host thread.

hipGetDeviceCount

hipError_t hipGetDeviceCount(int *count)

Return number of compute-capable devices.

hipDeviceGetMemPool

hipError_t hipDeviceGetMemPool(hipMemPool_t *mem_pool, int device)

Gets the current memory pool for the specified device.

hipDeviceReset

hipError_t hipDeviceReset(void)

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

hipDeviceGetLimit

hipError_t hipDeviceGetLimit(size_t *pValue, enum hipLimit_t limit)

Gets resource limits of current device.

hipDeviceSetSharedMemConfig

hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config)

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

hipDeviceSetLimit

hipError_t hipDeviceSetLimit(enum hipLimit_t limit, size_t value)

Sets resource limits of current device.

hipDeviceSetCacheConfig

hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig)

Set L1/Shared cache partition.

hipIpcCloseMemHandle

hipError_t hipIpcCloseMemHandle(void *devPtr)

Close memory mapped with hipIpcOpenMemHandle.

hipSetValidDevices

hipError_t hipSetValidDevices(int *device_arr, int len)

Set a list of devices that can be used.

hipIpcOpenEventHandle

hipError_t hipIpcOpenEventHandle(hipEvent_t *event, hipIpcEventHandle_t handle)

Opens an interprocess event handles.

hipDeviceSynchronize

hipError_t hipDeviceSynchronize(void)

Waits on all active streams on current device.

hipIpcGetMemHandle

hipError_t hipIpcGetMemHandle(hipIpcMemHandle_t *handle, void *devPtr)

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

hipInit

hipError_t hipInit(unsigned int flags)

Explicitly initializes the HIP runtime.

hipDeviceComputeCapability

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

Returns the compute capability of the device.

hipDeviceGetName

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

Returns an identifer string for the device.

hipDeviceGetByPCIBusId

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

Returns a handle to a compute device.

hipDeviceGetUuid

hipError_t hipDeviceGetUuid(hipUUID *uuid, hipDevice_t device)

Returns an UUID for the device.[BETA].

hipDeviceTotalMem

hipError_t hipDeviceTotalMem(size_t *bytes, hipDevice_t device)

Returns the total amount of memory on the device.

hipDeviceGetPCIBusId

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

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

hipDeviceGet

hipError_t hipDeviceGet(hipDevice_t *device, int ordinal)

Returns a handle to a compute device.

hipRuntimeGetVersion

hipError_t hipRuntimeGetVersion(int *runtimeVersion)

Returns the approximate HIP Runtime version.

hipDeviceGetP2PAttribute

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

Returns a value for attribute of link between two devices.

hipDriverGetVersion

hipError_t hipDriverGetVersion(int *driverVersion)

Returns the approximate HIP driver version.

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

hipGetErrorName

const char * hipGetErrorName(hipError_t hip_error)

Return hip error as text string form.

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.

hipEventSynchronize

hipError_t hipEventSynchronize(hipEvent_t event)

Wait for an event to complete.

hipEventRecord

hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream)

Record an event in the specified stream.

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.

hipEventElapsedTime

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

Return the elapsed time between two events.

hipEventCreateWithFlags

hipError_t hipEventCreateWithFlags(hipEvent_t *event, unsigned flags)

Create an event with the specified flags.

hipFuncSetSharedMemConfig

hipError_t hipFuncSetSharedMemConfig(const void *func, hipSharedMemConfig config)

Set shared memory configuation for a specific function.

hipFuncSetAttribute

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

Set attribute for a specific function.

hipFuncSetCacheConfig

hipError_t hipFuncSetCacheConfig(const void *func, hipFuncCache_t config)

Set Cache configuration for a specific function.

hipDestroyExternalMemory

hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem)

Destroys an external memory object.

hipImportExternalSemaphore

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

Imports an external semaphore.

hipImportExternalMemory

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

Imports an external memory object.

hipDestroyExternalSemaphore

hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem)

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

hipWaitExternalSemaphoresAsync

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

Waits on a set of external semaphore objects.

hipSignalExternalSemaphoresAsync

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

Signals a set of external semaphore objects.

hipExternalMemoryGetMappedMipmappedArray

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

Maps a mipmapped array onto an external memory object.

hipExternalMemoryGetMappedBuffer

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

Maps a buffer onto an imported memory object.

hipGraphicsUnregisterResource

hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource)

Unregisters a graphics resource.

hipGraphicsUnmapResources

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

Unmaps graphics resources.

hipGraphicsSubResourceGetMappedArray

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

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

hipGraphicsResourceGetMappedPointer

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

Gets device accessible address of a graphics resource.

hipGraphicsMapResources

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

Maps a graphics resource for access.

hipLimit_t

hipLimit_t

Definition: hip_runtime_api.h:651

hipMemAllocationHandleType

hipMemAllocationHandleType

Definition: hip_runtime_api.h:975

hipGraphicsResource_t

hipGraphicsResource * hipGraphicsResource_t

Definition: hip_runtime_api.h:1215

hipCtx_t

struct ihipCtx_t * hipCtx_t

Definition: hip_runtime_api.h:606

__dparm

#define __dparm(x)

Definition: hip_runtime_api.h:590

hipStream_t

struct ihipStream_t * hipStream_t

Definition: hip_runtime_api.h:615

hipGraphInstantiateResult

hipGraphInstantiateResult

Definition: hip_runtime_api.h:1430

hipDevice_t

int hipDevice_t

Definition: hip_runtime_api.h:608

hipAccessProperty

hipAccessProperty

Definition: hip_runtime_api.h:1290

hipGraphDependencyType

hipGraphDependencyType

Definition: hip_runtime_api.h:1646

hipMemRangeAttribute

hipMemRangeAttribute

Definition: hip_runtime_api.h:857

hipMemAttachSingle

#define hipMemAttachSingle

Definition: hip_runtime_api.h:741

hipMemoryAdvise

hipMemoryAdvise

Definition: hip_runtime_api.h:824

hipArrayDefault

#define hipArrayDefault

Definition: hip_runtime_api.h:792

hipSharedMemConfig

hipSharedMemConfig

Definition: hip_runtime_api.h:1045

hipKernelNodeAttrValue

#define hipKernelNodeAttrValue

Definition: hip_runtime_api.h:1334

hipComputeMode

hipComputeMode

Definition: hip_runtime_api.h:548

hipEvent_t

struct ihipEvent_t * hipEvent_t

Definition: hip_runtime_api.h:643

hipStreamCaptureMode

hipStreamCaptureMode

Definition: hip_runtime_api.h:1366

hipDriverProcAddressQueryResult

hipDriverProcAddressQueryResult

Definition: hip_runtime_api.h:542

HIP_DEPRECATED_MSG

#define HIP_DEPRECATED_MSG

Definition: hip_runtime_api.h:582

hipLaunchAttributeID

hipLaunchAttributeID

Definition: hip_runtime_api.h:1306

hipGraphNodeType

hipGraphNodeType

Definition: hip_runtime_api.h:1239

hipExternalMemoryHandleType

hipExternalMemoryHandleType

Definition: hip_runtime_api.h:1089

hipMemAttachGlobal

#define hipMemAttachGlobal

Definition: hip_runtime_api.h:735

hipFuncAttribute

hipFuncAttribute

Definition: hip_runtime_api.h:1028

hipExternalSemaphoreHandleType

hipExternalSemaphoreHandleType

Definition: hip_runtime_api.h:1127

hipJitOption

hipJitOption

Definition: hip_runtime_api.h:1005

hipDeviceP2PAttr

hipDeviceP2PAttr

Definition: hip_runtime_api.h:609

hipGraphDebugDotFlags

hipGraphDebugDotFlags

Definition: hip_runtime_api.h:1408

hipUserObjectRetainFlags

hipUserObjectRetainFlags

Definition: hip_runtime_api.h:1393

hipError_t

enum __HIP_NODISCARD hipError_t hipError_t

Definition: hip_runtime_api.h:287

hipHostAllocDefault

#define hipHostAllocDefault

Definition: hip_runtime_api.h:705

hipHostFn_t

void(* hipHostFn_t)(void *userData)

Definition: hip_runtime_api.h:1257

hipOccupancyDefault

#define hipOccupancyDefault

Definition: hip_runtime_api.h:797

hipStreamUpdateCaptureDependenciesFlags

hipStreamUpdateCaptureDependenciesFlags

Definition: hip_runtime_api.h:1378

hipGraph_t

struct ihipGraph * hipGraph_t

Definition: hip_runtime_api.h:1220

hipChooseDevice

#define hipChooseDevice

Definition: hip_runtime_api.h:93

hipMemHandleType

hipMemHandleType

Definition: hip_runtime_api.h:1509

hipFlushGPUDirectRDMAWritesOptions

hipFlushGPUDirectRDMAWritesOptions

Definition: hip_runtime_api.h:555

hipFuncCache_t

hipFuncCache_t

Definition: hip_runtime_api.h:1036

hipUserObjectFlags

hipUserObjectFlags

Definition: hip_runtime_api.h:1389

__HIP_NODISCARD

#define __HIP_NODISCARD

Definition: hip_runtime_api.h:277

hipGraphMemAttributeType

hipGraphMemAttributeType

Definition: hip_runtime_api.h:1383

hipMemPoolAttr

hipMemPoolAttr

Definition: hip_runtime_api.h:873

hipDeviceProp_t

#define hipDeviceProp_t

Definition: hip_runtime_api.h:92

hipModule_t

struct ihipModule_t * hipModule_t

Definition: hip_runtime_api.h:624

hipUserObject_t

struct hipUserObject * hipUserObject_t

Definition: hip_runtime_api.h:1233

hipMemOperationType

hipMemOperationType

Definition: hip_runtime_api.h:1516

hipExternalSemaphore_t

void * hipExternalSemaphore_t

Definition: hip_runtime_api.h:1152

hipGraphicsRegisterFlags

hipGraphicsRegisterFlags

Definition: hip_runtime_api.h:1203

hipMemRangeCoherencyMode

hipMemRangeCoherencyMode

Definition: hip_runtime_api.h:845

hipMemAccessFlags

hipMemAccessFlags

Definition: hip_runtime_api.h:948

hipMemAllocationGranularity_flags

hipMemAllocationGranularity_flags

Definition: hip_runtime_api.h:1501

hipGraphExec_t

struct hipGraphExec * hipGraphExec_t

Definition: hip_runtime_api.h:1228

hipGraphExecUpdateResult

hipGraphExecUpdateResult

Definition: hip_runtime_api.h:1351

hipFunction_t

struct ihipModuleSymbol_t * hipFunction_t

Definition: hip_runtime_api.h:625

hipKernelNodeAttrID

#define hipKernelNodeAttrID

Definition: hip_runtime_api.h:1326

hipExternalMemory_t

void * hipExternalMemory_t

Definition: hip_runtime_api.h:1126

hipStreamCaptureStatus

hipStreamCaptureStatus

Definition: hip_runtime_api.h:1371

hipDeviceAttribute_t

hipDeviceAttribute_t

Definition: hip_runtime_api.h:407

hipGPUDirectRDMAWritesOrdering

hipGPUDirectRDMAWritesOrdering

Definition: hip_runtime_api.h:560

hipGetDeviceProperties

#define hipGetDeviceProperties

Definition: hip_runtime_api.h:91

hipHostMallocDefault

#define hipHostMallocDefault

Definition: hip_runtime_api.h:704

HIP_DEPRECATED

#define HIP_DEPRECATED(msg)

Definition: hip_runtime_api.h:580

hipGraphicsResource

struct _hipGraphicsResource hipGraphicsResource

Definition: hip_runtime_api.h:1213

hipMemAllocationType

hipMemAllocationType

Definition: hip_runtime_api.h:963

hipGraphNode_t

struct hipGraphNode * hipGraphNode_t

Definition: hip_runtime_api.h:1224

hipMemGenericAllocationHandle_t

struct ihipMemGenericAllocationHandle * hipMemGenericAllocationHandle_t

Definition: hip_runtime_api.h:1496

hipMemoryType

hipMemoryType

Definition: hip_runtime_api.h:245

hipGraphInstantiateFlags

hipGraphInstantiateFlags

Definition: hip_runtime_api.h:1397

hipMemLocationType

hipMemLocationType

Definition: hip_runtime_api.h:931

HIP_IPC_HANDLE_SIZE

#define HIP_IPC_HANDLE_SIZE

Definition: hip_runtime_api.h:617

hipMemPool_t

struct ihipMemPoolHandle_t * hipMemPool_t

Definition: hip_runtime_api.h:629

hipArraySparseSubresourceType

hipArraySparseSubresourceType

Definition: hip_runtime_api.h:1524

hipLimitMallocHeapSize

@ hipLimitMallocHeapSize

Definition: hip_runtime_api.h:657

hipLimitStackSize

@ hipLimitStackSize

Definition: hip_runtime_api.h:652

hipLimitRange

@ hipLimitRange

Supported limit range.

Definition: hip_runtime_api.h:659

hipLimitPrintfFifoSize

@ hipLimitPrintfFifoSize

Definition: hip_runtime_api.h:655

hipMemHandleTypeWin32

@ hipMemHandleTypeWin32

Allows a Win32 NT handle for exporting. (HANDLE)

Definition: hip_runtime_api.h:978

hipMemHandleTypeWin32Kmt

@ hipMemHandleTypeWin32Kmt

Allows a Win32 KMT handle for exporting. (D3DKMT_HANDLE)

Definition: hip_runtime_api.h:979

hipMemHandleTypeNone

@ hipMemHandleTypeNone

Does not allow any export mechanism.

Definition: hip_runtime_api.h:976

hipMemHandleTypePosixFileDescriptor

@ hipMemHandleTypePosixFileDescriptor

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

Definition: hip_runtime_api.h:977

hipGraphInstantiateNodeOperationNotSupported

@ hipGraphInstantiateNodeOperationNotSupported

Definition: hip_runtime_api.h:1436

hipGraphInstantiateMultipleDevicesNotSupported

@ hipGraphInstantiateMultipleDevicesNotSupported

Definition: hip_runtime_api.h:1438

hipGraphInstantiateError

@ hipGraphInstantiateError

Definition: hip_runtime_api.h:1432

hipGraphInstantiateInvalidStructure

@ hipGraphInstantiateInvalidStructure

Definition: hip_runtime_api.h:1434

hipGraphInstantiateSuccess

@ hipGraphInstantiateSuccess

Definition: hip_runtime_api.h:1431

hipAccessPropertyNormal

@ hipAccessPropertyNormal

Definition: hip_runtime_api.h:1291

hipAccessPropertyPersisting

@ hipAccessPropertyPersisting

Definition: hip_runtime_api.h:1293

hipAccessPropertyStreaming

@ hipAccessPropertyStreaming

Definition: hip_runtime_api.h:1292

hipGraphDependencyTypeDefault

@ hipGraphDependencyTypeDefault

Definition: hip_runtime_api.h:1647

hipGraphDependencyTypeProgrammatic

@ hipGraphDependencyTypeProgrammatic

Definition: hip_runtime_api.h:1648

hipMemRangeAttributeLastPrefetchLocation

@ hipMemRangeAttributeLastPrefetchLocation

prefetched

Definition: hip_runtime_api.h:863

hipMemRangeAttributePreferredLocation

@ hipMemRangeAttributePreferredLocation

The preferred location of the range.

Definition: hip_runtime_api.h:860

hipMemRangeAttributeAccessedBy

@ hipMemRangeAttributeAccessedBy

Definition: hip_runtime_api.h:861

hipMemRangeAttributeReadMostly

@ hipMemRangeAttributeReadMostly

Definition: hip_runtime_api.h:858

hipMemRangeAttributeCoherencyMode

@ hipMemRangeAttributeCoherencyMode

Definition: hip_runtime_api.h:865

hipMemAdviseUnsetAccessedBy

@ hipMemAdviseUnsetAccessedBy

Definition: hip_runtime_api.h:833

hipMemAdviseUnsetCoarseGrain

@ hipMemAdviseUnsetCoarseGrain

Restores cache coherency policy back to fine-grain.

Definition: hip_runtime_api.h:840

hipMemAdviseSetCoarseGrain

@ hipMemAdviseSetCoarseGrain

Definition: hip_runtime_api.h:835

hipMemAdviseUnsetPreferredLocation

@ hipMemAdviseUnsetPreferredLocation

Clear the preferred location for the data.

Definition: hip_runtime_api.h:830

hipMemAdviseSetAccessedBy

@ hipMemAdviseSetAccessedBy

Definition: hip_runtime_api.h:831

hipMemAdviseSetPreferredLocation

@ hipMemAdviseSetPreferredLocation

Definition: hip_runtime_api.h:828

hipMemAdviseSetReadMostly

@ hipMemAdviseSetReadMostly

Definition: hip_runtime_api.h:825

hipMemAdviseUnsetReadMostly

@ hipMemAdviseUnsetReadMostly

Undo the effect of hipMemAdviseSetReadMostly.

Definition: hip_runtime_api.h:827

hipSharedMemBankSizeFourByte

@ hipSharedMemBankSizeFourByte

Definition: hip_runtime_api.h:1047

hipSharedMemBankSizeEightByte

@ hipSharedMemBankSizeEightByte

Definition: hip_runtime_api.h:1049

hipSharedMemBankSizeDefault

@ hipSharedMemBankSizeDefault

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

Definition: hip_runtime_api.h:1046

hipComputeModeProhibited

@ hipComputeModeProhibited

Definition: hip_runtime_api.h:551

hipComputeModeExclusive

@ hipComputeModeExclusive

Definition: hip_runtime_api.h:550

hipComputeModeDefault

@ hipComputeModeDefault

Definition: hip_runtime_api.h:549

hipComputeModeExclusiveProcess

@ hipComputeModeExclusiveProcess

Definition: hip_runtime_api.h:552

hipStreamCaptureModeRelaxed

@ hipStreamCaptureModeRelaxed

Definition: hip_runtime_api.h:1369

hipStreamCaptureModeThreadLocal

@ hipStreamCaptureModeThreadLocal

Definition: hip_runtime_api.h:1368

hipStreamCaptureModeGlobal

@ hipStreamCaptureModeGlobal

Definition: hip_runtime_api.h:1367

HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND

@ HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND

Definition: hip_runtime_api.h:544

HIP_GET_PROC_ADDRESS_SUCCESS

@ HIP_GET_PROC_ADDRESS_SUCCESS

Definition: hip_runtime_api.h:543

HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT

@ HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT

Definition: hip_runtime_api.h:545

hipLaunchAttributePriority

@ hipLaunchAttributePriority

Definition: hip_runtime_api.h:1309

hipLaunchAttributeAccessPolicyWindow

@ hipLaunchAttributeAccessPolicyWindow

Definition: hip_runtime_api.h:1307

hipLaunchAttributeCooperative

@ hipLaunchAttributeCooperative

Definition: hip_runtime_api.h:1308

hipGraphNodeTypeGraph

@ hipGraphNodeTypeGraph

Node which executes an embedded graph.

Definition: hip_runtime_api.h:1244

hipGraphNodeTypeMemset

@ hipGraphNodeTypeMemset

Memset node.

Definition: hip_runtime_api.h:1242

hipGraphNodeTypeEventRecord

@ hipGraphNodeTypeEventRecord

External event record node.

Definition: hip_runtime_api.h:1247

hipGraphNodeTypeExtSemaphoreSignal

@ hipGraphNodeTypeExtSemaphoreSignal

External Semaphore signal node.

Definition: hip_runtime_api.h:1248

hipGraphNodeTypeMemcpy

@ hipGraphNodeTypeMemcpy

Memcpy node.

Definition: hip_runtime_api.h:1241

hipGraphNodeTypeWaitEvent

@ hipGraphNodeTypeWaitEvent

External event wait node.

Definition: hip_runtime_api.h:1246

hipGraphNodeTypeCount

@ hipGraphNodeTypeCount

Definition: hip_runtime_api.h:1254

hipGraphNodeTypeKernel

@ hipGraphNodeTypeKernel

GPU kernel node.

Definition: hip_runtime_api.h:1240

hipGraphNodeTypeHost

@ hipGraphNodeTypeHost

Host (executable) node.

Definition: hip_runtime_api.h:1243

hipGraphNodeTypeMemAlloc

@ hipGraphNodeTypeMemAlloc

Memory alloc node.

Definition: hip_runtime_api.h:1250

hipGraphNodeTypeMemFree

@ hipGraphNodeTypeMemFree

Memory free node.

Definition: hip_runtime_api.h:1251

hipGraphNodeTypeMemcpyFromSymbol

@ hipGraphNodeTypeMemcpyFromSymbol

MemcpyFromSymbol node.

Definition: hip_runtime_api.h:1252

hipGraphNodeTypeMemcpyToSymbol

@ hipGraphNodeTypeMemcpyToSymbol

MemcpyToSymbol node.

Definition: hip_runtime_api.h:1253

hipGraphNodeTypeEmpty

@ hipGraphNodeTypeEmpty

Empty (no-op) node.

Definition: hip_runtime_api.h:1245

hipGraphNodeTypeExtSemaphoreWait

@ hipGraphNodeTypeExtSemaphoreWait

External Semaphore wait node.

Definition: hip_runtime_api.h:1249

hipExternalMemoryHandleTypeD3D11Resource

@ hipExternalMemoryHandleTypeD3D11Resource

Definition: hip_runtime_api.h:1095

hipExternalMemoryHandleTypeD3D12Resource

@ hipExternalMemoryHandleTypeD3D12Resource

Definition: hip_runtime_api.h:1094

hipExternalMemoryHandleTypeNvSciBuf

@ hipExternalMemoryHandleTypeNvSciBuf

Definition: hip_runtime_api.h:1097

hipExternalMemoryHandleTypeOpaqueFd

@ hipExternalMemoryHandleTypeOpaqueFd

Definition: hip_runtime_api.h:1090

hipExternalMemoryHandleTypeD3D12Heap

@ hipExternalMemoryHandleTypeD3D12Heap

Definition: hip_runtime_api.h:1093

hipExternalMemoryHandleTypeOpaqueWin32Kmt

@ hipExternalMemoryHandleTypeOpaqueWin32Kmt

Definition: hip_runtime_api.h:1092

hipExternalMemoryHandleTypeOpaqueWin32

@ hipExternalMemoryHandleTypeOpaqueWin32

Definition: hip_runtime_api.h:1091

hipExternalMemoryHandleTypeD3D11ResourceKmt

@ hipExternalMemoryHandleTypeD3D11ResourceKmt

Definition: hip_runtime_api.h:1096

hipFuncAttributePreferredSharedMemoryCarveout

@ hipFuncAttributePreferredSharedMemoryCarveout

Definition: hip_runtime_api.h:1030

hipFuncAttributeMaxDynamicSharedMemorySize

@ hipFuncAttributeMaxDynamicSharedMemorySize

Definition: hip_runtime_api.h:1029

hipFuncAttributeMax

@ hipFuncAttributeMax

Definition: hip_runtime_api.h:1031

hipExternalSemaphoreHandleTypeNvSciSync

@ hipExternalSemaphoreHandleTypeNvSciSync

Definition: hip_runtime_api.h:1133

hipExternalSemaphoreHandleTypeKeyedMutexKmt

@ hipExternalSemaphoreHandleTypeKeyedMutexKmt

Definition: hip_runtime_api.h:1135

hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

@ hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

Definition: hip_runtime_api.h:1130

hipExternalSemaphoreHandleTypeKeyedMutex

@ hipExternalSemaphoreHandleTypeKeyedMutex

Definition: hip_runtime_api.h:1134

hipExternalSemaphoreHandleTypeD3D11Fence

@ hipExternalSemaphoreHandleTypeD3D11Fence

Definition: hip_runtime_api.h:1132

hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

@ hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

Definition: hip_runtime_api.h:1137

hipExternalSemaphoreHandleTypeOpaqueFd

@ hipExternalSemaphoreHandleTypeOpaqueFd

Definition: hip_runtime_api.h:1128

hipExternalSemaphoreHandleTypeOpaqueWin32

@ hipExternalSemaphoreHandleTypeOpaqueWin32

Definition: hip_runtime_api.h:1129

hipExternalSemaphoreHandleTypeTimelineSemaphoreFd

@ hipExternalSemaphoreHandleTypeTimelineSemaphoreFd

Definition: hip_runtime_api.h:1136

hipExternalSemaphoreHandleTypeD3D12Fence

@ hipExternalSemaphoreHandleTypeD3D12Fence

Definition: hip_runtime_api.h:1131

hipJitOptionCacheMode

@ hipJitOptionCacheMode

Definition: hip_runtime_api.h:1020

hipJitOptionFastCompile

@ hipJitOptionFastCompile

Definition: hip_runtime_api.h:1022

hipJitOptionInfoLogBuffer

@ hipJitOptionInfoLogBuffer

Definition: hip_runtime_api.h:1009

hipJitOptionErrorLogBuffer

@ hipJitOptionErrorLogBuffer

Definition: hip_runtime_api.h:1011

hipJitOptionTarget

@ hipJitOptionTarget

Definition: hip_runtime_api.h:1015

hipJitOptionThreadsPerBlock

@ hipJitOptionThreadsPerBlock

Definition: hip_runtime_api.h:1007

hipJitOptionNumOptions

@ hipJitOptionNumOptions

Definition: hip_runtime_api.h:1023

hipJitOptionGenerateLineInfo

@ hipJitOptionGenerateLineInfo

Definition: hip_runtime_api.h:1019

hipJitOptionOptimizationLevel

@ hipJitOptionOptimizationLevel

Definition: hip_runtime_api.h:1013

hipJitOptionErrorLogBufferSizeBytes

@ hipJitOptionErrorLogBufferSizeBytes

Definition: hip_runtime_api.h:1012

hipJitOptionWallTime

@ hipJitOptionWallTime

Definition: hip_runtime_api.h:1008

hipJitOptionInfoLogBufferSizeBytes

@ hipJitOptionInfoLogBufferSizeBytes

Definition: hip_runtime_api.h:1010

hipJitOptionTargetFromContext

@ hipJitOptionTargetFromContext

Definition: hip_runtime_api.h:1014

hipJitOptionGenerateDebugInfo

@ hipJitOptionGenerateDebugInfo

Definition: hip_runtime_api.h:1017

hipJitOptionLogVerbose

@ hipJitOptionLogVerbose

Definition: hip_runtime_api.h:1018

hipJitOptionMaxRegisters

@ hipJitOptionMaxRegisters

Definition: hip_runtime_api.h:1006

hipJitOptionSm3xOpt

@ hipJitOptionSm3xOpt

Definition: hip_runtime_api.h:1021

hipJitOptionFallbackStrategy

@ hipJitOptionFallbackStrategy

Definition: hip_runtime_api.h:1016

hipDevP2PAttrAccessSupported

@ hipDevP2PAttrAccessSupported

Definition: hip_runtime_api.h:611

hipDevP2PAttrHipArrayAccessSupported

@ hipDevP2PAttrHipArrayAccessSupported

Definition: hip_runtime_api.h:613

hipDevP2PAttrNativeAtomicSupported

@ hipDevP2PAttrNativeAtomicSupported

Definition: hip_runtime_api.h:612

hipDevP2PAttrPerformanceRank

@ hipDevP2PAttrPerformanceRank

Definition: hip_runtime_api.h:610

hipGraphDebugDotFlagsKernelNodeAttributes

@ hipGraphDebugDotFlagsKernelNodeAttributes

Definition: hip_runtime_api.h:1421

hipGraphDebugDotFlagsMemsetNodeParams

@ hipGraphDebugDotFlagsMemsetNodeParams

Definition: hip_runtime_api.h:1413

hipGraphDebugDotFlagsKernelNodeParams

@ hipGraphDebugDotFlagsKernelNodeParams

Definition: hip_runtime_api.h:1411

hipGraphDebugDotFlagsExtSemasWaitNodeParams

@ hipGraphDebugDotFlagsExtSemasWaitNodeParams

Definition: hip_runtime_api.h:1419

hipGraphDebugDotFlagsHandles

@ hipGraphDebugDotFlagsHandles

Definition: hip_runtime_api.h:1423

hipGraphDebugDotFlagsExtSemasSignalNodeParams

@ hipGraphDebugDotFlagsExtSemasSignalNodeParams

Definition: hip_runtime_api.h:1417

hipGraphDebugDotFlagsHostNodeParams

@ hipGraphDebugDotFlagsHostNodeParams

Definition: hip_runtime_api.h:1414

hipGraphDebugDotFlagsEventNodeParams

@ hipGraphDebugDotFlagsEventNodeParams

Definition: hip_runtime_api.h:1415

hipGraphDebugDotFlagsVerbose

@ hipGraphDebugDotFlagsVerbose

Definition: hip_runtime_api.h:1409

hipGraphDebugDotFlagsMemcpyNodeParams

@ hipGraphDebugDotFlagsMemcpyNodeParams

Definition: hip_runtime_api.h:1412

hipGraphUserObjectMove

@ hipGraphUserObjectMove

Add new reference or retain.

Definition: hip_runtime_api.h:1394

hipStreamAddCaptureDependencies

@ hipStreamAddCaptureDependencies

Add new nodes to the dependency set.

Definition: hip_runtime_api.h:1379

hipStreamSetCaptureDependencies

@ hipStreamSetCaptureDependencies

Replace the dependency set with the new nodes.

Definition: hip_runtime_api.h:1380

hipMemHandleTypeGeneric

@ hipMemHandleTypeGeneric

Generic handle type.

Definition: hip_runtime_api.h:1510

hipFlushGPUDirectRDMAWritesOptionHost

@ hipFlushGPUDirectRDMAWritesOptionHost

Definition: hip_runtime_api.h:556

hipFlushGPUDirectRDMAWritesOptionMemOps

@ hipFlushGPUDirectRDMAWritesOptionMemOps

Definition: hip_runtime_api.h:557

hipFuncCachePreferNone

@ hipFuncCachePreferNone

no preference for shared memory or L1 (default)

Definition: hip_runtime_api.h:1037

hipFuncCachePreferEqual

@ hipFuncCachePreferEqual

prefer equal size L1 cache and shared memory

Definition: hip_runtime_api.h:1040

hipFuncCachePreferL1

@ hipFuncCachePreferL1

prefer larger L1 cache and smaller shared memory

Definition: hip_runtime_api.h:1039

hipFuncCachePreferShared

@ hipFuncCachePreferShared

prefer larger shared memory and smaller L1 cache

Definition: hip_runtime_api.h:1038

hipUserObjectNoDestructorSync

@ hipUserObjectNoDestructorSync

Destructor execution is not synchronized.

Definition: hip_runtime_api.h:1390

hipGraphMemAttrReservedMemHigh

@ hipGraphMemAttrReservedMemHigh

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

Definition: hip_runtime_api.h:1387

hipGraphMemAttrUsedMemCurrent

@ hipGraphMemAttrUsedMemCurrent

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

Definition: hip_runtime_api.h:1384

hipGraphMemAttrUsedMemHigh

@ hipGraphMemAttrUsedMemHigh

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

Definition: hip_runtime_api.h:1385

hipGraphMemAttrReservedMemCurrent

@ hipGraphMemAttrReservedMemCurrent

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

Definition: hip_runtime_api.h:1386

hipMemPoolAttrUsedMemCurrent

@ hipMemPoolAttrUsedMemCurrent

Definition: hip_runtime_api.h:920

hipMemPoolAttrReservedMemHigh

@ hipMemPoolAttrReservedMemHigh

Definition: hip_runtime_api.h:915

hipMemPoolAttrReservedMemCurrent

@ hipMemPoolAttrReservedMemCurrent

Definition: hip_runtime_api.h:909

hipMemPoolAttrReleaseThreshold

@ hipMemPoolAttrReleaseThreshold

Definition: hip_runtime_api.h:904

hipMemPoolAttrUsedMemHigh

@ hipMemPoolAttrUsedMemHigh

Definition: hip_runtime_api.h:926

hipMemPoolReuseAllowInternalDependencies

@ hipMemPoolReuseAllowInternalDependencies

Definition: hip_runtime_api.h:895

hipMemPoolReuseFollowEventDependencies

@ hipMemPoolReuseFollowEventDependencies

Definition: hip_runtime_api.h:882

hipMemPoolReuseAllowOpportunistic

@ hipMemPoolReuseAllowOpportunistic

Definition: hip_runtime_api.h:888

hipMemOperationTypeMap

@ hipMemOperationTypeMap

Map operation.

Definition: hip_runtime_api.h:1517

hipMemOperationTypeUnmap

@ hipMemOperationTypeUnmap

Unmap operation.

Definition: hip_runtime_api.h:1518

hipGraphicsRegisterFlagsReadOnly

@ hipGraphicsRegisterFlagsReadOnly

HIP will not write to this registered resource.

Definition: hip_runtime_api.h:1205

hipGraphicsRegisterFlagsTextureGather

@ hipGraphicsRegisterFlagsTextureGather

HIP will perform texture gather operations on this registered resource.

Definition: hip_runtime_api.h:1209

hipGraphicsRegisterFlagsWriteDiscard

@ hipGraphicsRegisterFlagsWriteDiscard

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

Definition: hip_runtime_api.h:1206

hipGraphicsRegisterFlagsNone

@ hipGraphicsRegisterFlagsNone

Definition: hip_runtime_api.h:1204

hipGraphicsRegisterFlagsSurfaceLoadStore

@ hipGraphicsRegisterFlagsSurfaceLoadStore

HIP will bind this resource to a surface.

Definition: hip_runtime_api.h:1208

hipMemRangeCoherencyModeFineGrain

@ hipMemRangeCoherencyModeFineGrain

Definition: hip_runtime_api.h:846

hipMemRangeCoherencyModeIndeterminate

@ hipMemRangeCoherencyModeIndeterminate

Definition: hip_runtime_api.h:850

hipMemRangeCoherencyModeCoarseGrain

@ hipMemRangeCoherencyModeCoarseGrain

Definition: hip_runtime_api.h:848

hipMemAccessFlagsProtRead

@ hipMemAccessFlagsProtRead

Set the address range read accessible.

Definition: hip_runtime_api.h:950

hipMemAccessFlagsProtNone

@ hipMemAccessFlagsProtNone

Default, make the address range not accessible.

Definition: hip_runtime_api.h:949

hipMemAccessFlagsProtReadWrite

@ hipMemAccessFlagsProtReadWrite

Set the address range read-write accessible.

Definition: hip_runtime_api.h:951

hipMemAllocationGranularityMinimum

@ hipMemAllocationGranularityMinimum

Minimum granularity.

Definition: hip_runtime_api.h:1502

hipMemAllocationGranularityRecommended

@ hipMemAllocationGranularityRecommended

Recommended granularity for performance.

Definition: hip_runtime_api.h:1503

hipGraphExecUpdateErrorNotSupported

@ hipGraphExecUpdateErrorNotSupported

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

Definition: hip_runtime_api.h:1361

hipGraphExecUpdateErrorNodeTypeChanged

@ hipGraphExecUpdateErrorNodeTypeChanged

The update failed because a node type changed.

Definition: hip_runtime_api.h:1356

hipGraphExecUpdateErrorTopologyChanged

@ hipGraphExecUpdateErrorTopologyChanged

The update failed because the topology changed.

Definition: hip_runtime_api.h:1355

hipGraphExecUpdateErrorUnsupportedFunctionChange

@ hipGraphExecUpdateErrorUnsupportedFunctionChange

Definition: hip_runtime_api.h:1363

hipGraphExecUpdateError

@ hipGraphExecUpdateError

Definition: hip_runtime_api.h:1353

hipGraphExecUpdateErrorFunctionChanged

@ hipGraphExecUpdateErrorFunctionChanged

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

Definition: hip_runtime_api.h:1357

hipGraphExecUpdateSuccess

@ hipGraphExecUpdateSuccess

The update succeeded.

Definition: hip_runtime_api.h:1352

hipGraphExecUpdateErrorParametersChanged

@ hipGraphExecUpdateErrorParametersChanged

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

Definition: hip_runtime_api.h:1359

hipStreamCaptureStatusInvalidated

@ hipStreamCaptureStatusInvalidated

Definition: hip_runtime_api.h:1374

hipStreamCaptureStatusNone

@ hipStreamCaptureStatusNone

Stream is not capturing.

Definition: hip_runtime_api.h:1372

hipStreamCaptureStatusActive

@ hipStreamCaptureStatusActive

Stream is actively capturing.

Definition: hip_runtime_api.h:1373

hipDeviceAttributeDirectManagedMemAccessFromHost

@ hipDeviceAttributeDirectManagedMemAccessFromHost

Definition: hip_runtime_api.h:425

hipDeviceAttributeSurfaceAlignment

@ hipDeviceAttributeSurfaceAlignment

Alignment requirement for surfaces.

Definition: hip_runtime_api.h:495

hipDeviceAttributeMaxGridDimX

@ hipDeviceAttributeMaxGridDimX

Max grid size in width.

Definition: hip_runtime_api.h:442

hipDeviceAttributeMaxSurfaceCubemapLayered

@ hipDeviceAttributeMaxSurfaceCubemapLayered

Cuda only. Maximum dimension of Cubemap layered surface.

Definition: hip_runtime_api.h:451

hipDeviceAttributeMaxSurface3D

@ hipDeviceAttributeMaxSurface3D

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

Definition: hip_runtime_api.h:449

hipDeviceAttributeMaxPitch

@ hipDeviceAttributeMaxPitch

Maximum pitch in bytes allowed by memory copies.

Definition: hip_runtime_api.h:472

hipDeviceAttributeTccDriver

@ hipDeviceAttributeTccDriver

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

Definition: hip_runtime_api.h:496

hipDeviceAttributeHostNativeAtomicSupported

@ hipDeviceAttributeHostNativeAtomicSupported

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

Definition: hip_runtime_api.h:428

hipDeviceAttributePageableMemoryAccessUsesHostPageTables

@ hipDeviceAttributePageableMemoryAccessUsesHostPageTables

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

Definition: hip_runtime_api.h:481

hipDeviceAttributeUnused5

@ hipDeviceAttributeUnused5

Previously hipDeviceAttributeGcnArchName.

Definition: hip_runtime_api.h:516

hipDeviceAttributeMaxBlockDimY

@ hipDeviceAttributeMaxBlockDimY

Max block size in height.

Definition: hip_runtime_api.h:440

hipDeviceAttributeMaxSurfaceCubemap

@ hipDeviceAttributeMaxSurfaceCubemap

Cuda only. Maximum dimensions of Cubemap surface.

Definition: hip_runtime_api.h:450

hipDeviceAttributePageableMemoryAccess

@ hipDeviceAttributePageableMemoryAccess

Definition: hip_runtime_api.h:479

hipDeviceAttributeClockRate

@ hipDeviceAttributeClockRate

Peak clock frequency in kilohertz.

Definition: hip_runtime_api.h:416

hipDeviceAttributeCudaCompatibleEnd

@ hipDeviceAttributeCudaCompatibleEnd

Definition: hip_runtime_api.h:509

hipDeviceAttributeMaxTexture1DMipmap

@ hipDeviceAttributeMaxTexture1DMipmap

Maximum size of 1D mipmapped texture.

Definition: hip_runtime_api.h:456

hipDeviceAttributeComputeCapabilityMajor

@ hipDeviceAttributeComputeCapabilityMajor

Major compute capability version number.

Definition: hip_runtime_api.h:436

hipDeviceAttributeGlobalL1CacheSupported

@ hipDeviceAttributeGlobalL1CacheSupported

Device supports caching globals in L1.

Definition: hip_runtime_api.h:427

hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

Definition: hip_runtime_api.h:525

hipDeviceAttributeAccessPolicyMaxWindowSize

@ hipDeviceAttributeAccessPolicyMaxWindowSize

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

Definition: hip_runtime_api.h:411

hipDeviceAttributeMaxTexture3DHeight

@ hipDeviceAttributeMaxTexture3DHeight

Maximum dimension height of 3D texture.

Definition: hip_runtime_api.h:464

hipDeviceAttributeComputeCapabilityMinor

@ hipDeviceAttributeComputeCapabilityMinor

Minor compute capability version number.

Definition: hip_runtime_api.h:475

hipDeviceAttributeMaxTextureCubemap

@ hipDeviceAttributeMaxTextureCubemap

Maximum dimensions of Cubemap texture.

Definition: hip_runtime_api.h:467

hipDeviceAttributeDeviceOverlap

@ hipDeviceAttributeDeviceOverlap

Definition: hip_runtime_api.h:423

hipDeviceAttributeMaxTexture2DLinear

@ hipDeviceAttributeMaxTexture2DLinear

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

Definition: hip_runtime_api.h:461

hipDeviceAttributeMaxSurface2D

@ hipDeviceAttributeMaxSurface2D

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

Definition: hip_runtime_api.h:447

hipDeviceAttributeMaxSurface1DLayered

@ hipDeviceAttributeMaxSurface1DLayered

Cuda only. Maximum dimensions of 1D layered surface.

Definition: hip_runtime_api.h:446

hipDeviceAttributeHdpRegFlushCntl

@ hipDeviceAttributeHdpRegFlushCntl

Address of the HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition: hip_runtime_api.h:518

hipDeviceAttributeComputeMode

@ hipDeviceAttributeComputeMode

Compute mode that device is currently in.

Definition: hip_runtime_api.h:417

hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

Definition: hip_runtime_api.h:519

hipDeviceAttributeAsicRevision

@ hipDeviceAttributeAsicRevision

Revision of the GPU in this device.

Definition: hip_runtime_api.h:528

hipDeviceAttributeUnused4

@ hipDeviceAttributeUnused4

Previously hipDeviceAttributeGcnArch.

Definition: hip_runtime_api.h:515

hipDeviceAttributeCooperativeMultiDeviceLaunch

@ hipDeviceAttributeCooperativeMultiDeviceLaunch

Support cooperative launch on multiple devices.

Definition: hip_runtime_api.h:422

hipDeviceAttributeMaxTexture2DHeight

@ hipDeviceAttributeMaxTexture2DHeight

Maximum dimension hight of 2D texture.

Definition: hip_runtime_api.h:458

hipDeviceAttributePersistingL2CacheMaxSize

@ hipDeviceAttributePersistingL2CacheMaxSize

Maximum l2 persisting lines capacity in bytes.

Definition: hip_runtime_api.h:485

hipDeviceAttributeEccEnabled

@ hipDeviceAttributeEccEnabled

Whether ECC support is enabled.

Definition: hip_runtime_api.h:410

hipDeviceAttributeCanUseHostPointerForRegisteredMem

@ hipDeviceAttributeCanUseHostPointerForRegisteredMem

Definition: hip_runtime_api.h:414

hipDeviceAttributePciBusId

@ hipDeviceAttributePciBusId

PCI Bus ID.

Definition: hip_runtime_api.h:482

hipDeviceAttributeL2CacheSize

@ hipDeviceAttributeL2CacheSize

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

Definition: hip_runtime_api.h:432

hipDeviceAttributeKernelExecTimeout

@ hipDeviceAttributeKernelExecTimeout

Run time limit for kernels executed on the device.

Definition: hip_runtime_api.h:431

hipDeviceAttributeMaxThreadsDim

@ hipDeviceAttributeMaxThreadsDim

Maximum dimension of a block.

Definition: hip_runtime_api.h:469

hipDeviceAttributeSingleToDoublePrecisionPerfRatio

@ hipDeviceAttributeSingleToDoublePrecisionPerfRatio

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

Definition: hip_runtime_api.h:493

hipDeviceAttributeMaxGridDimY

@ hipDeviceAttributeMaxGridDimY

Max grid size in height.

Definition: hip_runtime_api.h:443

hipDeviceAttributeMultiprocessorCount

@ hipDeviceAttributeMultiprocessorCount

Number of multiprocessors on the device.

Definition: hip_runtime_api.h:477

hipDeviceAttributeAmdSpecificBegin

@ hipDeviceAttributeAmdSpecificBegin

Definition: hip_runtime_api.h:510

hipDeviceAttributeMaxRegistersPerMultiprocessor

@ hipDeviceAttributeMaxRegistersPerMultiprocessor

32-bit registers available per block.

Definition: hip_runtime_api.h:488

hipDeviceAttributeIsMultiGpuBoard

@ hipDeviceAttributeIsMultiGpuBoard

Multiple GPU devices.

Definition: hip_runtime_api.h:430

hipDeviceAttributeSharedMemPerBlockOptin

@ hipDeviceAttributeSharedMemPerBlockOptin

Maximum shared memory per block usable by special opt in.

Definition: hip_runtime_api.h:491

hipDeviceAttributeMaxSurface2DLayered

@ hipDeviceAttributeMaxSurface2DLayered

Cuda only. Maximum dimensions of 2D layered surface.

Definition: hip_runtime_api.h:448

hipDeviceAttributeAmdSpecificEnd

@ hipDeviceAttributeAmdSpecificEnd

Definition: hip_runtime_api.h:537

hipDeviceAttributeMemoryClockRate

@ hipDeviceAttributeMemoryClockRate

Peak memory clock frequency in kilohertz.

Definition: hip_runtime_api.h:474

hipDeviceAttributeMaxGridDimZ

@ hipDeviceAttributeMaxGridDimZ

Max grid size in depth.

Definition: hip_runtime_api.h:444

hipDeviceAttributeHdpMemFlushCntl

@ hipDeviceAttributeHdpMemFlushCntl

Address of the HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition: hip_runtime_api.h:517

hipDeviceAttributeUnused2

@ hipDeviceAttributeUnused2

Previously hipDeviceAttributeUuid.

Definition: hip_runtime_api.h:502

hipDeviceAttributeFineGrainSupport

@ hipDeviceAttributeFineGrainSupport

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

Definition: hip_runtime_api.h:534

hipDeviceAttributeCooperativeLaunch

@ hipDeviceAttributeCooperativeLaunch

Support cooperative launch.

Definition: hip_runtime_api.h:421

hipDeviceAttributeUnifiedAddressing

@ hipDeviceAttributeUnifiedAddressing

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

Definition: hip_runtime_api.h:501

hipDeviceAttributeAsyncEngineCount

@ hipDeviceAttributeAsyncEngineCount

Asynchronous engines number.

Definition: hip_runtime_api.h:412

hipDeviceAttributeMultiGpuBoardGroupID

@ hipDeviceAttributeMultiGpuBoardGroupID

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

Definition: hip_runtime_api.h:476

hipDeviceAttributeStreamPrioritiesSupported

@ hipDeviceAttributeStreamPrioritiesSupported

Whether to support stream priorities.

Definition: hip_runtime_api.h:494

hipDeviceAttributeMaxSharedMemoryPerBlock

@ hipDeviceAttributeMaxSharedMemoryPerBlock

Maximum shared memory available per block in bytes.

Definition: hip_runtime_api.h:490

hipDeviceAttributeLocalL1CacheSupported

@ hipDeviceAttributeLocalL1CacheSupported

caching locals in L1 is supported

Definition: hip_runtime_api.h:433

hipDeviceAttributeCanUseStreamWaitValue

@ hipDeviceAttributeCanUseStreamWaitValue

Definition: hip_runtime_api.h:529

hipDeviceAttributeMaxRegistersPerBlock

@ hipDeviceAttributeMaxRegistersPerBlock

Definition: hip_runtime_api.h:486

hipDeviceAttributeMaxThreadsPerBlock

@ hipDeviceAttributeMaxThreadsPerBlock

Maximum number of threads per block.

Definition: hip_runtime_api.h:470

hipDeviceAttributeMemoryBusWidth

@ hipDeviceAttributeMemoryBusWidth

Global memory bus width in bits.

Definition: hip_runtime_api.h:473

hipDeviceAttributeMemoryPoolSupportedHandleTypes

@ hipDeviceAttributeMemoryPoolSupportedHandleTypes

Supported handle mask for HIP Stream Ordered Memory Allocator.

Definition: hip_runtime_api.h:507

hipDeviceAttributeComputePreemptionSupported

@ hipDeviceAttributeComputePreemptionSupported

Device supports Compute Preemption.

Definition: hip_runtime_api.h:418

hipDeviceAttributeMaxSurface1D

@ hipDeviceAttributeMaxSurface1D

Maximum size of 1D surface.

Definition: hip_runtime_api.h:445

hipDeviceAttributeUnused1

@ hipDeviceAttributeUnused1

Previously hipDeviceAttributeName.

Definition: hip_runtime_api.h:478

hipDeviceAttributeMaxTexture3DAlt

@ hipDeviceAttributeMaxTexture3DAlt

Maximum dimensions of alternate 3D texture.

Definition: hip_runtime_api.h:466

hipDeviceAttributeMaxTexture1DLinear

@ hipDeviceAttributeMaxTexture1DLinear

Definition: hip_runtime_api.h:454

hipDeviceAttributeMaxTexture2DGather

@ hipDeviceAttributeMaxTexture2DGather

Maximum dimensions of 2D texture if gather operations performed.

Definition: hip_runtime_api.h:459

hipDeviceAttributeWallClockRate

@ hipDeviceAttributeWallClockRate

Constant frequency of wall clock in kilohertz.

Definition: hip_runtime_api.h:535

hipDeviceAttributePciDeviceId

@ hipDeviceAttributePciDeviceId

PCI Device ID.

Definition: hip_runtime_api.h:483

hipDeviceAttributeCanMapHostMemory

@ hipDeviceAttributeCanMapHostMemory

Whether host memory can be mapped into device address space.

Definition: hip_runtime_api.h:413

hipDeviceAttributeMaxTexture1DWidth

@ hipDeviceAttributeMaxTexture1DWidth

Maximum size of 1D texture.

Definition: hip_runtime_api.h:452

hipDeviceAttributeConcurrentManagedAccess

@ hipDeviceAttributeConcurrentManagedAccess

Device can coherently access managed memory concurrently with the CPU.

Definition: hip_runtime_api.h:420

hipDeviceAttributeVendorSpecificBegin

@ hipDeviceAttributeVendorSpecificBegin

Definition: hip_runtime_api.h:538

hipDeviceAttributeManagedMemory

@ hipDeviceAttributeManagedMemory

Device supports allocating managed memory on this system.

Definition: hip_runtime_api.h:437

hipDeviceAttributeIntegrated

@ hipDeviceAttributeIntegrated

Device is integrated GPU.

Definition: hip_runtime_api.h:429

hipDeviceAttributeMaxTexture2DLayered

@ hipDeviceAttributeMaxTexture2DLayered

Maximum dimensions of 2D layered texture.

Definition: hip_runtime_api.h:460

hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

Definition: hip_runtime_api.h:521

hipDeviceAttributeMaxTexture3DDepth

@ hipDeviceAttributeMaxTexture3DDepth

Maximum dimension depth of 3D texture.

Definition: hip_runtime_api.h:465

hipDeviceAttributeImageSupport

@ hipDeviceAttributeImageSupport

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

Definition: hip_runtime_api.h:531

hipDeviceAttributeTotalGlobalMem

@ hipDeviceAttributeTotalGlobalMem

Global memory available on devicice.

Definition: hip_runtime_api.h:500

hipDeviceAttributeMaxBlocksPerMultiProcessor

@ hipDeviceAttributeMaxBlocksPerMultiProcessor

Max block size per multiprocessor.

Definition: hip_runtime_api.h:438

hipDeviceAttributeIsLargeBar

@ hipDeviceAttributeIsLargeBar

Whether it is LargeBar.

Definition: hip_runtime_api.h:527

hipDeviceAttributeMaxTexture2DWidth

@ hipDeviceAttributeMaxTexture2DWidth

Maximum dimension width of 2D texture.

Definition: hip_runtime_api.h:457

hipDeviceAttributeMaxBlockDimX

@ hipDeviceAttributeMaxBlockDimX

Max block size in width.

Definition: hip_runtime_api.h:439

hipDeviceAttributeMaxTexture3DWidth

@ hipDeviceAttributeMaxTexture3DWidth

Maximum dimension width of 3D texture.

Definition: hip_runtime_api.h:463

hipDeviceAttributeUnused3

@ hipDeviceAttributeUnused3

Previously hipDeviceAttributeArch.

Definition: hip_runtime_api.h:513

hipDeviceAttributeTotalConstantMemory

@ hipDeviceAttributeTotalConstantMemory

Constant memory size in bytes.

Definition: hip_runtime_api.h:499

hipDeviceAttributeTextureAlignment

@ hipDeviceAttributeTextureAlignment

Alignment requirement for textures.

Definition: hip_runtime_api.h:497

hipDeviceAttributeMaxTexture1DLayered

@ hipDeviceAttributeMaxTexture1DLayered

Maximum dimensions of 1D layered texture.

Definition: hip_runtime_api.h:453

hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

@ hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

Maximum Shared Memory PerMultiprocessor.

Definition: hip_runtime_api.h:514

hipDeviceAttributeReservedSharedMemPerBlock

@ hipDeviceAttributeReservedSharedMemPerBlock

Shared memory reserved by CUDA driver per block.

Definition: hip_runtime_api.h:489

hipDeviceAttributeCudaCompatibleBegin

@ hipDeviceAttributeCudaCompatibleBegin

Definition: hip_runtime_api.h:408

hipDeviceAttributeConcurrentKernels

@ hipDeviceAttributeConcurrentKernels

Device can possibly execute multiple kernels concurrently.

Definition: hip_runtime_api.h:419

hipDeviceAttributeLuid

@ hipDeviceAttributeLuid

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

Definition: hip_runtime_api.h:434

hipDeviceAttributePciDomainID

@ hipDeviceAttributePciDomainID

PCI Domain ID.

Definition: hip_runtime_api.h:484

hipDeviceAttributeMaxThreadsPerMultiProcessor

@ hipDeviceAttributeMaxThreadsPerMultiProcessor

Maximum resident threads per multiprocessor.

Definition: hip_runtime_api.h:471

hipDeviceAttributeTexturePitchAlignment

@ hipDeviceAttributeTexturePitchAlignment

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

Definition: hip_runtime_api.h:498

hipDeviceAttributePhysicalMultiProcessorCount

@ hipDeviceAttributePhysicalMultiProcessorCount

Definition: hip_runtime_api.h:532

hipDeviceAttributeHostRegisterSupported

@ hipDeviceAttributeHostRegisterSupported

Can device support host memory registration via hipHostRegister.

Definition: hip_runtime_api.h:506

hipDeviceAttributeSharedMemPerMultiprocessor

@ hipDeviceAttributeSharedMemPerMultiprocessor

Shared memory available per multiprocessor.

Definition: hip_runtime_api.h:492

hipDeviceAttributeLuidDeviceNodeMask

@ hipDeviceAttributeLuidDeviceNodeMask

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

Definition: hip_runtime_api.h:435

hipDeviceAttributeMaxTextureCubemapLayered

@ hipDeviceAttributeMaxTextureCubemapLayered

Maximum dimensions of Cubemap layered texture.

Definition: hip_runtime_api.h:468

hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

Definition: hip_runtime_api.h:523

hipDeviceAttributeVirtualMemoryManagementSupported

@ hipDeviceAttributeVirtualMemoryManagementSupported

Device supports HIP virtual memory management.

Definition: hip_runtime_api.h:505

hipDeviceAttributeMemoryPoolsSupported

@ hipDeviceAttributeMemoryPoolsSupported

Device supports HIP Stream Ordered Memory Allocator.

Definition: hip_runtime_api.h:504

hipDeviceAttributeClockInstructionRate

@ hipDeviceAttributeClockInstructionRate

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

Definition: hip_runtime_api.h:512

hipDeviceAttributeMaxTexture2DMipmap

@ hipDeviceAttributeMaxTexture2DMipmap

Maximum dimensions of 2D mipmapped texture.

Definition: hip_runtime_api.h:462

hipDeviceAttributeMaxBlockDimZ

@ hipDeviceAttributeMaxBlockDimZ

Max block size in depth.

Definition: hip_runtime_api.h:441

hipDeviceAttributeWarpSize

@ hipDeviceAttributeWarpSize

Warp size in threads.

Definition: hip_runtime_api.h:503

hipGPUDirectRDMAWritesOrderingOwner

@ hipGPUDirectRDMAWritesOrderingOwner

Definition: hip_runtime_api.h:562

hipGPUDirectRDMAWritesOrderingNone

@ hipGPUDirectRDMAWritesOrderingNone

Definition: hip_runtime_api.h:561

hipGPUDirectRDMAWritesOrderingAllDevices

@ hipGPUDirectRDMAWritesOrderingAllDevices

Definition: hip_runtime_api.h:563

hipMemAllocationTypeMax

@ hipMemAllocationTypeMax

Definition: hip_runtime_api.h:969

hipMemAllocationTypePinned

@ hipMemAllocationTypePinned

Definition: hip_runtime_api.h:968

hipMemAllocationTypeInvalid

@ hipMemAllocationTypeInvalid

Definition: hip_runtime_api.h:964

hipMemoryTypeDevice

@ hipMemoryTypeDevice

Definition: hip_runtime_api.h:248

hipMemoryTypeHost

@ hipMemoryTypeHost

Memory is physically located on host.

Definition: hip_runtime_api.h:247

hipMemoryTypeUnregistered

@ hipMemoryTypeUnregistered

Unregistered memory.

Definition: hip_runtime_api.h:246

hipMemoryTypeArray

@ hipMemoryTypeArray

Definition: hip_runtime_api.h:253

hipMemoryTypeManaged

@ hipMemoryTypeManaged

Definition: hip_runtime_api.h:250

hipMemoryTypeUnified

@ hipMemoryTypeUnified

unified address space

Definition: hip_runtime_api.h:255

hipGraphInstantiateFlagAutoFreeOnLaunch

@ hipGraphInstantiateFlagAutoFreeOnLaunch

Automatically free memory allocated in a graph before relaunching.

Definition: hip_runtime_api.h:1398

hipGraphInstantiateFlagUseNodePriority

@ hipGraphInstantiateFlagUseNodePriority

Run the graph using the per-node priority attributes rather than the priority of the stream it is lau...

Definition: hip_runtime_api.h:1404

hipGraphInstantiateFlagUpload

@ hipGraphInstantiateFlagUpload

Automatically upload the graph after instantiaton.

Definition: hip_runtime_api.h:1400

hipGraphInstantiateFlagDeviceLaunch

@ hipGraphInstantiateFlagDeviceLaunch

Instantiate the graph to be launchable from the device.

Definition: hip_runtime_api.h:1402

hipMemLocationTypeInvalid

@ hipMemLocationTypeInvalid

Definition: hip_runtime_api.h:932

hipMemLocationTypeDevice

@ hipMemLocationTypeDevice

Device location, thus it's HIP device ID.

Definition: hip_runtime_api.h:933

hipArraySparseSubresourceTypeSparseLevel

@ hipArraySparseSubresourceTypeSparseLevel

Sparse level.

Definition: hip_runtime_api.h:1525

hipArraySparseSubresourceTypeMiptail

@ hipArraySparseSubresourceTypeMiptail

Miptail.

Definition: hip_runtime_api.h:1526

hipGraphKernelNodeSetParams

hipError_t hipGraphKernelNodeSetParams(hipGraphNode_t node, const hipKernelNodeParams *pNodeParams)

Sets a kernel node's parameters.

hipGraphMemFreeNodeGetParams

hipError_t hipGraphMemFreeNodeGetParams(hipGraphNode_t node, void *dev_ptr)

Returns parameters for memory free node.

hipGraphNodeGetDependencies

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

Returns a node's dependencies.

hipGraphCreate

hipError_t hipGraphCreate(hipGraph_t *pGraph, unsigned int flags)

Creates a graph.

hipGraphAddMemcpyNode1D

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

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

hipDrvGraphMemcpyNodeGetParams

hipError_t hipDrvGraphMemcpyNodeGetParams(hipGraphNode_t hNode, HIP_MEMCPY3D *nodeParams)

Gets a memcpy node's parameters.

hipDeviceSetGraphMemAttribute

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

Set the mem attribute for graphs.

hipGraphMemcpyNodeSetParams

hipError_t hipGraphMemcpyNodeSetParams(hipGraphNode_t node, const hipMemcpy3DParms *pNodeParams)

Sets a memcpy node's parameters.

hipUserObjectCreate

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

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

hipGraphExecUpdate

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

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

hipGraphNodeFindInClone

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

Finds a cloned version of a node.

hipGraphAddEventWaitNode

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

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

hipGraphMemcpyNodeSetParamsToSymbol

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

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

hipStreamIsCapturing

hipError_t hipStreamIsCapturing(hipStream_t stream, hipStreamCaptureStatus *pCaptureStatus)

Get stream's capture state.

hipGraphNodeGetEnabled

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

Query whether a node in the given graphExec is enabled.

hipGraphAddChildGraphNode

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

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

hipGraphExternalSemaphoresSignalNodeSetParams

hipError_t hipGraphExternalSemaphoresSignalNodeSetParams(hipGraphNode_t hNode, const hipExternalSemaphoreSignalNodeParams *nodeParams)

Updates node parameters in the external semaphore signal node.

hipGraphDestroyNode

hipError_t hipGraphDestroyNode(hipGraphNode_t node)

Remove a node from the graph.

hipGraphMemcpyNodeSetParamsFromSymbol

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

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

hipGraphReleaseUserObject

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

Release user object from graphs.

hipDrvGraphAddMemcpyNode

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

Creates a memcpy node and adds it to a graph.

hipGraphRemoveDependencies

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

Removes dependency edges from a graph.

hipGraphMemcpyNodeSetParams1D

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

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

hipGraphExecMemcpyNodeSetParams1D

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

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

hipGraphExecDestroy

hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec)

Destroys an executable graph.

hipGraphAddExternalSemaphoresSignalNode

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

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

hipGraphExecExternalSemaphoresWaitNodeSetParams

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

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

hipGraphExecHostNodeSetParams

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

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

hipGraphExecChildGraphNodeSetParams

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

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

hipStreamGetCaptureInfo

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

Get capture status of a stream.

hipGraphAddDependencies

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

Adds dependency edges to a graph.

hipDrvGraphExecMemsetNodeSetParams

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

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

hipDrvGraphAddMemFreeNode

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

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

hipGraphExecKernelNodeSetParams

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

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

hipGraphNodeGetDependentNodes

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

Returns a node's dependent nodes.

hipDeviceGetGraphMemAttribute

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

Get the mem attribute for graphs.

hipGraphHostNodeGetParams

hipError_t hipGraphHostNodeGetParams(hipGraphNode_t node, hipHostNodeParams *pNodeParams)

Returns a host node's parameters.

hipGraphInstantiateWithFlags

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

Creates an executable graph from a graph.

hipGraphExternalSemaphoresSignalNodeGetParams

hipError_t hipGraphExternalSemaphoresSignalNodeGetParams(hipGraphNode_t hNode, hipExternalSemaphoreSignalNodeParams *params_out)

Returns external semaphore signal node params.

hipGraphUpload

hipError_t hipGraphUpload(hipGraphExec_t graphExec, hipStream_t stream)

uploads an executable graph in a stream

hipGraphExecExternalSemaphoresSignalNodeSetParams

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

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

hipGraphExecMemcpyNodeSetParamsToSymbol

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

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

hipUserObjectRelease

hipError_t hipUserObjectRelease(hipUserObject_t object, unsigned int count)

Release number of references to resource.

hipGraphKernelNodeGetParams

hipError_t hipGraphKernelNodeGetParams(hipGraphNode_t node, hipKernelNodeParams *pNodeParams)

Gets kernel node's parameters.

hipGraphAddMemcpyNodeFromSymbol

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

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

hipGraphKernelNodeCopyAttributes

hipError_t hipGraphKernelNodeCopyAttributes(hipGraphNode_t hSrc, hipGraphNode_t hDst)

Copies attributes from source node to destination node.

hipGraphAddMemFreeNode

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

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

hipDrvGraphMemcpyNodeSetParams

hipError_t hipDrvGraphMemcpyNodeSetParams(hipGraphNode_t hNode, const HIP_MEMCPY3D *nodeParams)

Sets a memcpy node's parameters.

hipGraphMemcpyNodeGetParams

hipError_t hipGraphMemcpyNodeGetParams(hipGraphNode_t node, hipMemcpy3DParms *pNodeParams)

Gets a memcpy node's parameters.

hipGraphNodeSetParams

hipError_t hipGraphNodeSetParams(hipGraphNode_t node, hipGraphNodeParams *nodeParams)

Updates parameters of a created 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 on 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 for a memcpy node in the given graphExec.

hipGraphExecNodeSetParams

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

Updates parameters of a created node on executable graph.

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 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 a 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 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 graph 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 on specific device used for graph back to OS.

hipGraphExternalSemaphoresWaitNodeGetParams

hipError_t hipGraphExternalSemaphoresWaitNodeGetParams(hipGraphNode_t hNode, hipExternalSemaphoreWaitNodeParams *params_out)

Returns external semaphore wait node params.

hipGraphClone

hipError_t hipGraphClone(hipGraph_t *pGraphClone, hipGraph_t originalGraph)

Clones a graph.

hipDrvGraphAddMemsetNode

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

Creates a memset node and adds it to a graph.

hipGraphGetRootNodes

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

Returns graph's root nodes.

hipGraphAddMemcpyNode

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

Creates a memcpy node and adds it to a graph.

hipHostFree

hipError_t hipHostFree(void *ptr)

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

hipMallocHost

hipError_t hipMallocHost(void **ptr, size_t size)

Allocate pinned host memory [Deprecated].

hipMemcpyToArray

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

Copies data between host and device [Deprecated].

hipMemcpyFromArray

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

Copies data between host and device [Deprecated].

hipMemAllocHost

hipError_t hipMemAllocHost(void **ptr, size_t size)

Allocate pinned host memory [Deprecated].

hipMemcpyAtoA

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

Copies from one 1D array to another.

hipHostAlloc

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

Allocate device accessible page locked host memory.

hipMemcpy2DArrayToArray

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

Copies data between host and device.

hipMemsetD8Async

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

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

hipMemcpyAtoHAsync

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

Copies from one 1D array to host memory.

hipFreeHost

hipError_t hipFreeHost(void *ptr)

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

hipMemset2DAsync

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

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

hipMemGetInfo

hipError_t hipMemGetInfo(size_t *free, size_t *total)

Query memory info.

hipExtMallocWithFlags

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

Allocate memory on the default accelerator.

hipMemcpy3D

hipError_t hipMemcpy3D(const struct hipMemcpy3DParms *p)

Copies data between host and device.

hipMalloc3DArray

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

Allocate an array on the device.

hipArrayCreate

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

Create an array memory pointer on the device.

hipMemset3D

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

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

hipModuleGetGlobal

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

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

hipMemsetD16

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

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

hipMemcpyAtoD

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

Copies from one 1D array to device memory.

hipMalloc

hipError_t hipMalloc(void **ptr, size_t size)

Allocate memory on the default accelerator.

hipHostUnregister

hipError_t hipHostUnregister(void *hostPtr)

Un-register host pointer.

hipHostGetFlags

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

Return flags associated with host pointer.

hipMemcpyFromSymbolAsync

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

Copies data from the given symbol on the device asynchronously.

hipMemsetD32

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

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

hipMemset3DAsync

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

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

hipMemcpyFromSymbol

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

Copies data from the given symbol on the device.

hipDrvMemcpy3DAsync

hipError_t hipDrvMemcpy3DAsync(const HIP_MEMCPY3D *pCopy, hipStream_t stream)

Copies data between host and device asynchronously.

hipArray3DGetDescriptor

hipError_t hipArray3DGetDescriptor(HIP_ARRAY3D_DESCRIPTOR *pArrayDescriptor, hipArray_t array)

Gets a 3D array descriptor.

hipMemcpy2DAsync

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

Copies data between host and device.

hipArrayGetDescriptor

hipError_t hipArrayGetDescriptor(HIP_ARRAY_DESCRIPTOR *pArrayDescriptor, hipArray_t array)

Gets a 1D or 2D array descriptor.

hipFree

hipError_t hipFree(void *ptr)

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

hipMemcpyHtoAAsync

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

Copies from host memory to a 1D array.

hipMemsetD16Async

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

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

hipGetProcAddress

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

Gets the pointer of requested HIP driver function.

hipPointerGetAttributes

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

Returns attributes for the specified pointer.

hipMallocPitch

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

hipMemcpyDtoD

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

Copy data from Device to Device.

hipMallocArray

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

Allocate an array on the device.

hipMemcpy2D

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

Copies data between host and device.

hipHostGetDevicePointer

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

Get Device pointer from Host Pointer allocated through hipHostMalloc.

hipMemcpyDtoA

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

Copies from device memory to a 1D array.

hipMemcpy2DFromArrayAsync

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

Copies data between host and device asynchronously.

hipMemcpy2DFromArray

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

Copies data between host and device.

hipMemcpy3DAsync

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

Copies data between host and device asynchronously.

hipArray3DCreate

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

Create a 3D array memory pointer on the device.

hipArrayGetInfo

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

Gets info about the specified array.

hipDrvMemcpy3D

hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D *pCopy)

Copies data between host and device.

hipMemcpyHtoD

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

Copy data from Host to Device.

hipMemcpyParam2D

hipError_t hipMemcpyParam2D(const hip_Memcpy2D *pCopy)

Copies memory for 2D arrays.

hipMemcpyHtoA

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

Copies data between host and device.

hipMemcpyToSymbolAsync

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

Copies data to the given symbol on the device asynchronously.

hipHostMalloc

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

Allocates device accessible page locked (pinned) host memory.

hipMemcpy2DToArrayAsync

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

Copies data between host and device.

hipHostRegister

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

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

hipMemcpyAtoH

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

Copies data between host and device.

hipMemcpyToSymbol

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

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

hipMemcpy

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

Copy data from src to dst.

hipMemset

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

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

hipMemcpy2DToArray

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

Copies data between host and device.

hipMemcpyParam2DAsync

hipError_t hipMemcpyParam2DAsync(const hip_Memcpy2D *pCopy, hipStream_t stream)

Copies memory for 2D arrays.

hipDrvPointerGetAttributes

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

Returns information about the specified pointer.[BETA].

hipMalloc3D

hipError_t hipMalloc3D(hipPitchedPtr *pitchedDevPtr, hipExtent extent)

Create a 3D memory pointer on the device.

hipPointerSetAttribute

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

Sets information on the specified pointer.[BETA].

hipMemcpyDtoDAsync

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

Copy data from Device to Device asynchronously.

hipMemAllocPitch

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

hipMemsetD8

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

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

hipMemcpyAsync

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

Copy data from src to dst asynchronously.

hipMemcpyDtoHAsync

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

Copy data from Device to Host asynchronously.

hipFreeArray

hipError_t hipFreeArray(hipArray_t array)

Frees an array on the device.

hipMemsetD32Async

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

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

hipMemset2D

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

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

hipMemcpyHtoDAsync

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

Copy data from Host to Device asynchronously.

hipGetSymbolSize

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

Gets the size of the given symbol on the device.

hipMemcpyDtoH

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

Copy data from Device to Host.

hipMemsetAsync

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

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

hipMemcpyWithStream

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

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

hipGetSymbolAddress

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

Gets device pointer associated with symbol on the device.

hipPointerGetAttribute

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

Returns information about the specified pointer.[BETA].

hipMemPtrGetInfo

hipError_t hipMemPtrGetInfo(void *ptr, size_t *size)

Get allocated memory size via memory pointer.

hipArrayDestroy

hipError_t hipArrayDestroy(hipArray_t array)

Destroy an array memory pointer on the device.

hipMemPrefetchAsync

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

Prefetches memory to the specified destination device using HIP.

hipMemRangeGetAttributes

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

Query attributes of a given memory range in HIP.

hipMemAdvise

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

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

hipMemRangeGetAttribute

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

Query an attribute of a given memory range in HIP.

hipMallocManaged

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

Allocates memory that will be automatically managed by HIP.

hipStreamAttachMemAsync

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

Attach memory to a stream asynchronously in HIP.

hipModuleLaunchCooperativeKernelMultiDevice

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

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

hipFuncGetAttributes

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

Find out attributes for a given function.

hipModuleGetTexRef

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

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

hipExtLaunchMultiKernelMultiDevice

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

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

hipModuleLaunchKernel

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

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

hipModuleLoad

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

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

hipModuleLoadDataEx

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

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

hipFuncGetAttribute

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

Find out a specific attribute for a given function.

hipGetFuncBySymbol

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

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

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

hipModuleGetFunction

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

Function with kname will be extracted if present in module.

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

hipModuleLoadData

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

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

hipModuleUnload

hipError_t hipModuleUnload(hipModule_t module)

Frees the module.

hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags

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

Returns occupancy for a device function.

hipModuleOccupancyMaxPotentialBlockSize

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

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

hipOccupancyMaxActiveBlocksPerMultiprocessor

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

Returns occupancy for a device function.

hipOccupancyMaxPotentialBlockSize

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

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

hipModuleOccupancyMaxActiveBlocksPerMultiprocessor

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

Returns occupancy for a device function.

hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags

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

Returns occupancy for a device function.

hipModuleOccupancyMaxPotentialBlockSizeWithFlags

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

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

hipDeviceCanAccessPeer

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

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

hipDeviceEnablePeerAccess

hipError_t hipDeviceEnablePeerAccess(int peerDeviceId, unsigned int flags)

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

hipMemcpyPeer

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

Copies memory from one device to memory on another device.

hipMemcpyPeerAsync

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

Copies memory from one device to memory on another device.

hipDeviceDisablePeerAccess

hipError_t hipDeviceDisablePeerAccess(int peerDeviceId)

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

hipMemGetAddressRange

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

Get information on memory allocations.

hipProfilerStart

hipError_t hipProfilerStart()

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

hipProfilerStop

hipError_t hipProfilerStop()

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

hipDeviceGetStreamPriorityRange

hipError_t hipDeviceGetStreamPriorityRange(int *leastPriority, int *greatestPriority)

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

hipStreamDestroy

hipError_t hipStreamDestroy(hipStream_t stream)

Destroys the specified stream.

hipStreamGetFlags

hipError_t hipStreamGetFlags(hipStream_t stream, unsigned int *flags)

Return flags associated with this stream.

hipStreamAddCallback

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

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

hipStreamCallback_t

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

Definition: hip_runtime_api.h:2605

hipStreamGetDevice

hipError_t hipStreamGetDevice(hipStream_t stream, hipDevice_t *device)

Get the device assocaited with the stream.

hipStreamQuery

hipError_t hipStreamQuery(hipStream_t stream)

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

hipStreamSynchronize

hipError_t hipStreamSynchronize(hipStream_t stream)

Wait for all commands in stream to complete.

hipStreamWaitEvent

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

Make the specified compute stream wait for an event.

hipStreamCreateWithPriority

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

Create an asynchronous stream with the specified priority.

hipExtStreamCreateWithCUMask

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

Create an asynchronous stream with the specified CU mask.

hipStreamGetPriority

hipError_t hipStreamGetPriority(hipStream_t stream, int *priority)

Query the priority of a stream.

hipExtStreamGetCUMask

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

Get CU mask associated with an asynchronous stream.

hipStreamCreateWithFlags

hipError_t hipStreamCreateWithFlags(hipStream_t *stream, unsigned int flags)

Create an asynchronous stream.

hipStreamCreate

hipError_t hipStreamCreate(hipStream_t *stream)

Create an asynchronous stream.

hipStreamWriteValue64

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

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

hipStreamWriteValue32

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

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

hipStreamWaitValue64

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

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

hipStreamWaitValue32

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

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

hipMemPoolImportPointer

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

Import a memory pool allocation from another process.

hipMemPoolImportFromShareableHandle

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

Imports a memory pool from a shared handle.

hipMallocFromPoolAsync

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

Allocates memory from a specified pool with stream ordered semantics.

hipFreeAsync

hipError_t hipFreeAsync(void *dev_ptr, hipStream_t stream)

Frees memory with stream ordered semantics.

hipMemPoolTrimTo

hipError_t hipMemPoolTrimTo(hipMemPool_t mem_pool, size_t min_bytes_to_hold)

Releases freed memory back to the OS.

hipMemPoolCreate

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

Creates a memory pool.

hipMemPoolSetAccess

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

Controls visibility of the specified pool between devices.

hipMemPoolDestroy

hipError_t hipMemPoolDestroy(hipMemPool_t mem_pool)

Destroys the specified memory pool.

hipMemPoolSetAttribute

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

Sets attributes of a memory pool.

hipMemPoolGetAttribute

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

Gets attributes of a memory pool.

hipMemPoolExportToShareableHandle

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

Exports a memory pool to the requested handle type.

hipMemPoolExportPointer

hipError_t hipMemPoolExportPointer(hipMemPoolPtrExportData *export_data, void *dev_ptr)

Export data to share a memory pool allocation between processes.

hipMallocAsync

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

Allocates memory with stream ordered semantics.

hipMemPoolGetAccess

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

Returns the accessibility of a pool from a device.

hipDestroySurfaceObject

hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject)

Destroy a surface object.

hipCreateSurfaceObject

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

Create a surface object.

hipTexRefGetFilterMode

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

Gets filter mode for a texture reference [Deprecated].

hipBindTextureToMipmappedArray

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

Binds a mipmapped array to a texture [Deprecated].

hipTexRefGetMipmapLevelClamp

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

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

hipTexRefGetAddressMode

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

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

hipTexRefGetFlags

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

Gets flags for a texture reference [Deprecated].

hipTexRefSetAddress

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

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

hipTexRefSetFilterMode

hipError_t hipTexRefSetFilterMode(textureReference *texRef, enum hipTextureFilterMode fm)

Set filter mode for a texture reference [Deprecated].

hipTexRefSetMipmappedArray

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

Binds mipmapped array to a texture reference [Deprecated].

hipTexRefGetMipmapFilterMode

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

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

hipGetTextureAlignmentOffset

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

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

hipBindTexture2D

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

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

hipTexRefGetMaxAnisotropy

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

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

hipBindTexture

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

Binds a memory area to a texture [Deprecated].

hipUnbindTexture

hipError_t hipUnbindTexture(const textureReference *tex)

Unbinds a texture [Deprecated].

hipTexRefGetBorderColor

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

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

hipTexRefSetFormat

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

Set format for a texture reference [Deprecated].

hipTexRefGetAddress

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

Gets the address for a texture reference [Deprecated].

hipTexRefGetArray

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

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

hipTexRefSetFlags

hipError_t hipTexRefSetFlags(textureReference *texRef, unsigned int Flags)

Set flags for a texture reference [Deprecated].

hipTexRefSetAddressMode

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

Sets address mode for a texture reference [Deprecated].

hipTexRefGetMipMappedArray

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

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

hipTexRefSetMaxAnisotropy

hipError_t hipTexRefSetMaxAnisotropy(textureReference *texRef, unsigned int maxAniso)

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

hipTexRefSetMipmapLevelClamp

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

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

hipTexRefSetBorderColor

hipError_t hipTexRefSetBorderColor(textureReference *texRef, float *pBorderColor)

Sets border color for a texture reference [Deprecated].

hipTexRefSetArray

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

Binds an array as a texture reference [Deprecated].

hipTexRefSetMipmapLevelBias

hipError_t hipTexRefSetMipmapLevelBias(textureReference *texRef, float bias)

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

hipTexRefGetMipmapLevelBias

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

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

hipBindTextureToArray

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

Binds a memory area to a texture [Deprecated].

hipGetTextureReference

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

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

hipTexRefSetAddress2D

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

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

hipTexRefSetMipmapFilterMode

hipError_t hipTexRefSetMipmapFilterMode(textureReference *texRef, enum hipTextureFilterMode fm)

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

hipTexRefGetFormat

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

Gets texture format for a texture reference [Deprecated].

hipFreeMipmappedArray

hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray)

Frees a mipmapped array on the device.

hipGetMipmappedArrayLevel

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

Gets a mipmap level of a HIP mipmapped array.

hipMipmappedArrayGetLevel

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

Get a mipmapped array on a mipmapped level.

hipMipmappedArrayDestroy

hipError_t hipMipmappedArrayDestroy(hipMipmappedArray_t hMipmappedArray)

Destroy a mipmapped array.

hipTexObjectCreate

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

Creates a texture object.

hipGetTextureObjectResourceDesc

hipError_t hipGetTextureObjectResourceDesc(hipResourceDesc *pResDesc, hipTextureObject_t textureObject)

Gets resource descriptor for the texture object.

hipGetTextureObjectResourceViewDesc

hipError_t hipGetTextureObjectResourceViewDesc(struct hipResourceViewDesc *pResViewDesc, hipTextureObject_t textureObject)

Gets resource view descriptor for the texture object.

hipTexObjectGetTextureDesc

hipError_t hipTexObjectGetTextureDesc(HIP_TEXTURE_DESC *pTexDesc, hipTextureObject_t texObject)

Gets texture descriptor of a texture object.

hipCreateTextureObject

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

Creates a texture object.

hipTexObjectDestroy

hipError_t hipTexObjectDestroy(hipTextureObject_t texObject)

Destroys a texture object.

hipMipmappedArrayCreate

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

Create a mipmapped array.

hipGetChannelDesc

hipError_t hipGetChannelDesc(hipChannelFormatDesc *desc, hipArray_const_t array)

Gets the channel descriptor in an array.

hipTexObjectGetResourceDesc

hipError_t hipTexObjectGetResourceDesc(HIP_RESOURCE_DESC *pResDesc, hipTextureObject_t texObject)

Gets resource descriptor of a texture object.

hipTexObjectGetResourceViewDesc

hipError_t hipTexObjectGetResourceViewDesc(HIP_RESOURCE_VIEW_DESC *pResViewDesc, hipTextureObject_t texObject)

Gets resource view descriptor of a texture object.

hipMallocMipmappedArray

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

Allocate a mipmapped array on the device.

hipDestroyTextureObject

hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject)

Destroys a texture object.

hipGetTextureObjectTextureDesc

hipError_t hipGetTextureObjectTextureDesc(hipTextureDesc *pTexDesc, hipTextureObject_t textureObject)

Gets texture descriptor for the texture object.

hipMemAddressFree

hipError_t hipMemAddressFree(void *devPtr, size_t size)

Frees an address range reservation made via hipMemAddressReserve.

hipMemExportToShareableHandle

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

Exports an allocation to a requested shareable handle type.

hipMemGetAccess

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

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

hipMemSetAccess

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

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

hipMemRelease

hipError_t hipMemRelease(hipMemGenericAllocationHandle_t handle)

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

hipMemUnmap

hipError_t hipMemUnmap(void *ptr, size_t size)

Unmap memory allocation of a given address range.

hipMemGetAllocationGranularity

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

Calculates either the minimal or recommended granularity.

hipMemRetainAllocationHandle

hipError_t hipMemRetainAllocationHandle(hipMemGenericAllocationHandle_t *handle, void *addr)

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

hipMemCreate

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

Creates a memory allocation described by the properties and size.

hipMemMap

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

Maps an allocation handle to a reserved virtual address range.

hipMemAddressReserve

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

Reserves an address range.

hipMemGetAllocationPropertiesFromHandle

hipError_t hipMemGetAllocationPropertiesFromHandle(hipMemAllocationProp *prop, hipMemGenericAllocationHandle_t handle)

Retrieve the property structure of the given handle.

hipMemMapArrayAsync

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

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

hipMemImportFromShareableHandle

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

Imports an allocation from a requested shareable handle type.

hip_common.h

hipErrorIllegalAddress

hipErrorIllegalAddress

Definition: hip_runtime_api.h:347

hipErrorMemoryAllocation

hipErrorMemoryAllocation

Memory allocation error.

Definition: hip_runtime_api.h:293

hipErrorNotFound

hipErrorNotFound

Not found.

Definition: hip_runtime_api.h:342

hipErrorProfilerDisabled

hipErrorProfilerDisabled

Definition: hip_runtime_api.h:298

hipErrorInvalidDevicePointer

hipErrorInvalidDevicePointer

Invalid Device Pointer.

Definition: hip_runtime_api.h:305

hipErrorRuntimeMemory

hipErrorRuntimeMemory

Definition: hip_runtime_api.h:394

hipErrorInvalidImage

hipErrorInvalidImage

Invalid image.

Definition: hip_runtime_api.h:313

hipErrorPeerAccessUnsupported

hipErrorPeerAccessUnsupported

Definition: hip_runtime_api.h:330

hipErrorArrayIsMapped

hipErrorArrayIsMapped

Definition: hip_runtime_api.h:320

hipErrorStreamCaptureIsolation

hipErrorStreamCaptureIsolation

Definition: hip_runtime_api.h:375

hipErrorInvalidKernelFile

hipErrorInvalidKernelFile

In CUDA DRV, it is CUDA_ERROR_INVALID_PTX.

Definition: hip_runtime_api.h:331

hipErrorNotMapped

hipErrorNotMapped

Definition: hip_runtime_api.h:324

hipErrorGraphExecUpdateFailure

hipErrorGraphExecUpdateFailure

Definition: hip_runtime_api.h:388

hipErrorNotInitialized

hipErrorNotInitialized

Invalid not initialized.

Definition: hip_runtime_api.h:294

hipErrorInvalidResourceHandle

hipErrorInvalidResourceHandle

Resource handle (hipEvent_t or hipStream_t) invalid.

Definition: hip_runtime_api.h:340

hipErrorSharedObjectInitFailed

hipErrorSharedObjectInitFailed

Failed to initialize shared object.

Definition: hip_runtime_api.h:336

hipErrorInvalidPitchValue

hipErrorInvalidPitchValue

Invalid pitch value.

Definition: hip_runtime_api.h:303

hipErrorNoBinaryForGpu

hipErrorNoBinaryForGpu

Definition: hip_runtime_api.h:322

hipErrorInvalidContext

hipErrorInvalidContext

Produced when input context is invalid.

Definition: hip_runtime_api.h:314

hipErrorStreamCaptureUnsupported

hipErrorStreamCaptureUnsupported

Definition: hip_runtime_api.h:366

hipErrorPeerAccessNotEnabled

hipErrorPeerAccessNotEnabled

Peer access was never enabled from the current device.

Definition: hip_runtime_api.h:352

hipErrorOperatingSystem

hipErrorOperatingSystem

Not the correct operating system.

Definition: hip_runtime_api.h:337

hipErrorStreamCaptureUnjoined

hipErrorStreamCaptureUnjoined

Definition: hip_runtime_api.h:373

hipErrorInitializationError

hipErrorInitializationError

Definition: hip_runtime_api.h:296

hipErrorNotMappedAsPointer

hipErrorNotMappedAsPointer

Definition: hip_runtime_api.h:326

hipErrorPriorLaunchFailure

hipErrorPriorLaunchFailure

Definition: hip_runtime_api.h:309

hipErrorContextIsDestroyed

hipErrorContextIsDestroyed

The context is already destroyed.

Definition: hip_runtime_api.h:354

hipErrorInvalidValue

hipErrorInvalidValue

Definition: hip_runtime_api.h:289

hipErrorLaunchTimeOut

hipErrorLaunchTimeOut

Timeout for the launch.

Definition: hip_runtime_api.h:349

hipErrorUnmapFailed

hipErrorUnmapFailed

Definition: hip_runtime_api.h:319

hipErrorSetOnActiveProcess

hipErrorSetOnActiveProcess

The process is active.

Definition: hip_runtime_api.h:353

hipErrorFileNotFound

hipErrorFileNotFound

the file is not found.

Definition: hip_runtime_api.h:334

hipErrorLaunchFailure

hipErrorLaunchFailure

An exception occurred on the device while executing a kernel.

Definition: hip_runtime_api.h:360

hipErrorInvalidDevice

hipErrorInvalidDevice

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

Definition: hip_runtime_api.h:312

hipErrorUnsupportedLimit

hipErrorUnsupportedLimit

Unsupported limit.

Definition: hip_runtime_api.h:328

hipErrorMapBufferObjectFailed

hipErrorMapBufferObjectFailed

Produced when the IPC memory attach failed from ROCr.

Definition: hip_runtime_api.h:318

hipErrorHostMemoryAlreadyRegistered

hipErrorHostMemoryAlreadyRegistered

Definition: hip_runtime_api.h:356

hipErrorMissingConfiguration

hipErrorMissingConfiguration

Definition: hip_runtime_api.h:308

hipErrorSharedObjectSymbolNotFound

hipErrorSharedObjectSymbolNotFound

Definition: hip_runtime_api.h:335

hipErrorECCNotCorrectable

hipErrorECCNotCorrectable

Definition: hip_runtime_api.h:327

hipErrorStreamCaptureWrongThread

hipErrorStreamCaptureWrongThread

Definition: hip_runtime_api.h:384

hipErrorAssert

hipErrorAssert

Produced when the kernel calls assert.

Definition: hip_runtime_api.h:355

hipErrorContextAlreadyInUse

hipErrorContextAlreadyInUse

The context is already in use.

Definition: hip_runtime_api.h:329

hipErrorNotReady

hipErrorNotReady

Definition: hip_runtime_api.h:343

hipErrorInvalidSource

hipErrorInvalidSource

Invalid source.

Definition: hip_runtime_api.h:333

hipErrorLaunchOutOfResources

hipErrorLaunchOutOfResources

Out of resources error.

Definition: hip_runtime_api.h:348

hipErrorInvalidDeviceFunction

hipErrorInvalidDeviceFunction

Invalid device function.

Definition: hip_runtime_api.h:310

hipErrorCooperativeLaunchTooLarge

hipErrorCooperativeLaunchTooLarge

Definition: hip_runtime_api.h:361

hipErrorAlreadyMapped

hipErrorAlreadyMapped

Definition: hip_runtime_api.h:321

hipErrorProfilerNotInitialized

hipErrorProfilerNotInitialized

Definition: hip_runtime_api.h:299

hipErrorProfilerAlreadyStarted

hipErrorProfilerAlreadyStarted

Definition: hip_runtime_api.h:300

hipErrorNoDevice

hipErrorNoDevice

Call to hipGetDeviceCount returned 0 devices.

Definition: hip_runtime_api.h:311

HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

@ HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

Definition: hip_runtime_api.h:41

HIP_ERROR_INVALID_VALUE

@ HIP_ERROR_INVALID_VALUE

Definition: hip_runtime_api.h:39

HIP_SUCCESS

@ HIP_SUCCESS

Definition: hip_runtime_api.h:38

HIP_ERROR_NOT_INITIALIZED

@ HIP_ERROR_NOT_INITIALIZED

Definition: hip_runtime_api.h:40

hipErrorMapFailed

hipErrorMapFailed

Definition: hip_runtime_api.h:316

hipErrorStreamCaptureInvalidated

hipErrorStreamCaptureInvalidated

Definition: hip_runtime_api.h:368

hipErrorProfilerAlreadyStopped

hipErrorProfilerAlreadyStopped

Definition: hip_runtime_api.h:301

hipErrorDeinitialized

hipErrorDeinitialized

Deinitialized.

Definition: hip_runtime_api.h:297

hipErrorPeerAccessAlreadyEnabled

hipErrorPeerAccessAlreadyEnabled

Definition: hip_runtime_api.h:350

hipErrorNotMappedAsArray

hipErrorNotMappedAsArray

Definition: hip_runtime_api.h:325

hipErrorNotSupported

hipErrorNotSupported

Produced when the hip API is not supported/implemented.

Definition: hip_runtime_api.h:365

hipErrorInvalidConfiguration

hipErrorInvalidConfiguration

Invalide configuration.

Definition: hip_runtime_api.h:302

hipErrorStreamCaptureImplicit

hipErrorStreamCaptureImplicit

Definition: hip_runtime_api.h:379

hipErrorStreamCaptureMerge

hipErrorStreamCaptureMerge

Definition: hip_runtime_api.h:370

hipErrorInvalidGraphicsContext

hipErrorInvalidGraphicsContext

Definition: hip_runtime_api.h:332

hipErrorIllegalState

hipErrorIllegalState

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

Definition: hip_runtime_api.h:341

hipErrorOutOfMemory

hipErrorOutOfMemory

out of memory range.

Definition: hip_runtime_api.h:291

hipErrorInvalidSymbol

hipErrorInvalidSymbol

Invalid symbol.

Definition: hip_runtime_api.h:304

hipSuccess

hipSuccess

Successful completion.

Definition: hip_runtime_api.h:288

hipErrorUnknown

hipErrorUnknown

Unknown error.

Definition: hip_runtime_api.h:392

hipErrorInvalidHandle

hipErrorInvalidHandle

Invalide handle.

Definition: hip_runtime_api.h:338

hipErrorStreamCaptureUnmatched

hipErrorStreamCaptureUnmatched

The capture was not initiated in this stream.

Definition: hip_runtime_api.h:372

hipErrorCapturedEvent

hipErrorCapturedEvent

Definition: hip_runtime_api.h:382

hipErrorAlreadyAcquired

hipErrorAlreadyAcquired

Definition: hip_runtime_api.h:323

hipErrorInsufficientDriver

hipErrorInsufficientDriver

Definition: hip_runtime_api.h:307

hipErrorHostMemoryNotRegistered

hipErrorHostMemoryNotRegistered

Definition: hip_runtime_api.h:358

hipErrorRuntimeOther

hipErrorRuntimeOther

Definition: hip_runtime_api.h:396

hipErrorContextAlreadyCurrent

hipErrorContextAlreadyCurrent

Definition: hip_runtime_api.h:315

hipErrorInvalidMemcpyDirection

hipErrorInvalidMemcpyDirection

Invalid memory copy direction.

Definition: hip_runtime_api.h:306

HIP_ARRAY3D_DESCRIPTOR

Definition: driver_types.h:76

HIP_ARRAY_DESCRIPTOR

Definition: driver_types.h:70

HIP_MEMCPY3D

Definition: driver_types.h:369

HIP_MEMSET_NODE_PARAMS

Definition: hip_runtime_api.h:1339

HIP_MEMSET_NODE_PARAMS::height

size_t height

Number of rows.

Definition: hip_runtime_api.h:1345

HIP_MEMSET_NODE_PARAMS::pitch

size_t pitch

Destination device pointer pitch. Unused if height equals 1.

Definition: hip_runtime_api.h:1341

HIP_MEMSET_NODE_PARAMS::dst

hipDeviceptr_t dst

Destination pointer on device.

Definition: hip_runtime_api.h:1340

HIP_MEMSET_NODE_PARAMS::value

unsigned int value

Value of memset to be set.

Definition: hip_runtime_api.h:1342

HIP_MEMSET_NODE_PARAMS::elementSize

unsigned int elementSize

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

Definition: hip_runtime_api.h:1343

HIP_MEMSET_NODE_PARAMS::width

size_t width

Width of a row.

Definition: hip_runtime_api.h:1344

HIP_RESOURCE_DESC

Definition: driver_types.h:271

HIP_RESOURCE_VIEW_DESC

Definition: driver_types.h:317

HIP_TEXTURE_DESC

Definition: driver_types.h:154

dim3

Definition: hip_runtime_api.h:1055

dim3::y

uint32_t y

y

Definition: hip_runtime_api.h:1057

dim3::z

uint32_t z

z

Definition: hip_runtime_api.h:1058

dim3::x

uint32_t x

x

Definition: hip_runtime_api.h:1056

hip_Memcpy2D

Definition: driver_types.h:85

hipAccessPolicyWindow

Definition: hip_runtime_api.h:1295

hipAccessPolicyWindow::hitProp

hipAccessProperty hitProp

Definition: hip_runtime_api.h:1297

hipAccessPolicyWindow::missProp

hipAccessProperty missProp

Definition: hip_runtime_api.h:1299

hipAccessPolicyWindow::hitRatio

float hitRatio

Definition: hip_runtime_api.h:1298

hipAccessPolicyWindow::base_ptr

void * base_ptr

Definition: hip_runtime_api.h:1296

hipAccessPolicyWindow::num_bytes

size_t num_bytes

Definition: hip_runtime_api.h:1300

hipArrayMapInfo

Definition: hip_runtime_api.h:1532

hipArrayMapInfo::level

unsigned int level

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

Definition: hip_runtime_api.h:1541

hipArrayMapInfo::sparseLevel

struct hipArrayMapInfo::@26::@28 sparseLevel

hipArrayMapInfo::flags

unsigned int flags

flags for future use, must be zero now.

Definition: hip_runtime_api.h:1563

hipArrayMapInfo::resource

union hipArrayMapInfo::@25 resource

hipArrayMapInfo::subresourceType

hipArraySparseSubresourceType subresourceType

Sparse subresource type.

Definition: hip_runtime_api.h:1538

hipArrayMapInfo::extentDepth

unsigned int extentDepth

Depth in elements.

Definition: hip_runtime_api.h:1548

hipArrayMapInfo::offsetX

unsigned int offsetX

X offset in elements.

Definition: hip_runtime_api.h:1543

hipArrayMapInfo::array

hipArray_t array

Definition: hip_runtime_api.h:1536

hipArrayMapInfo::resourceType

hipResourceType resourceType

Resource type.

Definition: hip_runtime_api.h:1533

hipArrayMapInfo::memOperationType

hipMemOperationType memOperationType

Memory operation type.

Definition: hip_runtime_api.h:1556

hipArrayMapInfo::reserved

unsigned int reserved[2]

Reserved for future use, must be zero now.

Definition: hip_runtime_api.h:1564

hipArrayMapInfo::extentWidth

unsigned int extentWidth

Width in elements.

Definition: hip_runtime_api.h:1546

hipArrayMapInfo::subresource

union hipArrayMapInfo::@26 subresource

hipArrayMapInfo::extentHeight

unsigned int extentHeight

Height in elements.

Definition: hip_runtime_api.h:1547

hipArrayMapInfo::offsetY

unsigned int offsetY

Y offset in elements.

Definition: hip_runtime_api.h:1544

hipArrayMapInfo::memHandleType

hipMemHandleType memHandleType

Memory handle type.

Definition: hip_runtime_api.h:1557

hipArrayMapInfo::miptail

struct hipArrayMapInfo::@26::@29 miptail

hipArrayMapInfo::memHandle

hipMemGenericAllocationHandle_t memHandle

Definition: hip_runtime_api.h:1559

hipArrayMapInfo::mipmap

hipMipmappedArray mipmap

Definition: hip_runtime_api.h:1535

hipArrayMapInfo::layer

unsigned int layer

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

Definition: hip_runtime_api.h:1542

hipArrayMapInfo::deviceBitMask

unsigned int deviceBitMask

Device ordinal bit mask.

Definition: hip_runtime_api.h:1562

hipArrayMapInfo::size

unsigned long long size

Extent in bytes.

Definition: hip_runtime_api.h:1553

hipArrayMapInfo::offset

unsigned long long offset

Offset within mip tail.

Definition: hip_runtime_api.h:1552

hipArrayMapInfo::offsetZ

unsigned int offsetZ

Z offset in elements.

Definition: hip_runtime_api.h:1545

hipChannelFormatDesc

Definition: driver_types.h:46

hipChildGraphNodeParams

Definition: hip_runtime_api.h:1579

hipChildGraphNodeParams::graph

hipGraph_t graph

Definition: hip_runtime_api.h:1580

hipDeviceArch_t

Definition: hip_runtime_api.h:53

hipDeviceArch_t::hasSharedInt64Atomics

unsigned hasSharedInt64Atomics

64-bit integer atomics for shared memory.

Definition: hip_runtime_api.h:63

hipDeviceArch_t::hasSharedInt32Atomics

unsigned hasSharedInt32Atomics

32-bit integer atomics for shared memory.

Definition: hip_runtime_api.h:57

hipDeviceArch_t::hasFloatAtomicAdd

unsigned hasFloatAtomicAdd

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

Definition: hip_runtime_api.h:59

hipDeviceArch_t::hasDoubles

unsigned hasDoubles

Double-precision floating point.

Definition: hip_runtime_api.h:66

hipDeviceArch_t::hasWarpVote

unsigned hasWarpVote

Warp vote instructions (__any, __all).

Definition: hip_runtime_api.h:69

hipDeviceArch_t::hasWarpShuffle

unsigned hasWarpShuffle

Warp shuffle operations. (__shfl_*).

Definition: hip_runtime_api.h:71

hipDeviceArch_t::hasGlobalInt32Atomics

unsigned hasGlobalInt32Atomics

32-bit integer atomics for global memory.

Definition: hip_runtime_api.h:55

hipDeviceArch_t::hasGlobalFloatAtomicExch

unsigned hasGlobalFloatAtomicExch

32-bit float atomic exch for global memory.

Definition: hip_runtime_api.h:56

hipDeviceArch_t::hasDynamicParallelism

unsigned hasDynamicParallelism

Dynamic parallelism.

Definition: hip_runtime_api.h:81

hipDeviceArch_t::hasSurfaceFuncs

unsigned hasSurfaceFuncs

Surface functions.

Definition: hip_runtime_api.h:79

hipDeviceArch_t::has3dGrid

unsigned has3dGrid

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

Definition: hip_runtime_api.h:80

hipDeviceArch_t::hasFunnelShift

unsigned hasFunnelShift

Funnel two words into one with shift&mask caps.

Definition: hip_runtime_api.h:72

hipDeviceArch_t::hasThreadFenceSystem

unsigned hasThreadFenceSystem

__threadfence_system.

Definition: hip_runtime_api.h:75

hipDeviceArch_t::hasGlobalInt64Atomics

unsigned hasGlobalInt64Atomics

64-bit integer atomics for global memory.

Definition: hip_runtime_api.h:62

hipDeviceArch_t::hasSyncThreadsExt

unsigned hasSyncThreadsExt

__syncthreads_count, syncthreads_and, syncthreads_or.

Definition: hip_runtime_api.h:76

hipDeviceArch_t::hasWarpBallot

unsigned hasWarpBallot

Warp ballot instructions (__ballot).

Definition: hip_runtime_api.h:70

hipDeviceArch_t::hasSharedFloatAtomicExch

unsigned hasSharedFloatAtomicExch

32-bit float atomic exch for shared memory.

Definition: hip_runtime_api.h:58

hipDeviceProp_t

Definition: hip_runtime_api.h:99

hipDeviceProp_t::ECCEnabled

int ECCEnabled

Device has ECC support enabled.

Definition: hip_runtime_api.h:153

hipDeviceProp_t::ipcEventSupported

int ipcEventSupported

Device supports IPC events.

Definition: hip_runtime_api.h:208

hipDeviceProp_t::computePreemptionSupported

int computePreemptionSupported

Is compute preemption supported on the device.

Definition: hip_runtime_api.h:179

hipDeviceProp_t::maxTexture1DLinear

int maxTexture1DLinear

Maximum size for 1D textures bound to linear memory.

Definition: hip_runtime_api.h:132

hipDeviceProp_t::timelineSemaphoreInteropSupported

int timelineSemaphoreInteropSupported

Indicates external timeline semaphore support.

Definition: hip_runtime_api.h:198

hipDeviceProp_t::pciBusID

int pciBusID

PCI Bus ID.

Definition: hip_runtime_api.h:154

hipDeviceProp_t::maxTexture1D

int maxTexture1D

Maximum number of elements in 1D images.

Definition: hip_runtime_api.h:130

hipDeviceProp_t::memoryBusWidth

int memoryBusWidth

Global memory bus width in bits.

Definition: hip_runtime_api.h:161

hipDeviceProp_t::maxTexture2DMipmap

int maxTexture2DMipmap[2]

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

Definition: hip_runtime_api.h:134

hipDeviceProp_t::clockRate

int clockRate

Max clock frequency of the multiProcessors in khz.

Definition: hip_runtime_api.h:113

hipDeviceProp_t::maxThreadsPerMultiProcessor

int maxThreadsPerMultiProcessor

Maximum resident threads per multi-processor.

Definition: hip_runtime_api.h:164

hipDeviceProp_t::l2CacheSize

int l2CacheSize

L2 cache size.

Definition: hip_runtime_api.h:162

hipDeviceProp_t::deferredMappingHipArraySupported

int deferredMappingHipArraySupported

Definition: hip_runtime_api.h:206

hipDeviceProp_t::asyncEngineCount

int asyncEngineCount

Number of async engines.

Definition: hip_runtime_api.h:158

hipDeviceProp_t::accessPolicyMaxWindowSize

int accessPolicyMaxWindowSize

Max value of access policy window.

Definition: hip_runtime_api.h:192

hipDeviceProp_t::totalConstMem

size_t totalConstMem

Definition: hip_runtime_api.h:114

hipDeviceProp_t::memoryPoolsSupported

int memoryPoolsSupported

Indicates if device supports hipMallocAsync and hipMemPool APIs.

Definition: hip_runtime_api.h:199

hipDeviceProp_t::unifiedFunctionPointers

int unifiedFunctionPointers

Indicates device supports unified function pointers.

Definition: hip_runtime_api.h:210

hipDeviceProp_t::maxTexture2DGather

int maxTexture2DGather[2]

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

Definition: hip_runtime_api.h:136

hipDeviceProp_t::memPitch

size_t memPitch

Definition: hip_runtime_api.h:108

hipDeviceProp_t::gpuDirectRDMAWritesOrdering

int gpuDirectRDMAWritesOrdering

value of hipGPUDirectRDMAWritesOrdering

Definition: hip_runtime_api.h:203

hipDeviceProp_t::uuid

hipUUID uuid

UUID of a device.

Definition: hip_runtime_api.h:101

hipDeviceProp_t::sharedMemPerBlock

size_t sharedMemPerBlock

Size of shared memory per block (in bytes).

Definition: hip_runtime_api.h:105

hipDeviceProp_t::gpuDirectRDMAFlushWritesOptions

unsigned int gpuDirectRDMAFlushWritesOptions

Definition: hip_runtime_api.h:201

hipDeviceProp_t::surfaceAlignment

size_t surfaceAlignment

Alignment requirement for surface.

Definition: hip_runtime_api.h:151

hipDeviceProp_t::reserved

int reserved[63]

CUDA Reserved.

Definition: hip_runtime_api.h:211

hipDeviceProp_t::maxTexture2DLayered

int maxTexture2DLayered[3]

Maximum number of elements in 2D array images.

Definition: hip_runtime_api.h:142

hipDeviceProp_t::streamPrioritiesSupported

int streamPrioritiesSupported

Device supports stream priority.

Definition: hip_runtime_api.h:165

hipDeviceProp_t::cooperativeMultiDeviceLaunch

int cooperativeMultiDeviceLaunch

Definition: hip_runtime_api.h:183

hipDeviceProp_t::hostRegisterSupported

int hostRegisterSupported

Device supports hipHostRegister.

Definition: hip_runtime_api.h:194

hipDeviceProp_t::pageableMemoryAccess

int pageableMemoryAccess

Definition: hip_runtime_api.h:175

hipDeviceProp_t::name

char name[256]

Device name.

Definition: hip_runtime_api.h:100

hipDeviceProp_t::textureAlignment

size_t textureAlignment

Alignment requirement for textures.

Definition: hip_runtime_api.h:122

hipDeviceProp_t::globalL1CacheSupported

int globalL1CacheSupported

Indicates globals are cached in L1.

Definition: hip_runtime_api.h:166

hipDeviceProp_t::hostNativeAtomicSupported

int hostNativeAtomicSupported

Link between host and device supports native atomics.

Definition: hip_runtime_api.h:173

hipDeviceProp_t::maxSurfaceCubemapLayered

int maxSurfaceCubemapLayered[2]

Maximum cubemap layered surface size.

Definition: hip_runtime_api.h:150

hipDeviceProp_t::maxTextureCubemapLayered

int maxTextureCubemapLayered[2]

Maximum cubemaps layered texture dims.

Definition: hip_runtime_api.h:143

hipDeviceProp_t::sharedMemPerBlockOptin

size_t sharedMemPerBlockOptin

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

Definition: hip_runtime_api.h:186

hipDeviceProp_t::sharedMemPerMultiprocessor

size_t sharedMemPerMultiprocessor

Amount of shared memory available per multiprocessor.

Definition: hip_runtime_api.h:168

hipDeviceProp_t::singleToDoublePrecisionPerfRatio

int singleToDoublePrecisionPerfRatio

Deprecated. CUDA only.

Definition: hip_runtime_api.h:174

hipDeviceProp_t::maxSurface2D

int maxSurface2D[2]

Maximum 2D surface size.

Definition: hip_runtime_api.h:145

hipDeviceProp_t::memoryClockRate

int memoryClockRate

Max global memory clock frequency in khz.

Definition: hip_runtime_api.h:160

hipDeviceProp_t::maxTexture2DLinear

int maxTexture2DLinear[3]

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

Definition: hip_runtime_api.h:135

hipDeviceProp_t::sparseHipArraySupported

int sparseHipArraySupported

Indicates if device supports sparse hip arrays.

Definition: hip_runtime_api.h:195

hipDeviceProp_t::clockInstructionRate

int clockInstructionRate

Definition: hip_runtime_api.h:218

hipDeviceProp_t::localL1CacheSupported

int localL1CacheSupported

Locals are cahced in L1.

Definition: hip_runtime_api.h:167

hipDeviceProp_t::regsPerMultiprocessor

int regsPerMultiprocessor

registers available per multiprocessor

Definition: hip_runtime_api.h:169

hipDeviceProp_t::regsPerBlock

int regsPerBlock

Registers per block.

Definition: hip_runtime_api.h:106

hipDeviceProp_t::maxTexture2D

int maxTexture2D[2]

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

Definition: hip_runtime_api.h:133

hipDeviceProp_t::cooperativeLaunch

int cooperativeLaunch

HIP device supports cooperative launch.

Definition: hip_runtime_api.h:182

hipDeviceProp_t::maxTexture3D

int maxTexture3D[3]

Definition: hip_runtime_api.h:137

hipDeviceProp_t::directManagedMemAccessFromHost

int directManagedMemAccessFromHost

Definition: hip_runtime_api.h:189

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedFunc

int cooperativeMultiDeviceUnmatchedFunc

Definition: hip_runtime_api.h:223

hipDeviceProp_t::deviceOverlap

int deviceOverlap

Deprecated. Use asyncEngineCount instead.

Definition: hip_runtime_api.h:124

hipDeviceProp_t::pageableMemoryAccessUsesHostPageTables

int pageableMemoryAccessUsesHostPageTables

Definition: hip_runtime_api.h:187

hipDeviceProp_t::hdpRegFlushCntl

unsigned int * hdpRegFlushCntl

Addres of HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition: hip_runtime_api.h:222

hipDeviceProp_t::maxThreadsDim

int maxThreadsDim[3]

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

Definition: hip_runtime_api.h:111

hipDeviceProp_t::unifiedAddressing

int unifiedAddressing

Does device and host share unified address space.

Definition: hip_runtime_api.h:159

hipDeviceProp_t::multiGpuBoardGroupID

int multiGpuBoardGroupID

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

Definition: hip_runtime_api.h:172

hipDeviceProp_t::isMultiGpuBoard

int isMultiGpuBoard

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

Definition: hip_runtime_api.h:171

hipDeviceProp_t::canUseHostPointerForRegisteredMem

int canUseHostPointerForRegisteredMem

Definition: hip_runtime_api.h:180

hipDeviceProp_t::maxTexture1DLayered

int maxTexture1DLayered[2]

Maximum number of elements in 1D array images.

Definition: hip_runtime_api.h:141

hipDeviceProp_t::pciDomainID

int pciDomainID

PCI Domain ID.

Definition: hip_runtime_api.h:156

hipDeviceProp_t::maxSharedMemoryPerMultiProcessor

size_t maxSharedMemoryPerMultiProcessor

Maximum Shared Memory Per CU. HIP Only.

Definition: hip_runtime_api.h:217

hipDeviceProp_t::maxTextureCubemap

int maxTextureCubemap

Maximum cubemap texture dims.

Definition: hip_runtime_api.h:140

hipDeviceProp_t::hipReserved

int hipReserved[32]

Reserved for adding new entries for HIP/CUDA.

Definition: hip_runtime_api.h:213

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedGridDim

int cooperativeMultiDeviceUnmatchedGridDim

Definition: hip_runtime_api.h:226

hipDeviceProp_t::gpuDirectRDMASupported

int gpuDirectRDMASupported

Indicates device support of RDMA APIs.

Definition: hip_runtime_api.h:200

hipDeviceProp_t::minor

int minor

Definition: hip_runtime_api.h:119

hipDeviceProp_t::gcnArchName

char gcnArchName[256]

AMD GCN Arch Name. HIP Only.

Definition: hip_runtime_api.h:216

hipDeviceProp_t::luid

char luid[8]

8-byte unique identifier. Only valid on windows

Definition: hip_runtime_api.h:102

hipDeviceProp_t::kernelExecTimeoutEnabled

int kernelExecTimeoutEnabled

Run time limit for kernels executed on the device.

Definition: hip_runtime_api.h:126

hipDeviceProp_t::memoryPoolSupportedHandleTypes

unsigned int memoryPoolSupportedHandleTypes

Bitmask of handle types support with mempool based IPC.

Definition: hip_runtime_api.h:205

hipDeviceProp_t::hdpMemFlushCntl

unsigned int * hdpMemFlushCntl

Addres of HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition: hip_runtime_api.h:221

hipDeviceProp_t::concurrentManagedAccess

int concurrentManagedAccess

Definition: hip_runtime_api.h:177

hipDeviceProp_t::integrated

int integrated

APU vs dGPU.

Definition: hip_runtime_api.h:127

hipDeviceProp_t::canMapHostMemory

int canMapHostMemory

Check whether HIP can map host memory.

Definition: hip_runtime_api.h:128

hipDeviceProp_t::reservedSharedMemPerBlock

size_t reservedSharedMemPerBlock

Shared memory reserved by driver per block.

Definition: hip_runtime_api.h:193

hipDeviceProp_t::maxSurfaceCubemap

int maxSurfaceCubemap

Maximum cubemap surface size.

Definition: hip_runtime_api.h:149

hipDeviceProp_t::maxSurface3D

int maxSurface3D[3]

Maximum 3D surface size.

Definition: hip_runtime_api.h:146

hipDeviceProp_t::asicRevision

int asicRevision

Revision of the GPU in this device.

Definition: hip_runtime_api.h:236

hipDeviceProp_t::totalGlobalMem

size_t totalGlobalMem

Size of global memory region (in bytes).

Definition: hip_runtime_api.h:104

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedBlockDim

int cooperativeMultiDeviceUnmatchedBlockDim

Definition: hip_runtime_api.h:229

hipDeviceProp_t::maxSurface1DLayered

int maxSurface1DLayered[2]

Maximum 1D layered surface size.

Definition: hip_runtime_api.h:147

hipDeviceProp_t::persistingL2CacheMaxSize

int persistingL2CacheMaxSize

Device's max L2 persisting lines in bytes.

Definition: hip_runtime_api.h:163

hipDeviceProp_t::maxSurface1D

int maxSurface1D

Maximum 1D surface size.

Definition: hip_runtime_api.h:144

hipDeviceProp_t::concurrentKernels

int concurrentKernels

Device can possibly execute multiple kernels concurrently.

Definition: hip_runtime_api.h:152

hipDeviceProp_t::isLargeBar

int isLargeBar

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

Definition: hip_runtime_api.h:235

hipDeviceProp_t::clusterLaunch

int clusterLaunch

Device supports cluster launch.

Definition: hip_runtime_api.h:209

hipDeviceProp_t::maxTexture1DMipmap

int maxTexture1DMipmap

Maximum 1D mipmap texture size.

Definition: hip_runtime_api.h:131

hipDeviceProp_t::multiProcessorCount

int multiProcessorCount

Number of multi-processors (compute units).

Definition: hip_runtime_api.h:125

hipDeviceProp_t::maxTexture3DAlt

int maxTexture3DAlt[3]

Maximum alternate 3D texture dims.

Definition: hip_runtime_api.h:139

hipDeviceProp_t::maxGridSize

int maxGridSize[3]

Max grid dimensions (XYZ).

Definition: hip_runtime_api.h:112

hipDeviceProp_t::pciDeviceID

int pciDeviceID

PCI Device ID.

Definition: hip_runtime_api.h:155

hipDeviceProp_t::maxBlocksPerMultiProcessor

int maxBlocksPerMultiProcessor

Max number of blocks on CU.

Definition: hip_runtime_api.h:191

hipDeviceProp_t::computeMode

int computeMode

Compute mode.

Definition: hip_runtime_api.h:129

hipDeviceProp_t::maxSurface2DLayered

int maxSurface2DLayered[3]

Maximum 2D layared surface size.

Definition: hip_runtime_api.h:148

hipDeviceProp_t::major

int major

Definition: hip_runtime_api.h:116

hipDeviceProp_t::warpSize

int warpSize

Warp size.

Definition: hip_runtime_api.h:107

hipDeviceProp_t::tccDriver

int tccDriver

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

Definition: hip_runtime_api.h:157

hipDeviceProp_t::luidDeviceNodeMask

unsigned int luidDeviceNodeMask

LUID node mask.

Definition: hip_runtime_api.h:103

hipDeviceProp_t::hostRegisterReadOnlySupported

int hostRegisterReadOnlySupported

Definition: hip_runtime_api.h:196

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedSharedMem

int cooperativeMultiDeviceUnmatchedSharedMem

Definition: hip_runtime_api.h:232

hipDeviceProp_t::maxThreadsPerBlock

int maxThreadsPerBlock

Max work items per work group or workgroup max size.

Definition: hip_runtime_api.h:110

hipDeviceProp_t::arch

hipDeviceArch_t arch

Architectural feature flags. New for HIP.

Definition: hip_runtime_api.h:220

hipDeviceProp_t::managedMemory

int managedMemory

Device supports allocating managed memory on this system.

Definition: hip_runtime_api.h:170

hipDeviceProp_t::texturePitchAlignment

size_t texturePitchAlignment

Pitch alignment requirement for texture references bound to.

Definition: hip_runtime_api.h:123

hipEventRecordNodeParams

Definition: hip_runtime_api.h:1594

hipEventRecordNodeParams::event

hipEvent_t event

The event to be recorded when node executes.

Definition: hip_runtime_api.h:1595

hipEventWaitNodeParams

Definition: hip_runtime_api.h:1587

hipEventWaitNodeParams::event

hipEvent_t event

Event to wait on.

Definition: hip_runtime_api.h:1588

hipExtent

Definition: driver_types.h:348

hipExternalMemoryBufferDesc

Definition: hip_runtime_api.h:1113

hipExternalMemoryBufferDesc::flags

unsigned int flags

Definition: hip_runtime_api.h:1116

hipExternalMemoryBufferDesc::offset

unsigned long long offset

Definition: hip_runtime_api.h:1114

hipExternalMemoryBufferDesc::size

unsigned long long size

Definition: hip_runtime_api.h:1115

hipExternalMemoryHandleDesc

Definition: hip_runtime_api.h:1099

hipExternalMemoryHandleDesc::flags

unsigned int flags

Definition: hip_runtime_api.h:1110

hipExternalMemoryHandleDesc::name

const void * name

Definition: hip_runtime_api.h:1105

hipExternalMemoryHandleDesc::fd

int fd

Definition: hip_runtime_api.h:1102

hipExternalMemoryHandleDesc::size

unsigned long long size

Definition: hip_runtime_api.h:1109

hipExternalMemoryHandleDesc::type

hipExternalMemoryHandleType type

Definition: hip_runtime_api.h:1100

hipExternalMemoryHandleDesc::nvSciBufObject

const void * nvSciBufObject

Definition: hip_runtime_api.h:1107

hipExternalMemoryHandleDesc::handle

void * handle

Definition: hip_runtime_api.h:1104

hipExternalMemoryMipmappedArrayDesc

Definition: hip_runtime_api.h:1119

hipExternalMemoryMipmappedArrayDesc::extent

hipExtent extent

Definition: hip_runtime_api.h:1122

hipExternalMemoryMipmappedArrayDesc::numLevels

unsigned int numLevels

Definition: hip_runtime_api.h:1124

hipExternalMemoryMipmappedArrayDesc::flags

unsigned int flags

Definition: hip_runtime_api.h:1123

hipExternalMemoryMipmappedArrayDesc::offset

unsigned long long offset

Definition: hip_runtime_api.h:1120

hipExternalMemoryMipmappedArrayDesc::formatDesc

hipChannelFormatDesc formatDesc

Definition: hip_runtime_api.h:1121

hipExternalSemaphoreHandleDesc

Definition: hip_runtime_api.h:1139

hipExternalSemaphoreHandleDesc::flags

unsigned int flags

Definition: hip_runtime_api.h:1149

hipExternalSemaphoreHandleDesc::name

const void * name

Definition: hip_runtime_api.h:1145

hipExternalSemaphoreHandleDesc::NvSciSyncObj

const void * NvSciSyncObj

Definition: hip_runtime_api.h:1147

hipExternalSemaphoreHandleDesc::type

hipExternalSemaphoreHandleType type

Definition: hip_runtime_api.h:1140

hipExternalSemaphoreHandleDesc::handle

void * handle

Definition: hip_runtime_api.h:1144

hipExternalSemaphoreHandleDesc::fd

int fd

Definition: hip_runtime_api.h:1142

hipExternalSemaphoreSignalNodeParams

Definition: hip_runtime_api.h:1472

hipExternalSemaphoreSignalNodeParams::paramsArray

const hipExternalSemaphoreSignalParams * paramsArray

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

Definition: hip_runtime_api.h:1476

hipExternalSemaphoreSignalNodeParams::extSemArray

hipExternalSemaphore_t * extSemArray

< Array containing external semaphore handles.

Definition: hip_runtime_api.h:1474

hipExternalSemaphoreSignalNodeParams::numExtSems

unsigned int numExtSems

Definition: hip_runtime_api.h:1478

hipExternalSemaphoreSignalParams

Definition: hip_runtime_api.h:1153

hipExternalSemaphoreSignalParams::reserved

unsigned long long reserved

Definition: hip_runtime_api.h:1160

hipExternalSemaphoreSignalParams::value

unsigned long long value

Definition: hip_runtime_api.h:1156

hipExternalSemaphoreSignalParams::fence

void * fence

Definition: hip_runtime_api.h:1159

hipExternalSemaphoreSignalParams::flags

unsigned int flags

Definition: hip_runtime_api.h:1167

hipExternalSemaphoreSignalParams::key

unsigned long long key

Definition: hip_runtime_api.h:1163

hipExternalSemaphoreWaitNodeParams

Definition: hip_runtime_api.h:1484

hipExternalSemaphoreWaitNodeParams::numExtSems

unsigned int numExtSems

Definition: hip_runtime_api.h:1490

hipExternalSemaphoreWaitNodeParams::paramsArray

const hipExternalSemaphoreWaitParams * paramsArray

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

Definition: hip_runtime_api.h:1488

hipExternalSemaphoreWaitNodeParams::extSemArray

hipExternalSemaphore_t * extSemArray

< Array containing external semaphore handles.

Definition: hip_runtime_api.h:1486

hipExternalSemaphoreWaitParams

Definition: hip_runtime_api.h:1173

hipExternalSemaphoreWaitParams::value

unsigned long long value

Definition: hip_runtime_api.h:1176

hipExternalSemaphoreWaitParams::fence

void * fence

Definition: hip_runtime_api.h:1179

hipExternalSemaphoreWaitParams::timeoutMs

unsigned int timeoutMs

Definition: hip_runtime_api.h:1184

hipExternalSemaphoreWaitParams::key

unsigned long long key

Definition: hip_runtime_api.h:1183

hipExternalSemaphoreWaitParams::flags

unsigned int flags

Definition: hip_runtime_api.h:1188

hipExternalSemaphoreWaitParams::reserved

unsigned long long reserved

Definition: hip_runtime_api.h:1180

hipFuncAttributes

Definition: hip_runtime_api.h:631

hipFuncAttributes::cacheModeCA

int cacheModeCA

Definition: hip_runtime_api.h:633

hipFuncAttributes::binaryVersion

int binaryVersion

Definition: hip_runtime_api.h:632

hipFuncAttributes::constSizeBytes

size_t constSizeBytes

Definition: hip_runtime_api.h:634

hipFuncAttributes::preferredShmemCarveout

int preferredShmemCarveout

Definition: hip_runtime_api.h:639

hipFuncAttributes::sharedSizeBytes

size_t sharedSizeBytes

Definition: hip_runtime_api.h:641

hipFuncAttributes::maxDynamicSharedSizeBytes

int maxDynamicSharedSizeBytes

Definition: hip_runtime_api.h:636

hipFuncAttributes::ptxVersion

int ptxVersion

Definition: hip_runtime_api.h:640

hipFuncAttributes::numRegs

int numRegs

Definition: hip_runtime_api.h:638

hipFuncAttributes::localSizeBytes

size_t localSizeBytes

Definition: hip_runtime_api.h:635

hipFuncAttributes::maxThreadsPerBlock

int maxThreadsPerBlock

Definition: hip_runtime_api.h:637

hipFunctionLaunchParams

Definition: hip_runtime_api.h:1077

hipFunctionLaunchParams::gridDimX

unsigned int gridDimX

Width(X) of grid in blocks.

Definition: hip_runtime_api.h:1079

hipFunctionLaunchParams::blockDimX

unsigned int blockDimX

X dimension of each thread block.

Definition: hip_runtime_api.h:1082

hipFunctionLaunchParams::hStream

hipStream_t hStream

Stream identifier.

Definition: hip_runtime_api.h:1086

hipFunctionLaunchParams::blockDimY

unsigned int blockDimY

Y dimension of each thread block.

Definition: hip_runtime_api.h:1083

hipFunctionLaunchParams::gridDimY

unsigned int gridDimY

Height(Y) of grid in blocks.

Definition: hip_runtime_api.h:1080

hipFunctionLaunchParams::gridDimZ

unsigned int gridDimZ

Depth(Z) of grid in blocks.

Definition: hip_runtime_api.h:1081

hipFunctionLaunchParams::sharedMemBytes

unsigned int sharedMemBytes

Shared memory.

Definition: hip_runtime_api.h:1085

hipFunctionLaunchParams::blockDimZ

unsigned int blockDimZ

Z dimension of each thread block.

Definition: hip_runtime_api.h:1084

hipFunctionLaunchParams::kernelParams

void ** kernelParams

Kernel parameters.

Definition: hip_runtime_api.h:1087

hipGraphEdgeData

Definition: hip_runtime_api.h:1651

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

hipGraphEdgeData::reserved

unsigned char reserved[5]

These bytes are unused and must be zeroed.

Definition: hip_runtime_api.h:1660

hipGraphEdgeData::type

unsigned char type

This should be populated with a value from hipGraphDependencyType.

Definition: hip_runtime_api.h:1663

hipGraphEdgeData::from_port

unsigned char from_port

Definition: hip_runtime_api.h:1653

hipGraphInstantiateParams

Definition: hip_runtime_api.h:1445

hipGraphInstantiateParams::result_out

hipGraphInstantiateResult result_out

Definition: hip_runtime_api.h:1448

hipGraphInstantiateParams::uploadStream

hipStream_t uploadStream

Definition: hip_runtime_api.h:1450

hipGraphInstantiateParams::errNode_out

hipGraphNode_t errNode_out

Definition: hip_runtime_api.h:1446

hipGraphInstantiateParams::flags

unsigned long long flags

Definition: hip_runtime_api.h:1447

hipGraphNodeParams

Definition: hip_runtime_api.h:1608

hipGraphNodeParams::type

hipGraphNodeType type

Definition: hip_runtime_api.h:1609

hipGraphNodeParams::reserved0

int reserved0[3]

Definition: hip_runtime_api.h:1610

hipGraphNodeParams::alloc

hipMemAllocNodeParams alloc

Definition: hip_runtime_api.h:1622

hipGraphNodeParams::reserved1

long long reserved1[29]

Definition: hip_runtime_api.h:1612

hipGraphNodeParams::eventRecord

hipEventRecordNodeParams eventRecord

Definition: hip_runtime_api.h:1619

hipGraphNodeParams::extSemSignal

hipExternalSemaphoreSignalNodeParams extSemSignal

Definition: hip_runtime_api.h:1620

hipGraphNodeParams::free

hipMemFreeNodeParams free

Definition: hip_runtime_api.h:1623

hipGraphNodeParams::graph

hipChildGraphNodeParams graph

Definition: hip_runtime_api.h:1617

hipGraphNodeParams::extSemWait

hipExternalSemaphoreWaitNodeParams extSemWait

Definition: hip_runtime_api.h:1621

hipGraphNodeParams::memset

hipMemsetParams memset

Definition: hip_runtime_api.h:1615

hipGraphNodeParams::host

hipHostNodeParams host

Definition: hip_runtime_api.h:1616

hipGraphNodeParams::reserved2

long long reserved2

Definition: hip_runtime_api.h:1626

hipGraphNodeParams::kernel

hipKernelNodeParams kernel

Definition: hip_runtime_api.h:1613

hipGraphNodeParams::eventWait

hipEventWaitNodeParams eventWait

Definition: hip_runtime_api.h:1618

hipGraphNodeParams::memcpy

hipMemcpyNodeParams memcpy

Definition: hip_runtime_api.h:1614

hipHostNodeParams

Definition: hip_runtime_api.h:1258

hipHostNodeParams::fn

hipHostFn_t fn

Definition: hip_runtime_api.h:1259

hipHostNodeParams::userData

void * userData

Definition: hip_runtime_api.h:1260

hipIpcEventHandle_t

Definition: hip_runtime_api.h:621

hipIpcMemHandle_t

Definition: hip_runtime_api.h:618

hipKernelNodeParams

Definition: hip_runtime_api.h:1262

hipKernelNodeParams::gridDim

dim3 gridDim

Definition: hip_runtime_api.h:1266

hipKernelNodeParams::sharedMemBytes

unsigned int sharedMemBytes

Definition: hip_runtime_api.h:1268

hipKernelNodeParams::blockDim

dim3 blockDim

Definition: hip_runtime_api.h:1263

hipKernelNodeParams::kernelParams

void ** kernelParams

Definition: hip_runtime_api.h:1267

hipKernelNodeParams::extra

void ** extra

Definition: hip_runtime_api.h:1264

hipKernelNodeParams::func

void * func

Definition: hip_runtime_api.h:1265

hipLaunchParams

Definition: hip_runtime_api.h:1066

hipLaunchParams::sharedMem

size_t sharedMem

Shared memory.

Definition: hip_runtime_api.h:1071

hipLaunchParams::args

void ** args

Arguments.

Definition: hip_runtime_api.h:1070

hipLaunchParams::blockDim

dim3 blockDim

Block dimentions.

Definition: hip_runtime_api.h:1069

hipLaunchParams::gridDim

dim3 gridDim

Grid dimentions.

Definition: hip_runtime_api.h:1068

hipLaunchParams::func

void * func

Device function symbol.

Definition: hip_runtime_api.h:1067

hipLaunchParams::stream

hipStream_t stream

Stream identifier.

Definition: hip_runtime_api.h:1072

hipMemAccessDesc

Definition: hip_runtime_api.h:956

hipMemAccessDesc::flags

hipMemAccessFlags flags

Accessibility flags to set.

Definition: hip_runtime_api.h:958

hipMemAccessDesc::location

hipMemLocation location

Location on which the accessibility has to change.

Definition: hip_runtime_api.h:957

hipMemAllocNodeParams

Definition: hip_runtime_api.h:1279

hipMemAllocNodeParams::accessDescs

const hipMemAccessDesc * accessDescs

Definition: hip_runtime_api.h:1282

hipMemAllocNodeParams::bytesize

size_t bytesize

The size of the requested allocation in bytes.

Definition: hip_runtime_api.h:1285

hipMemAllocNodeParams::poolProps

hipMemPoolProps poolProps

Definition: hip_runtime_api.h:1280

hipMemAllocNodeParams::accessDescCount

size_t accessDescCount

The number of access descriptors.

Definition: hip_runtime_api.h:1284

hipMemAllocNodeParams::dptr

void * dptr

Returned device address of the allocation.

Definition: hip_runtime_api.h:1286

hipMemAllocationProp

Definition: hip_runtime_api.h:1457

hipMemAllocationProp::win32HandleMetaData

void * win32HandleMetaData

Metadata for Win32 handles.

Definition: hip_runtime_api.h:1461

hipMemAllocationProp::type

hipMemAllocationType type

Memory allocation type.

Definition: hip_runtime_api.h:1458

hipMemAllocationProp::gpuDirectRDMACapable

unsigned char gpuDirectRDMACapable

RDMA capable.

Definition: hip_runtime_api.h:1464

hipMemAllocationProp::allocFlags

struct hipMemAllocationProp::@24 allocFlags

hipMemAllocationProp::usage

unsigned short usage

Usage.

Definition: hip_runtime_api.h:1465

hipMemAllocationProp::requestedHandleType

hipMemAllocationHandleType requestedHandleType

Requested handle type.

Definition: hip_runtime_api.h:1459

hipMemAllocationProp::location

hipMemLocation location

Memory location.

Definition: hip_runtime_api.h:1460

hipMemAllocationProp::compressionType

unsigned char compressionType

Compression type.

Definition: hip_runtime_api.h:1463

hipMemFreeNodeParams

Definition: hip_runtime_api.h:1601

hipMemFreeNodeParams::dptr

void * dptr

the pointer to be freed

Definition: hip_runtime_api.h:1602

hipMemLocation

Definition: hip_runtime_api.h:940

hipMemLocation::id

int id

Identifier for the provided location type hipMemLocationType.

Definition: hip_runtime_api.h:942

hipMemLocation::type

hipMemLocationType type

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

Definition: hip_runtime_api.h:941

hipMemPoolProps

Definition: hip_runtime_api.h:984

hipMemPoolProps::maxSize

size_t maxSize

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

Definition: hip_runtime_api.h:992

hipMemPoolProps::reserved

unsigned char reserved[56]

Reserved for future use, must be 0.

Definition: hip_runtime_api.h:993

hipMemPoolProps::location

hipMemLocation location

Location where allocations should reside.

Definition: hip_runtime_api.h:987

hipMemPoolProps::handleTypes

hipMemAllocationHandleType handleTypes

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

Definition: hip_runtime_api.h:986

hipMemPoolProps::allocType

hipMemAllocationType allocType

Allocation type. Currently must be specified as hipMemAllocationTypePinned.

Definition: hip_runtime_api.h:985

hipMemPoolProps::win32SecurityAttributes

void * win32SecurityAttributes

Definition: hip_runtime_api.h:991

hipMemPoolPtrExportData

Definition: hip_runtime_api.h:998

hipMemPoolPtrExportData::reserved

unsigned char reserved[64]

Definition: hip_runtime_api.h:999

hipMemcpy3DParms

Definition: driver_types.h:359

hipMemcpyNodeParams

Definition: hip_runtime_api.h:1570

hipMemcpyNodeParams::reserved

int reserved[3]

Must be zero.

Definition: hip_runtime_api.h:1572

hipMemcpyNodeParams::flags

int flags

Must be zero.

Definition: hip_runtime_api.h:1571

hipMemcpyNodeParams::copyParams

hipMemcpy3DParms copyParams

Params set for the memory copy.

Definition: hip_runtime_api.h:1573

hipMemsetParams

Definition: hip_runtime_api.h:1270

hipMemsetParams::dst

void * dst

Definition: hip_runtime_api.h:1271

hipMemsetParams::value

unsigned int value

Definition: hip_runtime_api.h:1275

hipMemsetParams::elementSize

unsigned int elementSize

Definition: hip_runtime_api.h:1272

hipMemsetParams::width

size_t width

Definition: hip_runtime_api.h:1276

hipMemsetParams::pitch

size_t pitch

Definition: hip_runtime_api.h:1274

hipMemsetParams::height

size_t height

Definition: hip_runtime_api.h:1273

hipMipmappedArray

Definition: driver_types.h:104

hipPitchedPtr

Definition: driver_types.h:342

hipPointerAttribute_t

Definition: hip_runtime_api.h:262

hipPointerAttribute_t::device

int device

Definition: hip_runtime_api.h:264

hipPointerAttribute_t::hostPointer

void * hostPointer

Definition: hip_runtime_api.h:266

hipPointerAttribute_t::type

enum hipMemoryType type

Definition: hip_runtime_api.h:263

hipPointerAttribute_t::isManaged

int isManaged

Definition: hip_runtime_api.h:267

hipPointerAttribute_t::devicePointer

void * devicePointer

Definition: hip_runtime_api.h:265

hipPointerAttribute_t::allocationFlags

unsigned allocationFlags

Definition: hip_runtime_api.h:268

hipResourceDesc

Definition: driver_types.h:247

hipResourceViewDesc

Definition: driver_types.h:303

hipTextureDesc

Definition: texture_types.h:117

hipUUID

Definition: hip_runtime_api.h:84

textureReference

Definition: texture_types.h:96

surface_types.h

Defines surface types for HIP runtime.

hipSurfaceObject_t

struct __hip_surface * hipSurfaceObject_t

Definition: surface_types.h:41

texture_types.h

hipTextureObject_t

struct __hip_texture * hipTextureObject_t

Definition: texture_types.h:71

hipTextureAddressMode

hipTextureAddressMode

Definition: texture_types.h:76

hipTextureFilterMode

hipTextureFilterMode

Definition: texture_types.h:86

hipLaunchAttributeValue

Definition: hip_runtime_api.h:1315

hipLaunchAttributeValue::priority

int priority

Definition: hip_runtime_api.h:1319

hipLaunchAttributeValue::cooperative

int cooperative

Definition: hip_runtime_api.h:1318

hipLaunchAttributeValue::accessPolicyWindow

hipAccessPolicyWindow accessPolicyWindow

Definition: hip_runtime_api.h:1316