/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/latest/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#define hipChooseDevice hipChooseDeviceR0600

94

99typedef struct hipDeviceProp_t {

100 char name[256];

101 hipUUID uuid;

102 char luid[8];

103 unsigned int luidDeviceNodeMask;

104 size_t totalGlobalMem;

105 size_t sharedMemPerBlock;

106 int regsPerBlock;

107 int warpSize;

108 size_t memPitch;

110 int maxThreadsPerBlock;

111 int maxThreadsDim[3];

112 int maxGridSize[3];

113 int clockRate;

114 size_t totalConstMem;

116 int major;

119 int minor;

122 size_t textureAlignment;

123 size_t texturePitchAlignment;

124 int deviceOverlap;

125 int multiProcessorCount;

126 int kernelExecTimeoutEnabled;

127 int integrated;

128 int canMapHostMemory;

129 int computeMode;

130 int maxTexture1D;

131 int maxTexture1DMipmap;

132 int maxTexture1DLinear;

133 int maxTexture2D[2];

134 int maxTexture2DMipmap[2];

135 int maxTexture2DLinear[3];

136 int maxTexture2DGather[2];

137 int maxTexture3D[3];

139 int maxTexture3DAlt[3];

140 int maxTextureCubemap;

141 int maxTexture1DLayered[2];

142 int maxTexture2DLayered[3];

143 int maxTextureCubemapLayered[2];

144 int maxSurface1D;

145 int maxSurface2D[2];

146 int maxSurface3D[3];

147 int maxSurface1DLayered[2];

148 int maxSurface2DLayered[3];

149 int maxSurfaceCubemap;

150 int maxSurfaceCubemapLayered[2];

151 size_t surfaceAlignment;

152 int concurrentKernels;

153 int ECCEnabled;

154 int pciBusID;

155 int pciDeviceID;

156 int pciDomainID;

157 int tccDriver;

158 int asyncEngineCount;

159 int unifiedAddressing;

160 int memoryClockRate;

161 int memoryBusWidth;

162 int l2CacheSize;

163 int persistingL2CacheMaxSize;

164 int maxThreadsPerMultiProcessor;

165 int streamPrioritiesSupported;

166 int globalL1CacheSupported;

167 int localL1CacheSupported;

168 size_t sharedMemPerMultiprocessor;

169 int regsPerMultiprocessor;

170 int managedMemory;

171 int isMultiGpuBoard;

172 int multiGpuBoardGroupID;

173 int hostNativeAtomicSupported;

174 int singleToDoublePrecisionPerfRatio;

175 int pageableMemoryAccess;

177 int concurrentManagedAccess;

179 int computePreemptionSupported;

180 int canUseHostPointerForRegisteredMem;

182 int cooperativeLaunch;

183 int cooperativeMultiDeviceLaunch;

185 size_t

186 sharedMemPerBlockOptin;

187 int pageableMemoryAccessUsesHostPageTables;

189 int directManagedMemAccessFromHost;

191 int maxBlocksPerMultiProcessor;

192 int accessPolicyMaxWindowSize;

193 size_t reservedSharedMemPerBlock;

194 int hostRegisterSupported;

195 int sparseHipArraySupported;

196 int hostRegisterReadOnlySupported;

198 int timelineSemaphoreInteropSupported;

199 int memoryPoolsSupported;

200 int gpuDirectRDMASupported;

201 unsigned int gpuDirectRDMAFlushWritesOptions;

203 int gpuDirectRDMAWritesOrdering;

204 unsigned int

205 memoryPoolSupportedHandleTypes;

206 int deferredMappingHipArraySupported;

208 int ipcEventSupported;

209 int clusterLaunch;

210 int unifiedFunctionPointers;

211 int reserved[63];

212

213 int hipReserved[32];

214

215 /* HIP Only struct members */

216 char gcnArchName[256];

217 size_t maxSharedMemoryPerMultiProcessor;

218 int clockInstructionRate;

220 hipDeviceArch_t arch;

221 unsigned int* hdpMemFlushCntl;

222 unsigned int* hdpRegFlushCntl;

223 int cooperativeMultiDeviceUnmatchedFunc;

226 int cooperativeMultiDeviceUnmatchedGridDim;

229 int cooperativeMultiDeviceUnmatchedBlockDim;

232 int cooperativeMultiDeviceUnmatchedSharedMem;

235 int isLargeBar;

236 int asicRevision;

237} hipDeviceProp_t;

238

245typedef enum hipMemoryType {

246 hipMemoryTypeUnregistered = 0,

247 hipMemoryTypeHost = 1,

248 hipMemoryTypeDevice = 2,

250 hipMemoryTypeManaged = 3,

253 hipMemoryTypeArray = 10,

255 hipMemoryTypeUnified = 11

256

257} hipMemoryType;

258

262typedef struct hipPointerAttribute_t {

263 enum hipMemoryType type;

264 int device;

265 void* devicePointer;

266 void* hostPointer;

267 int isManaged;

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

269 /* peers? */

270} hipPointerAttribute_t;

271

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

273// we can make that yield a warning

274#if __cplusplus >= 201703L

275#define __HIP_NODISCARD [[nodiscard]]

276#else

277#define __HIP_NODISCARD

278#endif

279

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

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

286

287typedef enum __HIP_NODISCARD hipError_t {

288 hipSuccess = 0,

289 hipErrorInvalidValue = 1,

291 hipErrorOutOfMemory = 2,

292 // Deprecated

293 hipErrorMemoryAllocation = 2,

294 hipErrorNotInitialized = 3,

295 // Deprecated

296 hipErrorInitializationError = 3,

297 hipErrorDeinitialized = 4,

298 hipErrorProfilerDisabled = 5,

299 hipErrorProfilerNotInitialized = 6,

300 hipErrorProfilerAlreadyStarted = 7,

301 hipErrorProfilerAlreadyStopped = 8,

302 hipErrorInvalidConfiguration = 9,

303 hipErrorInvalidPitchValue = 12,

304 hipErrorInvalidSymbol = 13,

305 hipErrorInvalidDevicePointer = 17,

306 hipErrorInvalidMemcpyDirection = 21,

307 hipErrorInsufficientDriver = 35,

308 hipErrorMissingConfiguration = 52,

309 hipErrorPriorLaunchFailure = 53,

310 hipErrorInvalidDeviceFunction = 98,

311 hipErrorNoDevice = 100,

312 hipErrorInvalidDevice = 101,

313 hipErrorInvalidImage = 200,

314 hipErrorInvalidContext = 201,

315 hipErrorContextAlreadyCurrent = 202,

316 hipErrorMapFailed = 205,

317 // Deprecated

318 hipErrorMapBufferObjectFailed = 205,

319 hipErrorUnmapFailed = 206,

320 hipErrorArrayIsMapped = 207,

321 hipErrorAlreadyMapped = 208,

322 hipErrorNoBinaryForGpu = 209,

323 hipErrorAlreadyAcquired = 210,

324 hipErrorNotMapped = 211,

325 hipErrorNotMappedAsArray = 212,

326 hipErrorNotMappedAsPointer = 213,

327 hipErrorECCNotCorrectable = 214,

328 hipErrorUnsupportedLimit = 215,

329 hipErrorContextAlreadyInUse = 216,

330 hipErrorPeerAccessUnsupported = 217,

331 hipErrorInvalidKernelFile = 218,

332 hipErrorInvalidGraphicsContext = 219,

333 hipErrorInvalidSource = 300,

334 hipErrorFileNotFound = 301,

335 hipErrorSharedObjectSymbolNotFound = 302,

336 hipErrorSharedObjectInitFailed = 303,

337 hipErrorOperatingSystem = 304,

338 hipErrorInvalidHandle = 400,

339 // Deprecated

340 hipErrorInvalidResourceHandle = 400,

341 hipErrorIllegalState = 401,

342 hipErrorNotFound = 500,

343 hipErrorNotReady = 600,

347 hipErrorIllegalAddress = 700,

348 hipErrorLaunchOutOfResources = 701,

349 hipErrorLaunchTimeOut = 702,

350 hipErrorPeerAccessAlreadyEnabled = 704,

352 hipErrorPeerAccessNotEnabled = 705,

353 hipErrorSetOnActiveProcess = 708,

354 hipErrorContextIsDestroyed = 709,

355 hipErrorAssert = 710,

356 hipErrorHostMemoryAlreadyRegistered = 712,

358 hipErrorHostMemoryNotRegistered = 713,

360 hipErrorLaunchFailure = 719,

361 hipErrorCooperativeLaunchTooLarge = 720,

365 hipErrorNotSupported = 801,

366 hipErrorStreamCaptureUnsupported = 900,

368 hipErrorStreamCaptureInvalidated = 901,

370 hipErrorStreamCaptureMerge = 902,

372 hipErrorStreamCaptureUnmatched = 903,

373 hipErrorStreamCaptureUnjoined = 904,

375 hipErrorStreamCaptureIsolation = 905,

379 hipErrorStreamCaptureImplicit = 906,

382 hipErrorCapturedEvent = 907,

384 hipErrorStreamCaptureWrongThread = 908,

388 hipErrorGraphExecUpdateFailure = 910,

392 hipErrorUnknown = 999,

393 // HSA Runtime Error Codes start here.

394 hipErrorRuntimeMemory = 1052,

396 hipErrorRuntimeOther = 1053,

398 hipErrorTbd

399} hipError_t;

400

401#undef __HIP_NODISCARD

402

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 hipDeviceAttributeDeviceOverlap,

425 hipDeviceAttributeDirectManagedMemAccessFromHost,

427 hipDeviceAttributeGlobalL1CacheSupported,

428 hipDeviceAttributeHostNativeAtomicSupported,

429 hipDeviceAttributeIntegrated,

430 hipDeviceAttributeIsMultiGpuBoard,

431 hipDeviceAttributeKernelExecTimeout,

432 hipDeviceAttributeL2CacheSize,

433 hipDeviceAttributeLocalL1CacheSupported,

434 hipDeviceAttributeLuid,

435 hipDeviceAttributeLuidDeviceNodeMask,

436 hipDeviceAttributeComputeCapabilityMajor,

437 hipDeviceAttributeManagedMemory,

438 hipDeviceAttributeMaxBlocksPerMultiProcessor,

439 hipDeviceAttributeMaxBlockDimX,

440 hipDeviceAttributeMaxBlockDimY,

441 hipDeviceAttributeMaxBlockDimZ,

442 hipDeviceAttributeMaxGridDimX,

443 hipDeviceAttributeMaxGridDimY,

444 hipDeviceAttributeMaxGridDimZ,

445 hipDeviceAttributeMaxSurface1D,

446 hipDeviceAttributeMaxSurface1DLayered,

447 hipDeviceAttributeMaxSurface2D,

448 hipDeviceAttributeMaxSurface2DLayered,

449 hipDeviceAttributeMaxSurface3D,

450 hipDeviceAttributeMaxSurfaceCubemap,

451 hipDeviceAttributeMaxSurfaceCubemapLayered,

452 hipDeviceAttributeMaxTexture1DWidth,

453 hipDeviceAttributeMaxTexture1DLayered,

454 hipDeviceAttributeMaxTexture1DLinear,

456 hipDeviceAttributeMaxTexture1DMipmap,

457 hipDeviceAttributeMaxTexture2DWidth,

458 hipDeviceAttributeMaxTexture2DHeight,

459 hipDeviceAttributeMaxTexture2DGather,

460 hipDeviceAttributeMaxTexture2DLayered,

461 hipDeviceAttributeMaxTexture2DLinear,

462 hipDeviceAttributeMaxTexture2DMipmap,

463 hipDeviceAttributeMaxTexture3DWidth,

464 hipDeviceAttributeMaxTexture3DHeight,

465 hipDeviceAttributeMaxTexture3DDepth,

466 hipDeviceAttributeMaxTexture3DAlt,

467 hipDeviceAttributeMaxTextureCubemap,

468 hipDeviceAttributeMaxTextureCubemapLayered,

469 hipDeviceAttributeMaxThreadsDim,

470 hipDeviceAttributeMaxThreadsPerBlock,

471 hipDeviceAttributeMaxThreadsPerMultiProcessor,

472 hipDeviceAttributeMaxPitch,

473 hipDeviceAttributeMemoryBusWidth,

474 hipDeviceAttributeMemoryClockRate,

475 hipDeviceAttributeComputeCapabilityMinor,

476 hipDeviceAttributeMultiGpuBoardGroupID,

477 hipDeviceAttributeMultiprocessorCount,

478 hipDeviceAttributeUnused1,

479 hipDeviceAttributePageableMemoryAccess,

481 hipDeviceAttributePageableMemoryAccessUsesHostPageTables,

482 hipDeviceAttributePciBusId,

483 hipDeviceAttributePciDeviceId,

484 hipDeviceAttributePciDomainID,

485 hipDeviceAttributePersistingL2CacheMaxSize,

486 hipDeviceAttributeMaxRegistersPerBlock,

488 hipDeviceAttributeMaxRegistersPerMultiprocessor,

489 hipDeviceAttributeReservedSharedMemPerBlock,

490 hipDeviceAttributeMaxSharedMemoryPerBlock,

491 hipDeviceAttributeSharedMemPerBlockOptin,

492 hipDeviceAttributeSharedMemPerMultiprocessor,

493 hipDeviceAttributeSingleToDoublePrecisionPerfRatio,

494 hipDeviceAttributeStreamPrioritiesSupported,

495 hipDeviceAttributeSurfaceAlignment,

496 hipDeviceAttributeTccDriver,

497 hipDeviceAttributeTextureAlignment,

498 hipDeviceAttributeTexturePitchAlignment,

499 hipDeviceAttributeTotalConstantMemory,

500 hipDeviceAttributeTotalGlobalMem,

501 hipDeviceAttributeUnifiedAddressing,

502 hipDeviceAttributeUnused2,

503 hipDeviceAttributeWarpSize,

504 hipDeviceAttributeMemoryPoolsSupported,

505 hipDeviceAttributeVirtualMemoryManagementSupported,

506 hipDeviceAttributeHostRegisterSupported,

507 hipDeviceAttributeMemoryPoolSupportedHandleTypes,

508

509 hipDeviceAttributeCudaCompatibleEnd = 9999,

510 hipDeviceAttributeAmdSpecificBegin = 10000,

511

512 hipDeviceAttributeClockInstructionRate = hipDeviceAttributeAmdSpecificBegin,

513 hipDeviceAttributeUnused3,

514 hipDeviceAttributeMaxSharedMemoryPerMultiprocessor,

515 hipDeviceAttributeUnused4,

516 hipDeviceAttributeUnused5,

517 hipDeviceAttributeHdpMemFlushCntl,

518 hipDeviceAttributeHdpRegFlushCntl,

519 hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc,

521 hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim,

523 hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim,

525 hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem,

527 hipDeviceAttributeIsLargeBar,

528 hipDeviceAttributeAsicRevision,

529 hipDeviceAttributeCanUseStreamWaitValue,

531 hipDeviceAttributeImageSupport,

532 hipDeviceAttributePhysicalMultiProcessorCount,

534 hipDeviceAttributeFineGrainSupport,

535 hipDeviceAttributeWallClockRate,

536

537 hipDeviceAttributeAmdSpecificEnd = 19999,

538 hipDeviceAttributeVendorSpecificBegin = 20000,

539 // Extended attributes for vendors

540} hipDeviceAttribute_t;

541

542typedef enum hipDriverProcAddressQueryResult {

543 HIP_GET_PROC_ADDRESS_SUCCESS = 0,

544 HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND = 1,

545 HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT = 2

546} hipDriverProcAddressQueryResult;

547

548enum hipComputeMode {

549 hipComputeModeDefault = 0,

550 hipComputeModeExclusive = 1,

551 hipComputeModeProhibited = 2,

552 hipComputeModeExclusiveProcess = 3

553};

554

555enum hipFlushGPUDirectRDMAWritesOptions {

556 hipFlushGPUDirectRDMAWritesOptionHost = 1 << 0,

557 hipFlushGPUDirectRDMAWritesOptionMemOps = 1 << 1

558};

559

560enum hipGPUDirectRDMAWritesOrdering {

561 hipGPUDirectRDMAWritesOrderingNone = 0,

562 hipGPUDirectRDMAWritesOrderingOwner = 100,

563 hipGPUDirectRDMAWritesOrderingAllDevices = 200

564};

565

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

567

568#include <stdint.h>

569#include <stddef.h>

570#ifndef GENERIC_GRID_LAUNCH

571#define GENERIC_GRID_LAUNCH 1

572#endif

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

574#include <hip/driver_types.h>

575#include <hip/texture_types.h>

576#include <hip/surface_types.h>

577#if defined(_MSC_VER)

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

579#else // !defined(_MSC_VER)

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

581#endif // !defined(_MSC_VER)

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

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

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

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

586#ifdef __cplusplus

587 #define __dparm(x) \

588 = x

589#else

590 #define __dparm(x)

591#endif

592#ifdef __GNUC__

593#pragma GCC visibility push (default)

594#endif

595#ifdef __cplusplus

596namespace hip_impl {

597hipError_t hip_init();

598} // namespace hip_impl

599#endif

600// Structure definitions:

601#ifdef __cplusplus

