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

• include
• hip

hip_runtime_api.h

Go to the documentation of this file.

1/*

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

3

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

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

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

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

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

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

10

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

12all copies or substantial portions of the Software.

13

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

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

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

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

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

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

20THE SOFTWARE.

21*/

22

30#ifndef HIP_INCLUDE_HIP_HIP_RUNTIME_API_H

31#define HIP_INCLUDE_HIP_HIP_RUNTIME_API_H

32

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

34#include <hip/hip_version.h>

35#include <hip/hip_common.h>

36

37enum {

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:

53typedef 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

84typedef 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

98typedef struct hipDeviceProp_t {

99 char name[256];

100 hipUUID uuid;

101 char luid[8];

102 unsigned int luidDeviceNodeMask;

103 size_t totalGlobalMem;

104 size_t sharedMemPerBlock;

105 int regsPerBlock;

106 int warpSize;

107 size_t memPitch;

109 int maxThreadsPerBlock;

110 int maxThreadsDim[3];

111 int maxGridSize[3];

112 int clockRate;

113 size_t totalConstMem;

114 int major;

117 int minor;

120 size_t textureAlignment;

121 size_t texturePitchAlignment;

122 int deviceOverlap;

123 int multiProcessorCount;

124 int kernelExecTimeoutEnabled;

125 int integrated;

126 int canMapHostMemory;

127 int computeMode;

128 int maxTexture1D;

129 int maxTexture1DMipmap;

130 int maxTexture1DLinear;

131 int maxTexture2D[2];

132 int maxTexture2DMipmap[2];

133 int maxTexture2DLinear[3];

134 int maxTexture2DGather[2];

135 int maxTexture3D[3];

137 int maxTexture3DAlt[3];

138 int maxTextureCubemap;

139 int maxTexture1DLayered[2];

140 int maxTexture2DLayered[3];

141 int maxTextureCubemapLayered[2];

142 int maxSurface1D;

143 int maxSurface2D[2];

144 int maxSurface3D[3];

145 int maxSurface1DLayered[2];

146 int maxSurface2DLayered[3];

147 int maxSurfaceCubemap;

148 int maxSurfaceCubemapLayered[2];

149 size_t surfaceAlignment;

150 int concurrentKernels;

151 int ECCEnabled;

152 int pciBusID;

153 int pciDeviceID;

154 int pciDomainID;

155 int tccDriver;

156 int asyncEngineCount;

157 int unifiedAddressing;

158 int memoryClockRate;

159 int memoryBusWidth;

160 int l2CacheSize;

161 int persistingL2CacheMaxSize;

162 int maxThreadsPerMultiProcessor;

163 int streamPrioritiesSupported;

164 int globalL1CacheSupported;

165 int localL1CacheSupported;

166 size_t sharedMemPerMultiprocessor;

167 int regsPerMultiprocessor;

168 int managedMemory;

169 int isMultiGpuBoard;

170 int multiGpuBoardGroupID;

171 int hostNativeAtomicSupported;

172 int singleToDoublePrecisionPerfRatio;

173 int pageableMemoryAccess;

175 int concurrentManagedAccess;

177 int computePreemptionSupported;

178 int canUseHostPointerForRegisteredMem;

180 int cooperativeLaunch;

181 int cooperativeMultiDeviceLaunch;

183 size_t

184 sharedMemPerBlockOptin;

185 int pageableMemoryAccessUsesHostPageTables;

187 int directManagedMemAccessFromHost;

189 int maxBlocksPerMultiProcessor;

190 int accessPolicyMaxWindowSize;

191 size_t reservedSharedMemPerBlock;

192 int hostRegisterSupported;

193 int sparseHipArraySupported;

194 int hostRegisterReadOnlySupported;

196 int timelineSemaphoreInteropSupported;

197 int memoryPoolsSupported;

198 int gpuDirectRDMASupported;

199 unsigned int gpuDirectRDMAFlushWritesOptions;

201 int gpuDirectRDMAWritesOrdering;

202 unsigned int

203 memoryPoolSupportedHandleTypes;

204 int deferredMappingHipArraySupported;

206 int ipcEventSupported;

207 int clusterLaunch;

208 int unifiedFunctionPointers;

209 int reserved[63];

210

211 int hipReserved[32];

212

213 /* HIP Only struct members */

214 char gcnArchName[256];

215 size_t maxSharedMemoryPerMultiProcessor;

216 int clockInstructionRate;

218 hipDeviceArch_t arch;

219 unsigned int* hdpMemFlushCntl;

220 unsigned int* hdpRegFlushCntl;

221 int cooperativeMultiDeviceUnmatchedFunc;

224 int cooperativeMultiDeviceUnmatchedGridDim;

227 int cooperativeMultiDeviceUnmatchedBlockDim;

230 int cooperativeMultiDeviceUnmatchedSharedMem;

233 int isLargeBar;

234 int asicRevision;

235} hipDeviceProp_t;

236

243typedef enum hipMemoryType {

244 hipMemoryTypeUnregistered = 0,

245 hipMemoryTypeHost = 1,

246 hipMemoryTypeDevice = 2,

248 hipMemoryTypeManaged = 3,

251 hipMemoryTypeArray = 10,

253 hipMemoryTypeUnified = 11

254

255} hipMemoryType;

256

260typedef struct hipPointerAttribute_t {

261 enum hipMemoryType type;

262 int device;

263 void* devicePointer;

264 void* hostPointer;

265 int isManaged;

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

267 /* peers? */

268} hipPointerAttribute_t;

269

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

271// we can make that yield a warning

272#if __cplusplus >= 201703L

273#define __HIP_NODISCARD [[nodiscard]]

274#else

275#define __HIP_NODISCARD

276#endif

277

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

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

284

285typedef enum __HIP_NODISCARD hipError_t {

286 hipSuccess = 0,

287 hipErrorInvalidValue = 1,

289 hipErrorOutOfMemory = 2,

290 // Deprecated

291 hipErrorMemoryAllocation = 2,

292 hipErrorNotInitialized = 3,

293 // Deprecated

294 hipErrorInitializationError = 3,

295 hipErrorDeinitialized = 4,

296 hipErrorProfilerDisabled = 5,

297 hipErrorProfilerNotInitialized = 6,

298 hipErrorProfilerAlreadyStarted = 7,

299 hipErrorProfilerAlreadyStopped = 8,

300 hipErrorInvalidConfiguration = 9,

301 hipErrorInvalidPitchValue = 12,

302 hipErrorInvalidSymbol = 13,

303 hipErrorInvalidDevicePointer = 17,

304 hipErrorInvalidMemcpyDirection = 21,

305 hipErrorInsufficientDriver = 35,

306 hipErrorMissingConfiguration = 52,

307 hipErrorPriorLaunchFailure = 53,

308 hipErrorInvalidDeviceFunction = 98,

309 hipErrorNoDevice = 100,

310 hipErrorInvalidDevice = 101,

311 hipErrorInvalidImage = 200,

312 hipErrorInvalidContext = 201,

313 hipErrorContextAlreadyCurrent = 202,

314 hipErrorMapFailed = 205,

315 // Deprecated

316 hipErrorMapBufferObjectFailed = 205,

317 hipErrorUnmapFailed = 206,

318 hipErrorArrayIsMapped = 207,

319 hipErrorAlreadyMapped = 208,

320 hipErrorNoBinaryForGpu = 209,

321 hipErrorAlreadyAcquired = 210,

322 hipErrorNotMapped = 211,

323 hipErrorNotMappedAsArray = 212,

324 hipErrorNotMappedAsPointer = 213,

325 hipErrorECCNotCorrectable = 214,

326 hipErrorUnsupportedLimit = 215,

327 hipErrorContextAlreadyInUse = 216,

328 hipErrorPeerAccessUnsupported = 217,

329 hipErrorInvalidKernelFile = 218,

330 hipErrorInvalidGraphicsContext = 219,

331 hipErrorInvalidSource = 300,

332 hipErrorFileNotFound = 301,

333 hipErrorSharedObjectSymbolNotFound = 302,

334 hipErrorSharedObjectInitFailed = 303,

335 hipErrorOperatingSystem = 304,

336 hipErrorInvalidHandle = 400,

337 // Deprecated

338 hipErrorInvalidResourceHandle = 400,

339 hipErrorIllegalState = 401,

340 hipErrorNotFound = 500,

341 hipErrorNotReady = 600,

345 hipErrorIllegalAddress = 700,

346 hipErrorLaunchOutOfResources = 701,

347 hipErrorLaunchTimeOut = 702,

348 hipErrorPeerAccessAlreadyEnabled =

349 704,

350 hipErrorPeerAccessNotEnabled =

351 705,

352 hipErrorSetOnActiveProcess = 708,

353 hipErrorContextIsDestroyed = 709,

354 hipErrorAssert = 710,

355 hipErrorHostMemoryAlreadyRegistered =

356 712,

357 hipErrorHostMemoryNotRegistered =

358 713,

359 hipErrorLaunchFailure =

360 719,

361 hipErrorCooperativeLaunchTooLarge =

362 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

407typedef 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 hipDeviceAttributeHostRegisterSupported,

424 hipDeviceAttributeDeviceOverlap,

426 hipDeviceAttributeDirectManagedMemAccessFromHost,

428 hipDeviceAttributeGlobalL1CacheSupported,

429 hipDeviceAttributeHostNativeAtomicSupported,

430 hipDeviceAttributeIntegrated,

431 hipDeviceAttributeIsMultiGpuBoard,

432 hipDeviceAttributeKernelExecTimeout,

433 hipDeviceAttributeL2CacheSize,

434 hipDeviceAttributeLocalL1CacheSupported,

435 hipDeviceAttributeLuid,

436 hipDeviceAttributeLuidDeviceNodeMask,

437 hipDeviceAttributeComputeCapabilityMajor,

438 hipDeviceAttributeManagedMemory,

439 hipDeviceAttributeMaxBlocksPerMultiProcessor,

440 hipDeviceAttributeMaxBlockDimX,

441 hipDeviceAttributeMaxBlockDimY,

442 hipDeviceAttributeMaxBlockDimZ,

443 hipDeviceAttributeMaxGridDimX,

444 hipDeviceAttributeMaxGridDimY,

445 hipDeviceAttributeMaxGridDimZ,

446 hipDeviceAttributeMaxSurface1D,

447 hipDeviceAttributeMaxSurface1DLayered,

448 hipDeviceAttributeMaxSurface2D,

449 hipDeviceAttributeMaxSurface2DLayered,

450 hipDeviceAttributeMaxSurface3D,

451 hipDeviceAttributeMaxSurfaceCubemap,

452 hipDeviceAttributeMaxSurfaceCubemapLayered,

453 hipDeviceAttributeMaxTexture1DWidth,

454 hipDeviceAttributeMaxTexture1DLayered,

455 hipDeviceAttributeMaxTexture1DLinear,

457 hipDeviceAttributeMaxTexture1DMipmap,

458 hipDeviceAttributeMaxTexture2DWidth,

459 hipDeviceAttributeMaxTexture2DHeight,

460 hipDeviceAttributeMaxTexture2DGather,

461 hipDeviceAttributeMaxTexture2DLayered,

462 hipDeviceAttributeMaxTexture2DLinear,

463 hipDeviceAttributeMaxTexture2DMipmap,

464 hipDeviceAttributeMaxTexture3DWidth,

465 hipDeviceAttributeMaxTexture3DHeight,

466 hipDeviceAttributeMaxTexture3DDepth,

467 hipDeviceAttributeMaxTexture3DAlt,

468 hipDeviceAttributeMaxTextureCubemap,

469 hipDeviceAttributeMaxTextureCubemapLayered,

470 hipDeviceAttributeMaxThreadsDim,

471 hipDeviceAttributeMaxThreadsPerBlock,

472 hipDeviceAttributeMaxThreadsPerMultiProcessor,

473 hipDeviceAttributeMaxPitch,

474 hipDeviceAttributeMemoryBusWidth,

475 hipDeviceAttributeMemoryClockRate,

476 hipDeviceAttributeComputeCapabilityMinor,

477 hipDeviceAttributeMultiGpuBoardGroupID,

478 hipDeviceAttributeMultiprocessorCount,

479 hipDeviceAttributeUnused1,

480 hipDeviceAttributePageableMemoryAccess,

482 hipDeviceAttributePageableMemoryAccessUsesHostPageTables,

483 hipDeviceAttributePciBusId,

484 hipDeviceAttributePciDeviceId,

485 hipDeviceAttributePciDomainID,

486 hipDeviceAttributePersistingL2CacheMaxSize,

487 hipDeviceAttributeMaxRegistersPerBlock,

489 hipDeviceAttributeMaxRegistersPerMultiprocessor,

490 hipDeviceAttributeReservedSharedMemPerBlock,

491 hipDeviceAttributeMaxSharedMemoryPerBlock,

492 hipDeviceAttributeSharedMemPerBlockOptin,

493 hipDeviceAttributeSharedMemPerMultiprocessor,

494 hipDeviceAttributeSingleToDoublePrecisionPerfRatio,

495 hipDeviceAttributeStreamPrioritiesSupported,

496 hipDeviceAttributeSurfaceAlignment,

497 hipDeviceAttributeTccDriver,

498 hipDeviceAttributeTextureAlignment,

499 hipDeviceAttributeTexturePitchAlignment,

500 hipDeviceAttributeTotalConstantMemory,

501 hipDeviceAttributeTotalGlobalMem,

502 hipDeviceAttributeUnifiedAddressing,

503 hipDeviceAttributeUnused2,

504 hipDeviceAttributeWarpSize,

505 hipDeviceAttributeMemoryPoolsSupported,

506 hipDeviceAttributeVirtualMemoryManagementSupported,

507

508 hipDeviceAttributeCudaCompatibleEnd = 9999,

509 hipDeviceAttributeAmdSpecificBegin = 10000,

510

511 hipDeviceAttributeClockInstructionRate = hipDeviceAttributeAmdSpecificBegin,

512 hipDeviceAttributeUnused3,

513 hipDeviceAttributeMaxSharedMemoryPerMultiprocessor,

514 hipDeviceAttributeUnused4,

515 hipDeviceAttributeUnused5,

516 hipDeviceAttributeHdpMemFlushCntl,

517 hipDeviceAttributeHdpRegFlushCntl,

518 hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc,

520 hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim,

522 hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim,

524 hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem,

526 hipDeviceAttributeIsLargeBar,

527 hipDeviceAttributeAsicRevision,

528 hipDeviceAttributeCanUseStreamWaitValue,

530 hipDeviceAttributeImageSupport,

531 hipDeviceAttributePhysicalMultiProcessorCount,

533 hipDeviceAttributeFineGrainSupport,

534 hipDeviceAttributeWallClockRate,

535

536 hipDeviceAttributeAmdSpecificEnd = 19999,

537 hipDeviceAttributeVendorSpecificBegin = 20000,

538 // Extended attributes for vendors

539} hipDeviceAttribute_t;

540

541enum hipComputeMode {

542 hipComputeModeDefault = 0,

543 hipComputeModeExclusive = 1,

544 hipComputeModeProhibited = 2,

545 hipComputeModeExclusiveProcess = 3

546};

547

548enum hipFlushGPUDirectRDMAWritesOptions {

549 hipFlushGPUDirectRDMAWritesOptionHost = 1 << 0,

550 hipFlushGPUDirectRDMAWritesOptionMemOps = 1 << 1

551};

552

553enum hipGPUDirectRDMAWritesOrdering {

554 hipGPUDirectRDMAWritesOrderingNone = 0,

555 hipGPUDirectRDMAWritesOrderingOwner = 100,

556 hipGPUDirectRDMAWritesOrderingAllDevices = 200

557};

558

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

560

561#include <stdint.h>

562#include <stddef.h>

563#ifndef GENERIC_GRID_LAUNCH

564#define GENERIC_GRID_LAUNCH 1

565#endif

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

567#include <hip/driver_types.h>

568#include <hip/texture_types.h>

569#include <hip/surface_types.h>

570#if defined(_MSC_VER)

571#define DEPRECATED(msg) __declspec(deprecated(msg))

572#else // !defined(_MSC_VER)

573#define DEPRECATED(msg) __attribute__ ((deprecated(msg)))

574#endif // !defined(_MSC_VER)

575#define DEPRECATED_MSG "This API is marked as deprecated and may not be supported in future releases. For more details please refer https://github.com/ROCm-Developer-Tools/HIP/blob/master/docs/markdown/hip_deprecated_api_list.md"

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

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

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

579#ifdef __cplusplus

580 #define __dparm(x) \

581 = x

582#else

583 #define __dparm(x)

584#endif

585#ifdef __GNUC__

586#pragma GCC visibility push (default)

587#endif

588#ifdef __cplusplus

589namespace hip_impl {

590hipError_t hip_init();

591} // namespace hip_impl

592#endif

593// Structure definitions:

594#ifdef __cplusplus

595extern "C" {

596#endif

597//---

598// API-visible structures

599typedef struct ihipCtx_t* hipCtx_t;

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

601typedef int hipDevice_t;

602typedef enum hipDeviceP2PAttr {

603 hipDevP2PAttrPerformanceRank = 0,

604 hipDevP2PAttrAccessSupported,

605 hipDevP2PAttrNativeAtomicSupported,

606 hipDevP2PAttrHipArrayAccessSupported

607} hipDeviceP2PAttr;

608typedef struct ihipStream_t* hipStream_t;

609#define hipIpcMemLazyEnablePeerAccess 0x01

610#define HIP_IPC_HANDLE_SIZE 64

611typedef struct hipIpcMemHandle_st {

612 char reserved[HIP_IPC_HANDLE_SIZE];

613} hipIpcMemHandle_t;

614typedef struct hipIpcEventHandle_st {

615 char reserved[HIP_IPC_HANDLE_SIZE];

616} hipIpcEventHandle_t;

617typedef struct ihipModule_t* hipModule_t;

618typedef struct ihipModuleSymbol_t* hipFunction_t;

622typedef struct ihipMemPoolHandle_t* hipMemPool_t;

623

624typedef struct hipFuncAttributes {

625 int binaryVersion;

626 int cacheModeCA;

627 size_t constSizeBytes;

628 size_t localSizeBytes;

629 int maxDynamicSharedSizeBytes;

630 int maxThreadsPerBlock;

631 int numRegs;

632 int preferredShmemCarveout;

633 int ptxVersion;

634 size_t sharedSizeBytes;

635} hipFuncAttributes;

636typedef struct ihipEvent_t* hipEvent_t;

637

644enum hipLimit_t {

645 hipLimitStackSize = 0x0,

648 hipLimitPrintfFifoSize = 0x01,

650 hipLimitMallocHeapSize = 0x02,

652 hipLimitRange

653};

657//Flags that can be used with hipStreamCreateWithFlags.

659#define hipStreamDefault 0x00

660

662#define hipStreamNonBlocking 0x01

663

664//Flags that can be used with hipEventCreateWithFlags.

666#define hipEventDefault 0x0

667

669#define hipEventBlockingSync 0x1

670

672#define hipEventDisableTiming 0x2

673

675#define hipEventInterprocess 0x4

676

685#define hipEventDisableSystemFence 0x20000000

686

689#define hipEventReleaseToDevice 0x40000000

690

693#define hipEventReleaseToSystem 0x80000000

694

695//Flags that can be used with hipHostMalloc.

697#define hipHostMallocDefault 0x0

698

700#define hipHostMallocPortable 0x1

701

704#define hipHostMallocMapped 0x2

705

709#define hipHostMallocWriteCombined 0x4

710

715#define hipHostMallocNumaUser 0x20000000

716

718#define hipHostMallocCoherent 0x40000000

719

721#define hipHostMallocNonCoherent 0x80000000

722

724#define hipMemAttachGlobal 0x01

725

727#define hipMemAttachHost 0x02

728

730#define hipMemAttachSingle 0x04

731

732#define hipDeviceMallocDefault 0x0

733

735#define hipDeviceMallocFinegrained 0x1

736

738#define hipMallocSignalMemory 0x2

739

741#define hipDeviceMallocUncached 0x3

742

743//Flags that can be used with hipHostRegister.

745#define hipHostRegisterDefault 0x0

746

748#define hipHostRegisterPortable 0x1

749

752#define hipHostRegisterMapped 0x2

753

755#define hipHostRegisterIoMemory 0x4

756

758#define hipHostRegisterReadOnly 0x08

759

761#define hipExtHostRegisterCoarseGrained 0x8

762

764#define hipDeviceScheduleAuto 0x0

765

768#define hipDeviceScheduleSpin 0x1

769

772#define hipDeviceScheduleYield 0x2

773#define hipDeviceScheduleBlockingSync 0x4

774#define hipDeviceScheduleMask 0x7

775#define hipDeviceMapHost 0x8

776#define hipDeviceLmemResizeToMax 0x10

778#define hipArrayDefault 0x00

779#define hipArrayLayered 0x01

780#define hipArraySurfaceLoadStore 0x02

781#define hipArrayCubemap 0x04

782#define hipArrayTextureGather 0x08

783#define hipOccupancyDefault 0x00

784#define hipOccupancyDisableCachingOverride 0x01

785#define hipCooperativeLaunchMultiDeviceNoPreSync 0x01

786#define hipCooperativeLaunchMultiDeviceNoPostSync 0x02

787#define hipCpuDeviceId ((int)-1)

788#define hipInvalidDeviceId ((int)-2)

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

791#define hipExtAnyOrderLaunch 0x01

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

793#define hipStreamWaitValueGte 0x0

794#define hipStreamWaitValueEq 0x1

795#define hipStreamWaitValueAnd 0x2

796#define hipStreamWaitValueNor 0x3

797// Stream per thread

799#define hipStreamPerThread ((hipStream_t)2)

800

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

802#define hipExternalMemoryDedicated 0x1

808typedef enum hipMemoryAdvise {

809 hipMemAdviseSetReadMostly = 1,

811 hipMemAdviseUnsetReadMostly = 2,

812 hipMemAdviseSetPreferredLocation = 3,

814 hipMemAdviseUnsetPreferredLocation = 4,

815 hipMemAdviseSetAccessedBy = 5,

817 hipMemAdviseUnsetAccessedBy = 6,

819 hipMemAdviseSetCoarseGrain = 100,

824 hipMemAdviseUnsetCoarseGrain = 101

825} hipMemoryAdvise;

829typedef enum hipMemRangeCoherencyMode {

830 hipMemRangeCoherencyModeFineGrain = 0,

832 hipMemRangeCoherencyModeCoarseGrain = 1,

834 hipMemRangeCoherencyModeIndeterminate = 2

837} hipMemRangeCoherencyMode;

841typedef enum hipMemRangeAttribute {

842 hipMemRangeAttributeReadMostly = 1,

844 hipMemRangeAttributePreferredLocation = 2,

845 hipMemRangeAttributeAccessedBy = 3,

847 hipMemRangeAttributeLastPrefetchLocation = 4,

849 hipMemRangeAttributeCoherencyMode = 100,

851} hipMemRangeAttribute;

852

856typedef enum hipMemPoolAttr

857{

866 hipMemPoolReuseFollowEventDependencies = 0x1,

872 hipMemPoolReuseAllowOpportunistic = 0x2,

879 hipMemPoolReuseAllowInternalDependencies = 0x3,

888 hipMemPoolAttrReleaseThreshold = 0x4,

893 hipMemPoolAttrReservedMemCurrent = 0x5,

899 hipMemPoolAttrReservedMemHigh = 0x6,

904 hipMemPoolAttrUsedMemCurrent = 0x7,

910 hipMemPoolAttrUsedMemHigh = 0x8

911} hipMemPoolAttr;

915 typedef enum hipMemLocationType {

916 hipMemLocationTypeInvalid = 0,

917 hipMemLocationTypeDevice = 1

918} hipMemLocationType;

924typedef struct hipMemLocation {

925 hipMemLocationType type;

926 int id;

927} hipMemLocation;

932typedef enum hipMemAccessFlags {

933 hipMemAccessFlagsProtNone = 0,

934 hipMemAccessFlagsProtRead = 1,

935 hipMemAccessFlagsProtReadWrite = 3

936} hipMemAccessFlags;

940typedef struct hipMemAccessDesc {

941 hipMemLocation location;

942 hipMemAccessFlags flags;

943} hipMemAccessDesc;

947typedef enum hipMemAllocationType {

948 hipMemAllocationTypeInvalid = 0x0,

952 hipMemAllocationTypePinned = 0x1,

953 hipMemAllocationTypeMax = 0x7FFFFFFF

954} hipMemAllocationType;

959typedef enum hipMemAllocationHandleType {

960 hipMemHandleTypeNone = 0x0,

961 hipMemHandleTypePosixFileDescriptor = 0x1,

962 hipMemHandleTypeWin32 = 0x2,

963 hipMemHandleTypeWin32Kmt = 0x4

964} hipMemAllocationHandleType;

968typedef struct hipMemPoolProps {

969 hipMemAllocationType allocType;

970 hipMemAllocationHandleType handleTypes;

971 hipMemLocation location;

975 void* win32SecurityAttributes;

976 unsigned char reserved[64];

977} hipMemPoolProps;

981typedef struct hipMemPoolPtrExportData {

982 unsigned char reserved[64];

983} hipMemPoolPtrExportData;

984

988typedef enum hipJitOption {

989 hipJitOptionMaxRegisters = 0,

990 hipJitOptionThreadsPerBlock,

991 hipJitOptionWallTime,

992 hipJitOptionInfoLogBuffer,

993 hipJitOptionInfoLogBufferSizeBytes,

994 hipJitOptionErrorLogBuffer,

995 hipJitOptionErrorLogBufferSizeBytes,

996 hipJitOptionOptimizationLevel,

997 hipJitOptionTargetFromContext,

998 hipJitOptionTarget,

999 hipJitOptionFallbackStrategy,

1000 hipJitOptionGenerateDebugInfo,

1001 hipJitOptionLogVerbose,

1002 hipJitOptionGenerateLineInfo,

1003 hipJitOptionCacheMode,

1004 hipJitOptionSm3xOpt,

1005 hipJitOptionFastCompile,

1006 hipJitOptionNumOptions

1007} hipJitOption;

1011typedef enum hipFuncAttribute {

1012 hipFuncAttributeMaxDynamicSharedMemorySize = 8,

1013 hipFuncAttributePreferredSharedMemoryCarveout = 9,

1014 hipFuncAttributeMax

1015} hipFuncAttribute;

1019typedef enum hipFuncCache_t {

1020 hipFuncCachePreferNone,

1021 hipFuncCachePreferShared,

1022 hipFuncCachePreferL1,

1023 hipFuncCachePreferEqual,

1024} hipFuncCache_t;

1028typedef enum hipSharedMemConfig {

1029 hipSharedMemBankSizeDefault,

1030 hipSharedMemBankSizeFourByte,

1032 hipSharedMemBankSizeEightByte

1034} hipSharedMemConfig;

1038typedef struct dim3 {

1039 uint32_t x;

1040 uint32_t y;

1041 uint32_t z;

1042#ifdef __cplusplus

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

1044#endif

1045} dim3;

1049typedef struct hipLaunchParams_t {

1050 void* func;

1051 dim3 gridDim;

1052 dim3 blockDim;

1053 void **args;

1054 size_t sharedMem;

1055 hipStream_t stream;

1056} hipLaunchParams;

1060typedef struct hipFunctionLaunchParams_t {

1061 hipFunction_t function;

1062 unsigned int gridDimX;

1063 unsigned int gridDimY;

1064 unsigned int gridDimZ;

1065 unsigned int blockDimX;

1066 unsigned int blockDimY;

1067 unsigned int blockDimZ;

1068 unsigned int sharedMemBytes;

1069 hipStream_t hStream;

1070 void **kernelParams;

1071} hipFunctionLaunchParams;

1072typedef enum hipExternalMemoryHandleType_enum {

1073 hipExternalMemoryHandleTypeOpaqueFd = 1,

1074 hipExternalMemoryHandleTypeOpaqueWin32 = 2,

1075 hipExternalMemoryHandleTypeOpaqueWin32Kmt = 3,

1076 hipExternalMemoryHandleTypeD3D12Heap = 4,

1077 hipExternalMemoryHandleTypeD3D12Resource = 5,

1078 hipExternalMemoryHandleTypeD3D11Resource = 6,

1079 hipExternalMemoryHandleTypeD3D11ResourceKmt = 7,

1080 hipExternalMemoryHandleTypeNvSciBuf = 8

1081} hipExternalMemoryHandleType;

1082typedef struct hipExternalMemoryHandleDesc_st {

1083 hipExternalMemoryHandleType type;

1084 union {

1085 int fd;

1086 struct {

1087 void *handle;

1088 const void *name;

1089 } win32;

1090 const void *nvSciBufObject;

1091 } handle;

1092 unsigned long long size;

1093 unsigned int flags;

1094 unsigned int reserved[16];

1095} hipExternalMemoryHandleDesc;

1096typedef struct hipExternalMemoryBufferDesc_st {

1097 unsigned long long offset;

1098 unsigned long long size;

1099 unsigned int flags;

1100 unsigned int reserved[16];

1101} hipExternalMemoryBufferDesc;

1102typedef struct hipExternalMemoryMipmappedArrayDesc_st {

1103 unsigned long long offset;

1104 hipChannelFormatDesc formatDesc;

1105 hipExtent extent;

1106 unsigned int flags;

1107 unsigned int numLevels;

1108} hipExternalMemoryMipmappedArrayDesc;

1109typedef void* hipExternalMemory_t;

1110typedef enum hipExternalSemaphoreHandleType_enum {

1111 hipExternalSemaphoreHandleTypeOpaqueFd = 1,

1112 hipExternalSemaphoreHandleTypeOpaqueWin32 = 2,

1113 hipExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3,

1114 hipExternalSemaphoreHandleTypeD3D12Fence = 4,

1115 hipExternalSemaphoreHandleTypeD3D11Fence = 5,

1116 hipExternalSemaphoreHandleTypeNvSciSync = 6,

1117 hipExternalSemaphoreHandleTypeKeyedMutex = 7,

1118 hipExternalSemaphoreHandleTypeKeyedMutexKmt = 8,

1119 hipExternalSemaphoreHandleTypeTimelineSemaphoreFd = 9,

1120 hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = 10

1121} hipExternalSemaphoreHandleType;

1122typedef struct hipExternalSemaphoreHandleDesc_st {

1123 hipExternalSemaphoreHandleType type;

1124 union {

1125 int fd;

1126 struct {

1127 void* handle;

1128 const void* name;

1129 } win32;

1130 const void* NvSciSyncObj;

1131 } handle;

1132 unsigned int flags;

1133 unsigned int reserved[16];

1134} hipExternalSemaphoreHandleDesc;

1135typedef void* hipExternalSemaphore_t;

1136typedef struct hipExternalSemaphoreSignalParams_st {

1137 struct {

1138 struct {

1139 unsigned long long value;

1140 } fence;

1141 union {

1142 void *fence;

1143 unsigned long long reserved;

1144 } nvSciSync;

1145 struct {

1146 unsigned long long key;

1147 } keyedMutex;

1148 unsigned int reserved[12];

1149 } params;

1150 unsigned int flags;

1151 unsigned int reserved[16];

1152} hipExternalSemaphoreSignalParams;

1156typedef struct hipExternalSemaphoreWaitParams_st {

1157 struct {

1158 struct {

1159 unsigned long long value;

1160 } fence;

1161 union {

1162 void *fence;

1163 unsigned long long reserved;

1164 } nvSciSync;

1165 struct {

1166 unsigned long long key;

1167 unsigned int timeoutMs;

1168 } keyedMutex;

1169 unsigned int reserved[10];

1170 } params;

1171 unsigned int flags;

1172 unsigned int reserved[16];

1173} hipExternalSemaphoreWaitParams;

1174

1175#if __HIP_HAS_GET_PCH

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

1181#endif

1182

1186typedef enum hipGraphicsRegisterFlags {

1187 hipGraphicsRegisterFlagsNone = 0,

1188 hipGraphicsRegisterFlagsReadOnly = 1,

1189 hipGraphicsRegisterFlagsWriteDiscard =

1190 2,

1191 hipGraphicsRegisterFlagsSurfaceLoadStore = 4,

1192 hipGraphicsRegisterFlagsTextureGather =

1193 8

1194} hipGraphicsRegisterFlags;

1195

1196typedef struct _hipGraphicsResource hipGraphicsResource;

1197

1198typedef hipGraphicsResource* hipGraphicsResource_t;

1199

1203typedef struct ihipGraph* hipGraph_t;

1207typedef struct hipGraphNode* hipGraphNode_t;

1211typedef struct hipGraphExec* hipGraphExec_t;

1212

1216typedef struct hipUserObject* hipUserObject_t;

1217

1218

1222typedef enum hipGraphNodeType {

1223 hipGraphNodeTypeKernel = 0,

1224 hipGraphNodeTypeMemcpy = 1,

1225 hipGraphNodeTypeMemset = 2,

1226 hipGraphNodeTypeHost = 3,

1227 hipGraphNodeTypeGraph = 4,

1228 hipGraphNodeTypeEmpty = 5,

1229 hipGraphNodeTypeWaitEvent = 6,

1230 hipGraphNodeTypeEventRecord = 7,

1231 hipGraphNodeTypeExtSemaphoreSignal = 8,

1232 hipGraphNodeTypeExtSemaphoreWait = 9,

1233 hipGraphNodeTypeMemAlloc = 10,

1234 hipGraphNodeTypeMemFree = 11,

1235 hipGraphNodeTypeMemcpyFromSymbol = 12,

1236 hipGraphNodeTypeMemcpyToSymbol = 13,

1237 hipGraphNodeTypeCount

1238} hipGraphNodeType;

1239

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

1241typedef struct hipHostNodeParams {

1242 hipHostFn_t fn;

1243 void* userData;

1244} hipHostNodeParams;

1245typedef struct hipKernelNodeParams {

1246 dim3 blockDim;

1247 void** extra;

1248 void* func;

1249 dim3 gridDim;

1250 void** kernelParams;

1251 unsigned int sharedMemBytes;

1252} hipKernelNodeParams;

1253typedef struct hipMemsetParams {

1254 void* dst;

1255 unsigned int elementSize;

1256 size_t height;

1257 size_t pitch;

1258 unsigned int value;

1259 size_t width;

1260} hipMemsetParams;

1261

1262typedef struct hipMemAllocNodeParams {

1263 hipMemPoolProps poolProps;

1265 const hipMemAccessDesc* accessDescs;

1267 size_t accessDescCount;

1268 size_t bytesize;

1269 void* dptr;

1270} hipMemAllocNodeParams;

1271

1275typedef enum hipKernelNodeAttrID {

1276 hipKernelNodeAttributeAccessPolicyWindow = 1,

1277 hipKernelNodeAttributeCooperative = 2,

1278} hipKernelNodeAttrID;

1279typedef enum hipAccessProperty {

1280 hipAccessPropertyNormal = 0,

1281 hipAccessPropertyStreaming = 1,

1282 hipAccessPropertyPersisting = 2,

1283} hipAccessProperty;

1284typedef struct hipAccessPolicyWindow {

1285 void* base_ptr;

1286 hipAccessProperty hitProp;

1287 float hitRatio;

1288 hipAccessProperty missProp;

1289 size_t num_bytes;

1290} hipAccessPolicyWindow;

1291typedef union hipKernelNodeAttrValue {

1292 hipAccessPolicyWindow accessPolicyWindow;

1293 int cooperative;

1294} hipKernelNodeAttrValue;

1295

1299typedef struct HIP_MEMSET_NODE_PARAMS {

1300 hipDeviceptr_t dst;

1301 size_t pitch;

1302 unsigned int value;

1303 unsigned int elementSize;

1304 size_t width;

1305 size_t height;

1306} HIP_MEMSET_NODE_PARAMS;

1307

1311typedef enum hipGraphExecUpdateResult {

1312 hipGraphExecUpdateSuccess = 0x0,

1313 hipGraphExecUpdateError = 0x1,

1315 hipGraphExecUpdateErrorTopologyChanged = 0x2,

1316 hipGraphExecUpdateErrorNodeTypeChanged = 0x3,

1317 hipGraphExecUpdateErrorFunctionChanged =

1318 0x4,

1319 hipGraphExecUpdateErrorParametersChanged =

1320 0x5,

1321 hipGraphExecUpdateErrorNotSupported =

1322 0x6,

1323 hipGraphExecUpdateErrorUnsupportedFunctionChange = 0x7

1324} hipGraphExecUpdateResult;

1325

1326typedef enum hipStreamCaptureMode {

1327 hipStreamCaptureModeGlobal = 0,

1328 hipStreamCaptureModeThreadLocal,

1329 hipStreamCaptureModeRelaxed

1330} hipStreamCaptureMode;

1331typedef enum hipStreamCaptureStatus {

1332 hipStreamCaptureStatusNone = 0,

1333 hipStreamCaptureStatusActive,

1334 hipStreamCaptureStatusInvalidated

1336} hipStreamCaptureStatus;

1337

1338typedef enum hipStreamUpdateCaptureDependenciesFlags {

1339 hipStreamAddCaptureDependencies = 0,

1340 hipStreamSetCaptureDependencies,

1341} hipStreamUpdateCaptureDependenciesFlags;

1342

1343typedef enum hipGraphMemAttributeType {

1344 hipGraphMemAttrUsedMemCurrent = 0,

1345 hipGraphMemAttrUsedMemHigh,

1346 hipGraphMemAttrReservedMemCurrent,

1347 hipGraphMemAttrReservedMemHigh,

1348}hipGraphMemAttributeType;

1349typedef enum hipUserObjectFlags {

1350 hipUserObjectNoDestructorSync = 0x1,

1351} hipUserObjectFlags;

1352

1353typedef enum hipUserObjectRetainFlags {

1354 hipGraphUserObjectMove = 0x1,

1355} hipUserObjectRetainFlags;

1356

1357typedef enum hipGraphInstantiateFlags {

1358 hipGraphInstantiateFlagAutoFreeOnLaunch =

1359 1,

1360 hipGraphInstantiateFlagUpload =

1361 2,

1362 hipGraphInstantiateFlagDeviceLaunch =

1363 4,

1364 hipGraphInstantiateFlagUseNodePriority =

1365 8,

1366} hipGraphInstantiateFlags;

1367

1368enum hipGraphDebugDotFlags {

1369 hipGraphDebugDotFlagsVerbose = 1

1370 << 0,

1371 hipGraphDebugDotFlagsKernelNodeParams = 1 << 2,

1372 hipGraphDebugDotFlagsMemcpyNodeParams = 1 << 3,

1373 hipGraphDebugDotFlagsMemsetNodeParams = 1 << 4,

1374 hipGraphDebugDotFlagsHostNodeParams = 1 << 5,

1375 hipGraphDebugDotFlagsEventNodeParams = 1

1376 << 6,

1377 hipGraphDebugDotFlagsExtSemasSignalNodeParams = 1

1378 << 7,

1379 hipGraphDebugDotFlagsExtSemasWaitNodeParams = 1

1380 << 8,

1381 hipGraphDebugDotFlagsKernelNodeAttributes = 1

1382 << 9,

1383 hipGraphDebugDotFlagsHandles = 1

1384 << 10

1385};

1389typedef struct hipMemAllocationProp {

1390 hipMemAllocationType type;

1391 hipMemAllocationHandleType requestedHandleType;

1392 hipMemLocation location;

1393 void* win32HandleMetaData;

1394 struct {

1395 unsigned char compressionType;

1396 unsigned char gpuDirectRDMACapable;

1397 unsigned short usage;

1398 } allocFlags;

1399} hipMemAllocationProp;

1400

1404typedef struct hipExternalSemaphoreSignalNodeParams {

1406 hipExternalSemaphore_t* extSemArray;

1408 const hipExternalSemaphoreSignalParams* paramsArray;

1410 unsigned int numExtSems;

1411} hipExternalSemaphoreSignalNodeParams;

1412

1416typedef struct hipExternalSemaphoreWaitNodeParams {

1418 hipExternalSemaphore_t* extSemArray;

1420 const hipExternalSemaphoreWaitParams* paramsArray;

1422 unsigned int numExtSems;

1423} hipExternalSemaphoreWaitNodeParams;

1424

1428typedef struct ihipMemGenericAllocationHandle* hipMemGenericAllocationHandle_t;

1429

1433typedef enum hipMemAllocationGranularity_flags {

1434 hipMemAllocationGranularityMinimum = 0x0,

1435 hipMemAllocationGranularityRecommended = 0x1

1436} hipMemAllocationGranularity_flags;

1437

1441typedef enum hipMemHandleType {

1442 hipMemHandleTypeGeneric = 0x0

1443} hipMemHandleType;

1444

1448typedef enum hipMemOperationType {

1449 hipMemOperationTypeMap = 0x1,

1450 hipMemOperationTypeUnmap = 0x2

1451} hipMemOperationType;

1452

1456typedef enum hipArraySparseSubresourceType {

1457 hipArraySparseSubresourceTypeSparseLevel = 0x0,

1458 hipArraySparseSubresourceTypeMiptail = 0x1

1459} hipArraySparseSubresourceType;

1460

1464typedef struct hipArrayMapInfo {

1465 hipResourceType resourceType;

1466 union {

1467 hipMipmappedArray mipmap;

1468 hipArray_t array;

1469 } resource;

1470 hipArraySparseSubresourceType subresourceType;

1471 union {

1472 struct {

1473 unsigned int level;

1474 unsigned int layer;

1475 unsigned int offsetX;

1476 unsigned int offsetY;

1477 unsigned int offsetZ;

1478 unsigned int extentWidth;

1479 unsigned int extentHeight;

1480 unsigned int extentDepth;

1481 } sparseLevel;

1482 struct {

1483 unsigned int layer;

1484 unsigned long long offset;

1485 unsigned long long size;

1486 } miptail;

1487 } subresource;

1488 hipMemOperationType memOperationType;

1489 hipMemHandleType memHandleType;

1490 union {

1491 hipMemGenericAllocationHandle_t memHandle;

1492 } memHandle;

1493 unsigned long long offset;

1494 unsigned int deviceBitMask;

1495 unsigned int flags;

1496 unsigned int reserved[2];

1497} hipArrayMapInfo;

1498// Doxygen end group GlobalDefs

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

1525hipError_t hipInit(unsigned int flags);

1541hipError_t hipDriverGetVersion(int* driverVersion);

1556hipError_t hipRuntimeGetVersion(int* runtimeVersion);

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

1565

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

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

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

1605hipError_t hipDeviceGetP2PAttribute(int* value, hipDeviceP2PAttr attr,

1606 int srcDevice, int dstDevice);

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

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

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

1632// doxygen end initialization

1651hipError_t hipDeviceSynchronize(void);

1663hipError_t hipDeviceReset(void);

1695hipError_t hipSetDevice(int deviceId);

1709hipError_t hipGetDevice(int* deviceId);

1722hipError_t hipGetDeviceCount(int* count);

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

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

1769hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool);

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

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

1815hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig);