602extern "C" {

603#endif

604//---

605// API-visible structures

606typedef struct ihipCtx_t* hipCtx_t;

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

608typedef int hipDevice_t;

609typedef enum hipDeviceP2PAttr {

610 hipDevP2PAttrPerformanceRank = 0,

611 hipDevP2PAttrAccessSupported,

612 hipDevP2PAttrNativeAtomicSupported,

613 hipDevP2PAttrHipArrayAccessSupported

614} hipDeviceP2PAttr;

615typedef struct ihipStream_t* hipStream_t;

616#define hipIpcMemLazyEnablePeerAccess 0x01

617#define HIP_IPC_HANDLE_SIZE 64

618typedef struct hipIpcMemHandle_st {

619 char reserved[HIP_IPC_HANDLE_SIZE];

620} hipIpcMemHandle_t;

621typedef struct hipIpcEventHandle_st {

622 char reserved[HIP_IPC_HANDLE_SIZE];

623} hipIpcEventHandle_t;

624typedef struct ihipModule_t* hipModule_t;

625typedef struct ihipModuleSymbol_t* hipFunction_t;

629typedef struct ihipMemPoolHandle_t* hipMemPool_t;

630

631typedef struct hipFuncAttributes {

632 int binaryVersion;

633 int cacheModeCA;

634 size_t constSizeBytes;

635 size_t localSizeBytes;

636 int maxDynamicSharedSizeBytes;

637 int maxThreadsPerBlock;

638 int numRegs;

639 int preferredShmemCarveout;

640 int ptxVersion;

641 size_t sharedSizeBytes;

642} hipFuncAttributes;

643typedef struct ihipEvent_t* hipEvent_t;

644

651enum hipLimit_t {

652 hipLimitStackSize = 0x0,

655 hipLimitPrintfFifoSize = 0x01,

657 hipLimitMallocHeapSize = 0x02,

659 hipLimitRange

660};

664//Flags that can be used with hipStreamCreateWithFlags.

666#define hipStreamDefault 0x00

667

669#define hipStreamNonBlocking 0x01

670

671//Flags that can be used with hipEventCreateWithFlags.

673#define hipEventDefault 0x0

674

676#define hipEventBlockingSync 0x1

677

679#define hipEventDisableTiming 0x2

680

682#define hipEventInterprocess 0x4

683

692#define hipEventDisableSystemFence 0x20000000

693

696#define hipEventReleaseToDevice 0x40000000

697

700#define hipEventReleaseToSystem 0x80000000

701

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

704#define hipHostMallocDefault 0x0

705#define hipHostAllocDefault 0x0

706

708#define hipHostMallocPortable 0x1

709#define hipHostAllocPortable 0x1

710

713#define hipHostMallocMapped 0x2

714#define hipHostAllocMapped 0x2

715

719#define hipHostMallocWriteCombined 0x4

720#define hipHostAllocWriteCombined 0x4

721

726#define hipHostMallocNumaUser 0x20000000

727

729#define hipHostMallocCoherent 0x40000000

730

732#define hipHostMallocNonCoherent 0x80000000

733

735#define hipMemAttachGlobal 0x01

736

738#define hipMemAttachHost 0x02

739

741#define hipMemAttachSingle 0x04

742

743#define hipDeviceMallocDefault 0x0

744

746#define hipDeviceMallocFinegrained 0x1

747

749#define hipMallocSignalMemory 0x2

750

752#define hipDeviceMallocUncached 0x3

753

755#define hipDeviceMallocContiguous 0x4

756

757//Flags that can be used with hipHostRegister.

759#define hipHostRegisterDefault 0x0

760

762#define hipHostRegisterPortable 0x1

763

766#define hipHostRegisterMapped 0x2

767

769#define hipHostRegisterIoMemory 0x4

770

772#define hipHostRegisterReadOnly 0x08

773

775#define hipExtHostRegisterCoarseGrained 0x8

776

778#define hipDeviceScheduleAuto 0x0

779

782#define hipDeviceScheduleSpin 0x1

783

786#define hipDeviceScheduleYield 0x2

787#define hipDeviceScheduleBlockingSync 0x4

788#define hipDeviceScheduleMask 0x7

789#define hipDeviceMapHost 0x8

790#define hipDeviceLmemResizeToMax 0x10

792#define hipArrayDefault 0x00

793#define hipArrayLayered 0x01

794#define hipArraySurfaceLoadStore 0x02

795#define hipArrayCubemap 0x04

796#define hipArrayTextureGather 0x08

797#define hipOccupancyDefault 0x00

798#define hipOccupancyDisableCachingOverride 0x01

799#define hipCooperativeLaunchMultiDeviceNoPreSync 0x01

800#define hipCooperativeLaunchMultiDeviceNoPostSync 0x02

801#define hipCpuDeviceId ((int)-1)

802#define hipInvalidDeviceId ((int)-2)

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

805#define hipExtAnyOrderLaunch 0x01

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

807#define hipStreamWaitValueGte 0x0

808#define hipStreamWaitValueEq 0x1

809#define hipStreamWaitValueAnd 0x2

810#define hipStreamWaitValueNor 0x3

811// Stream per thread

813#define hipStreamPerThread ((hipStream_t)2)

814

815#define hipStreamLegacy ((hipStream_t)1)

816

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

818#define hipExternalMemoryDedicated 0x1

824typedef enum hipMemoryAdvise {

825 hipMemAdviseSetReadMostly = 1,

827 hipMemAdviseUnsetReadMostly = 2,

828 hipMemAdviseSetPreferredLocation = 3,

830 hipMemAdviseUnsetPreferredLocation = 4,

831 hipMemAdviseSetAccessedBy = 5,

833 hipMemAdviseUnsetAccessedBy = 6,

835 hipMemAdviseSetCoarseGrain = 100,

840 hipMemAdviseUnsetCoarseGrain = 101

841} hipMemoryAdvise;

845typedef enum hipMemRangeCoherencyMode {

846 hipMemRangeCoherencyModeFineGrain = 0,

848 hipMemRangeCoherencyModeCoarseGrain = 1,

850 hipMemRangeCoherencyModeIndeterminate = 2

853} hipMemRangeCoherencyMode;

857typedef enum hipMemRangeAttribute {

858 hipMemRangeAttributeReadMostly = 1,

860 hipMemRangeAttributePreferredLocation = 2,

861 hipMemRangeAttributeAccessedBy = 3,

863 hipMemRangeAttributeLastPrefetchLocation = 4,

865 hipMemRangeAttributeCoherencyMode = 100,

867} hipMemRangeAttribute;

868

872typedef enum hipMemPoolAttr

873{

882 hipMemPoolReuseFollowEventDependencies = 0x1,

888 hipMemPoolReuseAllowOpportunistic = 0x2,

895 hipMemPoolReuseAllowInternalDependencies = 0x3,

904 hipMemPoolAttrReleaseThreshold = 0x4,

909 hipMemPoolAttrReservedMemCurrent = 0x5,

915 hipMemPoolAttrReservedMemHigh = 0x6,

920 hipMemPoolAttrUsedMemCurrent = 0x7,

926 hipMemPoolAttrUsedMemHigh = 0x8

927} hipMemPoolAttr;

931 typedef enum hipMemLocationType {

932 hipMemLocationTypeInvalid = 0,

933 hipMemLocationTypeDevice = 1

934} hipMemLocationType;

940typedef struct hipMemLocation {

941 hipMemLocationType type;

942 int id;

943} hipMemLocation;

948typedef enum hipMemAccessFlags {

949 hipMemAccessFlagsProtNone = 0,

950 hipMemAccessFlagsProtRead = 1,

951 hipMemAccessFlagsProtReadWrite = 3

952} hipMemAccessFlags;

956typedef struct hipMemAccessDesc {

957 hipMemLocation location;

958 hipMemAccessFlags flags;

959} hipMemAccessDesc;

963typedef enum hipMemAllocationType {

964 hipMemAllocationTypeInvalid = 0x0,

968 hipMemAllocationTypePinned = 0x1,

969 hipMemAllocationTypeMax = 0x7FFFFFFF

970} hipMemAllocationType;

975typedef enum hipMemAllocationHandleType {

976 hipMemHandleTypeNone = 0x0,

977 hipMemHandleTypePosixFileDescriptor = 0x1,

978 hipMemHandleTypeWin32 = 0x2,

979 hipMemHandleTypeWin32Kmt = 0x4

980} hipMemAllocationHandleType;

984typedef struct hipMemPoolProps {

985 hipMemAllocationType allocType;

986 hipMemAllocationHandleType handleTypes;

987 hipMemLocation location;

991 void* win32SecurityAttributes;

992 size_t maxSize;

993 unsigned char reserved[56];

994} hipMemPoolProps;

998typedef struct hipMemPoolPtrExportData {

999 unsigned char reserved[64];

1000} hipMemPoolPtrExportData;

1001

1005typedef enum hipJitOption {

1006 hipJitOptionMaxRegisters = 0,

1007 hipJitOptionThreadsPerBlock,

1008 hipJitOptionWallTime,

1009 hipJitOptionInfoLogBuffer,

1010 hipJitOptionInfoLogBufferSizeBytes,

1011 hipJitOptionErrorLogBuffer,

1012 hipJitOptionErrorLogBufferSizeBytes,

1013 hipJitOptionOptimizationLevel,

1014 hipJitOptionTargetFromContext,

1015 hipJitOptionTarget,

1016 hipJitOptionFallbackStrategy,

1017 hipJitOptionGenerateDebugInfo,

1018 hipJitOptionLogVerbose,

1019 hipJitOptionGenerateLineInfo,

1020 hipJitOptionCacheMode,

1021 hipJitOptionSm3xOpt,

1022 hipJitOptionFastCompile,

1023 hipJitOptionNumOptions

1024} hipJitOption;

1028typedef enum hipFuncAttribute {

1029 hipFuncAttributeMaxDynamicSharedMemorySize = 8,

1030 hipFuncAttributePreferredSharedMemoryCarveout = 9,

1031 hipFuncAttributeMax

1032} hipFuncAttribute;

1036typedef enum hipFuncCache_t {

1037 hipFuncCachePreferNone,

1038 hipFuncCachePreferShared,

1039 hipFuncCachePreferL1,

1040 hipFuncCachePreferEqual,

1041} hipFuncCache_t;

1045typedef enum hipSharedMemConfig {

1046 hipSharedMemBankSizeDefault,

1047 hipSharedMemBankSizeFourByte,

1049 hipSharedMemBankSizeEightByte

1051} hipSharedMemConfig;

1055typedef struct dim3 {

1056 uint32_t x;

1057 uint32_t y;

1058 uint32_t z;

1059#ifdef __cplusplus

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

1061#endif

1062} dim3;

1066typedef struct hipLaunchParams_t {

1067 void* func;

1068 dim3 gridDim;

1069 dim3 blockDim;

1070 void **args;

1071 size_t sharedMem;

1072 hipStream_t stream;

1073} hipLaunchParams;

1077typedef struct hipFunctionLaunchParams_t {

1078 hipFunction_t function;

1079 unsigned int gridDimX;

1080 unsigned int gridDimY;

1081 unsigned int gridDimZ;

1082 unsigned int blockDimX;

1083 unsigned int blockDimY;

1084 unsigned int blockDimZ;

1085 unsigned int sharedMemBytes;

1086 hipStream_t hStream;

1087 void **kernelParams;

1088} hipFunctionLaunchParams;

1089typedef enum hipExternalMemoryHandleType_enum {

1090 hipExternalMemoryHandleTypeOpaqueFd = 1,

1091 hipExternalMemoryHandleTypeOpaqueWin32 = 2,

1092 hipExternalMemoryHandleTypeOpaqueWin32Kmt = 3,

1093 hipExternalMemoryHandleTypeD3D12Heap = 4,

1094 hipExternalMemoryHandleTypeD3D12Resource = 5,

1095 hipExternalMemoryHandleTypeD3D11Resource = 6,

1096 hipExternalMemoryHandleTypeD3D11ResourceKmt = 7,

1097 hipExternalMemoryHandleTypeNvSciBuf = 8

1098} hipExternalMemoryHandleType;

1099typedef struct hipExternalMemoryHandleDesc_st {

1100 hipExternalMemoryHandleType type;

1101 union {

1102 int fd;

1103 struct {

1104 void *handle;

1105 const void *name;

1106 } win32;

1107 const void *nvSciBufObject;

1108 } handle;

1109 unsigned long long size;

1110 unsigned int flags;

1111 unsigned int reserved[16];

1112} hipExternalMemoryHandleDesc;

1113typedef struct hipExternalMemoryBufferDesc_st {

1114 unsigned long long offset;

1115 unsigned long long size;

1116 unsigned int flags;

1117 unsigned int reserved[16];

1118} hipExternalMemoryBufferDesc;

1119typedef struct hipExternalMemoryMipmappedArrayDesc_st {

1120 unsigned long long offset;

1121 hipChannelFormatDesc formatDesc;

1122 hipExtent extent;

1123 unsigned int flags;

1124 unsigned int numLevels;

1125} hipExternalMemoryMipmappedArrayDesc;

1126typedef void* hipExternalMemory_t;

1127typedef enum hipExternalSemaphoreHandleType_enum {

1128 hipExternalSemaphoreHandleTypeOpaqueFd = 1,

1129 hipExternalSemaphoreHandleTypeOpaqueWin32 = 2,

1130 hipExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3,

1131 hipExternalSemaphoreHandleTypeD3D12Fence = 4,

1132 hipExternalSemaphoreHandleTypeD3D11Fence = 5,

1133 hipExternalSemaphoreHandleTypeNvSciSync = 6,

1134 hipExternalSemaphoreHandleTypeKeyedMutex = 7,

1135 hipExternalSemaphoreHandleTypeKeyedMutexKmt = 8,

1136 hipExternalSemaphoreHandleTypeTimelineSemaphoreFd = 9,

1137 hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = 10

1138} hipExternalSemaphoreHandleType;

1139typedef struct hipExternalSemaphoreHandleDesc_st {

1140 hipExternalSemaphoreHandleType type;

1141 union {

1142 int fd;

1143 struct {

1144 void* handle;

1145 const void* name;

1146 } win32;

1147 const void* NvSciSyncObj;

1148 } handle;

1149 unsigned int flags;

1150 unsigned int reserved[16];

1151} hipExternalSemaphoreHandleDesc;

1152typedef void* hipExternalSemaphore_t;

1153typedef struct hipExternalSemaphoreSignalParams_st {

1154 struct {

1155 struct {

1156 unsigned long long value;

1157 } fence;

1158 union {

1159 void *fence;

1160 unsigned long long reserved;

1161 } nvSciSync;

1162 struct {

1163 unsigned long long key;

1164 } keyedMutex;

1165 unsigned int reserved[12];

1166 } params;

1167 unsigned int flags;

1168 unsigned int reserved[16];

1169} hipExternalSemaphoreSignalParams;

1173typedef struct hipExternalSemaphoreWaitParams_st {

1174 struct {

1175 struct {

1176 unsigned long long value;

1177 } fence;

1178 union {

1179 void *fence;

1180 unsigned long long reserved;

1181 } nvSciSync;

1182 struct {

1183 unsigned long long key;

1184 unsigned int timeoutMs;

1185 } keyedMutex;

1186 unsigned int reserved[10];

1187 } params;

1188 unsigned int flags;

1189 unsigned int reserved[16];

1190} hipExternalSemaphoreWaitParams;

1191

1192#if __HIP_HAS_GET_PCH

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

1198#endif

1199

1203typedef enum hipGraphicsRegisterFlags {

1204 hipGraphicsRegisterFlagsNone = 0,

1205 hipGraphicsRegisterFlagsReadOnly = 1,

1206 hipGraphicsRegisterFlagsWriteDiscard =

1207 2,

1208 hipGraphicsRegisterFlagsSurfaceLoadStore = 4,

1209 hipGraphicsRegisterFlagsTextureGather =

1210 8

1211} hipGraphicsRegisterFlags;

1212

1213typedef struct _hipGraphicsResource hipGraphicsResource;

1214

1215typedef hipGraphicsResource* hipGraphicsResource_t;

1216

1220typedef struct ihipGraph* hipGraph_t;

1224typedef struct hipGraphNode* hipGraphNode_t;

1228typedef struct hipGraphExec* hipGraphExec_t;

1229

1233typedef struct hipUserObject* hipUserObject_t;

1234

1235

1239typedef enum hipGraphNodeType {

1240 hipGraphNodeTypeKernel = 0,

1241 hipGraphNodeTypeMemcpy = 1,

1242 hipGraphNodeTypeMemset = 2,

1243 hipGraphNodeTypeHost = 3,

1244 hipGraphNodeTypeGraph = 4,

1245 hipGraphNodeTypeEmpty = 5,

1246 hipGraphNodeTypeWaitEvent = 6,

1247 hipGraphNodeTypeEventRecord = 7,

1248 hipGraphNodeTypeExtSemaphoreSignal = 8,

1249 hipGraphNodeTypeExtSemaphoreWait = 9,

1250 hipGraphNodeTypeMemAlloc = 10,

1251 hipGraphNodeTypeMemFree = 11,

1252 hipGraphNodeTypeMemcpyFromSymbol = 12,

1253 hipGraphNodeTypeMemcpyToSymbol = 13,

1254 hipGraphNodeTypeCount

1255} hipGraphNodeType;

1256

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

1258typedef struct hipHostNodeParams {

1259 hipHostFn_t fn;

1260 void* userData;

1261} hipHostNodeParams;

1262typedef struct hipKernelNodeParams {

1263 dim3 blockDim;

1264 void** extra;

1265 void* func;

1266 dim3 gridDim;

1267 void** kernelParams;

1268 unsigned int sharedMemBytes;

1269} hipKernelNodeParams;

1270typedef struct hipMemsetParams {

1271 void* dst;

1272 unsigned int elementSize;

1273 size_t height;

1274 size_t pitch;

1275 unsigned int value;

1276 size_t width;

1277} hipMemsetParams;

1278

1279typedef struct hipMemAllocNodeParams {

1280 hipMemPoolProps poolProps;

1282 const hipMemAccessDesc* accessDescs;

1283 size_t accessDescCount;

1285 size_t bytesize;

1286 void* dptr;

1287} hipMemAllocNodeParams;

1288

1289

1290typedef enum hipAccessProperty {

1291 hipAccessPropertyNormal = 0,

1292 hipAccessPropertyStreaming = 1,

1293 hipAccessPropertyPersisting = 2,

1294} hipAccessProperty;

1295typedef struct hipAccessPolicyWindow {

1296 void* base_ptr;

1297 hipAccessProperty hitProp;

1298 float hitRatio;

1299 hipAccessProperty missProp;

1300 size_t num_bytes;

1301} hipAccessPolicyWindow;

1302

1306typedef enum hipLaunchAttributeID {

1307 hipLaunchAttributeAccessPolicyWindow = 1,

1308 hipLaunchAttributeCooperative = 2,

1309 hipLaunchAttributePriority = 8,

1310} hipLaunchAttributeID;

1311

1315typedef union hipLaunchAttributeValue {

1316 hipAccessPolicyWindow accessPolicyWindow;

1318 int cooperative;

1319 int priority;

1321} hipLaunchAttributeValue;

1322

1326#define hipKernelNodeAttrID hipLaunchAttributeID

1327#define hipKernelNodeAttributeAccessPolicyWindow hipLaunchAttributeAccessPolicyWindow

1328#define hipKernelNodeAttributeCooperative hipLaunchAttributeCooperative

1329#define hipKernelNodeAttributePriority hipLaunchAttributePriority

1330

1334#define hipKernelNodeAttrValue hipLaunchAttributeValue

1335

1339typedef struct HIP_MEMSET_NODE_PARAMS {

1340 hipDeviceptr_t dst;

1341 size_t pitch;

1342 unsigned int value;

1343 unsigned int elementSize;

1344 size_t width;

1345 size_t height;

1346} HIP_MEMSET_NODE_PARAMS;

1347

1351typedef enum hipGraphExecUpdateResult {

1352 hipGraphExecUpdateSuccess = 0x0,

1353 hipGraphExecUpdateError = 0x1,

1355 hipGraphExecUpdateErrorTopologyChanged = 0x2,

1356 hipGraphExecUpdateErrorNodeTypeChanged = 0x3,

1357 hipGraphExecUpdateErrorFunctionChanged =

1358 0x4,

1359 hipGraphExecUpdateErrorParametersChanged =

1360 0x5,

1361 hipGraphExecUpdateErrorNotSupported =

1362 0x6,

1363 hipGraphExecUpdateErrorUnsupportedFunctionChange = 0x7

1364} hipGraphExecUpdateResult;

1365

1366typedef enum hipStreamCaptureMode {

1367 hipStreamCaptureModeGlobal = 0,

1368 hipStreamCaptureModeThreadLocal,

1369 hipStreamCaptureModeRelaxed

1370} hipStreamCaptureMode;

1371typedef enum hipStreamCaptureStatus {

1372 hipStreamCaptureStatusNone = 0,

1373 hipStreamCaptureStatusActive,

1374 hipStreamCaptureStatusInvalidated

1376} hipStreamCaptureStatus;

1377

1378typedef enum hipStreamUpdateCaptureDependenciesFlags {

1379 hipStreamAddCaptureDependencies = 0,

1380 hipStreamSetCaptureDependencies,

1381} hipStreamUpdateCaptureDependenciesFlags;

1382

1383typedef enum hipGraphMemAttributeType {

1384 hipGraphMemAttrUsedMemCurrent = 0,

1385 hipGraphMemAttrUsedMemHigh,

1386 hipGraphMemAttrReservedMemCurrent,

1387 hipGraphMemAttrReservedMemHigh,

1388}hipGraphMemAttributeType;

1389typedef enum hipUserObjectFlags {

1390 hipUserObjectNoDestructorSync = 0x1,

1391} hipUserObjectFlags;

1392

1393typedef enum hipUserObjectRetainFlags {

1394 hipGraphUserObjectMove = 0x1,

1395} hipUserObjectRetainFlags;

1396

1397typedef enum hipGraphInstantiateFlags {

1398 hipGraphInstantiateFlagAutoFreeOnLaunch =

1399 1,

1400 hipGraphInstantiateFlagUpload =

1401 2,

1402 hipGraphInstantiateFlagDeviceLaunch =

1403 4,

1404 hipGraphInstantiateFlagUseNodePriority =

1405 8,

1406} hipGraphInstantiateFlags;

1407

1408enum hipGraphDebugDotFlags {

1409 hipGraphDebugDotFlagsVerbose = 1

1410 << 0,

1411 hipGraphDebugDotFlagsKernelNodeParams = 1 << 2,

1412 hipGraphDebugDotFlagsMemcpyNodeParams = 1 << 3,

1413 hipGraphDebugDotFlagsMemsetNodeParams = 1 << 4,

1414 hipGraphDebugDotFlagsHostNodeParams = 1 << 5,

1415 hipGraphDebugDotFlagsEventNodeParams = 1

1416 << 6,

1417 hipGraphDebugDotFlagsExtSemasSignalNodeParams = 1

1418 << 7,

1419 hipGraphDebugDotFlagsExtSemasWaitNodeParams = 1

1420 << 8,

1421 hipGraphDebugDotFlagsKernelNodeAttributes = 1

1422 << 9,

1423 hipGraphDebugDotFlagsHandles = 1

1424 << 10

1425};

1426

1430typedef enum hipGraphInstantiateResult {

1431 hipGraphInstantiateSuccess = 0,

1432 hipGraphInstantiateError = 1,

1434 hipGraphInstantiateInvalidStructure = 2,

1436 hipGraphInstantiateNodeOperationNotSupported = 3,

1438 hipGraphInstantiateMultipleDevicesNotSupported = 4,

1440}hipGraphInstantiateResult;

1441

1445typedef struct hipGraphInstantiateParams {

1446 hipGraphNode_t errNode_out;

1447 unsigned long long flags;

1448 hipGraphInstantiateResult result_out;

1450 hipStream_t uploadStream;

1451} hipGraphInstantiateParams;

1452

1453

1457typedef struct hipMemAllocationProp {

1458 hipMemAllocationType type;

1459 hipMemAllocationHandleType requestedHandleType;

1460 hipMemLocation location;

1461 void* win32HandleMetaData;

1462 struct {

1463 unsigned char compressionType;

1464 unsigned char gpuDirectRDMACapable;

1465 unsigned short usage;

1466 } allocFlags;

1467} hipMemAllocationProp;

1468

1472typedef struct hipExternalSemaphoreSignalNodeParams {

1474 hipExternalSemaphore_t* extSemArray;

1476 const hipExternalSemaphoreSignalParams* paramsArray;

1478 unsigned int numExtSems;

1479} hipExternalSemaphoreSignalNodeParams;

1480

1484typedef struct hipExternalSemaphoreWaitNodeParams {

1486 hipExternalSemaphore_t* extSemArray;

1488 const hipExternalSemaphoreWaitParams* paramsArray;

1490 unsigned int numExtSems;

1491} hipExternalSemaphoreWaitNodeParams;

1492

1496typedef struct ihipMemGenericAllocationHandle* hipMemGenericAllocationHandle_t;

1497

1501typedef enum hipMemAllocationGranularity_flags {

1502 hipMemAllocationGranularityMinimum = 0x0,

1503 hipMemAllocationGranularityRecommended = 0x1

1504} hipMemAllocationGranularity_flags;

1505

1509typedef enum hipMemHandleType {

1510 hipMemHandleTypeGeneric = 0x0

1511} hipMemHandleType;

1512

1516typedef enum hipMemOperationType {

1517 hipMemOperationTypeMap = 0x1,

1518 hipMemOperationTypeUnmap = 0x2

1519} hipMemOperationType;

1520

1524typedef enum hipArraySparseSubresourceType {

1525 hipArraySparseSubresourceTypeSparseLevel = 0x0,

1526 hipArraySparseSubresourceTypeMiptail = 0x1

1527} hipArraySparseSubresourceType;

1528

1532typedef struct hipArrayMapInfo {

1533 hipResourceType resourceType;

1534 union {

1535 hipMipmappedArray mipmap;

1536 hipArray_t array;

1537 } resource;

1538 hipArraySparseSubresourceType subresourceType;

1539 union {

1540 struct {

1541 unsigned int level;

1542 unsigned int layer;

1543 unsigned int offsetX;

1544 unsigned int offsetY;

1545 unsigned int offsetZ;

1546 unsigned int extentWidth;

1547 unsigned int extentHeight;

1548 unsigned int extentDepth;

1549 } sparseLevel;

1550 struct {

1551 unsigned int layer;

1552 unsigned long long offset;

1553 unsigned long long size;

1554 } miptail;

1555 } subresource;

1556 hipMemOperationType memOperationType;

1557 hipMemHandleType memHandleType;

1558 union {

1559 hipMemGenericAllocationHandle_t memHandle;

1560 } memHandle;

1561 unsigned long long offset;

1562 unsigned int deviceBitMask;

1563 unsigned int flags;

1564 unsigned int reserved[2];

1565} hipArrayMapInfo;

1566

1570typedef struct hipMemcpyNodeParams {

1571 int flags;

1572 int reserved[3];

1573 hipMemcpy3DParms copyParams;

1574} hipMemcpyNodeParams;

1575

1579typedef struct hipChildGraphNodeParams {

1580 hipGraph_t graph;

1582} hipChildGraphNodeParams;

1583

1587typedef struct hipEventWaitNodeParams {

1588 hipEvent_t event;

1589} hipEventWaitNodeParams;

1590

1594typedef struct hipEventRecordNodeParams {

1595 hipEvent_t event;

1596} hipEventRecordNodeParams;

1597

1601typedef struct hipMemFreeNodeParams {

1602 void *dptr;

1603} hipMemFreeNodeParams;

1604

1608typedef struct hipGraphNodeParams {

1609 hipGraphNodeType type;

1610 int reserved0[3];

1611 union {

1612 long long reserved1[29];

1613 hipKernelNodeParams kernel;

1614 hipMemcpyNodeParams memcpy;

1615 hipMemsetParams memset;

1616 hipHostNodeParams host;

1617 hipChildGraphNodeParams graph;

1618 hipEventWaitNodeParams eventWait;

1619 hipEventRecordNodeParams eventRecord;

1620 hipExternalSemaphoreSignalNodeParams extSemSignal;

1621 hipExternalSemaphoreWaitNodeParams extSemWait;

1622 hipMemAllocNodeParams alloc;

1623 hipMemFreeNodeParams free;

1624 };

1625

1626 long long reserved2;

1627} hipGraphNodeParams;

1628

1632#define hipGraphKernelNodePortDefault 0

1633

1637#define hipGraphKernelNodePortLaunchCompletion 2

1638

1644#define hipGraphKernelNodePortProgrammatic 1

1645

1646typedef enum hipGraphDependencyType {

1647 hipGraphDependencyTypeDefault = 0,

1648 hipGraphDependencyTypeProgrammatic = 1

1649}hipGraphDependencyType;

1650

1651typedef struct hipGraphEdgeData {

1652 unsigned char

1653 from_port;

1660 unsigned char reserved[5];

1661 unsigned char

1662 to_port;

1663 unsigned char type;

1664} hipGraphEdgeData;

1665

1666// Doxygen end group GlobalDefs

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

1693hipError_t hipInit(unsigned int flags);

1694

1710hipError_t hipDriverGetVersion(int* driverVersion);

1725hipError_t hipRuntimeGetVersion(int* runtimeVersion);

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

1734

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

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

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

1774hipError_t hipDeviceGetP2PAttribute(int* value, hipDeviceP2PAttr attr,

1775 int srcDevice, int dstDevice);

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

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

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

1801// doxygen end initialization

1820hipError_t hipDeviceSynchronize(void);

1832hipError_t hipDeviceReset(void);

1864hipError_t hipSetDevice(int deviceId);

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

1890hipError_t hipGetDevice(int* deviceId);

1903hipError_t hipGetDeviceCount(int* count);

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

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

1950hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool);

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

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