1826hipError_t hipDeviceGetCacheConfig(hipFuncCache_t* cacheConfig);

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

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

1872hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig* pConfig);

1880hipError_t hipGetDeviceFlags(unsigned int* flags);

1892hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config);

1917hipError_t hipSetDeviceFlags(unsigned flags);

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

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

1940// TODO: implement IPC apis

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

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

2028hipError_t hipIpcCloseMemHandle(void* devPtr);

2029

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

2047

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

2066

2067// end doxygen Device

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

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

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

2117//doxygen end execution

2139hipError_t hipGetLastError(void);

2140

2152hipError_t hipExtGetLastError(void);

2153

2164hipError_t hipPeekAtLastError(void);

2173const char* hipGetErrorName(hipError_t hip_error);

2182const char* hipGetErrorString(hipError_t hipError);

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

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

2203// end doxygen Error

2233hipError_t hipStreamCreate(hipStream_t* stream);

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

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

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

2301hipError_t hipStreamDestroy(hipStream_t stream);

2317hipError_t hipStreamQuery(hipStream_t stream);

2337hipError_t hipStreamSynchronize(hipStream_t stream);

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

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

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

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

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

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

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

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

2450 unsigned int flags);

2451// end doxygen Stream

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

2495 uint32_t mask __dparm(0xFFFFFFFF));

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

2529 uint64_t mask __dparm(0xFFFFFFFFFFFFFFFF));

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

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

2570// end doxygen Stream Memory Operations

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

2618hipError_t hipEventCreate(hipEvent_t* event);

2646#ifdef __cplusplus

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

2648#else

2649hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream);

2650#endif

2667hipError_t hipEventDestroy(hipEvent_t event);

2685hipError_t hipEventSynchronize(hipEvent_t event);

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

2730hipError_t hipEventQuery(hipEvent_t event);

2731// end doxygen Events

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

2763 hipDeviceptr_t ptr);

2764

2765

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

2798hipError_t hipPointerGetAttribute(void* data, hipPointer_attribute attribute,

2799 hipDeviceptr_t ptr);

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

2817 void** data, hipDeviceptr_t ptr);

2838hipError_t hipImportExternalSemaphore(hipExternalSemaphore_t* extSem_out,

2839 const hipExternalSemaphoreHandleDesc* semHandleDesc);

2852hipError_t hipSignalExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

2853 const hipExternalSemaphoreSignalParams* paramsArray,

2854 unsigned int numExtSems, hipStream_t stream);

2867hipError_t hipWaitExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

2868 const hipExternalSemaphoreWaitParams* paramsArray,

2869 unsigned int numExtSems, hipStream_t stream);

2879hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem);

2880

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

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

2913hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem);

2927hipError_t hipExternalMemoryGetMappedMipmappedArray(hipMipmappedArray_t* mipmap, hipExternalMemory_t extMem,

2928 const hipExternalMemoryMipmappedArrayDesc* mipmapDesc);

2929 // end of external resource

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

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

2979DEPRECATED("use hipHostMalloc instead")

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

2993DEPRECATED("use hipHostMalloc instead")

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

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

3059hipError_t hipMallocManaged(void** dev_ptr,

3060 size_t size,

3061 unsigned int flags __dparm(hipMemAttachGlobal));

3074hipError_t hipMemPrefetchAsync(const void* dev_ptr,

3075 size_t count,

3076 int device,

3077 hipStream_t stream __dparm(0));

3097hipError_t hipMemAdvise(const void* dev_ptr,

3098 size_t count,

3099 hipMemoryAdvise advice,

3100 int device);

3115hipError_t hipMemRangeGetAttribute(void* data,

3116 size_t data_size,

3117 hipMemRangeAttribute attribute,

3118 const void* dev_ptr,

3119 size_t count);

3136hipError_t hipMemRangeGetAttributes(void** data,

3137 size_t* data_sizes,

3138 hipMemRangeAttribute* attributes,

3139 size_t num_attributes,

3140 const void* dev_ptr,

3141 size_t count);

3156hipError_t hipStreamAttachMemAsync(hipStream_t stream,

3157 void* dev_ptr,

3158 size_t length __dparm(0),

3159 unsigned int flags __dparm(hipMemAttachSingle));

3160// end doxygen Managed Memory

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

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

3273hipError_t hipMemPoolTrimTo(hipMemPool_t mem_pool, size_t min_bytes_to_hold);

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

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

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

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

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

3440hipError_t hipMemPoolDestroy(hipMemPool_t mem_pool);

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

3501hipError_t hipMemPoolExportToShareableHandle(

3502 void* shared_handle,

3503 hipMemPool_t mem_pool,

3504 hipMemAllocationHandleType handle_type,

3505 unsigned int flags);

3529hipError_t hipMemPoolImportFromShareableHandle(

3530 hipMemPool_t* mem_pool,

3531 void* shared_handle,

3532 hipMemAllocationHandleType handle_type,

3533 unsigned int flags);

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

3582hipError_t hipMemPoolImportPointer(

3583 void** dev_ptr,

3584 hipMemPool_t mem_pool,

3585 hipMemPoolPtrExportData* export_data);

3586// Doxygen end of ordered memory allocator

3604DEPRECATED("use hipHostMalloc instead")

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

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

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

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

3673hipError_t hipHostUnregister(void* hostPtr);

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

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

3715 unsigned int elementSizeBytes);

3729hipError_t hipFree(void* ptr);

3740DEPRECATED("use hipHostFree instead")

3741hipError_t hipFreeHost(void* ptr);

3755hipError_t hipHostFree(void* ptr);

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

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

3801 hipMemcpyKind kind, hipStream_t stream);

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

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

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

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

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

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

3910 hipStream_t stream);

3911

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

3927 hipModule_t hmod, const char* name);

3928

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

3939

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

3950

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

3970 size_t sizeBytes, size_t offset __dparm(0),

3971 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice));

3972

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

3987 size_t sizeBytes, size_t offset,

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

3989

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

4003 size_t sizeBytes, size_t offset __dparm(0),

4004 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost));

4005

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

4020 size_t sizeBytes, size_t offset,

4021 hipMemcpyKind kind,

4022 hipStream_t stream __dparm(0));

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

4052 hipStream_t stream __dparm(0));

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

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

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

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

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

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

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

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

4157 hipStream_t stream __dparm(0));

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

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

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

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

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

4217

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

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

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

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

4264hipError_t hipArrayDestroy(hipArray_t array);

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

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

4295hipError_t hipFreeArray(hipArray_t array);

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

4308 struct hipExtent extent, unsigned int flags);

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

4322 hipArray_t array);

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

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

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

4376 size_t height, hipMemcpyKind kind);

4386hipError_t hipMemcpyParam2D(const hip_Memcpy2D* pCopy);

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

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

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

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

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

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

4455 size_t spitch, size_t width, size_t height, hipMemcpyKind kind,

4456 hipStream_t stream __dparm(0));

4473DEPRECATED(DEPRECATED_MSG)

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

4475 size_t count, hipMemcpyKind kind);

4492DEPRECATED(DEPRECATED_MSG)

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

4494 size_t count, hipMemcpyKind kind);

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

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

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

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

4570hipError_t hipMemcpy3D(const struct hipMemcpy3DParms* p);

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

4593hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D* pCopy);

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

4606// doxygen end Memory

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

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

4663hipError_t hipDeviceDisablePeerAccess(int peerDeviceId);

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

4677#ifndef USE_PEER_NON_UNIFIED

4678#define USE_PEER_NON_UNIFIED 1

4679#endif

4680#if USE_PEER_NON_UNIFIED == 1

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

4693 size_t sizeBytes);

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

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

4708#endif

4709// doxygen end PeerToPeer

4741DEPRECATED(DEPRECATED_MSG)

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

4755DEPRECATED(DEPRECATED_MSG)

4756hipError_t hipCtxDestroy(hipCtx_t ctx);

4769DEPRECATED(DEPRECATED_MSG)

4770hipError_t hipCtxPopCurrent(hipCtx_t* ctx);

4783DEPRECATED(DEPRECATED_MSG)

4784hipError_t hipCtxPushCurrent(hipCtx_t ctx);

4797DEPRECATED(DEPRECATED_MSG)

4798hipError_t hipCtxSetCurrent(hipCtx_t ctx);

4811DEPRECATED(DEPRECATED_MSG)

4812hipError_t hipCtxGetCurrent(hipCtx_t* ctx);

4825DEPRECATED(DEPRECATED_MSG)

4826hipError_t hipCtxGetDevice(hipDevice_t* device);

4846DEPRECATED(DEPRECATED_MSG)

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

4863DEPRECATED(DEPRECATED_MSG)

4864hipError_t hipCtxGetCacheConfig(hipFuncCache_t* cacheConfig);

4880DEPRECATED(DEPRECATED_MSG)

4881hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig);

4897DEPRECATED(DEPRECATED_MSG)

4898hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config);

4914DEPRECATED(DEPRECATED_MSG)

4915hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig* pConfig);

4929DEPRECATED(DEPRECATED_MSG)

4930hipError_t hipCtxSynchronize(void);

4943DEPRECATED(DEPRECATED_MSG)

4944hipError_t hipCtxGetFlags(unsigned int* flags);

4966DEPRECATED(DEPRECATED_MSG)

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

4986DEPRECATED(DEPRECATED_MSG)

4987hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx);

4988// doxygen end Context deprecated

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

5017hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev);

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

5041hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev);

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

5054// doxygen end Context Management

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

5091hipError_t hipModuleUnload(hipModule_t module);

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

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

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

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

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

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

5155 hipJitOption* options, void** optionValues);

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

5185 unsigned int gridDimZ, unsigned int blockDimX,

5186 unsigned int blockDimY, unsigned int blockDimZ,

5187 unsigned int sharedMemBytes, hipStream_t stream,

5188 void** kernelParams, void** extra);

5214hipError_t hipModuleLaunchCooperativeKernel(hipFunction_t f, unsigned int gridDimX,

5215 unsigned int gridDimY, unsigned int gridDimZ,

5216 unsigned int blockDimX, unsigned int blockDimY,

5217 unsigned int blockDimZ, unsigned int sharedMemBytes,

5218 hipStream_t stream, void** kernelParams);

5233hipError_t hipModuleLaunchCooperativeKernelMultiDevice(hipFunctionLaunchParams* launchParamsList,

5234 unsigned int numDevices,

5235 unsigned int flags);

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

5255 void** kernelParams, unsigned int sharedMemBytes,

5256 hipStream_t stream);

5267hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

5268 int numDevices, unsigned int flags);

5280hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

5281 int numDevices, unsigned int flags);

5282// doxygen end Module

5309//TODO - Match CUoccupancyB2DSize

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

5311 hipFunction_t f, size_t dynSharedMemPerBlk,

5312 int blockSizeLimit);

5328//TODO - Match CUoccupancyB2DSize

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

5330 hipFunction_t f, size_t dynSharedMemPerBlk,

5331 int blockSizeLimit, unsigned int flags);

5342hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(

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

5354hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

5366hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(

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

5378hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

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

5395 const void* f, size_t dynSharedMemPerBlk,

5396 int blockSizeLimit);

5397// doxygen end Occupancy

5411// TODO - expand descriptions:

5418DEPRECATED("use roctracer/rocTX instead")

5419hipError_t hipProfilerStart();

5426DEPRECATED("use roctracer/rocTX instead")

5427hipError_t hipProfilerStop();

5428// doxygen end profiler

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

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

5475hipError_t hipLaunchByPtr(const void* func);

5492hipError_t __hipPushCallConfiguration(dim3 gridDim,

5493 dim3 blockDim,

5494 size_t sharedMem __dparm(0),

5495 hipStream_t stream __dparm(0));

5515hipError_t __hipPopCallConfiguration(dim3 *gridDim,

5516 dim3 *blockDim,

5517 size_t *sharedMem,

5518 hipStream_t *stream);

5534hipError_t hipLaunchKernel(const void* function_address,

5535 dim3 numBlocks,

5536 dim3 dimBlocks,

5537 void** args,

5538 size_t sharedMemBytes __dparm(0),

5539 hipStream_t stream __dparm(0));

5540

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

5553

5561hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D* pCopy);

5562//TODO: Move this to hip_ext.h

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

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

5585 hipEvent_t startEvent, hipEvent_t stopEvent, int flags);

5586// doxygen end Clang launch

5612hipError_t hipCreateTextureObject(

5613 hipTextureObject_t* pTexObject,

5614 const hipResourceDesc* pResDesc,

5615 const hipTextureDesc* pTexDesc,

5616 const struct hipResourceViewDesc* pResViewDesc);

5617

5626hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject);

5627

5637hipError_t hipGetChannelDesc(

5638 hipChannelFormatDesc* desc,

5639 hipArray_const_t array);

5640

5650hipError_t hipGetTextureObjectResourceDesc(

5651 hipResourceDesc* pResDesc,

5652 hipTextureObject_t textureObject);

5653

5663hipError_t hipGetTextureObjectResourceViewDesc(

5664 struct hipResourceViewDesc* pResViewDesc,

5665 hipTextureObject_t textureObject);

5666

5676hipError_t hipGetTextureObjectTextureDesc(

5677 hipTextureDesc* pTexDesc,

5678 hipTextureObject_t textureObject);

5679

5691hipError_t hipTexObjectCreate(

5692 hipTextureObject_t* pTexObject,

5693 const HIP_RESOURCE_DESC* pResDesc,

5694 const HIP_TEXTURE_DESC* pTexDesc,

5695 const HIP_RESOURCE_VIEW_DESC* pResViewDesc);

5696

5705hipError_t hipTexObjectDestroy(

5706 hipTextureObject_t texObject);

5707

5717hipError_t hipTexObjectGetResourceDesc(

5718 HIP_RESOURCE_DESC* pResDesc,

5719 hipTextureObject_t texObject);

5720

5730hipError_t hipTexObjectGetResourceViewDesc(

5731 HIP_RESOURCE_VIEW_DESC* pResViewDesc,

5732 hipTextureObject_t texObject);

5733

5743hipError_t hipTexObjectGetTextureDesc(

5744 HIP_TEXTURE_DESC* pTexDesc,

5745 hipTextureObject_t texObject);

5746

5761hipError_t hipMallocMipmappedArray(

5762 hipMipmappedArray_t *mipmappedArray,

5763 const struct hipChannelFormatDesc* desc,

5764 struct hipExtent extent,

5765 unsigned int numLevels,

5766 unsigned int flags __dparm(0));

5767

5778hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray);

5779

5792hipError_t hipGetMipmappedArrayLevel(

5793 hipArray_t *levelArray,

5794 hipMipmappedArray_const_t mipmappedArray,

5795 unsigned int level);

5796

5808hipError_t hipMipmappedArrayCreate(

5809 hipMipmappedArray_t* pHandle,

5810 HIP_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc,

5811 unsigned int numMipmapLevels);

5812

5823hipError_t hipMipmappedArrayDestroy(hipMipmappedArray_t hMipmappedArray);

5824

5837hipError_t hipMipmappedArrayGetLevel(

5838 hipArray_t* pLevelArray,

5839 hipMipmappedArray_t hMipMappedArray,

5840 unsigned int level);

5841

5860DEPRECATED(DEPRECATED_MSG)

5861hipError_t hipBindTextureToMipmappedArray(

5862 const textureReference* tex,

5863 hipMipmappedArray_const_t mipmappedArray,

5864 const hipChannelFormatDesc* desc);

5865

5876DEPRECATED(DEPRECATED_MSG)

5877hipError_t hipGetTextureReference(

5878 const textureReference** texref,

5879 const void* symbol);

5891DEPRECATED(DEPRECATED_MSG)

5892hipError_t hipTexRefSetAddressMode(

5893 textureReference* texRef,

5894 int dim,

5895 enum hipTextureAddressMode am);

5908DEPRECATED(DEPRECATED_MSG)

5909hipError_t hipTexRefSetArray(

5910 textureReference* tex,

5911 hipArray_const_t array,

5912 unsigned int flags);

5924DEPRECATED(DEPRECATED_MSG)

5925hipError_t hipTexRefSetFilterMode(

5926 textureReference* texRef,

5927 enum hipTextureFilterMode fm);

5939DEPRECATED(DEPRECATED_MSG)

5940hipError_t hipTexRefSetFlags(

5941 textureReference* texRef,

5942 unsigned int Flags);

5955DEPRECATED(DEPRECATED_MSG)

5956hipError_t hipTexRefSetFormat(

5957 textureReference* texRef,

5958 hipArray_Format fmt,

5959 int NumPackedComponents);

5974DEPRECATED(DEPRECATED_MSG)

5975hipError_t hipBindTexture(

5976 size_t* offset,

5977 const textureReference* tex,

5978 const void* devPtr,

5979 const hipChannelFormatDesc* desc,

5980 size_t size __dparm(UINT_MAX));

5997DEPRECATED(DEPRECATED_MSG)

5998hipError_t hipBindTexture2D(

5999 size_t* offset,

6000 const textureReference* tex,

6001 const void* devPtr,

6002 const hipChannelFormatDesc* desc,

6003 size_t width,

6004 size_t height,

6005 size_t pitch);

6018DEPRECATED(DEPRECATED_MSG)

6019hipError_t hipBindTextureToArray(

6020 const textureReference* tex,

6021 hipArray_const_t array,

6022 const hipChannelFormatDesc* desc);

6034DEPRECATED(DEPRECATED_MSG)

6035hipError_t hipGetTextureAlignmentOffset(

6036 size_t* offset,

6037 const textureReference* texref);

6048DEPRECATED(DEPRECATED_MSG)

6049hipError_t hipUnbindTexture(const textureReference* tex);

6061DEPRECATED(DEPRECATED_MSG)

6062hipError_t hipTexRefGetAddress(

6063 hipDeviceptr_t* dev_ptr,

6064 const textureReference* texRef);

6077DEPRECATED(DEPRECATED_MSG)

6078hipError_t hipTexRefGetAddressMode(

6079 enum hipTextureAddressMode* pam,

6080 const textureReference* texRef,

6081 int dim);

6093DEPRECATED(DEPRECATED_MSG)

6094hipError_t hipTexRefGetFilterMode(

6095 enum hipTextureFilterMode* pfm,

6096 const textureReference* texRef);

6108DEPRECATED(DEPRECATED_MSG)

6109hipError_t hipTexRefGetFlags(

6110 unsigned int* pFlags,

6111 const textureReference* texRef);

6124DEPRECATED(DEPRECATED_MSG)

6125hipError_t hipTexRefGetFormat(

6126 hipArray_Format* pFormat,

6127 int* pNumChannels,

6128 const textureReference* texRef);

6140DEPRECATED(DEPRECATED_MSG)

6141hipError_t hipTexRefGetMaxAnisotropy(

6142 int* pmaxAnsio,

6143 const textureReference* texRef);

6155DEPRECATED(DEPRECATED_MSG)

6156hipError_t hipTexRefGetMipmapFilterMode(

6157 enum hipTextureFilterMode* pfm,

6158 const textureReference* texRef);

6170DEPRECATED(DEPRECATED_MSG)

6171hipError_t hipTexRefGetMipmapLevelBias(

6172 float* pbias,

6173 const textureReference* texRef);

6186DEPRECATED(DEPRECATED_MSG)

6187hipError_t hipTexRefGetMipmapLevelClamp(

6188 float* pminMipmapLevelClamp,

6189 float* pmaxMipmapLevelClamp,

6190 const textureReference* texRef);

6202DEPRECATED(DEPRECATED_MSG)

6203hipError_t hipTexRefGetMipMappedArray(

6204 hipMipmappedArray_t* pArray,

6205 const textureReference* texRef);

6219DEPRECATED(DEPRECATED_MSG)

6220hipError_t hipTexRefSetAddress(

6221 size_t* ByteOffset,

6222 textureReference* texRef,

6223 hipDeviceptr_t dptr,

6224 size_t bytes);

6238DEPRECATED(DEPRECATED_MSG)

6239hipError_t hipTexRefSetAddress2D(

6240 textureReference* texRef,

6241 const HIP_ARRAY_DESCRIPTOR* desc,

6242 hipDeviceptr_t dptr,

6243 size_t Pitch);

6255DEPRECATED(DEPRECATED_MSG)

6256hipError_t hipTexRefSetMaxAnisotropy(

6257 textureReference* texRef,

6258 unsigned int maxAniso);

6270DEPRECATED(DEPRECATED_MSG)

6271hipError_t hipTexRefSetBorderColor(

6272 textureReference* texRef,

6273 float* pBorderColor);

6285DEPRECATED(DEPRECATED_MSG)

6286hipError_t hipTexRefSetMipmapFilterMode(

6287 textureReference* texRef,

6288 enum hipTextureFilterMode fm);

6300DEPRECATED(DEPRECATED_MSG)

6301hipError_t hipTexRefSetMipmapLevelBias(

6302 textureReference* texRef,

6303 float bias);

6316DEPRECATED(DEPRECATED_MSG)

6317hipError_t hipTexRefSetMipmapLevelClamp(

6318 textureReference* texRef,

6319 float minMipMapLevelClamp,

6320 float maxMipMapLevelClamp);

6333DEPRECATED(DEPRECATED_MSG)

6334hipError_t hipTexRefSetMipmappedArray(

6335 textureReference* texRef,

6336 struct hipMipmappedArray* mipmappedArray,

6337 unsigned int Flags);

6338

6339// doxygen end deprecated texture management

6344// doxygen end Texture management

6356// This group is for HIPrtc

6357

6358// doxygen end Runtime

6377const char* hipApiName(uint32_t id);

6386const char* hipKernelNameRef(const hipFunction_t f);

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

6405int hipGetStreamDeviceId(hipStream_t stream);

6406

6407// doxygen end Callback

6432hipError_t hipStreamBeginCapture(hipStream_t stream, hipStreamCaptureMode mode);

6433

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

6447

6461hipError_t hipStreamGetCaptureInfo(hipStream_t stream, hipStreamCaptureStatus* pCaptureStatus,

6462 unsigned long long* pId);

6463

6480hipError_t hipStreamGetCaptureInfo_v2(hipStream_t stream, hipStreamCaptureStatus* captureStatus_out,

6481 unsigned long long* id_out __dparm(0),

6482 hipGraph_t* graph_out __dparm(0),

6483 const hipGraphNode_t** dependencies_out __dparm(0),

6484 size_t* numDependencies_out __dparm(0));

6485

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

6499

6512hipError_t hipStreamUpdateCaptureDependencies(hipStream_t stream, hipGraphNode_t* dependencies,

6513 size_t numDependencies,

6514 unsigned int flags __dparm(0));

6515

6526hipError_t hipThreadExchangeStreamCaptureMode(hipStreamCaptureMode* mode);

6527

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

6541

6553hipError_t hipGraphDestroy(hipGraph_t graph);

6554

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

6569 const hipGraphNode_t* to, size_t numDependencies);

6570

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

6585 const hipGraphNode_t* to, size_t numDependencies);

6586

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

6605 size_t* numEdges);

6606

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

6624

6641hipError_t hipGraphGetRootNodes(hipGraph_t graph, hipGraphNode_t* pRootNodes,

6642 size_t* pNumRootNodes);

6643

6660hipError_t hipGraphNodeGetDependencies(hipGraphNode_t node, hipGraphNode_t* pDependencies,

6661 size_t* pNumDependencies);

6662

6680hipError_t hipGraphNodeGetDependentNodes(hipGraphNode_t node, hipGraphNode_t* pDependentNodes,

6681 size_t* pNumDependentNodes);

6682

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

6695

6706hipError_t hipGraphDestroyNode(hipGraphNode_t node);

6707

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

6720

6733hipError_t hipGraphNodeFindInClone(hipGraphNode_t* pNode, hipGraphNode_t originalNode,

6734 hipGraph_t clonedGraph);

6735

6752hipError_t hipGraphInstantiate(hipGraphExec_t* pGraphExec, hipGraph_t graph,

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

6754

6767hipError_t hipGraphInstantiateWithFlags(hipGraphExec_t* pGraphExec, hipGraph_t graph,

6768 unsigned long long flags);

6769

6780hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream);

6781

6792hipError_t hipGraphUpload(hipGraphExec_t graphExec, hipStream_t stream);

6793

6804hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec);

6805

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

6820hipError_t hipGraphExecUpdate(hipGraphExec_t hGraphExec, hipGraph_t hGraph,

6821 hipGraphNode_t* hErrorNode_out,

6822 hipGraphExecUpdateResult* updateResult_out);

6823

6836hipError_t hipGraphAddKernelNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

6837 const hipGraphNode_t* pDependencies, size_t numDependencies,

6838 const hipKernelNodeParams* pNodeParams);

6839

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

6850

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

6861

6872hipError_t hipGraphExecKernelNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

6873 const hipKernelNodeParams* pNodeParams);

6874

6888hipError_t hipDrvGraphAddMemcpyNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

6889 const hipGraphNode_t* dependencies,

6890 size_t numDependencies,

6891 const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);

6904hipError_t hipGraphAddMemcpyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

6905 const hipGraphNode_t* pDependencies, size_t numDependencies,

6906 const hipMemcpy3DParms* pCopyParams);

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

6917

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

6928

6939hipError_t hipGraphKernelNodeSetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

6940 const hipKernelNodeAttrValue* value);

6951hipError_t hipGraphKernelNodeGetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

6952 hipKernelNodeAttrValue* value);

6963hipError_t hipGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

6964 hipMemcpy3DParms* pNodeParams);

6965

6981hipError_t hipGraphAddMemcpyNode1D(hipGraphNode_t* pGraphNode, hipGraph_t graph,

6982 const hipGraphNode_t* pDependencies, size_t numDependencies,

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

6984

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

6998 size_t count, hipMemcpyKind kind);

6999

7014hipError_t hipGraphExecMemcpyNodeSetParams1D(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

7016 hipMemcpyKind kind);

7017

7034hipError_t hipGraphAddMemcpyNodeFromSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7035 const hipGraphNode_t* pDependencies,

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

7037 size_t count, size_t offset, hipMemcpyKind kind);

7038

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

7053 size_t count, size_t offset, hipMemcpyKind kind);

7054

7070hipError_t hipGraphExecMemcpyNodeSetParamsFromSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

7072 size_t offset, hipMemcpyKind kind);

7073

7090hipError_t hipGraphAddMemcpyNodeToSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7091 const hipGraphNode_t* pDependencies,

7092 size_t numDependencies, const void* symbol,

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

7094 hipMemcpyKind kind);

7095

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

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

7111 hipMemcpyKind kind);

7112

7113

7128hipError_t hipGraphExecMemcpyNodeSetParamsToSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7129 const void* symbol, const void* src,