1996hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig);

2007hipError_t hipDeviceGetCacheConfig(hipFuncCache_t* cacheConfig);

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

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

2053hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig* pConfig);

2061hipError_t hipGetDeviceFlags(unsigned int* flags);

2073hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config);

2098hipError_t hipSetDeviceFlags(unsigned flags);

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

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

2121// TODO: implement IPC apis

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

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

2199hipError_t hipIpcCloseMemHandle(void* devPtr);

2200

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

2218

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

2237

2238// end doxygen Device

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

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

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

2288//doxygen end execution

2310hipError_t hipGetLastError(void);

2311

2323hipError_t hipExtGetLastError(void);

2324

2335hipError_t hipPeekAtLastError(void);

2344const char* hipGetErrorName(hipError_t hip_error);

2353const char* hipGetErrorString(hipError_t hipError);

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

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

2374// end doxygen Error

2404hipError_t hipStreamCreate(hipStream_t* stream);

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

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

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

2472hipError_t hipStreamDestroy(hipStream_t stream);

2488hipError_t hipStreamQuery(hipStream_t stream);

2509hipError_t hipStreamSynchronize(hipStream_t stream);

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

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

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

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

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

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

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

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

2622 unsigned int flags);

2623// end doxygen Stream

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

2667 uint32_t mask __dparm(0xFFFFFFFF));

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

2701 uint64_t mask __dparm(0xFFFFFFFFFFFFFFFF));

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

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

2742// end doxygen Stream Memory Operations

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

2790hipError_t hipEventCreate(hipEvent_t* event);

2821#ifdef __cplusplus

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

2823#else

2824hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream);

2825#endif

2842hipError_t hipEventDestroy(hipEvent_t event);

2861hipError_t hipEventSynchronize(hipEvent_t event);

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

2907hipError_t hipEventQuery(hipEvent_t event);

2908// end doxygen Events

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

2940 hipDeviceptr_t ptr);

2941

2942

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

2977hipError_t hipPointerGetAttribute(void* data, hipPointer_attribute attribute,

2978 hipDeviceptr_t ptr);

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

2996 void** data, hipDeviceptr_t ptr);

3020hipError_t hipImportExternalSemaphore(hipExternalSemaphore_t* extSem_out,

3021 const hipExternalSemaphoreHandleDesc* semHandleDesc);

3037hipError_t hipSignalExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

3038 const hipExternalSemaphoreSignalParams* paramsArray,

3039 unsigned int numExtSems, hipStream_t stream);

3055hipError_t hipWaitExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

3056 const hipExternalSemaphoreWaitParams* paramsArray,

3057 unsigned int numExtSems, hipStream_t stream);

3070hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem);

3071

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

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

3105hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem);

3119hipError_t hipExternalMemoryGetMappedMipmappedArray(hipMipmappedArray_t* mipmap, hipExternalMemory_t extMem,

3120 const hipExternalMemoryMipmappedArrayDesc* mipmapDesc);

3121 // end of external resource

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

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

3159

3160

3183HIP_DEPRECATED("use hipHostMalloc instead")

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

3197HIP_DEPRECATED("use hipHostMalloc instead")

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

3199// end doxygen deprecated management memory

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

3270hipError_t hipMallocManaged(void** dev_ptr,

3271 size_t size,

3272 unsigned int flags __dparm(hipMemAttachGlobal));

3285hipError_t hipMemPrefetchAsync(const void* dev_ptr,

3286 size_t count,

3287 int device,

3288 hipStream_t stream __dparm(0));

3308hipError_t hipMemAdvise(const void* dev_ptr,

3309 size_t count,

3310 hipMemoryAdvise advice,

3311 int device);

3326hipError_t hipMemRangeGetAttribute(void* data,

3327 size_t data_size,

3328 hipMemRangeAttribute attribute,

3329 const void* dev_ptr,

3330 size_t count);

3347hipError_t hipMemRangeGetAttributes(void** data,

3348 size_t* data_sizes,

3349 hipMemRangeAttribute* attributes,

3350 size_t num_attributes,

3351 const void* dev_ptr,

3352 size_t count);

3368hipError_t hipStreamAttachMemAsync(hipStream_t stream,

3369 void* dev_ptr,

3370 size_t length __dparm(0),

3371 unsigned int flags __dparm(hipMemAttachSingle));

3372// end doxygen Managed Memory

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

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

3485hipError_t hipMemPoolTrimTo(hipMemPool_t mem_pool, size_t min_bytes_to_hold);

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

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

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

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

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

3652hipError_t hipMemPoolDestroy(hipMemPool_t mem_pool);

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

3713hipError_t hipMemPoolExportToShareableHandle(

3714 void* shared_handle,

3715 hipMemPool_t mem_pool,

3716 hipMemAllocationHandleType handle_type,

3717 unsigned int flags);

3741hipError_t hipMemPoolImportFromShareableHandle(

3742 hipMemPool_t* mem_pool,

3743 void* shared_handle,

3744 hipMemAllocationHandleType handle_type,

3745 unsigned int flags);

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

3794hipError_t hipMemPoolImportPointer(

3795 void** dev_ptr,

3796 hipMemPool_t mem_pool,

3797 hipMemPoolPtrExportData* export_data);

3798// Doxygen end of ordered memory allocator

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

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

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

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

3888hipError_t hipHostUnregister(void* hostPtr);

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

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

3931 unsigned int elementSizeBytes);

3945hipError_t hipFree(void* ptr);

3959hipError_t hipFreeHost(void* ptr);

3975hipError_t hipHostFree(void* ptr);

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

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

4021 hipMemcpyKind kind, hipStream_t stream);

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

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

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

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

4095 size_t ByteCount);

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

4115 size_t ByteCount);

4116

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

4137 size_t srcOffset, size_t ByteCount);

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

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

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

4195 hipStream_t stream);

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

4216 size_t ByteCount, hipStream_t stream);

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

4237 size_t ByteCount, hipStream_t stream);

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

4253 hipModule_t hmod, const char* name);

4254

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

4265

4266

4267

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

4278

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

4299 hipDriverProcAddressQueryResult* symbolStatus);

4300

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

4322 size_t sizeBytes, size_t offset __dparm(0),

4323 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice));

4324

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

4339 size_t sizeBytes, size_t offset,

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

4341

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

4355 size_t sizeBytes, size_t offset __dparm(0),

4356 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost));

4357

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

4372 size_t sizeBytes, size_t offset,

4373 hipMemcpyKind kind,

4374 hipStream_t stream __dparm(0));

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

4405 hipStream_t stream __dparm(0));

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

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

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

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

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

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

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

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

4510 hipStream_t stream __dparm(0));

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

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

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

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

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

4570

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

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

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

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

4617hipError_t hipArrayDestroy(hipArray_t array);

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

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

4648hipError_t hipFreeArray(hipArray_t array);

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

4661 struct hipExtent extent, unsigned int flags);

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

4675 hipArray_t array);

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

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

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

4729 size_t height, hipMemcpyKind kind);

4739hipError_t hipMemcpyParam2D(const hip_Memcpy2D* pCopy);

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

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

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

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

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

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

4808 size_t spitch, size_t width, size_t height, hipMemcpyKind kind,

4809 hipStream_t stream __dparm(0));

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

4829 hipArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc,

4830 size_t width, size_t height, hipMemcpyKind kind);

4849HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

4851 size_t count, hipMemcpyKind kind);

4870HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

4872 size_t count, hipMemcpyKind kind);

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

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

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

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

4948hipError_t hipMemcpy3D(const struct hipMemcpy3DParms* p);

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

4971hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D* pCopy);

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

4984// doxygen end Memory

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

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

5041hipError_t hipDeviceDisablePeerAccess(int peerDeviceId);

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

5055#ifndef USE_PEER_NON_UNIFIED

5056#define USE_PEER_NON_UNIFIED 1

5057#endif

5058#if USE_PEER_NON_UNIFIED == 1

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

5071 size_t sizeBytes);

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

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

5086#endif

5087// doxygen end PeerToPeer

5128HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5143HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5144hipError_t hipCtxDestroy(hipCtx_t ctx);

5158HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5159hipError_t hipCtxPopCurrent(hipCtx_t* ctx);

5173HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5174hipError_t hipCtxPushCurrent(hipCtx_t ctx);

5188HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5189hipError_t hipCtxSetCurrent(hipCtx_t ctx);

5203HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5204hipError_t hipCtxGetCurrent(hipCtx_t* ctx);

5218HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5219hipError_t hipCtxGetDevice(hipDevice_t* device);

5240HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5258HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5259hipError_t hipCtxGetCacheConfig(hipFuncCache_t* cacheConfig);

5276HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5277hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig);

5294HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5295hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config);

5312HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5313hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig* pConfig);

5328HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5329hipError_t hipCtxSynchronize(void);

5343HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5344hipError_t hipCtxGetFlags(unsigned int* flags);

5367HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5388HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5389hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx);

5390

5406HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5423HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5424hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev);

5439HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5454HIP_DEPRECATED(HIP_DEPRECATED_MSG)

5455hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev);

5470HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

5472// doxygen end Context Management

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

5509hipError_t hipModuleUnload(hipModule_t module);

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

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

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

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

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

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

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

5583 hipJitOption* options, void** optionValues);

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

5613 unsigned int gridDimZ, unsigned int blockDimX,

5614 unsigned int blockDimY, unsigned int blockDimZ,

5615 unsigned int sharedMemBytes, hipStream_t stream,

5616 void** kernelParams, void** extra);

5645hipError_t hipModuleLaunchCooperativeKernel(hipFunction_t f, unsigned int gridDimX,

5646 unsigned int gridDimY, unsigned int gridDimZ,

5647 unsigned int blockDimX, unsigned int blockDimY,

5648 unsigned int blockDimZ, unsigned int sharedMemBytes,

5649 hipStream_t stream, void** kernelParams);

5664hipError_t hipModuleLaunchCooperativeKernelMultiDevice(hipFunctionLaunchParams* launchParamsList,

5665 unsigned int numDevices,

5666 unsigned int flags);

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

5688 void** kernelParams, unsigned int sharedMemBytes,

5689 hipStream_t stream);

5701hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

5702 int numDevices, unsigned int flags);

5703

5704// Doxygen end group ModuleCooperativeG

5718hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

5719 int numDevices, unsigned int flags);

5720// doxygen end Module

5747//TODO - Match CUoccupancyB2DSize

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

5749 hipFunction_t f, size_t dynSharedMemPerBlk,

5750 int blockSizeLimit);

5766//TODO - Match CUoccupancyB2DSize

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

5768 hipFunction_t f, size_t dynSharedMemPerBlk,

5769 int blockSizeLimit, unsigned int flags);

5779hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(

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

5791hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

5802hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(

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

5814hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

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

5831 const void* f, size_t dynSharedMemPerBlk,

5832 int blockSizeLimit);

5833// doxygen end Occupancy

5847// TODO - expand descriptions:

5854HIP_DEPRECATED("use roctracer/rocTX instead")

5855hipError_t hipProfilerStart();

5862HIP_DEPRECATED("use roctracer/rocTX instead")

5863hipError_t hipProfilerStop();

5864// doxygen end profiler

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

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

5911hipError_t hipLaunchByPtr(const void* func);

5928hipError_t __hipPushCallConfiguration(dim3 gridDim,

5929 dim3 blockDim,

5930 size_t sharedMem __dparm(0),

5931 hipStream_t stream __dparm(0));

5951hipError_t __hipPopCallConfiguration(dim3 *gridDim,

5952 dim3 *blockDim,

5953 size_t *sharedMem,

5954 hipStream_t *stream);

5971hipError_t hipLaunchKernel(const void* function_address,

5972 dim3 numBlocks,

5973 dim3 dimBlocks,

5974 void** args,

5975 size_t sharedMemBytes __dparm(0),

5976 hipStream_t stream __dparm(0));

5977

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

6004

6012hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D* pCopy);

6013//TODO: Move this to hip_ext.h

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

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

6037 hipEvent_t startEvent, hipEvent_t stopEvent, int flags);

6038// doxygen end Clang launch

6064hipError_t hipCreateTextureObject(

6065 hipTextureObject_t* pTexObject,

6066 const hipResourceDesc* pResDesc,

6067 const hipTextureDesc* pTexDesc,

6068 const struct hipResourceViewDesc* pResViewDesc);

6069

6078hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject);

6079

6089hipError_t hipGetChannelDesc(

6090 hipChannelFormatDesc* desc,

6091 hipArray_const_t array);

6092

6102hipError_t hipGetTextureObjectResourceDesc(

6103 hipResourceDesc* pResDesc,

6104 hipTextureObject_t textureObject);

6105

6115hipError_t hipGetTextureObjectResourceViewDesc(

6116 struct hipResourceViewDesc* pResViewDesc,

6117 hipTextureObject_t textureObject);

6118

6128hipError_t hipGetTextureObjectTextureDesc(

6129 hipTextureDesc* pTexDesc,

6130 hipTextureObject_t textureObject);

6131

6143hipError_t hipTexObjectCreate(

6144 hipTextureObject_t* pTexObject,

6145 const HIP_RESOURCE_DESC* pResDesc,

6146 const HIP_TEXTURE_DESC* pTexDesc,

6147 const HIP_RESOURCE_VIEW_DESC* pResViewDesc);

6148

6157hipError_t hipTexObjectDestroy(

6158 hipTextureObject_t texObject);

6159

6169hipError_t hipTexObjectGetResourceDesc(

6170 HIP_RESOURCE_DESC* pResDesc,

6171 hipTextureObject_t texObject);

6172

6182hipError_t hipTexObjectGetResourceViewDesc(

6183 HIP_RESOURCE_VIEW_DESC* pResViewDesc,

6184 hipTextureObject_t texObject);

6185

6195hipError_t hipTexObjectGetTextureDesc(

6196 HIP_TEXTURE_DESC* pTexDesc,

6197 hipTextureObject_t texObject);

6198

6213hipError_t hipMallocMipmappedArray(

6214 hipMipmappedArray_t *mipmappedArray,

6215 const struct hipChannelFormatDesc* desc,

6216 struct hipExtent extent,

6217 unsigned int numLevels,

6218 unsigned int flags __dparm(0));

6219

6230hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray);

6231

6244hipError_t hipGetMipmappedArrayLevel(

6245 hipArray_t *levelArray,

6246 hipMipmappedArray_const_t mipmappedArray,

6247 unsigned int level);

6248

6260hipError_t hipMipmappedArrayCreate(

6261 hipMipmappedArray_t* pHandle,

6262 HIP_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc,

6263 unsigned int numMipmapLevels);

6264

6275hipError_t hipMipmappedArrayDestroy(hipMipmappedArray_t hMipmappedArray);

6276

6289hipError_t hipMipmappedArrayGetLevel(

6290 hipArray_t* pLevelArray,

6291 hipMipmappedArray_t hMipMappedArray,

6292 unsigned int level);

6293

6312HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6313hipError_t hipBindTextureToMipmappedArray(

6314 const textureReference* tex,

6315 hipMipmappedArray_const_t mipmappedArray,

6316 const hipChannelFormatDesc* desc);

6317

6328HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6329hipError_t hipGetTextureReference(

6330 const textureReference** texref,

6331 const void* symbol);

6332

6343HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6345

6357HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

6359

6371HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6372hipError_t hipTexRefSetAddressMode(

6373 textureReference* texRef,

6374 int dim,

6375 enum hipTextureAddressMode am);

6388HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6389hipError_t hipTexRefSetArray(

6390 textureReference* tex,

6391 hipArray_const_t array,

6392 unsigned int flags);

6404HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6405hipError_t hipTexRefSetFilterMode(

6406 textureReference* texRef,

6407 enum hipTextureFilterMode fm);

6419HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6420hipError_t hipTexRefSetFlags(

6421 textureReference* texRef,

6422 unsigned int Flags);

6435HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6436hipError_t hipTexRefSetFormat(

6437 textureReference* texRef,

6438 hipArray_Format fmt,

6439 int NumPackedComponents);

6454HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6455hipError_t hipBindTexture(

6456 size_t* offset,

6457 const textureReference* tex,

6458 const void* devPtr,

6459 const hipChannelFormatDesc* desc,

6460 size_t size __dparm(UINT_MAX));

6477HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6478hipError_t hipBindTexture2D(

6479 size_t* offset,

6480 const textureReference* tex,

6481 const void* devPtr,

6482 const hipChannelFormatDesc* desc,

6483 size_t width,

6484 size_t height,

6485 size_t pitch);

6498HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6499hipError_t hipBindTextureToArray(

6500 const textureReference* tex,

6501 hipArray_const_t array,

6502 const hipChannelFormatDesc* desc);

6514HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6515hipError_t hipGetTextureAlignmentOffset(

6516 size_t* offset,

6517 const textureReference* texref);

6528HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6529hipError_t hipUnbindTexture(const textureReference* tex);

6541HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6542hipError_t hipTexRefGetAddress(

6543 hipDeviceptr_t* dev_ptr,

6544 const textureReference* texRef);

6557HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6558hipError_t hipTexRefGetAddressMode(

6559 enum hipTextureAddressMode* pam,

6560 const textureReference* texRef,

6561 int dim);

6573HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6574hipError_t hipTexRefGetFilterMode(

6575 enum hipTextureFilterMode* pfm,

6576 const textureReference* texRef);

6588HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6589hipError_t hipTexRefGetFlags(

6590 unsigned int* pFlags,

6591 const textureReference* texRef);

6604HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6605hipError_t hipTexRefGetFormat(

6606 hipArray_Format* pFormat,

6607 int* pNumChannels,

6608 const textureReference* texRef);

6620HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6621hipError_t hipTexRefGetMaxAnisotropy(

6622 int* pmaxAnsio,

6623 const textureReference* texRef);

6635HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6636hipError_t hipTexRefGetMipmapFilterMode(

6637 enum hipTextureFilterMode* pfm,

6638 const textureReference* texRef);

6650HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6651hipError_t hipTexRefGetMipmapLevelBias(

6652 float* pbias,

6653 const textureReference* texRef);

6666HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6667hipError_t hipTexRefGetMipmapLevelClamp(

6668 float* pminMipmapLevelClamp,

6669 float* pmaxMipmapLevelClamp,

6670 const textureReference* texRef);

6682HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6683hipError_t hipTexRefGetMipMappedArray(

6684 hipMipmappedArray_t* pArray,

6685 const textureReference* texRef);

6699HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6700hipError_t hipTexRefSetAddress(

6701 size_t* ByteOffset,

6702 textureReference* texRef,

6703 hipDeviceptr_t dptr,

6704 size_t bytes);

6718HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6719hipError_t hipTexRefSetAddress2D(

6720 textureReference* texRef,

6721 const HIP_ARRAY_DESCRIPTOR* desc,

6722 hipDeviceptr_t dptr,

6723 size_t Pitch);

6735HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6736hipError_t hipTexRefSetMaxAnisotropy(

6737 textureReference* texRef,

6738 unsigned int maxAniso);

6750HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6751hipError_t hipTexRefSetBorderColor(

6752 textureReference* texRef,

6753 float* pBorderColor);

6765HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6766hipError_t hipTexRefSetMipmapFilterMode(

6767 textureReference* texRef,

6768 enum hipTextureFilterMode fm);

6780HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6781hipError_t hipTexRefSetMipmapLevelBias(

6782 textureReference* texRef,

6783 float bias);

6796HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6797hipError_t hipTexRefSetMipmapLevelClamp(

6798 textureReference* texRef,

6799 float minMipMapLevelClamp,

6800 float maxMipMapLevelClamp);

6813HIP_DEPRECATED(HIP_DEPRECATED_MSG)

6814hipError_t hipTexRefSetMipmappedArray(

6815 textureReference* texRef,

6816 struct hipMipmappedArray* mipmappedArray,

6817 unsigned int Flags);

6818

6819// doxygen end deprecated texture management

6824// doxygen end Texture management

6836// This group is for HIPrtc

6837

6838// doxygen end Runtime

6857const char* hipApiName(uint32_t id);

6866const char* hipKernelNameRef(const hipFunction_t f);

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

6885int hipGetStreamDeviceId(hipStream_t stream);

6886

6887// doxygen end Callback

6912hipError_t hipStreamBeginCapture(hipStream_t stream, hipStreamCaptureMode mode);

6913

6933hipError_t hipStreamBeginCaptureToGraph(hipStream_t stream, hipGraph_t graph,

6934 const hipGraphNode_t* dependencies,

6935 const hipGraphEdgeData* dependencyData,

6936 size_t numDependencies, hipStreamCaptureMode mode);

6937

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

6951

6965hipError_t hipStreamGetCaptureInfo(hipStream_t stream, hipStreamCaptureStatus* pCaptureStatus,

6966 unsigned long long* pId);

6967

6984hipError_t hipStreamGetCaptureInfo_v2(hipStream_t stream, hipStreamCaptureStatus* captureStatus_out,

6985 unsigned long long* id_out __dparm(0),

6986 hipGraph_t* graph_out __dparm(0),

6987 const hipGraphNode_t** dependencies_out __dparm(0),

6988 size_t* numDependencies_out __dparm(0));

6989

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

7003

7018hipError_t hipStreamUpdateCaptureDependencies(hipStream_t stream, hipGraphNode_t* dependencies,

7019 size_t numDependencies,

7020 unsigned int flags __dparm(0));

7021

7032hipError_t hipThreadExchangeStreamCaptureMode(hipStreamCaptureMode* mode);

7033

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

7047

7059hipError_t hipGraphDestroy(hipGraph_t graph);

7060

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

7075 const hipGraphNode_t* to, size_t numDependencies);

7076

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

7091 const hipGraphNode_t* to, size_t numDependencies);

7092

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

7111 size_t* numEdges);

7112

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

7130

7147hipError_t hipGraphGetRootNodes(hipGraph_t graph, hipGraphNode_t* pRootNodes,

7148 size_t* pNumRootNodes);

7149

7166hipError_t hipGraphNodeGetDependencies(hipGraphNode_t node, hipGraphNode_t* pDependencies,

7167 size_t* pNumDependencies);

7168

7186hipError_t hipGraphNodeGetDependentNodes(hipGraphNode_t node, hipGraphNode_t* pDependentNodes,

7187 size_t* pNumDependentNodes);

7188

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

7201

7212hipError_t hipGraphDestroyNode(hipGraphNode_t node);

7213

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

7226

7239hipError_t hipGraphNodeFindInClone(hipGraphNode_t* pNode, hipGraphNode_t originalNode,

7240 hipGraph_t clonedGraph);

7241

7258hipError_t hipGraphInstantiate(hipGraphExec_t* pGraphExec, hipGraph_t graph,

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

7260

7273hipError_t hipGraphInstantiateWithFlags(hipGraphExec_t* pGraphExec, hipGraph_t graph,

7274 unsigned long long flags);

7275

7287hipError_t hipGraphInstantiateWithParams(hipGraphExec_t* pGraphExec, hipGraph_t graph,

7288 hipGraphInstantiateParams *instantiateParams);

7299hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream);

7300

7311hipError_t hipGraphUpload(hipGraphExec_t graphExec, hipStream_t stream);

7312

7325hipError_t hipGraphAddNode(hipGraphNode_t *pGraphNode, hipGraph_t graph,

7326 const hipGraphNode_t *pDependencies, size_t numDependencies,

7327 hipGraphNodeParams *nodeParams);

7328

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

7339

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

7350

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

7362

7373hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec);

7374

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

7389hipError_t hipGraphExecUpdate(hipGraphExec_t hGraphExec, hipGraph_t hGraph,

7390 hipGraphNode_t* hErrorNode_out,

7391 hipGraphExecUpdateResult* updateResult_out);

7392

7405hipError_t hipGraphAddKernelNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7406 const hipGraphNode_t* pDependencies, size_t numDependencies,

7407 const hipKernelNodeParams* pNodeParams);

7408

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

7419

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

7430

7441hipError_t hipGraphExecKernelNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7442 const hipKernelNodeParams* pNodeParams);

7443

7457hipError_t hipDrvGraphAddMemcpyNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

7458 const hipGraphNode_t* dependencies,

7459 size_t numDependencies,

7460 const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);

7473hipError_t hipGraphAddMemcpyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7474 const hipGraphNode_t* pDependencies, size_t numDependencies,

7475 const hipMemcpy3DParms* pCopyParams);

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

7486

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

7497

7508hipError_t hipGraphKernelNodeSetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

7509 const hipKernelNodeAttrValue* value);

7520hipError_t hipGraphKernelNodeGetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

7521 hipKernelNodeAttrValue* value);

7532hipError_t hipGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7533 hipMemcpy3DParms* pNodeParams);

7534

7550hipError_t hipGraphAddMemcpyNode1D(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7551 const hipGraphNode_t* pDependencies, size_t numDependencies,

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

7553

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

7567 size_t count, hipMemcpyKind kind);

7568

7583hipError_t hipGraphExecMemcpyNodeSetParams1D(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

7585 hipMemcpyKind kind);

7586

7603hipError_t hipGraphAddMemcpyNodeFromSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7604 const hipGraphNode_t* pDependencies,

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

7606 size_t count, size_t offset, hipMemcpyKind kind);

7607

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

7622 size_t count, size_t offset, hipMemcpyKind kind);

7623

7639hipError_t hipGraphExecMemcpyNodeSetParamsFromSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

7641 size_t offset, hipMemcpyKind kind);

7642

7659hipError_t hipGraphAddMemcpyNodeToSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7660 const hipGraphNode_t* pDependencies,

7661 size_t numDependencies, const void* symbol,

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

7663 hipMemcpyKind kind);

7664

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

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

7680 hipMemcpyKind kind);

7681

7682

7697hipError_t hipGraphExecMemcpyNodeSetParamsToSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7698 const void* symbol, const void* src,

7699 size_t count, size_t offset, hipMemcpyKind kind);

7700

7713hipError_t hipGraphAddMemsetNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7714 const hipGraphNode_t* pDependencies, size_t numDependencies,

7715 const hipMemsetParams* pMemsetParams);

7716

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

7727

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

7738

7749hipError_t hipGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7750 const hipMemsetParams* pNodeParams);

7751

7764hipError_t hipGraphAddHostNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7765 const hipGraphNode_t* pDependencies, size_t numDependencies,

7766 const hipHostNodeParams* pNodeParams);

7767

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

7778

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

7789

7800hipError_t hipGraphExecHostNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7801 const hipHostNodeParams* pNodeParams);

7802

7815hipError_t hipGraphAddChildGraphNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7816 const hipGraphNode_t* pDependencies, size_t numDependencies,

7817 hipGraph_t childGraph);

7818

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

7829

7840hipError_t hipGraphExecChildGraphNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7841 hipGraph_t childGraph);

7842

7854hipError_t hipGraphAddEmptyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7855 const hipGraphNode_t* pDependencies, size_t numDependencies);

7856

7857

7870hipError_t hipGraphAddEventRecordNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7871 const hipGraphNode_t* pDependencies, size_t numDependencies,

7872 hipEvent_t event);

7873

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

7884

7894hipError_t hipGraphEventRecordNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

7895

7906hipError_t hipGraphExecEventRecordNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

7907 hipEvent_t event);

7908

7921hipError_t hipGraphAddEventWaitNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7922 const hipGraphNode_t* pDependencies, size_t numDependencies,

7923 hipEvent_t event);

7924

7925

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

7936

7946hipError_t hipGraphEventWaitNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

7947

7958hipError_t hipGraphExecEventWaitNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

7959 hipEvent_t event);

7960

7973hipError_t hipGraphAddMemAllocNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

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

7975

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

7986

7999hipError_t hipGraphAddMemFreeNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

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

8001

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

8012

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

8024

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

8036

8046hipError_t hipDeviceGraphMemTrim(int device);

8047

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

8061 unsigned int initialRefcount, unsigned int flags);

8062

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

8073

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

8084

8096hipError_t hipGraphRetainUserObject(hipGraph_t graph, hipUserObject_t object,

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

8098

8109hipError_t hipGraphReleaseUserObject(hipGraph_t graph, hipUserObject_t object,

8110 unsigned int count __dparm(1));

8111

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

8123

8138hipError_t hipGraphKernelNodeCopyAttributes(hipGraphNode_t hSrc, hipGraphNode_t hDst);

8139

8162hipError_t hipGraphNodeSetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8163 unsigned int isEnabled);

8184hipError_t hipGraphNodeGetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8185 unsigned int* isEnabled);

8186

8199hipError_t hipGraphAddExternalSemaphoresWaitNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8200 const hipGraphNode_t* pDependencies, size_t numDependencies,

8201 const hipExternalSemaphoreWaitNodeParams* nodeParams);

8202

8215hipError_t hipGraphAddExternalSemaphoresSignalNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

8216 const hipGraphNode_t* pDependencies, size_t numDependencies,

8217 const hipExternalSemaphoreSignalNodeParams* nodeParams);

8227hipError_t hipGraphExternalSemaphoresSignalNodeSetParams(hipGraphNode_t hNode,

8228 const hipExternalSemaphoreSignalNodeParams* nodeParams);

8238hipError_t hipGraphExternalSemaphoresWaitNodeSetParams(hipGraphNode_t hNode,

8239 const hipExternalSemaphoreWaitNodeParams* nodeParams);