7130 size_t count, size_t offset, hipMemcpyKind kind);

7131

7144hipError_t hipGraphAddMemsetNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7145 const hipGraphNode_t* pDependencies, size_t numDependencies,

7146 const hipMemsetParams* pMemsetParams);

7147

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

7158

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

7169

7180hipError_t hipGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7181 const hipMemsetParams* pNodeParams);

7182

7195hipError_t hipGraphAddHostNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7196 const hipGraphNode_t* pDependencies, size_t numDependencies,

7197 const hipHostNodeParams* pNodeParams);

7198

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

7209

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

7220

7231hipError_t hipGraphExecHostNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7232 const hipHostNodeParams* pNodeParams);

7233

7246hipError_t hipGraphAddChildGraphNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7247 const hipGraphNode_t* pDependencies, size_t numDependencies,

7248 hipGraph_t childGraph);

7249

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

7260

7271hipError_t hipGraphExecChildGraphNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7272 hipGraph_t childGraph);

7273

7285hipError_t hipGraphAddEmptyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7286 const hipGraphNode_t* pDependencies, size_t numDependencies);

7287

7288

7301hipError_t hipGraphAddEventRecordNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7302 const hipGraphNode_t* pDependencies, size_t numDependencies,

7303 hipEvent_t event);

7304

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

7315

7325hipError_t hipGraphEventRecordNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

7326

7337hipError_t hipGraphExecEventRecordNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

7338 hipEvent_t event);

7339

7352hipError_t hipGraphAddEventWaitNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7353 const hipGraphNode_t* pDependencies, size_t numDependencies,

7354 hipEvent_t event);

7355

7356

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

7367

7377hipError_t hipGraphEventWaitNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

7378

7389hipError_t hipGraphExecEventWaitNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

7390 hipEvent_t event);

7391

7404hipError_t hipGraphAddMemAllocNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

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

7406

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

7417

7430hipError_t hipGraphAddMemFreeNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

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

7432

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

7443

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

7455

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

7467

7477hipError_t hipDeviceGraphMemTrim(int device);

7478

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

7492 unsigned int initialRefcount, unsigned int flags);

7493

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

7504

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

7515

7527hipError_t hipGraphRetainUserObject(hipGraph_t graph, hipUserObject_t object,

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

7529

7540hipError_t hipGraphReleaseUserObject(hipGraph_t graph, hipUserObject_t object,

7541 unsigned int count __dparm(1));

7542

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

7554

7569hipError_t hipGraphKernelNodeCopyAttributes(hipGraphNode_t hSrc, hipGraphNode_t hDst);

7570

7593hipError_t hipGraphNodeSetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

7594 unsigned int isEnabled);

7615hipError_t hipGraphNodeGetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

7616 unsigned int* isEnabled);

7617

7630hipError_t hipGraphAddExternalSemaphoresWaitNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7631 const hipGraphNode_t* pDependencies, size_t numDependencies,

7632 const hipExternalSemaphoreWaitNodeParams* nodeParams);

7633

7646hipError_t hipGraphAddExternalSemaphoresSignalNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7647 const hipGraphNode_t* pDependencies, size_t numDependencies,

7648 const hipExternalSemaphoreSignalNodeParams* nodeParams);

7658hipError_t hipGraphExternalSemaphoresSignalNodeSetParams(hipGraphNode_t hNode,

7659 const hipExternalSemaphoreSignalNodeParams* nodeParams);

7669hipError_t hipGraphExternalSemaphoresWaitNodeSetParams(hipGraphNode_t hNode,

7670 const hipExternalSemaphoreWaitNodeParams* nodeParams);

7680hipError_t hipGraphExternalSemaphoresSignalNodeGetParams(hipGraphNode_t hNode,

7681 hipExternalSemaphoreSignalNodeParams* params_out);

7691hipError_t hipGraphExternalSemaphoresWaitNodeGetParams(hipGraphNode_t hNode,

7692 hipExternalSemaphoreWaitNodeParams* params_out);

7703hipError_t hipGraphExecExternalSemaphoresSignalNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

7704 const hipExternalSemaphoreSignalNodeParams* nodeParams);

7715hipError_t hipGraphExecExternalSemaphoresWaitNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

7716 const hipExternalSemaphoreWaitNodeParams* nodeParams);

7717

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

7728

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

7739

7753hipError_t hipDrvGraphAddMemsetNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

7754 const hipGraphNode_t* dependencies, size_t numDependencies,

7755 const HIP_MEMSET_NODE_PARAMS* memsetParams, hipCtx_t ctx);

7756

7757// doxygen end graph API

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

7786

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

7802

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

7817

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

7832

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

7846

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

7861

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

7874

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

7888

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

7904

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

7918

7929hipError_t hipMemRelease(hipMemGenericAllocationHandle_t handle);

7930

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

7943

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

7958

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

7971

7972// doxygen end virtual memory management API

7994hipError_t hipGraphicsMapResources(int count, hipGraphicsResource_t* resources,

7995 hipStream_t stream __dparm(0) );

8009hipError_t hipGraphicsSubResourceGetMappedArray(hipArray_t* array, hipGraphicsResource_t resource,

8010 unsigned int arrayIndex, unsigned int mipLevel);

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

8022 hipGraphicsResource_t resource);

8033hipError_t hipGraphicsUnmapResources(int count, hipGraphicsResource_t* resources,

8034 hipStream_t stream __dparm(0));

8043hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource);

8044// doxygen end GL Interop

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

8078hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject);

8079// end of surface

8083#ifdef __cplusplus

8084} /* extern "c" */

8085#endif

8086#ifdef __cplusplus

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

8088template <typename T>

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

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

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

8092}

8093template <typename T>

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

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

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

8097}

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

8099

8109template <typename T>

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

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

8112}

8123template <typename T>

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

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

8126}

8127

8136template <typename T>

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

8138 size_t offset __dparm(0),

8139 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice)) {

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

8141}

8150template <typename T>

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

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

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

8154}

8162template <typename T>

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

8164 size_t sizeBytes, size_t offset __dparm(0),

8165 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost)) {

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

8167}

8175template <typename T>

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

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

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

8179}

8180

8192template <class T>

8193inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(

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

8195 return hipOccupancyMaxActiveBlocksPerMultiprocessor(

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

8197}

8211template <class T>

8212inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

8214 return hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

8216}

8237template<typename UnaryFunction, class T>

8238static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(

8239 int* min_grid_size,

8240 int* block_size,

8241 T func,

8242 UnaryFunction block_size_to_dynamic_smem_size,

8243 int block_size_limit = 0,

8244 unsigned int flags = 0) {

8245 if (min_grid_size == nullptr || block_size == nullptr ||

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

8247 return hipErrorInvalidValue;

8248 }

8249

8250 int dev;

8251 hipError_t status;

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

8253 return status;

8254 }

8255

8256 int max_threads_per_cu;

8257 if ((status = hipDeviceGetAttribute(&max_threads_per_cu,

8258 hipDeviceAttributeMaxThreadsPerMultiProcessor, dev)) != hipSuccess) {

8259 return status;

8260 }

8261

8262 int warp_size;

8263 if ((status = hipDeviceGetAttribute(&warp_size,

8264 hipDeviceAttributeWarpSize, dev)) != hipSuccess) {

8265 return status;

8266 }

8267

8268 int max_cu_count;

8269 if ((status = hipDeviceGetAttribute(&max_cu_count,

8270 hipDeviceAttributeMultiprocessorCount, dev)) != hipSuccess) {

8271 return status;

8272 }

8273

8274 struct hipFuncAttributes attr;

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

8276 return status;

8277 }

8278

8279 // Initial limits for the execution

8280 const int func_max_threads_per_block = attr.maxThreadsPerBlock;

8281 if (block_size_limit == 0) {

8282 block_size_limit = func_max_threads_per_block;

8283 }

8284

8285 if (func_max_threads_per_block < block_size_limit) {

8286 block_size_limit = func_max_threads_per_block;

8287 }

8288

8289 const int block_size_limit_aligned =

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

8291

8292 // For maximum search

8293 int max_threads = 0;

8294 int max_block_size{};

8295 int max_num_blocks{};

8296 for (int block_size_check_aligned = block_size_limit_aligned;

8297 block_size_check_aligned > 0;

8298 block_size_check_aligned -= warp_size) {

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

8300 int block_size_check = (block_size_limit < block_size_check_aligned) ?

8301 block_size_limit : block_size_check_aligned;

8302

8303 size_t dyn_smem_size = block_size_to_dynamic_smem_size(block_size_check);

8304 int optimal_blocks;

8305 if ((status = hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

8307 return status;

8308 }

8309

8310 int total_threads = block_size_check * optimal_blocks;

8311 if (total_threads > max_threads) {

8312 max_block_size = block_size_check;

8313 max_num_blocks = optimal_blocks;

8314 max_threads = total_threads;

8315 }

8316

8317 // Break if the logic reached possible maximum

8318 if (max_threads_per_cu == max_threads) {

8319 break;

8320 }

8321 }

8322

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

8324 *min_grid_size = max_num_blocks * max_cu_count;

8325 *block_size = max_block_size;

8326

8327 return status;

8328}

8329

8349template<typename UnaryFunction, class T>

8350static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMem(

8351 int* min_grid_size,

8352 int* block_size,

8353 T func,

8354 UnaryFunction block_size_to_dynamic_smem_size,

8355 int block_size_limit = 0)

8356{

8357 return hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(min_grid_size, block_size, func,

8358 block_size_to_dynamic_smem_size, block_size_limit);

8359}

8374template <typename F>

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

8376 F kernel, size_t dynSharedMemPerBlk, uint32_t blockSizeLimit) {

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

8378}

8395template <class T>

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

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

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

8399 blockDim, kernelParams, sharedMemBytes, stream);

8400}

8415template <class T>

8416inline hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

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

8418 return hipLaunchCooperativeKernelMultiDevice(launchParamsList, numDevices, flags);

8419}

8434template <class T>

8435inline hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

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

8437 return hipExtLaunchMultiKernelMultiDevice(launchParamsList, numDevices, flags);

8438}

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

8453DEPRECATED(DEPRECATED_MSG)

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

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

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

8457}

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

8473DEPRECATED(DEPRECATED_MSG)

8474static inline hipError_t

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

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

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

8478}

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

8495DEPRECATED(DEPRECATED_MSG)

8496static inline hipError_t hipBindTexture2D(

8497 size_t *offset,

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

8499 const void *devPtr,

8500 size_t width,

8501 size_t height,

8502 size_t pitch)

8503{

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

8505}

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

8523DEPRECATED(DEPRECATED_MSG)

8524static inline hipError_t hipBindTexture2D(

8525 size_t *offset,

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

8527 const void *devPtr,

8528 const struct hipChannelFormatDesc &desc,

8529 size_t width,

8530 size_t height,

8531 size_t pitch)

8532{

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

8534}

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

8547DEPRECATED(DEPRECATED_MSG)

8548static inline hipError_t hipBindTextureToArray(

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

8550 hipArray_const_t array)

8551{

8552 struct hipChannelFormatDesc desc;

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

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

8555}

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

8569DEPRECATED(DEPRECATED_MSG)

8570static inline hipError_t hipBindTextureToArray(

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

8572 hipArray_const_t array,

8573 const struct hipChannelFormatDesc &desc)

8574{

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

8576}

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

8589DEPRECATED(DEPRECATED_MSG)

8590static inline hipError_t hipBindTextureToMipmappedArray(

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

8592 hipMipmappedArray_const_t mipmappedArray)

8593{

8594 struct hipChannelFormatDesc desc;

8595 hipArray_t levelArray;

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

8597 if (err != hipSuccess) {

8598 return err;

8599 }

8600 err = hipGetChannelDesc(&desc, levelArray);

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

8602}

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

8616DEPRECATED(DEPRECATED_MSG)

8617static inline hipError_t hipBindTextureToMipmappedArray(

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

8619 hipMipmappedArray_const_t mipmappedArray,

8620 const struct hipChannelFormatDesc &desc)

8621{

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

8623}

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

8635DEPRECATED(DEPRECATED_MSG)

8636static inline hipError_t hipUnbindTexture(

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

8638{

8639 return hipUnbindTexture(&tex);

8640}

8664static inline hipError_t hipMallocAsync(

8665 void** dev_ptr,

8666 size_t size,

8667 hipMemPool_t mem_pool,

8668 hipStream_t stream) {

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

8670}

8681template<class T>

8682static inline hipError_t hipMallocAsync(

8683 T** dev_ptr,

8684 size_t size,

8685 hipMemPool_t mem_pool,

8686 hipStream_t stream) {

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

8688}

8699template<class T>

8700static inline hipError_t hipMallocAsync(

8701 T** dev_ptr,

8702 size_t size,

8703 hipStream_t stream) {

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

8705}

8716template<class T>

8717static inline hipError_t hipMallocFromPoolAsync(

8718 T** dev_ptr,

8719 size_t size,

8720 hipMemPool_t mem_pool,

8721 hipStream_t stream) {

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

8723}

8727#endif // __cplusplus

8728

8729#ifdef __GNUC__

8730#pragma GCC visibility pop

8731#endif

8732

8733

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

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

8736#else

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

8738#endif

8739

8740

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

8753template <class T>

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

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

8756}

8769template <class T>

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

8771 unsigned int flags = hipHostMallocDefault) {

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

8773}

8788template <class T>

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

8790 unsigned int flags = hipMemAttachGlobal) {

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

8792}

8793

8794#endif

8795#endif

8796// doxygen end HIP API

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

8801

8802#if USE_PROF_API

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

8804#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

hipApiName

const char * hipApiName(uint32_t id)

Returns HIP API name by ID.

hipKernelNameRef

const char * hipKernelNameRef(const hipFunction_t f)

Returns kernel name reference by function name.

hipKernelNameRefByPtr

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

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

hipGetStreamDeviceId

int hipGetStreamDeviceId(hipStream_t stream)

Returns device ID on the stream.

hipSetupArgument

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

Set a kernel argument.

__hipPopCallConfiguration

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

Pop configuration of a kernel launch.

__hipPushCallConfiguration

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

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

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.

hipConfigureCall

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

Configure a kernel launch.

hipLaunchByPtr

hipError_t hipLaunchByPtr(const void *func)

Launch a kernel.

hipLaunchKernel

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

C compliant kernel launch API.

hipDrvMemcpy2DUnaligned

hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D *pCopy)

hipCtxGetFlags

hipError_t hipCtxGetFlags(unsigned int *flags)

Return flags used for creating default context.

hipCtxPopCurrent

hipError_t hipCtxPopCurrent(hipCtx_t *ctx)

Pop the current/default context and return the popped context.

hipCtxGetSharedMemConfig

hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig *pConfig)

Get Shared memory bank configuration.

hipCtxGetCurrent

hipError_t hipCtxGetCurrent(hipCtx_t *ctx)

Get the handle of the current/ default context.

hipCtxSetCacheConfig

hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig)

Set L1/Shared cache partition.

hipCtxSetCurrent

hipError_t hipCtxSetCurrent(hipCtx_t ctx)

Set the passed context as current/default.

hipCtxEnablePeerAccess

hipError_t hipCtxEnablePeerAccess(hipCtx_t peerCtx, unsigned int flags)

Enables direct access to memory allocations in a peer context.

hipCtxGetDevice

hipError_t hipCtxGetDevice(hipDevice_t *device)

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

hipCtxDestroy

hipError_t hipCtxDestroy(hipCtx_t ctx)

Destroy a HIP context.

hipCtxPushCurrent

hipError_t hipCtxPushCurrent(hipCtx_t ctx)

Push the context to be set as current/ default context.

hipCtxGetCacheConfig

hipError_t hipCtxGetCacheConfig(hipFuncCache_t *cacheConfig)

Get Cache configuration for a specific function.

hipCtxCreate

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

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

hipCtxGetApiVersion

hipError_t hipCtxGetApiVersion(hipCtx_t ctx, int *apiVersion)

Returns the approximate HIP api version.

hipCtxSynchronize

hipError_t hipCtxSynchronize(void)

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

hipCtxSetSharedMemConfig

hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config)

Set Shared memory bank configuration.

hipCtxDisablePeerAccess

hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx)

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

hipDevicePrimaryCtxSetFlags

hipError_t hipDevicePrimaryCtxSetFlags(hipDevice_t dev, unsigned int flags)

Set flags for the primary context.

hipDevicePrimaryCtxGetState

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

Get the state of the primary context.

hipDevicePrimaryCtxRelease

hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev)

Release the primary context on the GPU.

hipDevicePrimaryCtxRetain

hipError_t hipDevicePrimaryCtxRetain(hipCtx_t *pctx, hipDevice_t dev)

Retain the primary context on the GPU.

hipDevicePrimaryCtxReset

hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev)

Resets the primary context on the GPU.

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.

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.

hipChooseDevice

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

Device which matches hipDeviceProp_t is returned.

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

hipExtGetLastError

hipError_t hipExtGetLastError(void)

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

hipDrvGetErrorName

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

Return hip error as text string form.

hipGetErrorName

const char * hipGetErrorName(hipError_t hip_error)

Return hip error as text string form.

hipEventSynchronize

hipError_t hipEventSynchronize(hipEvent_t event)

Wait for an event to complete.

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.

hipGraphicsMapResources

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

Maps a graphics resource for access.

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.

hipGraphicsUnmapResources

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

Unmaps graphics resources.

hipGraphicsResourceGetMappedPointer

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

Gets device accessible address of a graphics resource.

hipLimit_t

hipLimit_t

Definition hip_runtime_api.h:644

hipMemAllocationHandleType

hipMemAllocationHandleType

Definition hip_runtime_api.h:959

hipGraphicsResource_t

hipGraphicsResource * hipGraphicsResource_t

Definition hip_runtime_api.h:1198

hipCtx_t

struct ihipCtx_t * hipCtx_t

Definition hip_runtime_api.h:599

__dparm

#define __dparm(x)

Definition hip_runtime_api.h:583

hipStream_t

struct ihipStream_t * hipStream_t

Definition hip_runtime_api.h:608

hipDevice_t

int hipDevice_t

Definition hip_runtime_api.h:601

hipAccessProperty

hipAccessProperty

Definition hip_runtime_api.h:1279

hipMemRangeAttribute

hipMemRangeAttribute

Definition hip_runtime_api.h:841

hipMemAttachSingle

#define hipMemAttachSingle

Definition hip_runtime_api.h:730

hipMemoryAdvise

hipMemoryAdvise

Definition hip_runtime_api.h:808

hipArrayDefault

#define hipArrayDefault

Definition hip_runtime_api.h:778

hipSharedMemConfig

hipSharedMemConfig

Definition hip_runtime_api.h:1028

hipComputeMode

hipComputeMode

Definition hip_runtime_api.h:541

hipEvent_t

struct ihipEvent_t * hipEvent_t

Definition hip_runtime_api.h:636

hipStreamCaptureMode

hipStreamCaptureMode

Definition hip_runtime_api.h:1326

hipGraphNodeType

hipGraphNodeType

Definition hip_runtime_api.h:1222

hipExternalMemoryHandleType

hipExternalMemoryHandleType

Definition hip_runtime_api.h:1072

hipMemAttachGlobal

#define hipMemAttachGlobal

Definition hip_runtime_api.h:724

hipFuncAttribute

hipFuncAttribute

Definition hip_runtime_api.h:1011

hipExternalSemaphoreHandleType

hipExternalSemaphoreHandleType

Definition hip_runtime_api.h:1110

hipJitOption

hipJitOption

Definition hip_runtime_api.h:988

hipDeviceP2PAttr

hipDeviceP2PAttr

Definition hip_runtime_api.h:602

hipGraphDebugDotFlags

hipGraphDebugDotFlags

Definition hip_runtime_api.h:1368

hipUserObjectRetainFlags

hipUserObjectRetainFlags

Definition hip_runtime_api.h:1353

hipError_t

enum __HIP_NODISCARD hipError_t hipError_t

Definition hip_runtime_api.h:285

hipHostFn_t

void(* hipHostFn_t)(void *userData)

Definition hip_runtime_api.h:1240

hipOccupancyDefault

#define hipOccupancyDefault

Definition hip_runtime_api.h:783

hipStreamUpdateCaptureDependenciesFlags

hipStreamUpdateCaptureDependenciesFlags

Definition hip_runtime_api.h:1338

hipGraph_t

struct ihipGraph * hipGraph_t

Definition hip_runtime_api.h:1203

hipMemHandleType

hipMemHandleType

Definition hip_runtime_api.h:1441

hipFlushGPUDirectRDMAWritesOptions

hipFlushGPUDirectRDMAWritesOptions

Definition hip_runtime_api.h:548

hipFuncCache_t

hipFuncCache_t

Definition hip_runtime_api.h:1019

hipUserObjectFlags

hipUserObjectFlags

Definition hip_runtime_api.h:1349

__HIP_NODISCARD

#define __HIP_NODISCARD

Definition hip_runtime_api.h:275

DEPRECATED_MSG

#define DEPRECATED_MSG

Definition hip_runtime_api.h:575

hipGraphMemAttributeType

hipGraphMemAttributeType

Definition hip_runtime_api.h:1343

hipMemPoolAttr

hipMemPoolAttr

Definition hip_runtime_api.h:857

hipDeviceProp_t

#define hipDeviceProp_t

Definition hip_runtime_api.h:92

hipModule_t

struct ihipModule_t * hipModule_t

Definition hip_runtime_api.h:617

hipUserObject_t

struct hipUserObject * hipUserObject_t

Definition hip_runtime_api.h:1216

hipMemOperationType

hipMemOperationType

Definition hip_runtime_api.h:1448

hipExternalSemaphore_t

void * hipExternalSemaphore_t

Definition hip_runtime_api.h:1135

hipGraphicsRegisterFlags

hipGraphicsRegisterFlags

Definition hip_runtime_api.h:1186

hipMemRangeCoherencyMode

hipMemRangeCoherencyMode

Definition hip_runtime_api.h:829

hipMemAccessFlags

hipMemAccessFlags

Definition hip_runtime_api.h:932

hipMemAllocationGranularity_flags

hipMemAllocationGranularity_flags

Definition hip_runtime_api.h:1433

hipGraphExec_t

struct hipGraphExec * hipGraphExec_t

Definition hip_runtime_api.h:1211

hipGraphExecUpdateResult

hipGraphExecUpdateResult

Definition hip_runtime_api.h:1311

hipFunction_t

struct ihipModuleSymbol_t * hipFunction_t

Definition hip_runtime_api.h:618

hipExternalMemory_t

void * hipExternalMemory_t

Definition hip_runtime_api.h:1109

hipStreamCaptureStatus

hipStreamCaptureStatus

Definition hip_runtime_api.h:1331

hipDeviceAttribute_t

hipDeviceAttribute_t

Definition hip_runtime_api.h:407

hipGPUDirectRDMAWritesOrdering

hipGPUDirectRDMAWritesOrdering

Definition hip_runtime_api.h:553

hipGetDeviceProperties

#define hipGetDeviceProperties

Definition hip_runtime_api.h:91

DEPRECATED

#define DEPRECATED(msg)

Definition hip_runtime_api.h:573

hipHostMallocDefault

#define hipHostMallocDefault

Definition hip_runtime_api.h:697

hipGraphicsResource

struct _hipGraphicsResource hipGraphicsResource