8249hipError_t hipGraphExternalSemaphoresSignalNodeGetParams(hipGraphNode_t hNode,

8250 hipExternalSemaphoreSignalNodeParams* params_out);

8260hipError_t hipGraphExternalSemaphoresWaitNodeGetParams(hipGraphNode_t hNode,

8261 hipExternalSemaphoreWaitNodeParams* params_out);

8272hipError_t hipGraphExecExternalSemaphoresSignalNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8273 const hipExternalSemaphoreSignalNodeParams* nodeParams);

8284hipError_t hipGraphExecExternalSemaphoresWaitNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8285 const hipExternalSemaphoreWaitNodeParams* nodeParams);

8286

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

8297

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

8308

8322hipError_t hipDrvGraphAddMemsetNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

8323 const hipGraphNode_t* dependencies, size_t numDependencies,

8324 const HIP_MEMSET_NODE_PARAMS* memsetParams, hipCtx_t ctx);

8325

8338hipError_t hipDrvGraphAddMemFreeNode(hipGraphNode_t* phGraphNode, hipGraph_t hGraph,

8339 const hipGraphNode_t* dependencies, size_t numDependencies,

8340 hipDeviceptr_t dptr);

8341

8353hipError_t hipDrvGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8354 const HIP_MEMCPY3D* copyParams, hipCtx_t ctx);

8355

8367hipError_t hipDrvGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

8368 const HIP_MEMSET_NODE_PARAMS* memsetParams, hipCtx_t ctx);

8369

8370// doxygen end graph API

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

8402

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

8418

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

8433

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

8448

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

8462

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

8477

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

8490

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

8504

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

8520

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

8532

8543hipError_t hipMemRelease(hipMemGenericAllocationHandle_t handle);

8544

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

8557

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

8572

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

8585

8586// doxygen end virtual memory management API

8608hipError_t hipGraphicsMapResources(int count, hipGraphicsResource_t* resources,

8609 hipStream_t stream __dparm(0) );

8623hipError_t hipGraphicsSubResourceGetMappedArray(hipArray_t* array, hipGraphicsResource_t resource,

8624 unsigned int arrayIndex, unsigned int mipLevel);

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

8636 hipGraphicsResource_t resource);

8647hipError_t hipGraphicsUnmapResources(int count, hipGraphicsResource_t* resources,

8648 hipStream_t stream __dparm(0));

8657hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource);

8658// doxygen end GL Interop

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

8692hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject);

8693// end of surface

8697#ifdef __cplusplus

8698} /* extern "c" */

8699#endif

8700#ifdef __cplusplus

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

8702template <typename T>

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

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

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

8706}

8707template <typename T>

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

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

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

8711}

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

8713

8723template <typename T>

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

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

8726}

8737template <typename T>

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

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

8740}

8741

8750template <typename T>

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

8752 size_t offset __dparm(0),

8753 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice)) {

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

8755}

8764template <typename T>

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

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

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

8768}

8776template <typename T>

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

8778 size_t sizeBytes, size_t offset __dparm(0),

8779 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost)) {

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

8781}

8789template <typename T>

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

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

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

8793}

8794

8806template <class T>

8807inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(

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

8809 return hipOccupancyMaxActiveBlocksPerMultiprocessor(

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

8811}

8825template <class T>

8826inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

8828 return hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

8830}

8851template<typename UnaryFunction, class T>

8852static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(

8853 int* min_grid_size,

8854 int* block_size,

8855 T func,

8856 UnaryFunction block_size_to_dynamic_smem_size,

8857 int block_size_limit = 0,

8858 unsigned int flags = 0) {

8859 if (min_grid_size == nullptr || block_size == nullptr ||

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

8861 return hipErrorInvalidValue;

8862 }

8863

8864 int dev;

8865 hipError_t status;

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

8867 return status;

8868 }

8869

8870 int max_threads_per_cu;

8871 if ((status = hipDeviceGetAttribute(&max_threads_per_cu,

8872 hipDeviceAttributeMaxThreadsPerMultiProcessor, dev)) != hipSuccess) {

8873 return status;

8874 }

8875

8876 int warp_size;

8877 if ((status = hipDeviceGetAttribute(&warp_size,

8878 hipDeviceAttributeWarpSize, dev)) != hipSuccess) {

8879 return status;

8880 }

8881

8882 int max_cu_count;

8883 if ((status = hipDeviceGetAttribute(&max_cu_count,

8884 hipDeviceAttributeMultiprocessorCount, dev)) != hipSuccess) {

8885 return status;

8886 }

8887

8888 struct hipFuncAttributes attr;

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

8890 return status;

8891 }

8892

8893 // Initial limits for the execution

8894 const int func_max_threads_per_block = attr.maxThreadsPerBlock;

8895 if (block_size_limit == 0) {

8896 block_size_limit = func_max_threads_per_block;

8897 }

8898

8899 if (func_max_threads_per_block < block_size_limit) {

8900 block_size_limit = func_max_threads_per_block;

8901 }

8902

8903 const int block_size_limit_aligned =

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

8905

8906 // For maximum search

8907 int max_threads = 0;

8908 int max_block_size{};

8909 int max_num_blocks{};

8910 for (int block_size_check_aligned = block_size_limit_aligned;

8911 block_size_check_aligned > 0;

8912 block_size_check_aligned -= warp_size) {

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

8914 int block_size_check = (block_size_limit < block_size_check_aligned) ?

8915 block_size_limit : block_size_check_aligned;

8916

8917 size_t dyn_smem_size = block_size_to_dynamic_smem_size(block_size_check);

8918 int optimal_blocks;

8919 if ((status = hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

8921 return status;

8922 }

8923

8924 int total_threads = block_size_check * optimal_blocks;

8925 if (total_threads > max_threads) {

8926 max_block_size = block_size_check;

8927 max_num_blocks = optimal_blocks;

8928 max_threads = total_threads;

8929 }

8930

8931 // Break if the logic reached possible maximum

8932 if (max_threads_per_cu == max_threads) {

8933 break;

8934 }

8935 }

8936

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

8938 *min_grid_size = max_num_blocks * max_cu_count;

8939 *block_size = max_block_size;

8940

8941 return status;

8942}

8943

8963template<typename UnaryFunction, class T>

8964static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMem(

8965 int* min_grid_size,

8966 int* block_size,

8967 T func,

8968 UnaryFunction block_size_to_dynamic_smem_size,

8969 int block_size_limit = 0)

8970{

8971 return hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(min_grid_size, block_size, func,

8972 block_size_to_dynamic_smem_size, block_size_limit);

8973}

8988template <typename F>

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

8990 F kernel, size_t dynSharedMemPerBlk, uint32_t blockSizeLimit) {

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

8992}

9014template <class T>

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

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

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

9018 blockDim, kernelParams, sharedMemBytes, stream);

9019}

9035template <class T>

9036inline hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

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

9038 return hipLaunchCooperativeKernelMultiDevice(launchParamsList, numDevices, flags);

9039}

9054template <class T>

9055inline hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

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

9057 return hipExtLaunchMultiKernelMultiDevice(launchParamsList, numDevices, flags);

9058}

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

9073HIP_DEPRECATED(HIP_DEPRECATED_MSG)

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

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

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

9077}

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

9093HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9094static inline hipError_t

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

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

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

9098}

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

9115HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9116static inline hipError_t hipBindTexture2D(

9117 size_t *offset,

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

9119 const void *devPtr,

9120 size_t width,

9121 size_t height,

9122 size_t pitch)

9123{

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

9125}

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

9143HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9144static inline hipError_t hipBindTexture2D(

9145 size_t *offset,

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

9147 const void *devPtr,

9148 const struct hipChannelFormatDesc &desc,

9149 size_t width,

9150 size_t height,

9151 size_t pitch)

9152{

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

9154}

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

9167HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9168static inline hipError_t hipBindTextureToArray(

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

9170 hipArray_const_t array)

9171{

9172 struct hipChannelFormatDesc desc;

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

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

9175}

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

9189HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9190static inline hipError_t hipBindTextureToArray(

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

9192 hipArray_const_t array,

9193 const struct hipChannelFormatDesc &desc)

9194{

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

9196}

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

9209HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9210static inline hipError_t hipBindTextureToMipmappedArray(

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

9212 hipMipmappedArray_const_t mipmappedArray)

9213{

9214 struct hipChannelFormatDesc desc;

9215 hipArray_t levelArray;

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

9217 if (err != hipSuccess) {

9218 return err;

9219 }

9220 err = hipGetChannelDesc(&desc, levelArray);

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

9222}

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

9236HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9237static inline hipError_t hipBindTextureToMipmappedArray(

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

9239 hipMipmappedArray_const_t mipmappedArray,

9240 const struct hipChannelFormatDesc &desc)

9241{

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

9243}

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

9255HIP_DEPRECATED(HIP_DEPRECATED_MSG)

9256static inline hipError_t hipUnbindTexture(

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

9258{

9259 return hipUnbindTexture(&tex);

9260}

9284static inline hipError_t hipMallocAsync(

9285 void** dev_ptr,

9286 size_t size,

9287 hipMemPool_t mem_pool,

9288 hipStream_t stream) {

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

9290}

9301template<class T>

9302static inline hipError_t hipMallocAsync(

9303 T** dev_ptr,

9304 size_t size,

9305 hipMemPool_t mem_pool,

9306 hipStream_t stream) {

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

9308}

9319template<class T>

9320static inline hipError_t hipMallocAsync(

9321 T** dev_ptr,

9322 size_t size,

9323 hipStream_t stream) {

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

9325}

9336template<class T>

9337static inline hipError_t hipMallocFromPoolAsync(

9338 T** dev_ptr,

9339 size_t size,

9340 hipMemPool_t mem_pool,

9341 hipStream_t stream) {

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

9343}

9349#endif // __cplusplus

9350

9351#ifdef __GNUC__

9352#pragma GCC visibility pop

9353#endif

9354

9355

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

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

9358#else

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

9360#endif

9361

9362

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

9375template <class T>

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

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

9378}

9390template <class T>

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

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

9393}

9406template <class T>

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

9408 unsigned int flags = hipHostMallocDefault) {

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

9410}

9423template <class T>

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

9425 unsigned int flags = hipHostAllocDefault) {

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

9427}

9442template <class T>

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

9444 unsigned int flags = hipMemAttachGlobal) {

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

9446}

9447

9448

9449#endif

9450#endif

9451// doxygen end HIP API

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

9456

9457#if USE_PROF_API

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

9459#endif

driver_types.h

hipApiName

const char * hipApiName(uint32_t id)

Returns HIP API name by ID.

hipKernelNameRef

const char * hipKernelNameRef(const hipFunction_t f)

Returns kernel name reference by function name.

hipKernelNameRefByPtr

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

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

hipGetStreamDeviceId

int hipGetStreamDeviceId(hipStream_t stream)

Returns device ID on the stream.

hipSetupArgument

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

Set a kernel argument.

__hipPopCallConfiguration

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

Pop configuration of a kernel launch.

hipLaunchHostFunc

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

Enqueues a host function call in a stream.

hipLaunchKernel

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

C compliant kernel launch API.

hipExtLaunchKernel

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

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

__hipPushCallConfiguration

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

Push configuration of a kernel launch.

hipLaunchByPtr

hipError_t hipLaunchByPtr(const void *func)

Launch a kernel.

hipDrvMemcpy2DUnaligned

hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D *pCopy)

hipConfigureCall

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

Configure a kernel launch.

hipCtxGetFlags

hipError_t hipCtxGetFlags(unsigned int *flags)

Return flags used for creating default context [Deprecated].

hipCtxPopCurrent

hipError_t hipCtxPopCurrent(hipCtx_t *ctx)

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

hipCtxGetSharedMemConfig

hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig *pConfig)

Get Shared memory bank configuration [Deprecated].

hipDevicePrimaryCtxSetFlags

hipError_t hipDevicePrimaryCtxSetFlags(hipDevice_t dev, unsigned int flags)

Set flags for the primary context [Deprecated].

hipDevicePrimaryCtxGetState

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

Get the state of the primary context [Deprecated].

hipCtxGetCurrent

hipError_t hipCtxGetCurrent(hipCtx_t *ctx)

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

hipDevicePrimaryCtxRelease

hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev)

Release the primary context on the GPU.

hipCtxSetCacheConfig

hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig)

Set L1/Shared cache partition [Deprecated].

hipCtxSetCurrent

hipError_t hipCtxSetCurrent(hipCtx_t ctx)

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

hipCtxEnablePeerAccess

hipError_t hipCtxEnablePeerAccess(hipCtx_t peerCtx, unsigned int flags)

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

hipCtxGetDevice

hipError_t hipCtxGetDevice(hipDevice_t *device)

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

hipCtxDestroy

hipError_t hipCtxDestroy(hipCtx_t ctx)

Destroy a HIP context [Deprecated].

hipCtxPushCurrent

hipError_t hipCtxPushCurrent(hipCtx_t ctx)

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

hipCtxGetCacheConfig

hipError_t hipCtxGetCacheConfig(hipFuncCache_t *cacheConfig)

Get Cache configuration for a specific function [Deprecated].

hipCtxCreate

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

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

hipDevicePrimaryCtxRetain

hipError_t hipDevicePrimaryCtxRetain(hipCtx_t *pctx, hipDevice_t dev)

Retain the primary context on the GPU [Deprecated].

hipCtxGetApiVersion

hipError_t hipCtxGetApiVersion(hipCtx_t ctx, int *apiVersion)

Returns the approximate HIP api version.

hipDevicePrimaryCtxReset

hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev)

Resets the primary context on the GPU [Deprecated].

hipCtxSynchronize

hipError_t hipCtxSynchronize(void)

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

hipCtxSetSharedMemConfig

hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config)

Set Shared memory bank configuration [Deprecated].

hipCtxDisablePeerAccess

hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx)

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

hipGetDeviceFlags

hipError_t hipGetDeviceFlags(unsigned int *flags)

Gets the flags set for current device.

hipIpcGetEventHandle

hipError_t hipIpcGetEventHandle(hipIpcEventHandle_t *handle, hipEvent_t event)

Gets an opaque interprocess handle for an event.

hipDeviceGetDefaultMemPool

hipError_t hipDeviceGetDefaultMemPool(hipMemPool_t *mem_pool, int device)

Returns the default memory pool of the specified device.

hipDeviceGetSharedMemConfig

hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig *pConfig)

Returns bank width of shared memory for current device.

hipDeviceSetMemPool

hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool)

Sets the current memory pool of a device.

hipIpcOpenMemHandle

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

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

hipDeviceGetCacheConfig

hipError_t hipDeviceGetCacheConfig(hipFuncCache_t *cacheConfig)

Get Cache configuration for a specific Device.

hipSetDevice

hipError_t hipSetDevice(int deviceId)

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

hipExtGetLinkTypeAndHopCount

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

Returns the link type and hop count between two devices.

hipSetDeviceFlags

hipError_t hipSetDeviceFlags(unsigned flags)

The current device behavior is changed according the flags passed.

hipDeviceGetAttribute

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

Query for a specific device attribute.

hipGetDevice

hipError_t hipGetDevice(int *deviceId)

Return the default device id for the calling host thread.

hipGetDeviceCount

hipError_t hipGetDeviceCount(int *count)

Return number of compute-capable devices.

hipDeviceGetMemPool

hipError_t hipDeviceGetMemPool(hipMemPool_t *mem_pool, int device)

Gets the current memory pool for the specified device.

hipDeviceReset

hipError_t hipDeviceReset(void)

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

hipDeviceGetLimit

hipError_t hipDeviceGetLimit(size_t *pValue, enum hipLimit_t limit)

Gets resource limits of current device.

hipDeviceSetSharedMemConfig

hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config)

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

hipDeviceSetLimit

hipError_t hipDeviceSetLimit(enum hipLimit_t limit, size_t value)

Sets resource limits of current device.

hipDeviceSetCacheConfig

hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig)

Set L1/Shared cache partition.

hipIpcCloseMemHandle

hipError_t hipIpcCloseMemHandle(void *devPtr)

Close memory mapped with hipIpcOpenMemHandle.

hipSetValidDevices

hipError_t hipSetValidDevices(int *device_arr, int len)

Set a list of devices that can be used.

hipIpcOpenEventHandle

hipError_t hipIpcOpenEventHandle(hipEvent_t *event, hipIpcEventHandle_t handle)

Opens an interprocess event handles.

hipDeviceSynchronize

hipError_t hipDeviceSynchronize(void)

Waits on all active streams on current device.

hipIpcGetMemHandle

hipError_t hipIpcGetMemHandle(hipIpcMemHandle_t *handle, void *devPtr)

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

hipInit

hipError_t hipInit(unsigned int flags)

Explicitly initializes the HIP runtime.

hipDeviceComputeCapability

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

Returns the compute capability of the device.

hipDeviceGetName

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

Returns an identifer string for the device.

hipDeviceGetByPCIBusId

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

Returns a handle to a compute device.

hipDeviceGetUuid

hipError_t hipDeviceGetUuid(hipUUID *uuid, hipDevice_t device)

Returns an UUID for the device.[BETA].

hipDeviceTotalMem

hipError_t hipDeviceTotalMem(size_t *bytes, hipDevice_t device)

Returns the total amount of memory on the device.

hipDeviceGetPCIBusId

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

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

hipDeviceGet

hipError_t hipDeviceGet(hipDevice_t *device, int ordinal)

Returns a handle to a compute device.

hipRuntimeGetVersion

hipError_t hipRuntimeGetVersion(int *runtimeVersion)

Returns the approximate HIP Runtime version.

hipDeviceGetP2PAttribute

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

Returns a value for attribute of link between two devices.

hipDriverGetVersion

hipError_t hipDriverGetVersion(int *driverVersion)

Returns the approximate HIP driver version.

hipMemcpyKind

hipMemcpyKind

Definition driver_types.h:376

hipPointer_attribute

hipPointer_attribute

Definition driver_types.h:517

hipArray_t

struct hipArray * hipArray_t

Definition driver_types.h:76

hipDeviceptr_t

void * hipDeviceptr_t

Definition driver_types.h:47

hipFunction_attribute

hipFunction_attribute

Definition driver_types.h:503

hipArray_const_t

const struct hipArray * hipArray_const_t

Definition driver_types.h:77

hipArray_Format

hipArray_Format

Definition driver_types.h:81

hipResourceType

hipResourceType

Definition driver_types.h:160

hipMemcpyDeviceToHost

@ hipMemcpyDeviceToHost

Device-to-Host Copy.

Definition driver_types.h:379

hipMemcpyHostToDevice

@ hipMemcpyHostToDevice

Host-to-Device Copy.

Definition driver_types.h:378

hipGetErrorString

const char * hipGetErrorString(hipError_t hipError)

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

hipPeekAtLastError

hipError_t hipPeekAtLastError(void)

Return last error returned by any HIP runtime API call.

hipDrvGetErrorString

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

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

hipGetLastError

hipError_t hipGetLastError(void)

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

hipExtGetLastError

hipError_t hipExtGetLastError(void)

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

hipDrvGetErrorName

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

Return hip error as text string form.

hipGetErrorName

const char * hipGetErrorName(hipError_t hip_error)

Return hip error as text string form.

hipEventSynchronize

hipError_t hipEventSynchronize(hipEvent_t event)

Wait for an event to complete.

hipEventQuery

hipError_t hipEventQuery(hipEvent_t event)

Query event status.

hipEventCreate

hipError_t hipEventCreate(hipEvent_t *event)

hipEventDestroy

hipError_t hipEventDestroy(hipEvent_t event)

Destroy the specified event.

hipEventRecord

hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream=NULL)

Record an event in the specified stream.

hipEventElapsedTime

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

Return the elapsed time between two events.

hipEventCreateWithFlags

hipError_t hipEventCreateWithFlags(hipEvent_t *event, unsigned flags)

Create an event with the specified flags.

hipFuncSetSharedMemConfig

hipError_t hipFuncSetSharedMemConfig(const void *func, hipSharedMemConfig config)

Set shared memory configuation for a specific function.

hipFuncSetAttribute

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

Set attribute for a specific function.

hipFuncSetCacheConfig

hipError_t hipFuncSetCacheConfig(const void *func, hipFuncCache_t config)

Set Cache configuration for a specific function.

hipDestroyExternalMemory

hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem)

Destroys an external memory object.

hipImportExternalSemaphore

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

Imports an external semaphore.

hipImportExternalMemory

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

Imports an external memory object.

hipDestroyExternalSemaphore

hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem)

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

hipWaitExternalSemaphoresAsync

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

Waits on a set of external semaphore objects.

hipSignalExternalSemaphoresAsync

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

Signals a set of external semaphore objects.

hipExternalMemoryGetMappedMipmappedArray

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

Maps a mipmapped array onto an external memory object.

hipExternalMemoryGetMappedBuffer

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

Maps a buffer onto an imported memory object.

hipGraphicsUnregisterResource

hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource)

Unregisters a graphics resource.

hipGraphicsUnmapResources

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

Unmaps graphics resources.

hipGraphicsSubResourceGetMappedArray

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

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

hipGraphicsResourceGetMappedPointer

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

Gets device accessible address of a graphics resource.

hipGraphicsMapResources

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

Maps a graphics resource for access.

hipLimit_t

hipLimit_t

Definition hip_runtime_api.h:651

hipMemAllocationHandleType

hipMemAllocationHandleType

Definition hip_runtime_api.h:975

hipGraphicsResource_t

hipGraphicsResource * hipGraphicsResource_t

Definition hip_runtime_api.h:1215

hipCtx_t

struct ihipCtx_t * hipCtx_t

Definition hip_runtime_api.h:606

__dparm

#define __dparm(x)

Definition hip_runtime_api.h:587

hipStream_t

struct ihipStream_t * hipStream_t

Definition hip_runtime_api.h:615

hipGraphInstantiateResult

hipGraphInstantiateResult

Definition hip_runtime_api.h:1430

hipDevice_t

int hipDevice_t

Definition hip_runtime_api.h:608

hipAccessProperty

hipAccessProperty

Definition hip_runtime_api.h:1290

hipGraphDependencyType

hipGraphDependencyType

Definition hip_runtime_api.h:1646

hipMemRangeAttribute

hipMemRangeAttribute

Definition hip_runtime_api.h:857

hipMemAttachSingle

#define hipMemAttachSingle

Definition hip_runtime_api.h:741

hipMemoryAdvise

hipMemoryAdvise

Definition hip_runtime_api.h:824

hipArrayDefault

#define hipArrayDefault

Definition hip_runtime_api.h:792

hipSharedMemConfig

hipSharedMemConfig

Definition hip_runtime_api.h:1045

hipKernelNodeAttrValue

#define hipKernelNodeAttrValue

Definition hip_runtime_api.h:1334

hipComputeMode

hipComputeMode

Definition hip_runtime_api.h:548

hipEvent_t

struct ihipEvent_t * hipEvent_t

Definition hip_runtime_api.h:643

hipStreamCaptureMode

hipStreamCaptureMode

Definition hip_runtime_api.h:1366

hipDriverProcAddressQueryResult

hipDriverProcAddressQueryResult

Definition hip_runtime_api.h:542

HIP_DEPRECATED_MSG

#define HIP_DEPRECATED_MSG

Definition hip_runtime_api.h:582

hipLaunchAttributeID

hipLaunchAttributeID

Definition hip_runtime_api.h:1306

hipGraphNodeType

hipGraphNodeType

Definition hip_runtime_api.h:1239

hipExternalMemoryHandleType

hipExternalMemoryHandleType

Definition hip_runtime_api.h:1089

hipMemAttachGlobal

#define hipMemAttachGlobal

Definition hip_runtime_api.h:735

hipFuncAttribute

hipFuncAttribute

Definition hip_runtime_api.h:1028

hipExternalSemaphoreHandleType

hipExternalSemaphoreHandleType

Definition hip_runtime_api.h:1127

hipJitOption

hipJitOption

Definition hip_runtime_api.h:1005

hipDeviceP2PAttr

hipDeviceP2PAttr

Definition hip_runtime_api.h:609

hipGraphDebugDotFlags

hipGraphDebugDotFlags

Definition hip_runtime_api.h:1408

hipUserObjectRetainFlags

hipUserObjectRetainFlags

Definition hip_runtime_api.h:1393

hipError_t

enum __HIP_NODISCARD hipError_t hipError_t

Definition hip_runtime_api.h:287

hipHostAllocDefault

#define hipHostAllocDefault

Definition hip_runtime_api.h:705

hipHostFn_t

void(* hipHostFn_t)(void *userData)

Definition hip_runtime_api.h:1257

hipOccupancyDefault

#define hipOccupancyDefault

Definition hip_runtime_api.h:797

hipStreamUpdateCaptureDependenciesFlags

hipStreamUpdateCaptureDependenciesFlags

Definition hip_runtime_api.h:1378

hipGraph_t

struct ihipGraph * hipGraph_t

Definition hip_runtime_api.h:1220

hipChooseDevice

#define hipChooseDevice

Definition hip_runtime_api.h:93

hipMemHandleType

hipMemHandleType

Definition hip_runtime_api.h:1509

hipFlushGPUDirectRDMAWritesOptions

hipFlushGPUDirectRDMAWritesOptions

Definition hip_runtime_api.h:555

hipFuncCache_t

hipFuncCache_t

Definition hip_runtime_api.h:1036

hipUserObjectFlags

hipUserObjectFlags

Definition hip_runtime_api.h:1389

__HIP_NODISCARD

#define __HIP_NODISCARD

Definition hip_runtime_api.h:277

hipGraphMemAttributeType

hipGraphMemAttributeType

Definition hip_runtime_api.h:1383

hipMemPoolAttr

hipMemPoolAttr

Definition hip_runtime_api.h:873

hipDeviceProp_t

#define hipDeviceProp_t

Definition hip_runtime_api.h:92

hipModule_t

struct ihipModule_t * hipModule_t

Definition hip_runtime_api.h:624

hipUserObject_t

struct hipUserObject * hipUserObject_t

Definition hip_runtime_api.h:1233

hipMemOperationType

hipMemOperationType

Definition hip_runtime_api.h:1516

hipExternalSemaphore_t

void * hipExternalSemaphore_t

Definition hip_runtime_api.h:1152

hipGraphicsRegisterFlags

hipGraphicsRegisterFlags

Definition hip_runtime_api.h:1203

hipMemRangeCoherencyMode

hipMemRangeCoherencyMode

Definition hip_runtime_api.h:845

hipMemAccessFlags

hipMemAccessFlags

Definition hip_runtime_api.h:948

hipMemAllocationGranularity_flags

hipMemAllocationGranularity_flags

Definition hip_runtime_api.h:1501

hipGraphExec_t

struct hipGraphExec * hipGraphExec_t

Definition hip_runtime_api.h:1228

hipGraphExecUpdateResult

hipGraphExecUpdateResult

Definition hip_runtime_api.h:1351

hipFunction_t

struct ihipModuleSymbol_t * hipFunction_t

Definition hip_runtime_api.h:625

hipKernelNodeAttrID

#define hipKernelNodeAttrID

Definition hip_runtime_api.h:1326

hipExternalMemory_t

void * hipExternalMemory_t

Definition hip_runtime_api.h:1126

hipStreamCaptureStatus

hipStreamCaptureStatus

Definition hip_runtime_api.h:1371

hipDeviceAttribute_t

hipDeviceAttribute_t

Definition hip_runtime_api.h:407

hipGPUDirectRDMAWritesOrdering

hipGPUDirectRDMAWritesOrdering

Definition hip_runtime_api.h:560

hipGetDeviceProperties

#define hipGetDeviceProperties

Definition hip_runtime_api.h:91

hipHostMallocDefault

#define hipHostMallocDefault

Definition hip_runtime_api.h:704

HIP_DEPRECATED

#define HIP_DEPRECATED(msg)

Definition hip_runtime_api.h:580

hipGraphicsResource

struct _hipGraphicsResource hipGraphicsResource

Definition hip_runtime_api.h:1213

hipMemAllocationType

hipMemAllocationType

Definition hip_runtime_api.h:963

hipGraphNode_t

struct hipGraphNode * hipGraphNode_t

Definition hip_runtime_api.h:1224

hipMemGenericAllocationHandle_t

struct ihipMemGenericAllocationHandle * hipMemGenericAllocationHandle_t

Definition hip_runtime_api.h:1496

hipMemoryType

hipMemoryType

Definition hip_runtime_api.h:245

hipGraphInstantiateFlags

hipGraphInstantiateFlags

Definition hip_runtime_api.h:1397

hipMemLocationType

hipMemLocationType

Definition hip_runtime_api.h:931

HIP_IPC_HANDLE_SIZE

#define HIP_IPC_HANDLE_SIZE

Definition hip_runtime_api.h:617

hipMemPool_t

struct ihipMemPoolHandle_t * hipMemPool_t

Definition hip_runtime_api.h:629

hipArraySparseSubresourceType

hipArraySparseSubresourceType

Definition hip_runtime_api.h:1524

hipLimitMallocHeapSize

@ hipLimitMallocHeapSize

Definition hip_runtime_api.h:657

hipLimitStackSize

@ hipLimitStackSize

Definition hip_runtime_api.h:652

hipLimitRange

@ hipLimitRange

Supported limit range.

Definition hip_runtime_api.h:659

hipLimitPrintfFifoSize

@ hipLimitPrintfFifoSize

Definition hip_runtime_api.h:655

hipMemHandleTypeWin32

@ hipMemHandleTypeWin32

Allows a Win32 NT handle for exporting. (HANDLE)

Definition hip_runtime_api.h:978

hipMemHandleTypeWin32Kmt

@ hipMemHandleTypeWin32Kmt

Allows a Win32 KMT handle for exporting. (D3DKMT_HANDLE)

Definition hip_runtime_api.h:979

hipMemHandleTypeNone

@ hipMemHandleTypeNone

Does not allow any export mechanism.

Definition hip_runtime_api.h:976

hipMemHandleTypePosixFileDescriptor

@ hipMemHandleTypePosixFileDescriptor

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

Definition hip_runtime_api.h:977

hipGraphInstantiateNodeOperationNotSupported

@ hipGraphInstantiateNodeOperationNotSupported

Definition hip_runtime_api.h:1436

hipGraphInstantiateMultipleDevicesNotSupported

@ hipGraphInstantiateMultipleDevicesNotSupported

Definition hip_runtime_api.h:1438

hipGraphInstantiateError

@ hipGraphInstantiateError

Definition hip_runtime_api.h:1432

hipGraphInstantiateInvalidStructure

@ hipGraphInstantiateInvalidStructure

Definition hip_runtime_api.h:1434

hipGraphInstantiateSuccess

@ hipGraphInstantiateSuccess

Definition hip_runtime_api.h:1431

hipAccessPropertyNormal

@ hipAccessPropertyNormal

Definition hip_runtime_api.h:1291

hipAccessPropertyPersisting

@ hipAccessPropertyPersisting

Definition hip_runtime_api.h:1293

hipAccessPropertyStreaming

@ hipAccessPropertyStreaming

Definition hip_runtime_api.h:1292

hipGraphDependencyTypeDefault

@ hipGraphDependencyTypeDefault

Definition hip_runtime_api.h:1647

hipGraphDependencyTypeProgrammatic

@ hipGraphDependencyTypeProgrammatic

Definition hip_runtime_api.h:1648

hipMemRangeAttributeLastPrefetchLocation

@ hipMemRangeAttributeLastPrefetchLocation

prefetched

Definition hip_runtime_api.h:863

hipMemRangeAttributePreferredLocation

@ hipMemRangeAttributePreferredLocation

The preferred location of the range.

Definition hip_runtime_api.h:860

hipMemRangeAttributeAccessedBy

@ hipMemRangeAttributeAccessedBy

Definition hip_runtime_api.h:861

hipMemRangeAttributeReadMostly

@ hipMemRangeAttributeReadMostly

Definition hip_runtime_api.h:858

hipMemRangeAttributeCoherencyMode

@ hipMemRangeAttributeCoherencyMode

Definition hip_runtime_api.h:865

hipMemAdviseUnsetAccessedBy

@ hipMemAdviseUnsetAccessedBy

Definition hip_runtime_api.h:833

hipMemAdviseUnsetCoarseGrain

@ hipMemAdviseUnsetCoarseGrain

Restores cache coherency policy back to fine-grain.

Definition hip_runtime_api.h:840

hipMemAdviseSetCoarseGrain

@ hipMemAdviseSetCoarseGrain

Definition hip_runtime_api.h:835

hipMemAdviseUnsetPreferredLocation

@ hipMemAdviseUnsetPreferredLocation

Clear the preferred location for the data.

Definition hip_runtime_api.h:830

hipMemAdviseSetAccessedBy

@ hipMemAdviseSetAccessedBy

Definition hip_runtime_api.h:831

hipMemAdviseSetPreferredLocation

@ hipMemAdviseSetPreferredLocation

Definition hip_runtime_api.h:828

hipMemAdviseSetReadMostly

@ hipMemAdviseSetReadMostly

Definition hip_runtime_api.h:825

hipMemAdviseUnsetReadMostly

@ hipMemAdviseUnsetReadMostly

Undo the effect of hipMemAdviseSetReadMostly.

Definition hip_runtime_api.h:827

hipSharedMemBankSizeFourByte

@ hipSharedMemBankSizeFourByte

Definition hip_runtime_api.h:1047

hipSharedMemBankSizeEightByte

@ hipSharedMemBankSizeEightByte

Definition hip_runtime_api.h:1049

hipSharedMemBankSizeDefault

@ hipSharedMemBankSizeDefault

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

Definition hip_runtime_api.h:1046

hipComputeModeProhibited

@ hipComputeModeProhibited

Definition hip_runtime_api.h:551

hipComputeModeExclusive

@ hipComputeModeExclusive

Definition hip_runtime_api.h:550

hipComputeModeDefault

@ hipComputeModeDefault

Definition hip_runtime_api.h:549

hipComputeModeExclusiveProcess

@ hipComputeModeExclusiveProcess

Definition hip_runtime_api.h:552

hipStreamCaptureModeRelaxed

@ hipStreamCaptureModeRelaxed

Definition hip_runtime_api.h:1369

hipStreamCaptureModeThreadLocal

@ hipStreamCaptureModeThreadLocal

Definition hip_runtime_api.h:1368

hipStreamCaptureModeGlobal

@ hipStreamCaptureModeGlobal

Definition hip_runtime_api.h:1367

HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND

@ HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND

Definition hip_runtime_api.h:544

HIP_GET_PROC_ADDRESS_SUCCESS

@ HIP_GET_PROC_ADDRESS_SUCCESS

Definition hip_runtime_api.h:543

HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT

@ HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT

Definition hip_runtime_api.h:545

hipLaunchAttributePriority

@ hipLaunchAttributePriority

Definition hip_runtime_api.h:1309

hipLaunchAttributeAccessPolicyWindow

@ hipLaunchAttributeAccessPolicyWindow

Definition hip_runtime_api.h:1307

hipLaunchAttributeCooperative

@ hipLaunchAttributeCooperative

Definition hip_runtime_api.h:1308

hipGraphNodeTypeGraph

@ hipGraphNodeTypeGraph

Node which executes an embedded graph.

Definition hip_runtime_api.h:1244

hipGraphNodeTypeMemset

@ hipGraphNodeTypeMemset

Memset node.

Definition hip_runtime_api.h:1242

hipGraphNodeTypeEventRecord

@ hipGraphNodeTypeEventRecord

External event record node.

Definition hip_runtime_api.h:1247

hipGraphNodeTypeExtSemaphoreSignal

@ hipGraphNodeTypeExtSemaphoreSignal

External Semaphore signal node.

Definition hip_runtime_api.h:1248

hipGraphNodeTypeMemcpy

@ hipGraphNodeTypeMemcpy

Memcpy node.

Definition hip_runtime_api.h:1241

hipGraphNodeTypeWaitEvent

@ hipGraphNodeTypeWaitEvent

External event wait node.

Definition hip_runtime_api.h:1246

hipGraphNodeTypeCount

@ hipGraphNodeTypeCount

Definition hip_runtime_api.h:1254

hipGraphNodeTypeKernel

@ hipGraphNodeTypeKernel

GPU kernel node.

Definition hip_runtime_api.h:1240

hipGraphNodeTypeHost

@ hipGraphNodeTypeHost

Host (executable) node.

Definition hip_runtime_api.h:1243

hipGraphNodeTypeMemAlloc

@ hipGraphNodeTypeMemAlloc

Memory alloc node.

Definition hip_runtime_api.h:1250

hipGraphNodeTypeMemFree

@ hipGraphNodeTypeMemFree

Memory free node.

Definition hip_runtime_api.h:1251

hipGraphNodeTypeMemcpyFromSymbol

@ hipGraphNodeTypeMemcpyFromSymbol

MemcpyFromSymbol node.

Definition hip_runtime_api.h:1252

hipGraphNodeTypeMemcpyToSymbol

@ hipGraphNodeTypeMemcpyToSymbol

MemcpyToSymbol node.

Definition hip_runtime_api.h:1253

hipGraphNodeTypeEmpty

@ hipGraphNodeTypeEmpty

Empty (no-op) node.

Definition hip_runtime_api.h:1245

hipGraphNodeTypeExtSemaphoreWait

@ hipGraphNodeTypeExtSemaphoreWait

External Semaphore wait node.

Definition hip_runtime_api.h:1249

hipExternalMemoryHandleTypeD3D11Resource

@ hipExternalMemoryHandleTypeD3D11Resource

Definition hip_runtime_api.h:1095

hipExternalMemoryHandleTypeD3D12Resource

@ hipExternalMemoryHandleTypeD3D12Resource

Definition hip_runtime_api.h:1094

hipExternalMemoryHandleTypeNvSciBuf

@ hipExternalMemoryHandleTypeNvSciBuf

Definition hip_runtime_api.h:1097

hipExternalMemoryHandleTypeOpaqueFd

@ hipExternalMemoryHandleTypeOpaqueFd

Definition hip_runtime_api.h:1090

hipExternalMemoryHandleTypeD3D12Heap

@ hipExternalMemoryHandleTypeD3D12Heap