Definition hip_runtime_api.h:1196

hipMemAllocationType

hipMemAllocationType

Definition hip_runtime_api.h:947

hipGraphNode_t

struct hipGraphNode * hipGraphNode_t

Definition hip_runtime_api.h:1207

hipMemGenericAllocationHandle_t

struct ihipMemGenericAllocationHandle * hipMemGenericAllocationHandle_t

Definition hip_runtime_api.h:1428

hipMemoryType

hipMemoryType

Definition hip_runtime_api.h:243

hipGraphInstantiateFlags

hipGraphInstantiateFlags

Definition hip_runtime_api.h:1357

hipKernelNodeAttrID

hipKernelNodeAttrID

Definition hip_runtime_api.h:1275

hipMemLocationType

hipMemLocationType

Definition hip_runtime_api.h:915

HIP_IPC_HANDLE_SIZE

#define HIP_IPC_HANDLE_SIZE

Definition hip_runtime_api.h:610

hipMemPool_t

struct ihipMemPoolHandle_t * hipMemPool_t

Definition hip_runtime_api.h:622

hipArraySparseSubresourceType

hipArraySparseSubresourceType

Definition hip_runtime_api.h:1456

hipLimitMallocHeapSize

@ hipLimitMallocHeapSize

Definition hip_runtime_api.h:650

hipLimitStackSize

@ hipLimitStackSize

Definition hip_runtime_api.h:645

hipLimitRange

@ hipLimitRange

Supported limit range.

Definition hip_runtime_api.h:652

hipLimitPrintfFifoSize

@ hipLimitPrintfFifoSize

Definition hip_runtime_api.h:648

hipMemHandleTypeWin32

@ hipMemHandleTypeWin32

Allows a Win32 NT handle for exporting. (HANDLE)

Definition hip_runtime_api.h:962

hipMemHandleTypeWin32Kmt

@ hipMemHandleTypeWin32Kmt

Allows a Win32 KMT handle for exporting. (D3DKMT_HANDLE)

Definition hip_runtime_api.h:963

hipMemHandleTypeNone

@ hipMemHandleTypeNone

Does not allow any export mechanism.

Definition hip_runtime_api.h:960

hipMemHandleTypePosixFileDescriptor

@ hipMemHandleTypePosixFileDescriptor

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

Definition hip_runtime_api.h:961

hipAccessPropertyNormal

@ hipAccessPropertyNormal

Definition hip_runtime_api.h:1280

hipAccessPropertyPersisting

@ hipAccessPropertyPersisting

Definition hip_runtime_api.h:1282

hipAccessPropertyStreaming

@ hipAccessPropertyStreaming

Definition hip_runtime_api.h:1281

hipMemRangeAttributeLastPrefetchLocation

@ hipMemRangeAttributeLastPrefetchLocation

prefetched

Definition hip_runtime_api.h:847

hipMemRangeAttributePreferredLocation

@ hipMemRangeAttributePreferredLocation

The preferred location of the range.

Definition hip_runtime_api.h:844

hipMemRangeAttributeAccessedBy

@ hipMemRangeAttributeAccessedBy

Definition hip_runtime_api.h:845

hipMemRangeAttributeReadMostly

@ hipMemRangeAttributeReadMostly

Definition hip_runtime_api.h:842

hipMemRangeAttributeCoherencyMode

@ hipMemRangeAttributeCoherencyMode

Definition hip_runtime_api.h:849

hipMemAdviseUnsetAccessedBy

@ hipMemAdviseUnsetAccessedBy

Definition hip_runtime_api.h:817

hipMemAdviseUnsetCoarseGrain

@ hipMemAdviseUnsetCoarseGrain

Restores cache coherency policy back to fine-grain.

Definition hip_runtime_api.h:824

hipMemAdviseSetCoarseGrain

@ hipMemAdviseSetCoarseGrain

Definition hip_runtime_api.h:819

hipMemAdviseUnsetPreferredLocation

@ hipMemAdviseUnsetPreferredLocation

Clear the preferred location for the data.

Definition hip_runtime_api.h:814

hipMemAdviseSetAccessedBy

@ hipMemAdviseSetAccessedBy

Definition hip_runtime_api.h:815

hipMemAdviseSetPreferredLocation

@ hipMemAdviseSetPreferredLocation

Definition hip_runtime_api.h:812

hipMemAdviseSetReadMostly

@ hipMemAdviseSetReadMostly

Definition hip_runtime_api.h:809

hipMemAdviseUnsetReadMostly

@ hipMemAdviseUnsetReadMostly

Undo the effect of hipMemAdviseSetReadMostly.

Definition hip_runtime_api.h:811

hipSharedMemBankSizeFourByte

@ hipSharedMemBankSizeFourByte

Definition hip_runtime_api.h:1030

hipSharedMemBankSizeEightByte

@ hipSharedMemBankSizeEightByte

Definition hip_runtime_api.h:1032

hipSharedMemBankSizeDefault

@ hipSharedMemBankSizeDefault

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

Definition hip_runtime_api.h:1029

hipComputeModeProhibited

@ hipComputeModeProhibited

Definition hip_runtime_api.h:544

hipComputeModeExclusive

@ hipComputeModeExclusive

Definition hip_runtime_api.h:543

hipComputeModeDefault

@ hipComputeModeDefault

Definition hip_runtime_api.h:542

hipComputeModeExclusiveProcess

@ hipComputeModeExclusiveProcess

Definition hip_runtime_api.h:545

hipStreamCaptureModeRelaxed

@ hipStreamCaptureModeRelaxed

Definition hip_runtime_api.h:1329

hipStreamCaptureModeThreadLocal

@ hipStreamCaptureModeThreadLocal

Definition hip_runtime_api.h:1328

hipStreamCaptureModeGlobal

@ hipStreamCaptureModeGlobal

Definition hip_runtime_api.h:1327

hipGraphNodeTypeGraph

@ hipGraphNodeTypeGraph

Node which executes an embedded graph.

Definition hip_runtime_api.h:1227

hipGraphNodeTypeMemset

@ hipGraphNodeTypeMemset

Memset node.

Definition hip_runtime_api.h:1225

hipGraphNodeTypeEventRecord

@ hipGraphNodeTypeEventRecord

External event record node.

Definition hip_runtime_api.h:1230

hipGraphNodeTypeExtSemaphoreSignal

@ hipGraphNodeTypeExtSemaphoreSignal

External Semaphore signal node.

Definition hip_runtime_api.h:1231

hipGraphNodeTypeMemcpy

@ hipGraphNodeTypeMemcpy

Memcpy node.

Definition hip_runtime_api.h:1224

hipGraphNodeTypeWaitEvent

@ hipGraphNodeTypeWaitEvent

External event wait node.

Definition hip_runtime_api.h:1229

hipGraphNodeTypeCount

@ hipGraphNodeTypeCount

Definition hip_runtime_api.h:1237

hipGraphNodeTypeKernel

@ hipGraphNodeTypeKernel

GPU kernel node.

Definition hip_runtime_api.h:1223

hipGraphNodeTypeHost

@ hipGraphNodeTypeHost

Host (executable) node.

Definition hip_runtime_api.h:1226

hipGraphNodeTypeMemAlloc

@ hipGraphNodeTypeMemAlloc

Memory alloc node.

Definition hip_runtime_api.h:1233

hipGraphNodeTypeMemFree

@ hipGraphNodeTypeMemFree

Memory free node.

Definition hip_runtime_api.h:1234

hipGraphNodeTypeMemcpyFromSymbol

@ hipGraphNodeTypeMemcpyFromSymbol

MemcpyFromSymbol node.

Definition hip_runtime_api.h:1235

hipGraphNodeTypeMemcpyToSymbol

@ hipGraphNodeTypeMemcpyToSymbol

MemcpyToSymbol node.

Definition hip_runtime_api.h:1236

hipGraphNodeTypeEmpty

@ hipGraphNodeTypeEmpty

Empty (no-op) node.

Definition hip_runtime_api.h:1228

hipGraphNodeTypeExtSemaphoreWait

@ hipGraphNodeTypeExtSemaphoreWait

External Semaphore wait node.

Definition hip_runtime_api.h:1232

hipExternalMemoryHandleTypeD3D11Resource

@ hipExternalMemoryHandleTypeD3D11Resource

Definition hip_runtime_api.h:1078

hipExternalMemoryHandleTypeD3D12Resource

@ hipExternalMemoryHandleTypeD3D12Resource

Definition hip_runtime_api.h:1077

hipExternalMemoryHandleTypeNvSciBuf

@ hipExternalMemoryHandleTypeNvSciBuf

Definition hip_runtime_api.h:1080

hipExternalMemoryHandleTypeOpaqueFd

@ hipExternalMemoryHandleTypeOpaqueFd

Definition hip_runtime_api.h:1073

hipExternalMemoryHandleTypeD3D12Heap

@ hipExternalMemoryHandleTypeD3D12Heap

Definition hip_runtime_api.h:1076

hipExternalMemoryHandleTypeOpaqueWin32Kmt

@ hipExternalMemoryHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:1075

hipExternalMemoryHandleTypeOpaqueWin32

@ hipExternalMemoryHandleTypeOpaqueWin32

Definition hip_runtime_api.h:1074

hipExternalMemoryHandleTypeD3D11ResourceKmt

@ hipExternalMemoryHandleTypeD3D11ResourceKmt

Definition hip_runtime_api.h:1079

hipFuncAttributePreferredSharedMemoryCarveout

@ hipFuncAttributePreferredSharedMemoryCarveout

Definition hip_runtime_api.h:1013

hipFuncAttributeMaxDynamicSharedMemorySize

@ hipFuncAttributeMaxDynamicSharedMemorySize

Definition hip_runtime_api.h:1012

hipFuncAttributeMax

@ hipFuncAttributeMax

Definition hip_runtime_api.h:1014

hipExternalSemaphoreHandleTypeNvSciSync

@ hipExternalSemaphoreHandleTypeNvSciSync

Definition hip_runtime_api.h:1116

hipExternalSemaphoreHandleTypeKeyedMutexKmt

@ hipExternalSemaphoreHandleTypeKeyedMutexKmt

Definition hip_runtime_api.h:1118

hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

@ hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:1113

hipExternalSemaphoreHandleTypeKeyedMutex

@ hipExternalSemaphoreHandleTypeKeyedMutex

Definition hip_runtime_api.h:1117

hipExternalSemaphoreHandleTypeD3D11Fence

@ hipExternalSemaphoreHandleTypeD3D11Fence

Definition hip_runtime_api.h:1115

hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

@ hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

Definition hip_runtime_api.h:1120

hipExternalSemaphoreHandleTypeOpaqueFd

@ hipExternalSemaphoreHandleTypeOpaqueFd

Definition hip_runtime_api.h:1111

hipExternalSemaphoreHandleTypeOpaqueWin32

@ hipExternalSemaphoreHandleTypeOpaqueWin32

Definition hip_runtime_api.h:1112

hipExternalSemaphoreHandleTypeTimelineSemaphoreFd

@ hipExternalSemaphoreHandleTypeTimelineSemaphoreFd

Definition hip_runtime_api.h:1119

hipExternalSemaphoreHandleTypeD3D12Fence

@ hipExternalSemaphoreHandleTypeD3D12Fence

Definition hip_runtime_api.h:1114

hipJitOptionCacheMode

@ hipJitOptionCacheMode

Definition hip_runtime_api.h:1003

hipJitOptionFastCompile

@ hipJitOptionFastCompile

Definition hip_runtime_api.h:1005

hipJitOptionInfoLogBuffer

@ hipJitOptionInfoLogBuffer

Definition hip_runtime_api.h:992

hipJitOptionErrorLogBuffer

@ hipJitOptionErrorLogBuffer

Definition hip_runtime_api.h:994

hipJitOptionTarget

@ hipJitOptionTarget

Definition hip_runtime_api.h:998

hipJitOptionThreadsPerBlock

@ hipJitOptionThreadsPerBlock

Definition hip_runtime_api.h:990

hipJitOptionNumOptions

@ hipJitOptionNumOptions

Definition hip_runtime_api.h:1006

hipJitOptionGenerateLineInfo

@ hipJitOptionGenerateLineInfo

Definition hip_runtime_api.h:1002

hipJitOptionOptimizationLevel

@ hipJitOptionOptimizationLevel

Definition hip_runtime_api.h:996

hipJitOptionErrorLogBufferSizeBytes

@ hipJitOptionErrorLogBufferSizeBytes

Definition hip_runtime_api.h:995

hipJitOptionWallTime

@ hipJitOptionWallTime

Definition hip_runtime_api.h:991

hipJitOptionInfoLogBufferSizeBytes

@ hipJitOptionInfoLogBufferSizeBytes

Definition hip_runtime_api.h:993

hipJitOptionTargetFromContext

@ hipJitOptionTargetFromContext

Definition hip_runtime_api.h:997

hipJitOptionGenerateDebugInfo

@ hipJitOptionGenerateDebugInfo

Definition hip_runtime_api.h:1000

hipJitOptionLogVerbose

@ hipJitOptionLogVerbose

Definition hip_runtime_api.h:1001

hipJitOptionMaxRegisters

@ hipJitOptionMaxRegisters

Definition hip_runtime_api.h:989

hipJitOptionSm3xOpt

@ hipJitOptionSm3xOpt

Definition hip_runtime_api.h:1004

hipJitOptionFallbackStrategy

@ hipJitOptionFallbackStrategy

Definition hip_runtime_api.h:999

hipDevP2PAttrAccessSupported

@ hipDevP2PAttrAccessSupported

Definition hip_runtime_api.h:604

hipDevP2PAttrHipArrayAccessSupported

@ hipDevP2PAttrHipArrayAccessSupported

Definition hip_runtime_api.h:606

hipDevP2PAttrNativeAtomicSupported

@ hipDevP2PAttrNativeAtomicSupported

Definition hip_runtime_api.h:605

hipDevP2PAttrPerformanceRank

@ hipDevP2PAttrPerformanceRank

Definition hip_runtime_api.h:603

hipGraphDebugDotFlagsKernelNodeAttributes

@ hipGraphDebugDotFlagsKernelNodeAttributes

Definition hip_runtime_api.h:1381

hipGraphDebugDotFlagsMemsetNodeParams

@ hipGraphDebugDotFlagsMemsetNodeParams

Definition hip_runtime_api.h:1373

hipGraphDebugDotFlagsKernelNodeParams

@ hipGraphDebugDotFlagsKernelNodeParams

Definition hip_runtime_api.h:1371

hipGraphDebugDotFlagsExtSemasWaitNodeParams

@ hipGraphDebugDotFlagsExtSemasWaitNodeParams

Definition hip_runtime_api.h:1379

hipGraphDebugDotFlagsHandles

@ hipGraphDebugDotFlagsHandles

Definition hip_runtime_api.h:1383

hipGraphDebugDotFlagsExtSemasSignalNodeParams

@ hipGraphDebugDotFlagsExtSemasSignalNodeParams

Definition hip_runtime_api.h:1377

hipGraphDebugDotFlagsHostNodeParams

@ hipGraphDebugDotFlagsHostNodeParams

Definition hip_runtime_api.h:1374

hipGraphDebugDotFlagsEventNodeParams

@ hipGraphDebugDotFlagsEventNodeParams

Definition hip_runtime_api.h:1375

hipGraphDebugDotFlagsVerbose

@ hipGraphDebugDotFlagsVerbose

Definition hip_runtime_api.h:1369

hipGraphDebugDotFlagsMemcpyNodeParams

@ hipGraphDebugDotFlagsMemcpyNodeParams

Definition hip_runtime_api.h:1372

hipGraphUserObjectMove

@ hipGraphUserObjectMove

Add new reference or retain.

Definition hip_runtime_api.h:1354

hipStreamAddCaptureDependencies

@ hipStreamAddCaptureDependencies

Add new nodes to the dependency set.

Definition hip_runtime_api.h:1339

hipStreamSetCaptureDependencies

@ hipStreamSetCaptureDependencies

Replace the dependency set with the new nodes.

Definition hip_runtime_api.h:1340

hipMemHandleTypeGeneric

@ hipMemHandleTypeGeneric

Generic handle type.

Definition hip_runtime_api.h:1442

hipFlushGPUDirectRDMAWritesOptionHost

@ hipFlushGPUDirectRDMAWritesOptionHost

Definition hip_runtime_api.h:549

hipFlushGPUDirectRDMAWritesOptionMemOps

@ hipFlushGPUDirectRDMAWritesOptionMemOps

Definition hip_runtime_api.h:550

hipFuncCachePreferNone

@ hipFuncCachePreferNone

no preference for shared memory or L1 (default)

Definition hip_runtime_api.h:1020

hipFuncCachePreferEqual

@ hipFuncCachePreferEqual

prefer equal size L1 cache and shared memory

Definition hip_runtime_api.h:1023

hipFuncCachePreferL1

@ hipFuncCachePreferL1

prefer larger L1 cache and smaller shared memory

Definition hip_runtime_api.h:1022

hipFuncCachePreferShared

@ hipFuncCachePreferShared

prefer larger shared memory and smaller L1 cache

Definition hip_runtime_api.h:1021

hipUserObjectNoDestructorSync

@ hipUserObjectNoDestructorSync

Destructor execution is not synchronized.

Definition hip_runtime_api.h:1350

hipGraphMemAttrReservedMemHigh

@ hipGraphMemAttrReservedMemHigh

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

Definition hip_runtime_api.h:1347

hipGraphMemAttrUsedMemCurrent

@ hipGraphMemAttrUsedMemCurrent

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

Definition hip_runtime_api.h:1344

hipGraphMemAttrUsedMemHigh

@ hipGraphMemAttrUsedMemHigh

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

Definition hip_runtime_api.h:1345

hipGraphMemAttrReservedMemCurrent

@ hipGraphMemAttrReservedMemCurrent

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

Definition hip_runtime_api.h:1346

hipMemPoolAttrUsedMemCurrent

@ hipMemPoolAttrUsedMemCurrent

Definition hip_runtime_api.h:904

hipMemPoolAttrReservedMemHigh

@ hipMemPoolAttrReservedMemHigh

Definition hip_runtime_api.h:899

hipMemPoolAttrReservedMemCurrent

@ hipMemPoolAttrReservedMemCurrent

Definition hip_runtime_api.h:893

hipMemPoolAttrReleaseThreshold

@ hipMemPoolAttrReleaseThreshold

Definition hip_runtime_api.h:888

hipMemPoolAttrUsedMemHigh

@ hipMemPoolAttrUsedMemHigh

Definition hip_runtime_api.h:910

hipMemPoolReuseAllowInternalDependencies

@ hipMemPoolReuseAllowInternalDependencies

Definition hip_runtime_api.h:879

hipMemPoolReuseFollowEventDependencies

@ hipMemPoolReuseFollowEventDependencies

Definition hip_runtime_api.h:866

hipMemPoolReuseAllowOpportunistic

@ hipMemPoolReuseAllowOpportunistic

Definition hip_runtime_api.h:872

hipMemOperationTypeMap

@ hipMemOperationTypeMap

Map operation.

Definition hip_runtime_api.h:1449

hipMemOperationTypeUnmap

@ hipMemOperationTypeUnmap

Unmap operation.

Definition hip_runtime_api.h:1450

hipGraphicsRegisterFlagsReadOnly

@ hipGraphicsRegisterFlagsReadOnly

HIP will not write to this registered resource.

Definition hip_runtime_api.h:1188

hipGraphicsRegisterFlagsTextureGather

@ hipGraphicsRegisterFlagsTextureGather

HIP will perform texture gather operations on this registered resource.

Definition hip_runtime_api.h:1192

hipGraphicsRegisterFlagsWriteDiscard

@ hipGraphicsRegisterFlagsWriteDiscard

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

Definition hip_runtime_api.h:1189

hipGraphicsRegisterFlagsNone

@ hipGraphicsRegisterFlagsNone

Definition hip_runtime_api.h:1187

hipGraphicsRegisterFlagsSurfaceLoadStore

@ hipGraphicsRegisterFlagsSurfaceLoadStore

HIP will bind this resource to a surface.

Definition hip_runtime_api.h:1191

hipMemRangeCoherencyModeFineGrain

@ hipMemRangeCoherencyModeFineGrain

Definition hip_runtime_api.h:830

hipMemRangeCoherencyModeIndeterminate

@ hipMemRangeCoherencyModeIndeterminate

Definition hip_runtime_api.h:834

hipMemRangeCoherencyModeCoarseGrain

@ hipMemRangeCoherencyModeCoarseGrain

Definition hip_runtime_api.h:832

hipMemAccessFlagsProtRead

@ hipMemAccessFlagsProtRead

Set the address range read accessible.

Definition hip_runtime_api.h:934

hipMemAccessFlagsProtNone

@ hipMemAccessFlagsProtNone

Default, make the address range not accessible.

Definition hip_runtime_api.h:933

hipMemAccessFlagsProtReadWrite

@ hipMemAccessFlagsProtReadWrite

Set the address range read-write accessible.

Definition hip_runtime_api.h:935

hipMemAllocationGranularityMinimum

@ hipMemAllocationGranularityMinimum

Minimum granularity.

Definition hip_runtime_api.h:1434

hipMemAllocationGranularityRecommended

@ hipMemAllocationGranularityRecommended

Recommended granularity for performance.

Definition hip_runtime_api.h:1435

hipGraphExecUpdateErrorNotSupported

@ hipGraphExecUpdateErrorNotSupported

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

Definition hip_runtime_api.h:1321

hipGraphExecUpdateErrorNodeTypeChanged

@ hipGraphExecUpdateErrorNodeTypeChanged

The update failed because a node type changed.

Definition hip_runtime_api.h:1316

hipGraphExecUpdateErrorTopologyChanged

@ hipGraphExecUpdateErrorTopologyChanged

The update failed because the topology changed.

Definition hip_runtime_api.h:1315

hipGraphExecUpdateErrorUnsupportedFunctionChange

@ hipGraphExecUpdateErrorUnsupportedFunctionChange

Definition hip_runtime_api.h:1323

hipGraphExecUpdateError

@ hipGraphExecUpdateError

Definition hip_runtime_api.h:1313

hipGraphExecUpdateErrorFunctionChanged

@ hipGraphExecUpdateErrorFunctionChanged

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

Definition hip_runtime_api.h:1317

hipGraphExecUpdateSuccess

@ hipGraphExecUpdateSuccess

The update succeeded.

Definition hip_runtime_api.h:1312

hipGraphExecUpdateErrorParametersChanged

@ hipGraphExecUpdateErrorParametersChanged

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

Definition hip_runtime_api.h:1319

hipStreamCaptureStatusInvalidated

@ hipStreamCaptureStatusInvalidated

Definition hip_runtime_api.h:1334

hipStreamCaptureStatusNone

@ hipStreamCaptureStatusNone

Stream is not capturing.

Definition hip_runtime_api.h:1332

hipStreamCaptureStatusActive

@ hipStreamCaptureStatusActive

Stream is actively capturing.

Definition hip_runtime_api.h:1333

hipDeviceAttributeDirectManagedMemAccessFromHost

@ hipDeviceAttributeDirectManagedMemAccessFromHost

Definition hip_runtime_api.h:426

hipDeviceAttributeSurfaceAlignment

@ hipDeviceAttributeSurfaceAlignment