Definition hip_runtime_api.h:1093

hipExternalMemoryHandleTypeOpaqueWin32Kmt

@ hipExternalMemoryHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:1092

hipExternalMemoryHandleTypeOpaqueWin32

@ hipExternalMemoryHandleTypeOpaqueWin32

Definition hip_runtime_api.h:1091

hipExternalMemoryHandleTypeD3D11ResourceKmt

@ hipExternalMemoryHandleTypeD3D11ResourceKmt

Definition hip_runtime_api.h:1096

hipFuncAttributePreferredSharedMemoryCarveout

@ hipFuncAttributePreferredSharedMemoryCarveout

Definition hip_runtime_api.h:1030

hipFuncAttributeMaxDynamicSharedMemorySize

@ hipFuncAttributeMaxDynamicSharedMemorySize

Definition hip_runtime_api.h:1029

hipFuncAttributeMax

@ hipFuncAttributeMax

Definition hip_runtime_api.h:1031

hipExternalSemaphoreHandleTypeNvSciSync

@ hipExternalSemaphoreHandleTypeNvSciSync

Definition hip_runtime_api.h:1133

hipExternalSemaphoreHandleTypeKeyedMutexKmt

@ hipExternalSemaphoreHandleTypeKeyedMutexKmt

Definition hip_runtime_api.h:1135

hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

@ hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:1130

hipExternalSemaphoreHandleTypeKeyedMutex

@ hipExternalSemaphoreHandleTypeKeyedMutex

Definition hip_runtime_api.h:1134

hipExternalSemaphoreHandleTypeD3D11Fence

@ hipExternalSemaphoreHandleTypeD3D11Fence

Definition hip_runtime_api.h:1132

hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

@ hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32

Definition hip_runtime_api.h:1137

hipExternalSemaphoreHandleTypeOpaqueFd

@ hipExternalSemaphoreHandleTypeOpaqueFd

Definition hip_runtime_api.h:1128

hipExternalSemaphoreHandleTypeOpaqueWin32

@ hipExternalSemaphoreHandleTypeOpaqueWin32

Definition hip_runtime_api.h:1129

hipExternalSemaphoreHandleTypeTimelineSemaphoreFd

@ hipExternalSemaphoreHandleTypeTimelineSemaphoreFd

Definition hip_runtime_api.h:1136

hipExternalSemaphoreHandleTypeD3D12Fence

@ hipExternalSemaphoreHandleTypeD3D12Fence

Definition hip_runtime_api.h:1131

hipJitOptionCacheMode

@ hipJitOptionCacheMode

Definition hip_runtime_api.h:1020

hipJitOptionFastCompile

@ hipJitOptionFastCompile

Definition hip_runtime_api.h:1022

hipJitOptionInfoLogBuffer

@ hipJitOptionInfoLogBuffer

Definition hip_runtime_api.h:1009

hipJitOptionErrorLogBuffer

@ hipJitOptionErrorLogBuffer

Definition hip_runtime_api.h:1011

hipJitOptionTarget

@ hipJitOptionTarget

Definition hip_runtime_api.h:1015

hipJitOptionThreadsPerBlock

@ hipJitOptionThreadsPerBlock

Definition hip_runtime_api.h:1007

hipJitOptionNumOptions

@ hipJitOptionNumOptions

Definition hip_runtime_api.h:1023

hipJitOptionGenerateLineInfo

@ hipJitOptionGenerateLineInfo

Definition hip_runtime_api.h:1019

hipJitOptionOptimizationLevel

@ hipJitOptionOptimizationLevel

Definition hip_runtime_api.h:1013

hipJitOptionErrorLogBufferSizeBytes

@ hipJitOptionErrorLogBufferSizeBytes

Definition hip_runtime_api.h:1012

hipJitOptionWallTime

@ hipJitOptionWallTime

Definition hip_runtime_api.h:1008

hipJitOptionInfoLogBufferSizeBytes

@ hipJitOptionInfoLogBufferSizeBytes

Definition hip_runtime_api.h:1010

hipJitOptionTargetFromContext

@ hipJitOptionTargetFromContext

Definition hip_runtime_api.h:1014

hipJitOptionGenerateDebugInfo

@ hipJitOptionGenerateDebugInfo

Definition hip_runtime_api.h:1017

hipJitOptionLogVerbose

@ hipJitOptionLogVerbose

Definition hip_runtime_api.h:1018

hipJitOptionMaxRegisters

@ hipJitOptionMaxRegisters

Definition hip_runtime_api.h:1006

hipJitOptionSm3xOpt

@ hipJitOptionSm3xOpt

Definition hip_runtime_api.h:1021

hipJitOptionFallbackStrategy

@ hipJitOptionFallbackStrategy

Definition hip_runtime_api.h:1016

hipDevP2PAttrAccessSupported

@ hipDevP2PAttrAccessSupported

Definition hip_runtime_api.h:611

hipDevP2PAttrHipArrayAccessSupported

@ hipDevP2PAttrHipArrayAccessSupported

Definition hip_runtime_api.h:613

hipDevP2PAttrNativeAtomicSupported

@ hipDevP2PAttrNativeAtomicSupported

Definition hip_runtime_api.h:612

hipDevP2PAttrPerformanceRank

@ hipDevP2PAttrPerformanceRank

Definition hip_runtime_api.h:610

hipGraphDebugDotFlagsKernelNodeAttributes

@ hipGraphDebugDotFlagsKernelNodeAttributes

Definition hip_runtime_api.h:1421

hipGraphDebugDotFlagsMemsetNodeParams

@ hipGraphDebugDotFlagsMemsetNodeParams

Definition hip_runtime_api.h:1413

hipGraphDebugDotFlagsKernelNodeParams

@ hipGraphDebugDotFlagsKernelNodeParams

Definition hip_runtime_api.h:1411

hipGraphDebugDotFlagsExtSemasWaitNodeParams

@ hipGraphDebugDotFlagsExtSemasWaitNodeParams

Definition hip_runtime_api.h:1419

hipGraphDebugDotFlagsHandles

@ hipGraphDebugDotFlagsHandles

Definition hip_runtime_api.h:1423

hipGraphDebugDotFlagsExtSemasSignalNodeParams

@ hipGraphDebugDotFlagsExtSemasSignalNodeParams

Definition hip_runtime_api.h:1417

hipGraphDebugDotFlagsHostNodeParams

@ hipGraphDebugDotFlagsHostNodeParams

Definition hip_runtime_api.h:1414

hipGraphDebugDotFlagsEventNodeParams

@ hipGraphDebugDotFlagsEventNodeParams

Definition hip_runtime_api.h:1415

hipGraphDebugDotFlagsVerbose

@ hipGraphDebugDotFlagsVerbose

Definition hip_runtime_api.h:1409

hipGraphDebugDotFlagsMemcpyNodeParams

@ hipGraphDebugDotFlagsMemcpyNodeParams

Definition hip_runtime_api.h:1412

hipGraphUserObjectMove

@ hipGraphUserObjectMove

Add new reference or retain.

Definition hip_runtime_api.h:1394

hipStreamAddCaptureDependencies

@ hipStreamAddCaptureDependencies

Add new nodes to the dependency set.

Definition hip_runtime_api.h:1379

hipStreamSetCaptureDependencies

@ hipStreamSetCaptureDependencies

Replace the dependency set with the new nodes.

Definition hip_runtime_api.h:1380

hipMemHandleTypeGeneric

@ hipMemHandleTypeGeneric

Generic handle type.

Definition hip_runtime_api.h:1510

hipFlushGPUDirectRDMAWritesOptionHost

@ hipFlushGPUDirectRDMAWritesOptionHost

Definition hip_runtime_api.h:556

hipFlushGPUDirectRDMAWritesOptionMemOps

@ hipFlushGPUDirectRDMAWritesOptionMemOps

Definition hip_runtime_api.h:557

hipFuncCachePreferNone

@ hipFuncCachePreferNone

no preference for shared memory or L1 (default)

Definition hip_runtime_api.h:1037

hipFuncCachePreferEqual

@ hipFuncCachePreferEqual

prefer equal size L1 cache and shared memory

Definition hip_runtime_api.h:1040

hipFuncCachePreferL1

@ hipFuncCachePreferL1

prefer larger L1 cache and smaller shared memory

Definition hip_runtime_api.h:1039

hipFuncCachePreferShared

@ hipFuncCachePreferShared

prefer larger shared memory and smaller L1 cache

Definition hip_runtime_api.h:1038

hipUserObjectNoDestructorSync

@ hipUserObjectNoDestructorSync

Destructor execution is not synchronized.

Definition hip_runtime_api.h:1390

hipGraphMemAttrReservedMemHigh

@ hipGraphMemAttrReservedMemHigh

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

Definition hip_runtime_api.h:1387

hipGraphMemAttrUsedMemCurrent

@ hipGraphMemAttrUsedMemCurrent

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

Definition hip_runtime_api.h:1384

hipGraphMemAttrUsedMemHigh

@ hipGraphMemAttrUsedMemHigh

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

Definition hip_runtime_api.h:1385

hipGraphMemAttrReservedMemCurrent

@ hipGraphMemAttrReservedMemCurrent

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

Definition hip_runtime_api.h:1386

hipMemPoolAttrUsedMemCurrent

@ hipMemPoolAttrUsedMemCurrent

Definition hip_runtime_api.h:920

hipMemPoolAttrReservedMemHigh

@ hipMemPoolAttrReservedMemHigh

Definition hip_runtime_api.h:915

hipMemPoolAttrReservedMemCurrent

@ hipMemPoolAttrReservedMemCurrent

Definition hip_runtime_api.h:909

hipMemPoolAttrReleaseThreshold

@ hipMemPoolAttrReleaseThreshold

Definition hip_runtime_api.h:904

hipMemPoolAttrUsedMemHigh

@ hipMemPoolAttrUsedMemHigh

Definition hip_runtime_api.h:926

hipMemPoolReuseAllowInternalDependencies

@ hipMemPoolReuseAllowInternalDependencies

Definition hip_runtime_api.h:895

hipMemPoolReuseFollowEventDependencies

@ hipMemPoolReuseFollowEventDependencies

Definition hip_runtime_api.h:882

hipMemPoolReuseAllowOpportunistic

@ hipMemPoolReuseAllowOpportunistic

Definition hip_runtime_api.h:888

hipMemOperationTypeMap

@ hipMemOperationTypeMap

Map operation.

Definition hip_runtime_api.h:1517

hipMemOperationTypeUnmap

@ hipMemOperationTypeUnmap

Unmap operation.

Definition hip_runtime_api.h:1518

hipGraphicsRegisterFlagsReadOnly

@ hipGraphicsRegisterFlagsReadOnly

HIP will not write to this registered resource.

Definition hip_runtime_api.h:1205

hipGraphicsRegisterFlagsTextureGather

@ hipGraphicsRegisterFlagsTextureGather

HIP will perform texture gather operations on this registered resource.

Definition hip_runtime_api.h:1209

hipGraphicsRegisterFlagsWriteDiscard

@ hipGraphicsRegisterFlagsWriteDiscard

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

Definition hip_runtime_api.h:1206

hipGraphicsRegisterFlagsNone

@ hipGraphicsRegisterFlagsNone

Definition hip_runtime_api.h:1204

hipGraphicsRegisterFlagsSurfaceLoadStore

@ hipGraphicsRegisterFlagsSurfaceLoadStore

HIP will bind this resource to a surface.

Definition hip_runtime_api.h:1208

hipMemRangeCoherencyModeFineGrain

@ hipMemRangeCoherencyModeFineGrain

Definition hip_runtime_api.h:846

hipMemRangeCoherencyModeIndeterminate

@ hipMemRangeCoherencyModeIndeterminate

Definition hip_runtime_api.h:850

hipMemRangeCoherencyModeCoarseGrain

@ hipMemRangeCoherencyModeCoarseGrain

Definition hip_runtime_api.h:848

hipMemAccessFlagsProtRead

@ hipMemAccessFlagsProtRead

Set the address range read accessible.

Definition hip_runtime_api.h:950

hipMemAccessFlagsProtNone

@ hipMemAccessFlagsProtNone

Default, make the address range not accessible.

Definition hip_runtime_api.h:949

hipMemAccessFlagsProtReadWrite

@ hipMemAccessFlagsProtReadWrite

Set the address range read-write accessible.

Definition hip_runtime_api.h:951

hipMemAllocationGranularityMinimum

@ hipMemAllocationGranularityMinimum

Minimum granularity.

Definition hip_runtime_api.h:1502

hipMemAllocationGranularityRecommended

@ hipMemAllocationGranularityRecommended

Recommended granularity for performance.

Definition hip_runtime_api.h:1503

hipGraphExecUpdateErrorNotSupported

@ hipGraphExecUpdateErrorNotSupported

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

Definition hip_runtime_api.h:1361

hipGraphExecUpdateErrorNodeTypeChanged

@ hipGraphExecUpdateErrorNodeTypeChanged

The update failed because a node type changed.

Definition hip_runtime_api.h:1356

hipGraphExecUpdateErrorTopologyChanged

@ hipGraphExecUpdateErrorTopologyChanged

The update failed because the topology changed.

Definition hip_runtime_api.h:1355

hipGraphExecUpdateErrorUnsupportedFunctionChange

@ hipGraphExecUpdateErrorUnsupportedFunctionChange

Definition hip_runtime_api.h:1363

hipGraphExecUpdateError

@ hipGraphExecUpdateError

Definition hip_runtime_api.h:1353

hipGraphExecUpdateErrorFunctionChanged

@ hipGraphExecUpdateErrorFunctionChanged

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

Definition hip_runtime_api.h:1357

hipGraphExecUpdateSuccess

@ hipGraphExecUpdateSuccess

The update succeeded.

Definition hip_runtime_api.h:1352

hipGraphExecUpdateErrorParametersChanged

@ hipGraphExecUpdateErrorParametersChanged

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

Definition hip_runtime_api.h:1359

hipStreamCaptureStatusInvalidated

@ hipStreamCaptureStatusInvalidated

Definition hip_runtime_api.h:1374

hipStreamCaptureStatusNone

@ hipStreamCaptureStatusNone

Stream is not capturing.

Definition hip_runtime_api.h:1372

hipStreamCaptureStatusActive

@ hipStreamCaptureStatusActive

Stream is actively capturing.

Definition hip_runtime_api.h:1373

hipDeviceAttributeDirectManagedMemAccessFromHost

@ hipDeviceAttributeDirectManagedMemAccessFromHost

Definition hip_runtime_api.h:425

hipDeviceAttributeSurfaceAlignment

@ hipDeviceAttributeSurfaceAlignment

Alignment requirement for surfaces.

Definition hip_runtime_api.h:495

hipDeviceAttributeMaxGridDimX

@ hipDeviceAttributeMaxGridDimX

Max grid size in width.

Definition hip_runtime_api.h:442

hipDeviceAttributeMaxSurfaceCubemapLayered

@ hipDeviceAttributeMaxSurfaceCubemapLayered

Cuda only. Maximum dimension of Cubemap layered surface.

Definition hip_runtime_api.h:451

hipDeviceAttributeMaxSurface3D

@ hipDeviceAttributeMaxSurface3D

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

Definition hip_runtime_api.h:449

hipDeviceAttributeMaxPitch

@ hipDeviceAttributeMaxPitch

Maximum pitch in bytes allowed by memory copies.

Definition hip_runtime_api.h:472

hipDeviceAttributeTccDriver

@ hipDeviceAttributeTccDriver

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

Definition hip_runtime_api.h:496

hipDeviceAttributeHostNativeAtomicSupported

@ hipDeviceAttributeHostNativeAtomicSupported

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

Definition hip_runtime_api.h:428

hipDeviceAttributePageableMemoryAccessUsesHostPageTables

@ hipDeviceAttributePageableMemoryAccessUsesHostPageTables

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

Definition hip_runtime_api.h:481

hipDeviceAttributeUnused5

@ hipDeviceAttributeUnused5

Previously hipDeviceAttributeGcnArchName.

Definition hip_runtime_api.h:516

hipDeviceAttributeMaxBlockDimY

@ hipDeviceAttributeMaxBlockDimY

Max block size in height.

Definition hip_runtime_api.h:440

hipDeviceAttributeMaxSurfaceCubemap

@ hipDeviceAttributeMaxSurfaceCubemap

Cuda only. Maximum dimensions of Cubemap surface.

Definition hip_runtime_api.h:450

hipDeviceAttributePageableMemoryAccess

@ hipDeviceAttributePageableMemoryAccess

Definition hip_runtime_api.h:479

hipDeviceAttributeClockRate

@ hipDeviceAttributeClockRate

Peak clock frequency in kilohertz.

Definition hip_runtime_api.h:416

hipDeviceAttributeCudaCompatibleEnd

@ hipDeviceAttributeCudaCompatibleEnd

Definition hip_runtime_api.h:509

hipDeviceAttributeMaxTexture1DMipmap

@ hipDeviceAttributeMaxTexture1DMipmap

Maximum size of 1D mipmapped texture.

Definition hip_runtime_api.h:456

hipDeviceAttributeComputeCapabilityMajor

@ hipDeviceAttributeComputeCapabilityMajor

Major compute capability version number.

Definition hip_runtime_api.h:436

hipDeviceAttributeGlobalL1CacheSupported

@ hipDeviceAttributeGlobalL1CacheSupported

Device supports caching globals in L1.

Definition hip_runtime_api.h:427

hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

Definition hip_runtime_api.h:525

hipDeviceAttributeAccessPolicyMaxWindowSize

@ hipDeviceAttributeAccessPolicyMaxWindowSize

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

Definition hip_runtime_api.h:411

hipDeviceAttributeMaxTexture3DHeight

@ hipDeviceAttributeMaxTexture3DHeight

Maximum dimension height of 3D texture.

Definition hip_runtime_api.h:464

hipDeviceAttributeComputeCapabilityMinor

@ hipDeviceAttributeComputeCapabilityMinor

Minor compute capability version number.

Definition hip_runtime_api.h:475

hipDeviceAttributeMaxTextureCubemap

@ hipDeviceAttributeMaxTextureCubemap

Maximum dimensions of Cubemap texture.

Definition hip_runtime_api.h:467

hipDeviceAttributeDeviceOverlap

@ hipDeviceAttributeDeviceOverlap

Definition hip_runtime_api.h:423

hipDeviceAttributeMaxTexture2DLinear

@ hipDeviceAttributeMaxTexture2DLinear

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

Definition hip_runtime_api.h:461

hipDeviceAttributeMaxSurface2D

@ hipDeviceAttributeMaxSurface2D

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

Definition hip_runtime_api.h:447

hipDeviceAttributeMaxSurface1DLayered

@ hipDeviceAttributeMaxSurface1DLayered

Cuda only. Maximum dimensions of 1D layered surface.

Definition hip_runtime_api.h:446

hipDeviceAttributeHdpRegFlushCntl

@ hipDeviceAttributeHdpRegFlushCntl

Address of the HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:518

hipDeviceAttributeComputeMode

@ hipDeviceAttributeComputeMode

Compute mode that device is currently in.

Definition hip_runtime_api.h:417

hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

Definition hip_runtime_api.h:519