Alignment requirement for surfaces.

Definition hip_runtime_api.h:496

hipDeviceAttributeMaxGridDimX

@ hipDeviceAttributeMaxGridDimX

Max grid size in width.

Definition hip_runtime_api.h:443

hipDeviceAttributeMaxSurfaceCubemapLayered

@ hipDeviceAttributeMaxSurfaceCubemapLayered

Cuda only. Maximum dimension of Cubemap layered surface.

Definition hip_runtime_api.h:452

hipDeviceAttributeMaxSurface3D

@ hipDeviceAttributeMaxSurface3D

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

Definition hip_runtime_api.h:450

hipDeviceAttributeMaxPitch

@ hipDeviceAttributeMaxPitch

Maximum pitch in bytes allowed by memory copies.

Definition hip_runtime_api.h:473

hipDeviceAttributeTccDriver

@ hipDeviceAttributeTccDriver

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

Definition hip_runtime_api.h:497

hipDeviceAttributeHostNativeAtomicSupported

@ hipDeviceAttributeHostNativeAtomicSupported

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

Definition hip_runtime_api.h:429

hipDeviceAttributePageableMemoryAccessUsesHostPageTables

@ hipDeviceAttributePageableMemoryAccessUsesHostPageTables

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

Definition hip_runtime_api.h:482

hipDeviceAttributeUnused5

@ hipDeviceAttributeUnused5

Previously hipDeviceAttributeGcnArchName.

Definition hip_runtime_api.h:515

hipDeviceAttributeMaxBlockDimY

@ hipDeviceAttributeMaxBlockDimY

Max block size in height.

Definition hip_runtime_api.h:441

hipDeviceAttributeMaxSurfaceCubemap

@ hipDeviceAttributeMaxSurfaceCubemap

Cuda only. Maximum dimensions of Cubemap surface.

Definition hip_runtime_api.h:451

hipDeviceAttributePageableMemoryAccess

@ hipDeviceAttributePageableMemoryAccess

Definition hip_runtime_api.h:480

hipDeviceAttributeClockRate

@ hipDeviceAttributeClockRate

Peak clock frequency in kilohertz.

Definition hip_runtime_api.h:416

hipDeviceAttributeCudaCompatibleEnd

@ hipDeviceAttributeCudaCompatibleEnd

Definition hip_runtime_api.h:508

hipDeviceAttributeMaxTexture1DMipmap

@ hipDeviceAttributeMaxTexture1DMipmap

Maximum size of 1D mipmapped texture.

Definition hip_runtime_api.h:457

hipDeviceAttributeComputeCapabilityMajor

@ hipDeviceAttributeComputeCapabilityMajor

Major compute capability version number.

Definition hip_runtime_api.h:437

hipDeviceAttributeGlobalL1CacheSupported

@ hipDeviceAttributeGlobalL1CacheSupported

Device supports caching globals in L1.

Definition hip_runtime_api.h:428

hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

Definition hip_runtime_api.h:524

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

hipDeviceAttributeComputeCapabilityMinor

@ hipDeviceAttributeComputeCapabilityMinor

Minor compute capability version number.

Definition hip_runtime_api.h:476

hipDeviceAttributeMaxTextureCubemap

@ hipDeviceAttributeMaxTextureCubemap

Maximum dimensions of Cubemap texture.

Definition hip_runtime_api.h:468

hipDeviceAttributeDeviceOverlap

@ hipDeviceAttributeDeviceOverlap

Definition hip_runtime_api.h:424

hipDeviceAttributeMaxTexture2DLinear

@ hipDeviceAttributeMaxTexture2DLinear

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

Definition hip_runtime_api.h:462

hipDeviceAttributeMaxSurface2D

@ hipDeviceAttributeMaxSurface2D

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

Definition hip_runtime_api.h:448

hipDeviceAttributeMaxSurface1DLayered

@ hipDeviceAttributeMaxSurface1DLayered

Cuda only. Maximum dimensions of 1D layered surface.

Definition hip_runtime_api.h:447

hipDeviceAttributeHdpRegFlushCntl

@ hipDeviceAttributeHdpRegFlushCntl

Address of the HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:517

hipDeviceAttributeComputeMode

@ hipDeviceAttributeComputeMode

Compute mode that device is currently in.

Definition hip_runtime_api.h:417

hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

Definition hip_runtime_api.h:518

hipDeviceAttributeAsicRevision

@ hipDeviceAttributeAsicRevision

Revision of the GPU in this device.

Definition hip_runtime_api.h:527

hipDeviceAttributeUnused4

@ hipDeviceAttributeUnused4

Previously hipDeviceAttributeGcnArch.

Definition hip_runtime_api.h:514

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

hipDeviceAttributePersistingL2CacheMaxSize

@ hipDeviceAttributePersistingL2CacheMaxSize

Maximum l2 persisting lines capacity in bytes.

Definition hip_runtime_api.h:486

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

hipDeviceAttributeL2CacheSize

@ hipDeviceAttributeL2CacheSize

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

Definition hip_runtime_api.h:433

hipDeviceAttributeKernelExecTimeout

@ hipDeviceAttributeKernelExecTimeout

Run time limit for kernels executed on the device.

Definition hip_runtime_api.h:432

hipDeviceAttributeMaxThreadsDim

@ hipDeviceAttributeMaxThreadsDim

Maximum dimension of a block.

Definition hip_runtime_api.h:470

hipDeviceAttributeSingleToDoublePrecisionPerfRatio

@ hipDeviceAttributeSingleToDoublePrecisionPerfRatio

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

Definition hip_runtime_api.h:494

hipDeviceAttributeMaxGridDimY

@ hipDeviceAttributeMaxGridDimY

Max grid size in height.

Definition hip_runtime_api.h:444

hipDeviceAttributeMultiprocessorCount

@ hipDeviceAttributeMultiprocessorCount

Number of multiprocessors on the device.

Definition hip_runtime_api.h:478

hipDeviceAttributeAmdSpecificBegin

@ hipDeviceAttributeAmdSpecificBegin

Definition hip_runtime_api.h:509

hipDeviceAttributeMaxRegistersPerMultiprocessor

@ hipDeviceAttributeMaxRegistersPerMultiprocessor

32-bit registers available per block.

Definition hip_runtime_api.h:489

hipDeviceAttributeIsMultiGpuBoard

@ hipDeviceAttributeIsMultiGpuBoard

Multiple GPU devices.

Definition hip_runtime_api.h:431

hipDeviceAttributeSharedMemPerBlockOptin

@ hipDeviceAttributeSharedMemPerBlockOptin

Maximum shared memory per block usable by special opt in.

Definition hip_runtime_api.h:492

hipDeviceAttributeMaxSurface2DLayered

@ hipDeviceAttributeMaxSurface2DLayered

Cuda only. Maximum dimensions of 2D layered surface.

Definition hip_runtime_api.h:449

hipDeviceAttributeAmdSpecificEnd

@ hipDeviceAttributeAmdSpecificEnd

Definition hip_runtime_api.h:536

hipDeviceAttributeMemoryClockRate

@ hipDeviceAttributeMemoryClockRate

Peak memory clock frequency in kilohertz.

Definition hip_runtime_api.h:475

hipDeviceAttributeMaxGridDimZ

@ hipDeviceAttributeMaxGridDimZ

Max grid size in depth.

Definition hip_runtime_api.h:445

hipDeviceAttributeHdpMemFlushCntl

@ hipDeviceAttributeHdpMemFlushCntl

Address of the HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:516

hipDeviceAttributeUnused2

@ hipDeviceAttributeUnused2

Previously hipDeviceAttributeUuid.

Definition hip_runtime_api.h:503

hipDeviceAttributeFineGrainSupport

@ hipDeviceAttributeFineGrainSupport

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

Definition hip_runtime_api.h:533

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

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

hipDeviceAttributeStreamPrioritiesSupported

@ hipDeviceAttributeStreamPrioritiesSupported

Whether to support stream priorities.

Definition hip_runtime_api.h:495

hipDeviceAttributeMaxSharedMemoryPerBlock

@ hipDeviceAttributeMaxSharedMemoryPerBlock

Maximum shared memory available per block in bytes.

Definition hip_runtime_api.h:491

hipDeviceAttributeLocalL1CacheSupported

@ hipDeviceAttributeLocalL1CacheSupported

caching locals in L1 is supported

Definition hip_runtime_api.h:434

hipDeviceAttributeCanUseStreamWaitValue

@ hipDeviceAttributeCanUseStreamWaitValue

Definition hip_runtime_api.h:528

hipDeviceAttributeMaxRegistersPerBlock

@ hipDeviceAttributeMaxRegistersPerBlock

Definition hip_runtime_api.h:487

hipDeviceAttributeMaxThreadsPerBlock

@ hipDeviceAttributeMaxThreadsPerBlock

Maximum number of threads per block.

Definition hip_runtime_api.h:471

hipDeviceAttributeMemoryBusWidth

@ hipDeviceAttributeMemoryBusWidth

Global memory bus width in bits.

Definition hip_runtime_api.h:474

hipDeviceAttributeComputePreemptionSupported

@ hipDeviceAttributeComputePreemptionSupported

Device supports Compute Preemption.

Definition hip_runtime_api.h:418

hipDeviceAttributeMaxSurface1D

@ hipDeviceAttributeMaxSurface1D

Maximum size of 1D surface.

Definition hip_runtime_api.h:446

hipDeviceAttributeUnused1

@ hipDeviceAttributeUnused1

Previously hipDeviceAttributeName.

Definition hip_runtime_api.h:479

hipDeviceAttributeMaxTexture3DAlt

@ hipDeviceAttributeMaxTexture3DAlt

Maximum dimensions of alternate 3D texture.

Definition hip_runtime_api.h:467

hipDeviceAttributeMaxTexture1DLinear

@ hipDeviceAttributeMaxTexture1DLinear

Definition hip_runtime_api.h:455

hipDeviceAttributeMaxTexture2DGather

@ hipDeviceAttributeMaxTexture2DGather

Maximum dimensions of 2D texture if gather operations performed.

Definition hip_runtime_api.h:460

hipDeviceAttributeWallClockRate

@ hipDeviceAttributeWallClockRate

Constant frequency of wall clock in kilohertz.

Definition hip_runtime_api.h:534

hipDeviceAttributePciDeviceId

@ hipDeviceAttributePciDeviceId

PCI Device ID.

Definition hip_runtime_api.h:484

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

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

hipDeviceAttributeManagedMemory

@ hipDeviceAttributeManagedMemory

Device supports allocating managed memory on this system.

Definition hip_runtime_api.h:438

hipDeviceAttributeIntegrated

@ hipDeviceAttributeIntegrated

Device is integrated GPU.

Definition hip_runtime_api.h:430

hipDeviceAttributeMaxTexture2DLayered

@ hipDeviceAttributeMaxTexture2DLayered

Maximum dimensions of 2D layered texture.

Definition hip_runtime_api.h:461

hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

Definition hip_runtime_api.h:520

hipDeviceAttributeMaxTexture3DDepth

@ hipDeviceAttributeMaxTexture3DDepth

Maximum dimension depth of 3D texture.

Definition hip_runtime_api.h:466

hipDeviceAttributeImageSupport

@ hipDeviceAttributeImageSupport

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

Definition hip_runtime_api.h:530

hipDeviceAttributeTotalGlobalMem

@ hipDeviceAttributeTotalGlobalMem

Global memory available on devicice.

Definition hip_runtime_api.h:501

hipDeviceAttributeMaxBlocksPerMultiProcessor

@ hipDeviceAttributeMaxBlocksPerMultiProcessor

Max block size per multiprocessor.

Definition hip_runtime_api.h:439

hipDeviceAttributeIsLargeBar

@ hipDeviceAttributeIsLargeBar

Whether it is LargeBar.

Definition hip_runtime_api.h:526

hipDeviceAttributeMaxTexture2DWidth

@ hipDeviceAttributeMaxTexture2DWidth

Maximum dimension width of 2D texture.

Definition hip_runtime_api.h:458

hipDeviceAttributeMaxBlockDimX

@ hipDeviceAttributeMaxBlockDimX

Max block size in width.

Definition hip_runtime_api.h:440

hipDeviceAttributeMaxTexture3DWidth

@ hipDeviceAttributeMaxTexture3DWidth

Maximum dimension width of 3D texture.

Definition hip_runtime_api.h:464

hipDeviceAttributeUnused3

@ hipDeviceAttributeUnused3

Previously hipDeviceAttributeArch.

Definition hip_runtime_api.h:512

hipDeviceAttributeTotalConstantMemory

@ hipDeviceAttributeTotalConstantMemory

Constant memory size in bytes.

Definition hip_runtime_api.h:500

hipDeviceAttributeTextureAlignment

@ hipDeviceAttributeTextureAlignment

Alignment requirement for textures.

Definition hip_runtime_api.h:498

hipDeviceAttributeMaxTexture1DLayered

@ hipDeviceAttributeMaxTexture1DLayered

Maximum dimensions of 1D layered texture.

Definition hip_runtime_api.h:454

hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

@ hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

Maximum Shared Memory PerMultiprocessor.

Definition hip_runtime_api.h:513

hipDeviceAttributeReservedSharedMemPerBlock

@ hipDeviceAttributeReservedSharedMemPerBlock

Shared memory reserved by CUDA driver per block.

Definition hip_runtime_api.h:490

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

hipDeviceAttributePciDomainID

@ hipDeviceAttributePciDomainID

PCI Domain ID.

Definition hip_runtime_api.h:485

hipDeviceAttributeMaxThreadsPerMultiProcessor

@ hipDeviceAttributeMaxThreadsPerMultiProcessor

Maximum resident threads per multiprocessor.

Definition hip_runtime_api.h:472

hipDeviceAttributeTexturePitchAlignment

@ hipDeviceAttributeTexturePitchAlignment

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

Definition hip_runtime_api.h:499

hipDeviceAttributePhysicalMultiProcessorCount

@ hipDeviceAttributePhysicalMultiProcessorCount

Definition hip_runtime_api.h:531

hipDeviceAttributeHostRegisterSupported

@ hipDeviceAttributeHostRegisterSupported

Can device support host memory registration via hipHostRegister.

Definition hip_runtime_api.h:423

hipDeviceAttributeSharedMemPerMultiprocessor

@ hipDeviceAttributeSharedMemPerMultiprocessor

Shared memory available per multiprocessor.

Definition hip_runtime_api.h:493

hipDeviceAttributeLuidDeviceNodeMask

@ hipDeviceAttributeLuidDeviceNodeMask

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

Definition hip_runtime_api.h:436

hipDeviceAttributeMaxTextureCubemapLayered

@ hipDeviceAttributeMaxTextureCubemapLayered

Maximum dimensions of Cubemap layered texture.

Definition hip_runtime_api.h:469

hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

Definition hip_runtime_api.h:522

hipDeviceAttributeVirtualMemoryManagementSupported

@ hipDeviceAttributeVirtualMemoryManagementSupported

Device supports HIP virtual memory management.

Definition hip_runtime_api.h:506

hipDeviceAttributeMemoryPoolsSupported

@ hipDeviceAttributeMemoryPoolsSupported

Device supports HIP Stream Ordered Memory Allocator.

Definition hip_runtime_api.h:505

hipDeviceAttributeClockInstructionRate

@ hipDeviceAttributeClockInstructionRate

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

Definition hip_runtime_api.h:511

hipDeviceAttributeMaxTexture2DMipmap

@ hipDeviceAttributeMaxTexture2DMipmap

Maximum dimensions of 2D mipmapped texture.

Definition hip_runtime_api.h:463

hipDeviceAttributeMaxBlockDimZ

@ hipDeviceAttributeMaxBlockDimZ

Max block size in depth.

Definition hip_runtime_api.h:442

hipDeviceAttributeWarpSize

@ hipDeviceAttributeWarpSize

Warp size in threads.

Definition hip_runtime_api.h:504

hipGPUDirectRDMAWritesOrderingOwner

@ hipGPUDirectRDMAWritesOrderingOwner

Definition hip_runtime_api.h:555

hipGPUDirectRDMAWritesOrderingNone

@ hipGPUDirectRDMAWritesOrderingNone

Definition hip_runtime_api.h:554

hipGPUDirectRDMAWritesOrderingAllDevices

@ hipGPUDirectRDMAWritesOrderingAllDevices

Definition hip_runtime_api.h:556

hipMemAllocationTypeMax

@ hipMemAllocationTypeMax

Definition hip_runtime_api.h:953

hipMemAllocationTypePinned

@ hipMemAllocationTypePinned

Definition hip_runtime_api.h:952

hipMemAllocationTypeInvalid

@ hipMemAllocationTypeInvalid

Definition hip_runtime_api.h:948

hipMemoryTypeDevice

@ hipMemoryTypeDevice

Definition hip_runtime_api.h:246

hipMemoryTypeHost

@ hipMemoryTypeHost

Memory is physically located on host.

Definition hip_runtime_api.h:245

hipMemoryTypeUnregistered

@ hipMemoryTypeUnregistered

Unregistered memory.

Definition hip_runtime_api.h:244

hipMemoryTypeArray

@ hipMemoryTypeArray

Definition hip_runtime_api.h:251

hipMemoryTypeManaged

@ hipMemoryTypeManaged

Definition hip_runtime_api.h:248

hipMemoryTypeUnified

@ hipMemoryTypeUnified

unified address space

Definition hip_runtime_api.h:253

hipGraphInstantiateFlagAutoFreeOnLaunch

@ hipGraphInstantiateFlagAutoFreeOnLaunch

Automatically free memory allocated in a graph before relaunching.

Definition hip_runtime_api.h:1358

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

hipGraphInstantiateFlagUpload

@ hipGraphInstantiateFlagUpload

Automatically upload the graph after instantiaton.

Definition hip_runtime_api.h:1360

hipGraphInstantiateFlagDeviceLaunch

@ hipGraphInstantiateFlagDeviceLaunch

Instantiate the graph to be launchable from the device.

Definition hip_runtime_api.h:1362

hipKernelNodeAttributeCooperative

@ hipKernelNodeAttributeCooperative

Definition hip_runtime_api.h:1277

hipKernelNodeAttributeAccessPolicyWindow

@ hipKernelNodeAttributeAccessPolicyWindow

Definition hip_runtime_api.h:1276

hipMemLocationTypeInvalid

@ hipMemLocationTypeInvalid

Definition hip_runtime_api.h:916

hipMemLocationTypeDevice

@ hipMemLocationTypeDevice

Device location, thus it's HIP device ID.

Definition hip_runtime_api.h:917

hipArraySparseSubresourceTypeSparseLevel

@ hipArraySparseSubresourceTypeSparseLevel

Sparse level.

Definition hip_runtime_api.h:1457

hipArraySparseSubresourceTypeMiptail

@ hipArraySparseSubresourceTypeMiptail

Miptail.

Definition hip_runtime_api.h:1458

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.

hipGraphRetainUserObject

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

Retain user object for graphs.

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.

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.

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.

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.

hipUserObjectRelease

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

Release number of references to resource.

hipGraphMemcpyNodeGetParams

hipError_t hipGraphMemcpyNodeGetParams(hipGraphNode_t node, hipMemcpy3DParms *pNodeParams)

Gets a memcpy node's parameters.

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.

hipStreamUpdateCaptureDependencies

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

Update the set of dependencies in a capturing stream.

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.

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.

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.

hipUserObjectRetain

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

Retain number of references to resource.

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.

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.

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.

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.

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.

hipStreamGetCaptureInfo_v2

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

Get stream's capture state.

hipGraphReleaseUserObject

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

Release user object from graphs.

hipMemcpyToSymbol

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

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

hipHostAlloc

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

Allocate device accessible page locked host memory [Deprecated].

hipMemsetD16Async

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

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

hipFreeHost

hipError_t hipFreeHost(void *ptr)

Free memory allocated by the hcc hip host memory allocation API [Deprecated].

hipMemcpyFromSymbol

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

Copies data from the given symbol on the device.

hipHostFree

hipError_t hipHostFree(void *ptr)

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

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

Copies data between host and device asynchronously.

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.

hipMemcpy3DAsync

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

Copies data between host and device asynchronously.

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

hipMemcpyFromSymbolAsync

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

Copies data from the given symbol on the device asynchronously.

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.

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

hipDrvMemcpy3DAsync

hipError_t hipDrvMemcpy3DAsync(const HIP_MEMCPY3D *pCopy, hipStream_t stream)

Copies data between host and device asynchronously.

hipMallocHost

hipError_t hipMallocHost(void **ptr, size_t size)

Allocate pinned host memory [Deprecated].

hipArray3DGetDescriptor

hipError_t hipArray3DGetDescriptor(HIP_ARRAY3D_DESCRIPTOR *pArrayDescriptor, hipArray_t array)

Gets a 3D array descriptor.

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

hipMemcpyToSymbolAsync

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

Copies data to the given symbol on the device asynchronously.

hipPointerGetAttributes

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

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

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.

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.

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.

hipHostGetDevicePointer

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

Get Device pointer from Host Pointer allocated through hipHostMalloc.

hipMemcpyParam2DAsync

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

Copies memory for 2D arrays.

hipMemsetD8Async

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

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

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.

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.

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

Copies data between host and device.

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.

hipMemsetAsync

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

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

hipMemset3DAsync

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

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

hipHostMalloc

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

Allocates device accessible page locked (pinned) host memory.

hipMemcpyAsync

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

Copy data from src to dst asynchronously.

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.

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

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

Copies data between host and device.

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.

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

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.

hipMemset2DAsync

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

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

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.

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.

hipMemAllocHost

hipError_t hipMemAllocHost(void **ptr, size_t size)

Allocate pinned host memory [Deprecated].

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.

hipMallocArray

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

Allocate an array on the device.

hipMemsetD32Async

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

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

hipArrayDestroy

hipError_t hipArrayDestroy(hipArray_t array)

Destroy an array memory pointer on the device.

hipStreamAttachMemAsync

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

Attach memory to a stream asynchronously in 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.

hipMemPrefetchAsync

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

Prefetches memory to the specified destination device using 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 __dparm(hipMemAttachGlobal))

Allocates memory that will be automatically managed by 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.

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 __dparm(hipOccupancyDefault))

Returns occupancy for a device function.

hipModuleOccupancyMaxPotentialBlockSize

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

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

hipOccupancyMaxActiveBlocksPerMultiprocessor

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

Returns occupancy for a device function.

hipOccupancyMaxPotentialBlockSize

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

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

hipModuleOccupancyMaxActiveBlocksPerMultiprocessor

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

Returns occupancy for a device function.

hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags

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

Returns occupancy for a device function.

hipModuleOccupancyMaxPotentialBlockSizeWithFlags

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

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

hipDeviceCanAccessPeer

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

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

hipDeviceEnablePeerAccess

hipError_t hipDeviceEnablePeerAccess(int peerDeviceId, unsigned int flags)

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

hipDeviceDisablePeerAccess

hipError_t hipDeviceDisablePeerAccess(int peerDeviceId)

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

hipMemGetAddressRange

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

Get information on memory allocations.

hipProfilerStart

hipError_t hipProfilerStart()

Start recording of profiling information When using this API, start the profiler with profiling disab...

hipProfilerStop

hipError_t hipProfilerStop()

Stop recording of profiling information. When using this API, start the profiler with profiling disab...

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

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

hipStreamWaitValue32

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

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

hipStreamWaitValue64

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

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.

hipBindTextureToMipmappedArray

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

Binds a mipmapped array to a texture.

hipTexRefGetMipmapLevelClamp

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

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

hipTexRefGetAddressMode

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

Gets the address mode for a texture reference.

hipTexRefGetFlags

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

Gets flags for a texture reference.

hipTexRefSetAddress

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

Sets an bound address for a texture reference.

hipTexRefSetFilterMode

hipError_t hipTexRefSetFilterMode(textureReference *texRef, enum hipTextureFilterMode fm)

Set filter mode for a texture reference.

hipTexRefSetMipmappedArray

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

Binds mipmapped array to a texture reference.

hipTexRefGetMipmapFilterMode

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

Gets the mipmap filter mode for a texture reference.

hipGetTextureAlignmentOffset

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

Get the offset of the alignment in a texture.

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.

hipTexRefGetMaxAnisotropy

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

Gets the maximum anisotropy for a texture reference.

hipUnbindTexture

hipError_t hipUnbindTexture(const textureReference *tex)

Unbinds a texture.

hipTexRefSetFormat

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

Set format for a texture reference.

hipTexRefGetAddress

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

Gets the the address for a texture reference.

hipTexRefSetFlags

hipError_t hipTexRefSetFlags(textureReference *texRef, unsigned int Flags)

Set flags for a texture reference.

hipTexRefSetAddressMode

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

Sets address mode for a texture reference.

hipTexRefGetMipMappedArray

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

Gets the mipmapped array bound to a texture reference.

hipTexRefSetMaxAnisotropy

hipError_t hipTexRefSetMaxAnisotropy(textureReference *texRef, unsigned int maxAniso)

Sets the maximum anisotropy for a texture reference.

hipTexRefSetMipmapLevelClamp

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

Sets mipmap level clamp for a texture reference.

hipTexRefSetBorderColor

hipError_t hipTexRefSetBorderColor(textureReference *texRef, float *pBorderColor)

Sets border color for a texture reference.

hipTexRefSetArray

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

Binds an array as a texture reference.

hipTexRefSetMipmapLevelBias

hipError_t hipTexRefSetMipmapLevelBias(textureReference *texRef, float bias)

Sets mipmap level bias for a texture reference.

hipTexRefGetMipmapLevelBias

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

Gets the mipmap level bias for a texture reference.

hipBindTextureToArray

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

Binds a memory area to a texture.

hipBindTexture

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

Binds a memory area to a texture.

hipGetTextureReference

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

Gets the texture reference related with the symbol.

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.

hipTexRefSetMipmapFilterMode

hipError_t hipTexRefSetMipmapFilterMode(textureReference *texRef, enum hipTextureFilterMode fm)

Sets mipmap filter mode for a texture reference.

hipTexRefGetFormat

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

Gets texture format for a texture reference.

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.

hipDestroyTextureObject

hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject)

Destroys a texture object.

hipMallocMipmappedArray

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

Allocate a mipmapped array on the device.

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

hipErrorMemoryAllocation

hipErrorMemoryAllocation

Memory allocation error.

Definition hip_runtime_api.h:291

hipErrorNotFound

hipErrorNotFound

Not found.

Definition hip_runtime_api.h:340

hipErrorProfilerDisabled

hipErrorProfilerDisabled

Definition hip_runtime_api.h:296

hipErrorInvalidDevicePointer

hipErrorInvalidDevicePointer

Invalid Device Pointer.

Definition hip_runtime_api.h:303

hipErrorRuntimeMemory

hipErrorRuntimeMemory

Definition hip_runtime_api.h:394

hipErrorInvalidImage

hipErrorInvalidImage

Invalid image.

Definition hip_runtime_api.h:311

hipErrorPeerAccessUnsupported

hipErrorPeerAccessUnsupported

Definition hip_runtime_api.h:328

hipErrorArrayIsMapped

hipErrorArrayIsMapped

Definition hip_runtime_api.h:318

hipErrorStreamCaptureIsolation

hipErrorStreamCaptureIsolation

Definition hip_runtime_api.h:375

hipErrorInvalidKernelFile

hipErrorInvalidKernelFile

In CUDA DRV, it is CUDA_ERROR_INVALID_PTX.

Definition hip_runtime_api.h:329

hipErrorNotMapped

hipErrorNotMapped

Definition hip_runtime_api.h:322

hipErrorGraphExecUpdateFailure

hipErrorGraphExecUpdateFailure

Definition hip_runtime_api.h:388

hipErrorNotInitialized

hipErrorNotInitialized

Invalid not initialized.

Definition hip_runtime_api.h:292

hipErrorInvalidResourceHandle

hipErrorInvalidResourceHandle

Resource handle (hipEvent_t or hipStream_t) invalid.

Definition hip_runtime_api.h:338

hipErrorSharedObjectInitFailed

hipErrorSharedObjectInitFailed

Failed to initialize shared object.

Definition hip_runtime_api.h:334

hipErrorInvalidPitchValue

hipErrorInvalidPitchValue

Invalid pitch value.

Definition hip_runtime_api.h:301

hipErrorNoBinaryForGpu

hipErrorNoBinaryForGpu

Definition hip_runtime_api.h:320

hipErrorInvalidContext

hipErrorInvalidContext

Produced when input context is invalid.

Definition hip_runtime_api.h:312

hipErrorStreamCaptureUnsupported

hipErrorStreamCaptureUnsupported

Definition hip_runtime_api.h:366

hipErrorPeerAccessNotEnabled

hipErrorPeerAccessNotEnabled

Peer access was never enabled from the current device.

Definition hip_runtime_api.h:350

hipErrorOperatingSystem

hipErrorOperatingSystem

Not the correct operating system.

Definition hip_runtime_api.h:335

hipErrorStreamCaptureUnjoined

hipErrorStreamCaptureUnjoined

Definition hip_runtime_api.h:373

hipErrorInitializationError

hipErrorInitializationError

Definition hip_runtime_api.h:294

hipErrorNotMappedAsPointer

hipErrorNotMappedAsPointer

Definition hip_runtime_api.h:324

hipErrorPriorLaunchFailure

hipErrorPriorLaunchFailure

Definition hip_runtime_api.h:307

hipErrorContextIsDestroyed

hipErrorContextIsDestroyed

The context is already destroyed.

Definition hip_runtime_api.h:353

hipErrorInvalidValue

hipErrorInvalidValue

Definition hip_runtime_api.h:287

hipErrorLaunchTimeOut

hipErrorLaunchTimeOut

Timeout for the launch.

Definition hip_runtime_api.h:347

hipErrorUnmapFailed

hipErrorUnmapFailed

Definition hip_runtime_api.h:317

hipErrorSetOnActiveProcess

hipErrorSetOnActiveProcess

The process is active.

Definition hip_runtime_api.h:352

hipErrorFileNotFound

hipErrorFileNotFound

the file is not found.

Definition hip_runtime_api.h:332

hipErrorLaunchFailure

hipErrorLaunchFailure

An exception occurred on the device while executing a kernel.

Definition hip_runtime_api.h:359

hipErrorInvalidDevice

hipErrorInvalidDevice

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

Definition hip_runtime_api.h:310

hipErrorUnsupportedLimit

hipErrorUnsupportedLimit

Unsupported limit.

Definition hip_runtime_api.h:326

hipErrorMapBufferObjectFailed

hipErrorMapBufferObjectFailed

Produced when the IPC memory attach failed from ROCr.

Definition hip_runtime_api.h:316

hipErrorHostMemoryAlreadyRegistered

hipErrorHostMemoryAlreadyRegistered

Produced when trying to lock a page-locked memory.

Definition hip_runtime_api.h:355

hipErrorMissingConfiguration

hipErrorMissingConfiguration

Definition hip_runtime_api.h:306

hipErrorSharedObjectSymbolNotFound

hipErrorSharedObjectSymbolNotFound

Definition hip_runtime_api.h:333

hipErrorECCNotCorrectable

hipErrorECCNotCorrectable

Definition hip_runtime_api.h:325

hipErrorStreamCaptureWrongThread

hipErrorStreamCaptureWrongThread

Definition hip_runtime_api.h:384

hipErrorAssert

hipErrorAssert

Produced when the kernel calls assert.

Definition hip_runtime_api.h:354

hipErrorContextAlreadyInUse

hipErrorContextAlreadyInUse

The context is already in use.

Definition hip_runtime_api.h:327

hipErrorNotReady

hipErrorNotReady

Definition hip_runtime_api.h:341

hipErrorInvalidSource

hipErrorInvalidSource

Invalid source.

Definition hip_runtime_api.h:331

hipErrorLaunchOutOfResources

hipErrorLaunchOutOfResources

Out of resources error.

Definition hip_runtime_api.h:346

hipErrorInvalidDeviceFunction

hipErrorInvalidDeviceFunction

Invalid device function.

Definition hip_runtime_api.h:308

hipErrorCooperativeLaunchTooLarge

hipErrorCooperativeLaunchTooLarge

Definition hip_runtime_api.h:361

hipErrorAlreadyMapped

hipErrorAlreadyMapped

Definition hip_runtime_api.h:319

hipErrorProfilerNotInitialized

hipErrorProfilerNotInitialized

Definition hip_runtime_api.h:297

hipErrorProfilerAlreadyStarted

hipErrorProfilerAlreadyStarted

Definition hip_runtime_api.h:298

hipErrorNoDevice

hipErrorNoDevice

Call to hipGetDeviceCount returned 0 devices.

Definition hip_runtime_api.h:309

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

hipErrorStreamCaptureInvalidated

hipErrorStreamCaptureInvalidated

Definition hip_runtime_api.h:368

hipErrorProfilerAlreadyStopped

hipErrorProfilerAlreadyStopped

Definition hip_runtime_api.h:299

hipErrorDeinitialized

hipErrorDeinitialized

Deinitialized.

Definition hip_runtime_api.h:295

hipErrorPeerAccessAlreadyEnabled

hipErrorPeerAccessAlreadyEnabled

Peer access was already enabled from the current device.

Definition hip_runtime_api.h:348

hipErrorNotMappedAsArray

hipErrorNotMappedAsArray

Definition hip_runtime_api.h:323

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

hipErrorStreamCaptureImplicit

hipErrorStreamCaptureImplicit

Definition hip_runtime_api.h:379

hipErrorStreamCaptureMerge

hipErrorStreamCaptureMerge

Definition hip_runtime_api.h:370

hipErrorInvalidGraphicsContext

hipErrorInvalidGraphicsContext

Definition hip_runtime_api.h:330

hipErrorIllegalState

hipErrorIllegalState

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

Definition hip_runtime_api.h:339

hipErrorOutOfMemory

hipErrorOutOfMemory

out of memory range.

Definition hip_runtime_api.h:289

hipErrorInvalidSymbol

hipErrorInvalidSymbol

Invalid symbol.

Definition hip_runtime_api.h:302

hipSuccess

hipSuccess

Successful completion.

Definition hip_runtime_api.h:286

hipErrorUnknown

hipErrorUnknown

Unknown error.

Definition hip_runtime_api.h:392

hipErrorInvalidHandle

hipErrorInvalidHandle

Invalide handle.

Definition hip_runtime_api.h:336

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

hipErrorInsufficientDriver

hipErrorInsufficientDriver

Definition hip_runtime_api.h:305

hipErrorHostMemoryNotRegistered

hipErrorHostMemoryNotRegistered

Produced when trying to unlock a non-page-locked memory.

Definition hip_runtime_api.h:357

hipErrorRuntimeOther

hipErrorRuntimeOther

Definition hip_runtime_api.h:396

hipErrorContextAlreadyCurrent

hipErrorContextAlreadyCurrent

Definition hip_runtime_api.h:313

hipErrorInvalidMemcpyDirection

hipErrorInvalidMemcpyDirection

Invalid memory copy direction.

Definition hip_runtime_api.h:304

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

HIP_MEMSET_NODE_PARAMS::height

size_t height

Number of rows.

Definition hip_runtime_api.h:1305

HIP_MEMSET_NODE_PARAMS::pitch

size_t pitch

Destination device pointer pitch. Unused if height equals 1.

Definition hip_runtime_api.h:1301

HIP_MEMSET_NODE_PARAMS::dst

hipDeviceptr_t dst

Destination pointer on device.

Definition hip_runtime_api.h:1300

HIP_MEMSET_NODE_PARAMS::value

unsigned int value

Value of memset to be set.

Definition hip_runtime_api.h:1302

HIP_MEMSET_NODE_PARAMS::elementSize

unsigned int elementSize

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

Definition hip_runtime_api.h:1303

HIP_MEMSET_NODE_PARAMS::width

size_t width

Width of a row.

Definition hip_runtime_api.h:1304

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

dim3::y

uint32_t y

y

Definition hip_runtime_api.h:1040

dim3::z

uint32_t z

z

Definition hip_runtime_api.h:1041

dim3::x

uint32_t x

x

Definition hip_runtime_api.h:1039

hip_Memcpy2D

Definition driver_types.h:85

hipAccessPolicyWindow

Definition hip_runtime_api.h:1284

hipAccessPolicyWindow::hitProp

hipAccessProperty hitProp

Definition hip_runtime_api.h:1286

hipAccessPolicyWindow::missProp

hipAccessProperty missProp

Definition hip_runtime_api.h:1288

hipAccessPolicyWindow::hitRatio

float hitRatio

Definition hip_runtime_api.h:1287

hipAccessPolicyWindow::base_ptr

void * base_ptr

Definition hip_runtime_api.h:1285

hipAccessPolicyWindow::num_bytes

size_t num_bytes

Definition hip_runtime_api.h:1289

hipArrayMapInfo

Definition hip_runtime_api.h:1464

hipArrayMapInfo::level

unsigned int level

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

Definition hip_runtime_api.h:1473

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

hipArrayMapInfo::resource

union hipArrayMapInfo::@25 resource

hipArrayMapInfo::subresourceType

hipArraySparseSubresourceType subresourceType

Sparse subresource type.

Definition hip_runtime_api.h:1470

hipArrayMapInfo::extentDepth

unsigned int extentDepth

Depth in elements.

Definition hip_runtime_api.h:1480

hipArrayMapInfo::offsetX

unsigned int offsetX

X offset in elements.

Definition hip_runtime_api.h:1475

hipArrayMapInfo::array

hipArray_t array

Definition hip_runtime_api.h:1468

hipArrayMapInfo::resourceType

hipResourceType resourceType

Resource type.

Definition hip_runtime_api.h:1465

hipArrayMapInfo::memOperationType

hipMemOperationType memOperationType

Memory operation type.

Definition hip_runtime_api.h:1488

hipArrayMapInfo::reserved

unsigned int reserved[2]

Reserved for future use, must be zero now.

Definition hip_runtime_api.h:1496

hipArrayMapInfo::extentWidth

unsigned int extentWidth

Width in elements.

Definition hip_runtime_api.h:1478

hipArrayMapInfo::subresource

union hipArrayMapInfo::@26 subresource

hipArrayMapInfo::extentHeight

unsigned int extentHeight

Height in elements.

Definition hip_runtime_api.h:1479

hipArrayMapInfo::offsetY

unsigned int offsetY

Y offset in elements.

Definition hip_runtime_api.h:1476

hipArrayMapInfo::memHandleType

hipMemHandleType memHandleType

Memory handle type.

Definition hip_runtime_api.h:1489

hipArrayMapInfo::miptail

struct hipArrayMapInfo::@26::@29 miptail

hipArrayMapInfo::memHandle

hipMemGenericAllocationHandle_t memHandle

Definition hip_runtime_api.h:1491

hipArrayMapInfo::mipmap

hipMipmappedArray mipmap

Definition hip_runtime_api.h:1467

hipArrayMapInfo::layer

unsigned int layer

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

Definition hip_runtime_api.h:1474

hipArrayMapInfo::deviceBitMask

unsigned int deviceBitMask

Device ordinal bit mask.

Definition hip_runtime_api.h:1494

hipArrayMapInfo::size

unsigned long long size

Extent in bytes.

Definition hip_runtime_api.h:1485

hipArrayMapInfo::offset

unsigned long long offset

Offset within mip tail.

Definition hip_runtime_api.h:1484

hipArrayMapInfo::offsetZ

unsigned int offsetZ

Z offset in elements.

Definition hip_runtime_api.h:1477

hipChannelFormatDesc

Definition driver_types.h:46

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

hipDeviceProp_t::ECCEnabled

int ECCEnabled

Device has ECC support enabled.

Definition hip_runtime_api.h:151

hipDeviceProp_t::ipcEventSupported

int ipcEventSupported

Device supports IPC events.

Definition hip_runtime_api.h:206

hipDeviceProp_t::computePreemptionSupported

int computePreemptionSupported

Is compute preemption supported on the device.

Definition hip_runtime_api.h:177

hipDeviceProp_t::maxTexture1DLinear

int maxTexture1DLinear

Maximum size for 1D textures bound to linear memory.

Definition hip_runtime_api.h:130

hipDeviceProp_t::timelineSemaphoreInteropSupported

int timelineSemaphoreInteropSupported

Indicates external timeline semaphore support.

Definition hip_runtime_api.h:196

hipDeviceProp_t::pciBusID

int pciBusID

PCI Bus ID.

Definition hip_runtime_api.h:152

hipDeviceProp_t::maxTexture1D

int maxTexture1D

Maximum number of elements in 1D images.

Definition hip_runtime_api.h:128

hipDeviceProp_t::memoryBusWidth

int memoryBusWidth

Global memory bus width in bits.

Definition hip_runtime_api.h:159

hipDeviceProp_t::maxTexture2DMipmap

int maxTexture2DMipmap[2]

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

Definition hip_runtime_api.h:132

hipDeviceProp_t::clockRate

int clockRate

Max clock frequency of the multiProcessors in khz.

Definition hip_runtime_api.h:112

hipDeviceProp_t::maxThreadsPerMultiProcessor

int maxThreadsPerMultiProcessor

Maximum resident threads per multi-processor.

Definition hip_runtime_api.h:162

hipDeviceProp_t::l2CacheSize

int l2CacheSize

L2 cache size.

Definition hip_runtime_api.h:160

hipDeviceProp_t::deferredMappingHipArraySupported

int deferredMappingHipArraySupported

Definition hip_runtime_api.h:204

hipDeviceProp_t::asyncEngineCount

int asyncEngineCount

Number of async engines.

Definition hip_runtime_api.h:156

hipDeviceProp_t::accessPolicyMaxWindowSize

int accessPolicyMaxWindowSize

Max value of access policy window.

Definition hip_runtime_api.h:190

hipDeviceProp_t::totalConstMem

size_t totalConstMem

Size of shared memory region (in bytes).

Definition hip_runtime_api.h:113

hipDeviceProp_t::memoryPoolsSupported

int memoryPoolsSupported

Indicates if device supports hipMallocAsync and hipMemPool APIs.

Definition hip_runtime_api.h:197

hipDeviceProp_t::unifiedFunctionPointers

int unifiedFunctionPointers

Indicates device supports unified function pointers.

Definition hip_runtime_api.h:208

hipDeviceProp_t::maxTexture2DGather

int maxTexture2DGather[2]

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

Definition hip_runtime_api.h:134

hipDeviceProp_t::memPitch

size_t memPitch

Definition hip_runtime_api.h:107

hipDeviceProp_t::gpuDirectRDMAWritesOrdering

int gpuDirectRDMAWritesOrdering

value of hipGPUDirectRDMAWritesOrdering

Definition hip_runtime_api.h:201

hipDeviceProp_t::uuid

hipUUID uuid

UUID of a device.

Definition hip_runtime_api.h:100

hipDeviceProp_t::sharedMemPerBlock

size_t sharedMemPerBlock

Size of shared memory region (in bytes).

Definition hip_runtime_api.h:104

hipDeviceProp_t::gpuDirectRDMAFlushWritesOptions

unsigned int gpuDirectRDMAFlushWritesOptions

Definition hip_runtime_api.h:199

hipDeviceProp_t::surfaceAlignment

size_t surfaceAlignment

Alignment requirement for surface.

Definition hip_runtime_api.h:149

hipDeviceProp_t::reserved

int reserved[63]

CUDA Reserved.

Definition hip_runtime_api.h:209

hipDeviceProp_t::maxTexture2DLayered

int maxTexture2DLayered[3]

Maximum number of elements in 2D array images.

Definition hip_runtime_api.h:140

hipDeviceProp_t::streamPrioritiesSupported

int streamPrioritiesSupported

Device supports stream priority.

Definition hip_runtime_api.h:163

hipDeviceProp_t::cooperativeMultiDeviceLaunch

int cooperativeMultiDeviceLaunch

Definition hip_runtime_api.h:181

hipDeviceProp_t::hostRegisterSupported

int hostRegisterSupported

Device supports hipHostRegister.

Definition hip_runtime_api.h:192

hipDeviceProp_t::pageableMemoryAccess

int pageableMemoryAccess

Definition hip_runtime_api.h:173

hipDeviceProp_t::name

char name[256]

Device name.

Definition hip_runtime_api.h:99

hipDeviceProp_t::textureAlignment

size_t textureAlignment

Alignment requirement for textures.

Definition hip_runtime_api.h:120

hipDeviceProp_t::globalL1CacheSupported

int globalL1CacheSupported

Indicates globals are cached in L1.

Definition hip_runtime_api.h:164

hipDeviceProp_t::hostNativeAtomicSupported

int hostNativeAtomicSupported

Link between host and device supports native atomics.

Definition hip_runtime_api.h:171

hipDeviceProp_t::maxSurfaceCubemapLayered

int maxSurfaceCubemapLayered[2]

Maximum cubemap layered surface size.

Definition hip_runtime_api.h:148

hipDeviceProp_t::maxTextureCubemapLayered

int maxTextureCubemapLayered[2]

Maximum cubemaps layered texture dims.

Definition hip_runtime_api.h:141

hipDeviceProp_t::sharedMemPerBlockOptin

size_t sharedMemPerBlockOptin

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

Definition hip_runtime_api.h:184

hipDeviceProp_t::sharedMemPerMultiprocessor

size_t sharedMemPerMultiprocessor

Amount of shared memory available per multiprocessor.

Definition hip_runtime_api.h:166

hipDeviceProp_t::singleToDoublePrecisionPerfRatio

int singleToDoublePrecisionPerfRatio

Deprecated. CUDA only.

Definition hip_runtime_api.h:172

hipDeviceProp_t::maxSurface2D

int maxSurface2D[2]

Maximum 2D surface size.

Definition hip_runtime_api.h:143

hipDeviceProp_t::memoryClockRate

int memoryClockRate

Max global memory clock frequency in khz.

Definition hip_runtime_api.h:158

hipDeviceProp_t::maxTexture2DLinear

int maxTexture2DLinear[3]

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

Definition hip_runtime_api.h:133

hipDeviceProp_t::sparseHipArraySupported

int sparseHipArraySupported

Indicates if device supports sparse hip arrays.

Definition hip_runtime_api.h:193

hipDeviceProp_t::clockInstructionRate

int clockInstructionRate

Definition hip_runtime_api.h:216

hipDeviceProp_t::localL1CacheSupported

int localL1CacheSupported

Locals are cahced in L1.

Definition hip_runtime_api.h:165

hipDeviceProp_t::regsPerMultiprocessor