hipDeviceAttributeAsicRevision

@ hipDeviceAttributeAsicRevision

Revision of the GPU in this device.

Definition hip_runtime_api.h:528

hipDeviceAttributeUnused4

@ hipDeviceAttributeUnused4

Previously hipDeviceAttributeGcnArch.

Definition hip_runtime_api.h:515

hipDeviceAttributeCooperativeMultiDeviceLaunch

@ hipDeviceAttributeCooperativeMultiDeviceLaunch

Support cooperative launch on multiple devices.

Definition hip_runtime_api.h:422

hipDeviceAttributeMaxTexture2DHeight

@ hipDeviceAttributeMaxTexture2DHeight

Maximum dimension hight of 2D texture.

Definition hip_runtime_api.h:458

hipDeviceAttributePersistingL2CacheMaxSize

@ hipDeviceAttributePersistingL2CacheMaxSize

Maximum l2 persisting lines capacity in bytes.

Definition hip_runtime_api.h:485

hipDeviceAttributeEccEnabled

@ hipDeviceAttributeEccEnabled

Whether ECC support is enabled.

Definition hip_runtime_api.h:410

hipDeviceAttributeCanUseHostPointerForRegisteredMem

@ hipDeviceAttributeCanUseHostPointerForRegisteredMem

Definition hip_runtime_api.h:414

hipDeviceAttributePciBusId

@ hipDeviceAttributePciBusId

PCI Bus ID.

Definition hip_runtime_api.h:482

hipDeviceAttributeL2CacheSize

@ hipDeviceAttributeL2CacheSize

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

Definition hip_runtime_api.h:432

hipDeviceAttributeKernelExecTimeout

@ hipDeviceAttributeKernelExecTimeout

Run time limit for kernels executed on the device.

Definition hip_runtime_api.h:431

hipDeviceAttributeMaxThreadsDim

@ hipDeviceAttributeMaxThreadsDim

Maximum dimension of a block.

Definition hip_runtime_api.h:469

hipDeviceAttributeSingleToDoublePrecisionPerfRatio

@ hipDeviceAttributeSingleToDoublePrecisionPerfRatio

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

Definition hip_runtime_api.h:493

hipDeviceAttributeMaxGridDimY

@ hipDeviceAttributeMaxGridDimY

Max grid size in height.

Definition hip_runtime_api.h:443

hipDeviceAttributeMultiprocessorCount

@ hipDeviceAttributeMultiprocessorCount

Number of multiprocessors on the device.

Definition hip_runtime_api.h:477

hipDeviceAttributeAmdSpecificBegin

@ hipDeviceAttributeAmdSpecificBegin

Definition hip_runtime_api.h:510

hipDeviceAttributeMaxRegistersPerMultiprocessor

@ hipDeviceAttributeMaxRegistersPerMultiprocessor

32-bit registers available per block.

Definition hip_runtime_api.h:488

hipDeviceAttributeIsMultiGpuBoard

@ hipDeviceAttributeIsMultiGpuBoard

Multiple GPU devices.

Definition hip_runtime_api.h:430

hipDeviceAttributeSharedMemPerBlockOptin

@ hipDeviceAttributeSharedMemPerBlockOptin

Maximum shared memory per block usable by special opt in.

Definition hip_runtime_api.h:491

hipDeviceAttributeMaxSurface2DLayered

@ hipDeviceAttributeMaxSurface2DLayered

Cuda only. Maximum dimensions of 2D layered surface.

Definition hip_runtime_api.h:448

hipDeviceAttributeAmdSpecificEnd

@ hipDeviceAttributeAmdSpecificEnd

Definition hip_runtime_api.h:537

hipDeviceAttributeMemoryClockRate

@ hipDeviceAttributeMemoryClockRate

Peak memory clock frequency in kilohertz.

Definition hip_runtime_api.h:474

hipDeviceAttributeMaxGridDimZ

@ hipDeviceAttributeMaxGridDimZ

Max grid size in depth.

Definition hip_runtime_api.h:444

hipDeviceAttributeHdpMemFlushCntl

@ hipDeviceAttributeHdpMemFlushCntl

Address of the HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:517

hipDeviceAttributeUnused2

@ hipDeviceAttributeUnused2

Previously hipDeviceAttributeUuid.

Definition hip_runtime_api.h:502

hipDeviceAttributeFineGrainSupport

@ hipDeviceAttributeFineGrainSupport

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

Definition hip_runtime_api.h:534

hipDeviceAttributeCooperativeLaunch

@ hipDeviceAttributeCooperativeLaunch

Support cooperative launch.

Definition hip_runtime_api.h:421

hipDeviceAttributeUnifiedAddressing

@ hipDeviceAttributeUnifiedAddressing

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

Definition hip_runtime_api.h:501

hipDeviceAttributeAsyncEngineCount

@ hipDeviceAttributeAsyncEngineCount

Asynchronous engines number.

Definition hip_runtime_api.h:412

hipDeviceAttributeMultiGpuBoardGroupID

@ hipDeviceAttributeMultiGpuBoardGroupID

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

Definition hip_runtime_api.h:476

hipDeviceAttributeStreamPrioritiesSupported

@ hipDeviceAttributeStreamPrioritiesSupported

Whether to support stream priorities.

Definition hip_runtime_api.h:494

hipDeviceAttributeMaxSharedMemoryPerBlock

@ hipDeviceAttributeMaxSharedMemoryPerBlock

Maximum shared memory available per block in bytes.

Definition hip_runtime_api.h:490

hipDeviceAttributeLocalL1CacheSupported

@ hipDeviceAttributeLocalL1CacheSupported

caching locals in L1 is supported

Definition hip_runtime_api.h:433

hipDeviceAttributeCanUseStreamWaitValue

@ hipDeviceAttributeCanUseStreamWaitValue

Definition hip_runtime_api.h:529

hipDeviceAttributeMaxRegistersPerBlock

@ hipDeviceAttributeMaxRegistersPerBlock

Definition hip_runtime_api.h:486

hipDeviceAttributeMaxThreadsPerBlock

@ hipDeviceAttributeMaxThreadsPerBlock

Maximum number of threads per block.

Definition hip_runtime_api.h:470

hipDeviceAttributeMemoryBusWidth

@ hipDeviceAttributeMemoryBusWidth

Global memory bus width in bits.

Definition hip_runtime_api.h:473

hipDeviceAttributeMemoryPoolSupportedHandleTypes

@ hipDeviceAttributeMemoryPoolSupportedHandleTypes

Supported handle mask for HIP Stream Ordered Memory Allocator.

Definition hip_runtime_api.h:507

hipDeviceAttributeComputePreemptionSupported

@ hipDeviceAttributeComputePreemptionSupported

Device supports Compute Preemption.

Definition hip_runtime_api.h:418

hipDeviceAttributeMaxSurface1D

@ hipDeviceAttributeMaxSurface1D

Maximum size of 1D surface.

Definition hip_runtime_api.h:445

hipDeviceAttributeUnused1

@ hipDeviceAttributeUnused1

Previously hipDeviceAttributeName.

Definition hip_runtime_api.h:478

hipDeviceAttributeMaxTexture3DAlt

@ hipDeviceAttributeMaxTexture3DAlt

Maximum dimensions of alternate 3D texture.

Definition hip_runtime_api.h:466

hipDeviceAttributeMaxTexture1DLinear

@ hipDeviceAttributeMaxTexture1DLinear

Definition hip_runtime_api.h:454

hipDeviceAttributeMaxTexture2DGather

@ hipDeviceAttributeMaxTexture2DGather

Maximum dimensions of 2D texture if gather operations performed.

Definition hip_runtime_api.h:459

hipDeviceAttributeWallClockRate

@ hipDeviceAttributeWallClockRate

Constant frequency of wall clock in kilohertz.

Definition hip_runtime_api.h:535

hipDeviceAttributePciDeviceId

@ hipDeviceAttributePciDeviceId

PCI Device ID.

Definition hip_runtime_api.h:483

hipDeviceAttributeCanMapHostMemory

@ hipDeviceAttributeCanMapHostMemory

Whether host memory can be mapped into device address space.

Definition hip_runtime_api.h:413

hipDeviceAttributeMaxTexture1DWidth

@ hipDeviceAttributeMaxTexture1DWidth

Maximum size of 1D texture.

Definition hip_runtime_api.h:452

hipDeviceAttributeConcurrentManagedAccess

@ hipDeviceAttributeConcurrentManagedAccess

Device can coherently access managed memory concurrently with the CPU.

Definition hip_runtime_api.h:420

hipDeviceAttributeVendorSpecificBegin

@ hipDeviceAttributeVendorSpecificBegin

Definition hip_runtime_api.h:538

hipDeviceAttributeManagedMemory

@ hipDeviceAttributeManagedMemory

Device supports allocating managed memory on this system.

Definition hip_runtime_api.h:437

hipDeviceAttributeIntegrated

@ hipDeviceAttributeIntegrated

Device is integrated GPU.

Definition hip_runtime_api.h:429

hipDeviceAttributeMaxTexture2DLayered

@ hipDeviceAttributeMaxTexture2DLayered

Maximum dimensions of 2D layered texture.

Definition hip_runtime_api.h:460

hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

Definition hip_runtime_api.h:521

hipDeviceAttributeMaxTexture3DDepth

@ hipDeviceAttributeMaxTexture3DDepth

Maximum dimension depth of 3D texture.

Definition hip_runtime_api.h:465

hipDeviceAttributeImageSupport

@ hipDeviceAttributeImageSupport

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

Definition hip_runtime_api.h:531

hipDeviceAttributeTotalGlobalMem

@ hipDeviceAttributeTotalGlobalMem

Global memory available on devicice.

Definition hip_runtime_api.h:500

hipDeviceAttributeMaxBlocksPerMultiProcessor

@ hipDeviceAttributeMaxBlocksPerMultiProcessor

Max block size per multiprocessor.

Definition hip_runtime_api.h:438

hipDeviceAttributeIsLargeBar

@ hipDeviceAttributeIsLargeBar

Whether it is LargeBar.

Definition hip_runtime_api.h:527

hipDeviceAttributeMaxTexture2DWidth

@ hipDeviceAttributeMaxTexture2DWidth

Maximum dimension width of 2D texture.

Definition hip_runtime_api.h:457

hipDeviceAttributeMaxBlockDimX

@ hipDeviceAttributeMaxBlockDimX

Max block size in width.

Definition hip_runtime_api.h:439

hipDeviceAttributeMaxTexture3DWidth

@ hipDeviceAttributeMaxTexture3DWidth

Maximum dimension width of 3D texture.

Definition hip_runtime_api.h:463

hipDeviceAttributeUnused3

@ hipDeviceAttributeUnused3

Previously hipDeviceAttributeArch.

Definition hip_runtime_api.h:513

hipDeviceAttributeTotalConstantMemory

@ hipDeviceAttributeTotalConstantMemory

Constant memory size in bytes.

Definition hip_runtime_api.h:499

hipDeviceAttributeTextureAlignment

@ hipDeviceAttributeTextureAlignment

Alignment requirement for textures.

Definition hip_runtime_api.h:497

hipDeviceAttributeMaxTexture1DLayered

@ hipDeviceAttributeMaxTexture1DLayered

Maximum dimensions of 1D layered texture.

Definition hip_runtime_api.h:453

hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

@ hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

Maximum Shared Memory PerMultiprocessor.

Definition hip_runtime_api.h:514

hipDeviceAttributeReservedSharedMemPerBlock

@ hipDeviceAttributeReservedSharedMemPerBlock

Shared memory reserved by CUDA driver per block.

Definition hip_runtime_api.h:489

hipDeviceAttributeCudaCompatibleBegin

@ hipDeviceAttributeCudaCompatibleBegin

Definition hip_runtime_api.h:408

hipDeviceAttributeConcurrentKernels

@ hipDeviceAttributeConcurrentKernels

Device can possibly execute multiple kernels concurrently.

Definition hip_runtime_api.h:419

hipDeviceAttributeLuid

@ hipDeviceAttributeLuid

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

Definition hip_runtime_api.h:434

hipDeviceAttributePciDomainID

@ hipDeviceAttributePciDomainID

PCI Domain ID.

Definition hip_runtime_api.h:484

hipDeviceAttributeMaxThreadsPerMultiProcessor

@ hipDeviceAttributeMaxThreadsPerMultiProcessor

Maximum resident threads per multiprocessor.

Definition hip_runtime_api.h:471

hipDeviceAttributeTexturePitchAlignment

@ hipDeviceAttributeTexturePitchAlignment

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

Definition hip_runtime_api.h:498

hipDeviceAttributePhysicalMultiProcessorCount

@ hipDeviceAttributePhysicalMultiProcessorCount

Definition hip_runtime_api.h:532

hipDeviceAttributeHostRegisterSupported

@ hipDeviceAttributeHostRegisterSupported

Can device support host memory registration via hipHostRegister.

Definition hip_runtime_api.h:506

hipDeviceAttributeSharedMemPerMultiprocessor

@ hipDeviceAttributeSharedMemPerMultiprocessor

Shared memory available per multiprocessor.

Definition hip_runtime_api.h:492

hipDeviceAttributeLuidDeviceNodeMask

@ hipDeviceAttributeLuidDeviceNodeMask

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

Definition hip_runtime_api.h:435

hipDeviceAttributeMaxTextureCubemapLayered

@ hipDeviceAttributeMaxTextureCubemapLayered

Maximum dimensions of Cubemap layered texture.

Definition hip_runtime_api.h:468

hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

Definition hip_runtime_api.h:523

hipDeviceAttributeVirtualMemoryManagementSupported

@ hipDeviceAttributeVirtualMemoryManagementSupported

Device supports HIP virtual memory management.

Definition hip_runtime_api.h:505

hipDeviceAttributeMemoryPoolsSupported

@ hipDeviceAttributeMemoryPoolsSupported

Device supports HIP Stream Ordered Memory Allocator.

Definition hip_runtime_api.h:504

hipDeviceAttributeClockInstructionRate

@ hipDeviceAttributeClockInstructionRate

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

Definition hip_runtime_api.h:512

hipDeviceAttributeMaxTexture2DMipmap

@ hipDeviceAttributeMaxTexture2DMipmap

Maximum dimensions of 2D mipmapped texture.

Definition hip_runtime_api.h:462

hipDeviceAttributeMaxBlockDimZ

@ hipDeviceAttributeMaxBlockDimZ

Max block size in depth.

Definition hip_runtime_api.h:441

hipDeviceAttributeWarpSize

@ hipDeviceAttributeWarpSize

Warp size in threads.

Definition hip_runtime_api.h:503

hipGPUDirectRDMAWritesOrderingOwner

@ hipGPUDirectRDMAWritesOrderingOwner

Definition hip_runtime_api.h:562

hipGPUDirectRDMAWritesOrderingNone

@ hipGPUDirectRDMAWritesOrderingNone

Definition hip_runtime_api.h:561

hipGPUDirectRDMAWritesOrderingAllDevices

@ hipGPUDirectRDMAWritesOrderingAllDevices

Definition hip_runtime_api.h:563

hipMemAllocationTypeMax

@ hipMemAllocationTypeMax

Definition hip_runtime_api.h:969

hipMemAllocationTypePinned

@ hipMemAllocationTypePinned

Definition hip_runtime_api.h:968

hipMemAllocationTypeInvalid

@ hipMemAllocationTypeInvalid

Definition hip_runtime_api.h:964

hipMemoryTypeDevice

@ hipMemoryTypeDevice

Definition hip_runtime_api.h:248

hipMemoryTypeHost

@ hipMemoryTypeHost

Memory is physically located on host.

Definition hip_runtime_api.h:247

hipMemoryTypeUnregistered

@ hipMemoryTypeUnregistered

Unregistered memory.

Definition hip_runtime_api.h:246

hipMemoryTypeArray

@ hipMemoryTypeArray

Definition hip_runtime_api.h:253

hipMemoryTypeManaged

@ hipMemoryTypeManaged

Definition hip_runtime_api.h:250

hipMemoryTypeUnified

@ hipMemoryTypeUnified

unified address space

Definition hip_runtime_api.h:255

hipGraphInstantiateFlagAutoFreeOnLaunch

@ hipGraphInstantiateFlagAutoFreeOnLaunch

Automatically free memory allocated in a graph before relaunching.

Definition hip_runtime_api.h:1398

hipGraphInstantiateFlagUseNodePriority

@ hipGraphInstantiateFlagUseNodePriority

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

Definition hip_runtime_api.h:1404

hipGraphInstantiateFlagUpload

@ hipGraphInstantiateFlagUpload

Automatically upload the graph after instantiation.

Definition hip_runtime_api.h:1400

hipGraphInstantiateFlagDeviceLaunch

@ hipGraphInstantiateFlagDeviceLaunch

Instantiate the graph to be launched from the device.

Definition hip_runtime_api.h:1402

hipMemLocationTypeInvalid

@ hipMemLocationTypeInvalid

Definition hip_runtime_api.h:932

hipMemLocationTypeDevice

@ hipMemLocationTypeDevice

Device location, thus it's HIP device ID.

Definition hip_runtime_api.h:933

hipArraySparseSubresourceTypeSparseLevel

@ hipArraySparseSubresourceTypeSparseLevel

Sparse level.

Definition hip_runtime_api.h:1525

hipArraySparseSubresourceTypeMiptail

@ hipArraySparseSubresourceTypeMiptail

Miptail.

Definition hip_runtime_api.h:1526

hipGraphKernelNodeSetParams

hipError_t hipGraphKernelNodeSetParams(hipGraphNode_t node, const hipKernelNodeParams *pNodeParams)

Sets a kernel node's parameters.

hipGraphMemFreeNodeGetParams

hipError_t hipGraphMemFreeNodeGetParams(hipGraphNode_t node, void *dev_ptr)

Returns parameters for memory free node.

hipGraphNodeGetDependencies

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

Returns a node's dependencies.

hipGraphCreate

hipError_t hipGraphCreate(hipGraph_t *pGraph, unsigned int flags)

Creates a graph.

hipGraphAddMemcpyNode1D

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

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

hipDrvGraphMemcpyNodeGetParams

hipError_t hipDrvGraphMemcpyNodeGetParams(hipGraphNode_t hNode, HIP_MEMCPY3D *nodeParams)

Gets a memcpy node's parameters.

hipDeviceSetGraphMemAttribute

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

Set the mem attribute for graphs.

hipGraphMemcpyNodeSetParams

hipError_t hipGraphMemcpyNodeSetParams(hipGraphNode_t node, const hipMemcpy3DParms *pNodeParams)

Sets a memcpy node's parameters.

hipUserObjectCreate

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

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

hipGraphExecUpdate

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

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

hipGraphNodeFindInClone

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

Finds a cloned version of a node.

hipGraphAddEventWaitNode

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

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

hipGraphMemcpyNodeSetParamsToSymbol

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

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

hipStreamIsCapturing

hipError_t hipStreamIsCapturing(hipStream_t stream, hipStreamCaptureStatus *pCaptureStatus)

Get stream's capture state.

hipGraphNodeGetEnabled

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

Query whether a node in the given graphExec is enabled.

hipGraphAddChildGraphNode

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

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