int regsPerMultiprocessor

registers available per multiprocessor

Definition hip_runtime_api.h:167

hipDeviceProp_t::regsPerBlock

int regsPerBlock

Registers per block.

Definition hip_runtime_api.h:105

hipDeviceProp_t::maxTexture2D

int maxTexture2D[2]

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

Definition hip_runtime_api.h:131

hipDeviceProp_t::cooperativeLaunch

int cooperativeLaunch

HIP device supports cooperative launch.

Definition hip_runtime_api.h:180

hipDeviceProp_t::maxTexture3D

int maxTexture3D[3]

elements

Definition hip_runtime_api.h:135

hipDeviceProp_t::directManagedMemAccessFromHost

int directManagedMemAccessFromHost

Definition hip_runtime_api.h:187

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedFunc

int cooperativeMultiDeviceUnmatchedFunc

Definition hip_runtime_api.h:221

hipDeviceProp_t::deviceOverlap

int deviceOverlap

Deprecated. Use asyncEngineCount instead.

Definition hip_runtime_api.h:122

hipDeviceProp_t::pageableMemoryAccessUsesHostPageTables

int pageableMemoryAccessUsesHostPageTables

Definition hip_runtime_api.h:185

hipDeviceProp_t::hdpRegFlushCntl

unsigned int * hdpRegFlushCntl

Addres of HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:220

hipDeviceProp_t::maxThreadsDim

int maxThreadsDim[3]

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

Definition hip_runtime_api.h:110

hipDeviceProp_t::unifiedAddressing

int unifiedAddressing

Does device and host share unified address space.

Definition hip_runtime_api.h:157

hipDeviceProp_t::multiGpuBoardGroupID

int multiGpuBoardGroupID

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

Definition hip_runtime_api.h:170

hipDeviceProp_t::isMultiGpuBoard

int isMultiGpuBoard

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

Definition hip_runtime_api.h:169

hipDeviceProp_t::canUseHostPointerForRegisteredMem

int canUseHostPointerForRegisteredMem

Definition hip_runtime_api.h:178

hipDeviceProp_t::maxTexture1DLayered

int maxTexture1DLayered[2]

Maximum number of elements in 1D array images.

Definition hip_runtime_api.h:139

hipDeviceProp_t::pciDomainID

int pciDomainID

PCI Domain ID.

Definition hip_runtime_api.h:154

hipDeviceProp_t::maxSharedMemoryPerMultiProcessor

size_t maxSharedMemoryPerMultiProcessor

Maximum Shared Memory Per CU. HIP Only.

Definition hip_runtime_api.h:215

hipDeviceProp_t::maxTextureCubemap

int maxTextureCubemap

Maximum cubemap texture dims.

Definition hip_runtime_api.h:138

hipDeviceProp_t::hipReserved

int hipReserved[32]

Reserved for adding new entries for HIP/CUDA.

Definition hip_runtime_api.h:211

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedGridDim

int cooperativeMultiDeviceUnmatchedGridDim

Definition hip_runtime_api.h:224

hipDeviceProp_t::gpuDirectRDMASupported

int gpuDirectRDMASupported

Indicates device support of RDMA APIs.

Definition hip_runtime_api.h:198

hipDeviceProp_t::minor

int minor

Definition hip_runtime_api.h:117

hipDeviceProp_t::gcnArchName

char gcnArchName[256]

AMD GCN Arch Name. HIP Only.

Definition hip_runtime_api.h:214

hipDeviceProp_t::luid

char luid[8]

8-byte unique identifier. Only valid on windows

Definition hip_runtime_api.h:101

hipDeviceProp_t::kernelExecTimeoutEnabled

int kernelExecTimeoutEnabled

Run time limit for kernels executed on the device.

Definition hip_runtime_api.h:124

hipDeviceProp_t::memoryPoolSupportedHandleTypes

unsigned int memoryPoolSupportedHandleTypes

Bitmask of handle types support with mempool based IPC.

Definition hip_runtime_api.h:203

hipDeviceProp_t::hdpMemFlushCntl

unsigned int * hdpMemFlushCntl

Addres of HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:219

hipDeviceProp_t::concurrentManagedAccess

int concurrentManagedAccess

Definition hip_runtime_api.h:175

hipDeviceProp_t::integrated

int integrated

APU vs dGPU.

Definition hip_runtime_api.h:125

hipDeviceProp_t::canMapHostMemory

int canMapHostMemory

Check whether HIP can map host memory.

Definition hip_runtime_api.h:126

hipDeviceProp_t::reservedSharedMemPerBlock

size_t reservedSharedMemPerBlock

Shared memory reserved by driver per block.

Definition hip_runtime_api.h:191

hipDeviceProp_t::maxSurfaceCubemap

int maxSurfaceCubemap

Maximum cubemap surface size.

Definition hip_runtime_api.h:147

hipDeviceProp_t::maxSurface3D

int maxSurface3D[3]

Maximum 3D surface size.

Definition hip_runtime_api.h:144

hipDeviceProp_t::asicRevision

int asicRevision

Revision of the GPU in this device.

Definition hip_runtime_api.h:234

hipDeviceProp_t::totalGlobalMem

size_t totalGlobalMem

Size of global memory region (in bytes).

Definition hip_runtime_api.h:103

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedBlockDim

int cooperativeMultiDeviceUnmatchedBlockDim

Definition hip_runtime_api.h:227

hipDeviceProp_t::maxSurface1DLayered

int maxSurface1DLayered[2]

Maximum 1D layered surface size.

Definition hip_runtime_api.h:145

hipDeviceProp_t::persistingL2CacheMaxSize

int persistingL2CacheMaxSize

Device's max L2 persisting lines in bytes.

Definition hip_runtime_api.h:161

hipDeviceProp_t::maxSurface1D

int maxSurface1D

Maximum 1D surface size.

Definition hip_runtime_api.h:142

hipDeviceProp_t::concurrentKernels

int concurrentKernels

Device can possibly execute multiple kernels concurrently.

Definition hip_runtime_api.h:150

hipDeviceProp_t::isLargeBar

int isLargeBar

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

Definition hip_runtime_api.h:233

hipDeviceProp_t::clusterLaunch

int clusterLaunch

Device supports cluster launch.

Definition hip_runtime_api.h:207

hipDeviceProp_t::maxTexture1DMipmap

int maxTexture1DMipmap

Maximum 1D mipmap texture size.

Definition hip_runtime_api.h:129

hipDeviceProp_t::multiProcessorCount

int multiProcessorCount

Number of multi-processors (compute units).

Definition hip_runtime_api.h:123

hipDeviceProp_t::maxTexture3DAlt

int maxTexture3DAlt[3]

Maximum alternate 3D texture dims.

Definition hip_runtime_api.h:137

hipDeviceProp_t::maxGridSize

int maxGridSize[3]

Max grid dimensions (XYZ).

Definition hip_runtime_api.h:111

hipDeviceProp_t::pciDeviceID

int pciDeviceID

PCI Device ID.

Definition hip_runtime_api.h:153

hipDeviceProp_t::maxBlocksPerMultiProcessor

int maxBlocksPerMultiProcessor

Max number of blocks on CU.

Definition hip_runtime_api.h:189

hipDeviceProp_t::computeMode

int computeMode

Compute mode.

Definition hip_runtime_api.h:127

hipDeviceProp_t::maxSurface2DLayered

int maxSurface2DLayered[3]

Maximum 2D layared surface size.

Definition hip_runtime_api.h:146

hipDeviceProp_t::major

int major

Definition hip_runtime_api.h:114

hipDeviceProp_t::warpSize

int warpSize

Warp size.

Definition hip_runtime_api.h:106

hipDeviceProp_t::tccDriver

int tccDriver

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

Definition hip_runtime_api.h:155

hipDeviceProp_t::luidDeviceNodeMask

unsigned int luidDeviceNodeMask

LUID node mask.

Definition hip_runtime_api.h:102

hipDeviceProp_t::hostRegisterReadOnlySupported

int hostRegisterReadOnlySupported

Definition hip_runtime_api.h:194

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedSharedMem

int cooperativeMultiDeviceUnmatchedSharedMem

Definition hip_runtime_api.h:230

hipDeviceProp_t::maxThreadsPerBlock

int maxThreadsPerBlock

Max work items per work group or workgroup max size.

Definition hip_runtime_api.h:109

hipDeviceProp_t::arch

hipDeviceArch_t arch

Architectural feature flags. New for HIP.

Definition hip_runtime_api.h:218

hipDeviceProp_t::managedMemory

int managedMemory

Device supports allocating managed memory on this system.

Definition hip_runtime_api.h:168

hipDeviceProp_t::texturePitchAlignment

size_t texturePitchAlignment

Pitch alignment requirement for texture references bound to.

Definition hip_runtime_api.h:121

hipExtent

Definition driver_types.h:348

hipExternalMemoryBufferDesc

Definition hip_runtime_api.h:1096

hipExternalMemoryBufferDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1099

hipExternalMemoryBufferDesc::offset

unsigned long long offset

Definition hip_runtime_api.h:1097

hipExternalMemoryBufferDesc::size

unsigned long long size

Definition hip_runtime_api.h:1098

hipExternalMemoryHandleDesc

Definition hip_runtime_api.h:1082

hipExternalMemoryHandleDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1093

hipExternalMemoryHandleDesc::name

const void * name

Definition hip_runtime_api.h:1088

hipExternalMemoryHandleDesc::fd

int fd

Definition hip_runtime_api.h:1085

hipExternalMemoryHandleDesc::size

unsigned long long size

Definition hip_runtime_api.h:1092

hipExternalMemoryHandleDesc::type

hipExternalMemoryHandleType type

Definition hip_runtime_api.h:1083

hipExternalMemoryHandleDesc::nvSciBufObject

const void * nvSciBufObject

Definition hip_runtime_api.h:1090

hipExternalMemoryHandleDesc::handle

void * handle

Definition hip_runtime_api.h:1087

hipExternalMemoryMipmappedArrayDesc

Definition hip_runtime_api.h:1102

hipExternalMemoryMipmappedArrayDesc::extent

hipExtent extent

Definition hip_runtime_api.h:1105

hipExternalMemoryMipmappedArrayDesc::numLevels

unsigned int numLevels

Definition hip_runtime_api.h:1107

hipExternalMemoryMipmappedArrayDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1106

hipExternalMemoryMipmappedArrayDesc::offset

unsigned long long offset

Definition hip_runtime_api.h:1103

hipExternalMemoryMipmappedArrayDesc::formatDesc

hipChannelFormatDesc formatDesc

Definition hip_runtime_api.h:1104

hipExternalSemaphoreHandleDesc

Definition hip_runtime_api.h:1122

hipExternalSemaphoreHandleDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1132

hipExternalSemaphoreHandleDesc::name

const void * name

Definition hip_runtime_api.h:1128

hipExternalSemaphoreHandleDesc::NvSciSyncObj

const void * NvSciSyncObj

Definition hip_runtime_api.h:1130

hipExternalSemaphoreHandleDesc::type

hipExternalSemaphoreHandleType type

Definition hip_runtime_api.h:1123

hipExternalSemaphoreHandleDesc::handle

void * handle

Definition hip_runtime_api.h:1127

hipExternalSemaphoreHandleDesc::fd

int fd

Definition hip_runtime_api.h:1125

hipExternalSemaphoreSignalNodeParams

Definition hip_runtime_api.h:1404

hipExternalSemaphoreSignalNodeParams::paramsArray

const hipExternalSemaphoreSignalParams * paramsArray

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

Definition hip_runtime_api.h:1408

hipExternalSemaphoreSignalNodeParams::extSemArray

hipExternalSemaphore_t * extSemArray

< Array containing external semaphore handles.

Definition hip_runtime_api.h:1406

hipExternalSemaphoreSignalNodeParams::numExtSems

unsigned int numExtSems

Definition hip_runtime_api.h:1410

hipExternalSemaphoreSignalParams

Definition hip_runtime_api.h:1136

hipExternalSemaphoreSignalParams::reserved

unsigned long long reserved

Definition hip_runtime_api.h:1143

hipExternalSemaphoreSignalParams::value

unsigned long long value

Definition hip_runtime_api.h:1139

hipExternalSemaphoreSignalParams::fence

void * fence

Definition hip_runtime_api.h:1142

hipExternalSemaphoreSignalParams::flags

unsigned int flags

Definition hip_runtime_api.h:1150

hipExternalSemaphoreSignalParams::key

unsigned long long key

Definition hip_runtime_api.h:1146

hipExternalSemaphoreWaitNodeParams

Definition hip_runtime_api.h:1416

hipExternalSemaphoreWaitNodeParams::numExtSems

unsigned int numExtSems

Definition hip_runtime_api.h:1422

hipExternalSemaphoreWaitNodeParams::paramsArray

const hipExternalSemaphoreWaitParams * paramsArray

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

Definition hip_runtime_api.h:1420

hipExternalSemaphoreWaitNodeParams::extSemArray

hipExternalSemaphore_t * extSemArray

< Array containing external semaphore handles.

Definition hip_runtime_api.h:1418

hipExternalSemaphoreWaitParams

Definition hip_runtime_api.h:1156

hipExternalSemaphoreWaitParams::value

unsigned long long value

Definition hip_runtime_api.h:1159

hipExternalSemaphoreWaitParams::fence

void * fence

Definition hip_runtime_api.h:1162

hipExternalSemaphoreWaitParams::timeoutMs

unsigned int timeoutMs

Definition hip_runtime_api.h:1167

hipExternalSemaphoreWaitParams::key

unsigned long long key

Definition hip_runtime_api.h:1166

hipExternalSemaphoreWaitParams::flags

unsigned int flags

Definition hip_runtime_api.h:1171

hipExternalSemaphoreWaitParams::reserved

unsigned long long reserved

Definition hip_runtime_api.h:1163

hipFuncAttributes

Definition hip_runtime_api.h:624

hipFuncAttributes::cacheModeCA

int cacheModeCA

Definition hip_runtime_api.h:626

hipFuncAttributes::binaryVersion

int binaryVersion

Definition hip_runtime_api.h:625

hipFuncAttributes::constSizeBytes

size_t constSizeBytes

Definition hip_runtime_api.h:627

hipFuncAttributes::preferredShmemCarveout

int preferredShmemCarveout

Definition hip_runtime_api.h:632

hipFuncAttributes::sharedSizeBytes

size_t sharedSizeBytes

Definition hip_runtime_api.h:634

hipFuncAttributes::maxDynamicSharedSizeBytes

int maxDynamicSharedSizeBytes

Definition hip_runtime_api.h:629

hipFuncAttributes::ptxVersion

int ptxVersion

Definition hip_runtime_api.h:633

hipFuncAttributes::numRegs

int numRegs

Definition hip_runtime_api.h:631

hipFuncAttributes::localSizeBytes

size_t localSizeBytes

Definition hip_runtime_api.h:628

hipFuncAttributes::maxThreadsPerBlock

int maxThreadsPerBlock

Definition hip_runtime_api.h:630

hipFunctionLaunchParams

Definition hip_runtime_api.h:1060

hipFunctionLaunchParams::gridDimX

unsigned int gridDimX

Width(X) of grid in blocks.

Definition hip_runtime_api.h:1062

hipFunctionLaunchParams::blockDimX

unsigned int blockDimX

X dimension of each thread block.

Definition hip_runtime_api.h:1065

hipFunctionLaunchParams::function

hipFunction_t function

Kernel to launch.

Definition hip_runtime_api.h:1061

hipFunctionLaunchParams::hStream

hipStream_t hStream

Stream identifier.

Definition hip_runtime_api.h:1069

hipFunctionLaunchParams::blockDimY

unsigned int blockDimY

Y dimension of each thread block.

Definition hip_runtime_api.h:1066

hipFunctionLaunchParams::gridDimY

unsigned int gridDimY

Height(Y) of grid in blocks.

Definition hip_runtime_api.h:1063

hipFunctionLaunchParams::gridDimZ

unsigned int gridDimZ

Depth(Z) of grid in blocks.

Definition hip_runtime_api.h:1064

hipFunctionLaunchParams::sharedMemBytes

unsigned int sharedMemBytes

Shared memory.

Definition hip_runtime_api.h:1068

hipFunctionLaunchParams::blockDimZ

unsigned int blockDimZ

Z dimension of each thread block.

Definition hip_runtime_api.h:1067

hipFunctionLaunchParams::kernelParams

void ** kernelParams

Kernel parameters.

Definition hip_runtime_api.h:1070

hipHostNodeParams

Definition hip_runtime_api.h:1241

hipHostNodeParams::fn

hipHostFn_t fn

Definition hip_runtime_api.h:1242

hipHostNodeParams::userData

void * userData

Definition hip_runtime_api.h:1243

hipIpcEventHandle_t

Definition hip_runtime_api.h:614

hipIpcMemHandle_t

Definition hip_runtime_api.h:611

hipKernelNodeParams

Definition hip_runtime_api.h:1245

hipKernelNodeParams::gridDim

dim3 gridDim

Definition hip_runtime_api.h:1249

hipKernelNodeParams::sharedMemBytes

unsigned int sharedMemBytes

Definition hip_runtime_api.h:1251

hipKernelNodeParams::blockDim

dim3 blockDim

Definition hip_runtime_api.h:1246

hipKernelNodeParams::kernelParams

void ** kernelParams

Definition hip_runtime_api.h:1250

hipKernelNodeParams::extra

void ** extra

Definition hip_runtime_api.h:1247

hipKernelNodeParams::func

void * func

Definition hip_runtime_api.h:1248

hipLaunchParams

Definition hip_runtime_api.h:1049

hipLaunchParams::sharedMem

size_t sharedMem

Shared memory.

Definition hip_runtime_api.h:1054

hipLaunchParams::args

void ** args

Arguments.

Definition hip_runtime_api.h:1053

hipLaunchParams::blockDim

dim3 blockDim

Block dimentions.

Definition hip_runtime_api.h:1052

hipLaunchParams::gridDim

dim3 gridDim

Grid dimentions.

Definition hip_runtime_api.h:1051

hipLaunchParams::func

void * func

Device function symbol.

Definition hip_runtime_api.h:1050

hipLaunchParams::stream

hipStream_t stream

Stream identifier.

Definition hip_runtime_api.h:1055

hipMemAccessDesc

Definition hip_runtime_api.h:940

hipMemAccessDesc::flags

hipMemAccessFlags flags

Accessibility flags to set.

Definition hip_runtime_api.h:942

hipMemAccessDesc::location

hipMemLocation location

Location on which the accessibility has to change.

Definition hip_runtime_api.h:941

hipMemAllocNodeParams

Definition hip_runtime_api.h:1262

hipMemAllocNodeParams::accessDescs

const hipMemAccessDesc * accessDescs

Definition hip_runtime_api.h:1265

hipMemAllocNodeParams::bytesize

size_t bytesize

The size of the requested allocation in bytes.

Definition hip_runtime_api.h:1268

hipMemAllocNodeParams::poolProps

hipMemPoolProps poolProps

Definition hip_runtime_api.h:1263

hipMemAllocNodeParams::accessDescCount

size_t accessDescCount

The number of access descriptors.

Definition hip_runtime_api.h:1267

hipMemAllocNodeParams::dptr

void * dptr

Returned device address of the allocation.

Definition hip_runtime_api.h:1269

hipMemAllocationProp

Definition hip_runtime_api.h:1389

hipMemAllocationProp::win32HandleMetaData

void * win32HandleMetaData

Metadata for Win32 handles.

Definition hip_runtime_api.h:1393

hipMemAllocationProp::type

hipMemAllocationType type

Memory allocation type.

Definition hip_runtime_api.h:1390

hipMemAllocationProp::gpuDirectRDMACapable

unsigned char gpuDirectRDMACapable

RDMA capable.

Definition hip_runtime_api.h:1396

hipMemAllocationProp::allocFlags

struct hipMemAllocationProp::@24 allocFlags

hipMemAllocationProp::usage

unsigned short usage

Usage.

Definition hip_runtime_api.h:1397

hipMemAllocationProp::requestedHandleType

hipMemAllocationHandleType requestedHandleType

Requested handle type.

Definition hip_runtime_api.h:1391

hipMemAllocationProp::location

hipMemLocation location

Memory location.

Definition hip_runtime_api.h:1392

hipMemAllocationProp::compressionType

unsigned char compressionType

Compression type.

Definition hip_runtime_api.h:1395

hipMemLocation

Definition hip_runtime_api.h:924

hipMemLocation::id

int id

Identifier for the provided location type hipMemLocationType.

Definition hip_runtime_api.h:926

hipMemLocation::type

hipMemLocationType type

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

Definition hip_runtime_api.h:925

hipMemPoolProps

Definition hip_runtime_api.h:968

hipMemPoolProps::location

hipMemLocation location

Location where allocations should reside.

Definition hip_runtime_api.h:971

hipMemPoolProps::handleTypes

hipMemAllocationHandleType handleTypes

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

Definition hip_runtime_api.h:970

hipMemPoolProps::allocType

hipMemAllocationType allocType

Allocation type. Currently must be specified as hipMemAllocationTypePinned.

Definition hip_runtime_api.h:969

hipMemPoolProps::reserved

unsigned char reserved[64]

Reserved for future use, must be 0.

Definition hip_runtime_api.h:976

hipMemPoolProps::win32SecurityAttributes

void * win32SecurityAttributes

Definition hip_runtime_api.h:975

hipMemPoolPtrExportData

Definition hip_runtime_api.h:981

hipMemPoolPtrExportData::reserved

unsigned char reserved[64]

Definition hip_runtime_api.h:982

hipMemcpy3DParms

Definition driver_types.h:359

hipMemsetParams

Definition hip_runtime_api.h:1253

hipMemsetParams::dst

void * dst

Definition hip_runtime_api.h:1254

hipMemsetParams::value

unsigned int value

Definition hip_runtime_api.h:1258

hipMemsetParams::elementSize

unsigned int elementSize

Definition hip_runtime_api.h:1255

hipMemsetParams::width

size_t width

Definition hip_runtime_api.h:1259

hipMemsetParams::pitch

size_t pitch

Definition hip_runtime_api.h:1257

hipMemsetParams::height

size_t height

Definition hip_runtime_api.h:1256

hipMipmappedArray

Definition driver_types.h:104

hipPitchedPtr

Definition driver_types.h:342

hipPointerAttribute_t

Definition hip_runtime_api.h:260

hipPointerAttribute_t::device

int device

Definition hip_runtime_api.h:262

hipPointerAttribute_t::hostPointer

void * hostPointer

Definition hip_runtime_api.h:264

hipPointerAttribute_t::type

enum hipMemoryType type

Definition hip_runtime_api.h:261

hipPointerAttribute_t::isManaged

int isManaged

Definition hip_runtime_api.h:265

hipPointerAttribute_t::devicePointer

void * devicePointer

Definition hip_runtime_api.h:263

hipPointerAttribute_t::allocationFlags

unsigned allocationFlags

Definition hip_runtime_api.h:266

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

hipKernelNodeAttrValue

Definition hip_runtime_api.h:1291

hipKernelNodeAttrValue::cooperative

int cooperative

Definition hip_runtime_api.h:1293

hipKernelNodeAttrValue::accessPolicyWindow

hipAccessPolicyWindow accessPolicyWindow

Definition hip_runtime_api.h:1292