/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-5.5.1/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 - 2022 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

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

35#include <hip/hip_version.h>

36#include <hip/hip_common.h>

37

38enum {

39 HIP_SUCCESS = 0,

40 HIP_ERROR_INVALID_VALUE,

41 HIP_ERROR_NOT_INITIALIZED,

42 HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

43};

44

45typedef struct {

46 // 32-bit Atomics

47 unsigned hasGlobalInt32Atomics : 1;

48 unsigned hasGlobalFloatAtomicExch : 1;

49 unsigned hasSharedInt32Atomics : 1;

50 unsigned hasSharedFloatAtomicExch : 1;

51 unsigned hasFloatAtomicAdd : 1;

52

53 // 64-bit Atomics

54 unsigned hasGlobalInt64Atomics : 1;

55 unsigned hasSharedInt64Atomics : 1;

56

57 // Doubles

58 unsigned hasDoubles : 1;

59

60 // Warp cross-lane operations

61 unsigned hasWarpVote : 1;

62 unsigned hasWarpBallot : 1;

63 unsigned hasWarpShuffle : 1;

64 unsigned hasFunnelShift : 1;

65

66 // Sync

67 unsigned hasThreadFenceSystem : 1;

68 unsigned hasSyncThreadsExt : 1;

69

70 // Misc

71 unsigned hasSurfaceFuncs : 1;

72 unsigned has3dGrid : 1;

73 unsigned hasDynamicParallelism : 1;

74} hipDeviceArch_t;

75

76typedef struct hipUUID_t {

77 char bytes[16];

78} hipUUID;

79

80//---

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

82

87typedef struct hipDeviceProp_t {

88 char name[256];

89 size_t totalGlobalMem;

90 size_t sharedMemPerBlock;

91 int regsPerBlock;

92 int warpSize;

93 int maxThreadsPerBlock;

94 int maxThreadsDim[3];

95 int maxGridSize[3];

96 int clockRate;

97 int memoryClockRate;

98 int memoryBusWidth;

99 size_t totalConstMem;

100 int major;

103 int minor;

106 int multiProcessorCount;

107 int l2CacheSize;

108 int maxThreadsPerMultiProcessor;

109 int computeMode;

110 int clockInstructionRate;

112 hipDeviceArch_t arch;

113 int concurrentKernels;

114 int pciDomainID;

115 int pciBusID;

116 int pciDeviceID;

117 size_t maxSharedMemoryPerMultiProcessor;

118 int isMultiGpuBoard;

119 int canMapHostMemory;

120 int gcnArch;

121 char gcnArchName[256];

122 int integrated;

123 int cooperativeLaunch;

124 int cooperativeMultiDeviceLaunch;

125 int maxTexture1DLinear;

126 int maxTexture1D;

127 int maxTexture2D[2];

128 int maxTexture3D[3];

129 unsigned int* hdpMemFlushCntl;

130 unsigned int* hdpRegFlushCntl;

131 size_t memPitch;

132 size_t textureAlignment;

133 size_t texturePitchAlignment;

134 int kernelExecTimeoutEnabled;

135 int ECCEnabled;

136 int tccDriver;

137 int cooperativeMultiDeviceUnmatchedFunc;

139 int cooperativeMultiDeviceUnmatchedGridDim;

141 int cooperativeMultiDeviceUnmatchedBlockDim;

143 int cooperativeMultiDeviceUnmatchedSharedMem;

145 int isLargeBar;

146 int asicRevision;

147 int managedMemory;

148 int directManagedMemAccessFromHost;

149 int concurrentManagedAccess;

150 int pageableMemoryAccess;

152 int pageableMemoryAccessUsesHostPageTables;

153} hipDeviceProp_t;

154

155

156 /*

157 * @brief HIP Memory type (for pointer attributes)

158 * @enum

159 * @ingroup Enumerations

160 */

161typedef enum hipMemoryType {

162 hipMemoryTypeHost = 0,

163 hipMemoryTypeDevice = 1,

165 hipMemoryTypeArray = 2,

167 hipMemoryTypeUnified = 3,

168 hipMemoryTypeManaged = 4

170} hipMemoryType;

171

175typedef struct hipPointerAttribute_t {

176 union {

177 // Deprecated, use instead type

178 enum hipMemoryType memoryType;

179 enum hipMemoryType type;

180 };

181 int device;

182 void* devicePointer;

183 void* hostPointer;

184 int isManaged;

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

186 /* peers? */

187} hipPointerAttribute_t;

188

189

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

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

198// we can make that yield a warning

199#if __cplusplus >= 201703L

200#define __HIP_NODISCARD [[nodiscard]]

201#else

202#define __HIP_NODISCARD

203#endif

204

205/*

206 * @brief hipError_t

207 * @enum

208 * @ingroup Enumerations

209 */

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

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

212

213typedef enum __HIP_NODISCARD hipError_t {

214 hipSuccess = 0,

215 hipErrorInvalidValue = 1,

217 hipErrorOutOfMemory = 2,

218 // Deprecated

219 hipErrorMemoryAllocation = 2,

220 hipErrorNotInitialized = 3,

221 // Deprecated

222 hipErrorInitializationError = 3,

223 hipErrorDeinitialized = 4,

224 hipErrorProfilerDisabled = 5,

225 hipErrorProfilerNotInitialized = 6,

226 hipErrorProfilerAlreadyStarted = 7,

227 hipErrorProfilerAlreadyStopped = 8,

228 hipErrorInvalidConfiguration = 9,

229 hipErrorInvalidPitchValue = 12,

230 hipErrorInvalidSymbol = 13,

231 hipErrorInvalidDevicePointer = 17,

232 hipErrorInvalidMemcpyDirection = 21,

233 hipErrorInsufficientDriver = 35,

234 hipErrorMissingConfiguration = 52,

235 hipErrorPriorLaunchFailure = 53,

236 hipErrorInvalidDeviceFunction = 98,

237 hipErrorNoDevice = 100,

238 hipErrorInvalidDevice = 101,

239 hipErrorInvalidImage = 200,

240 hipErrorInvalidContext = 201,

241 hipErrorContextAlreadyCurrent = 202,

242 hipErrorMapFailed = 205,

243 // Deprecated

244 hipErrorMapBufferObjectFailed = 205,

245 hipErrorUnmapFailed = 206,

246 hipErrorArrayIsMapped = 207,

247 hipErrorAlreadyMapped = 208,

248 hipErrorNoBinaryForGpu = 209,

249 hipErrorAlreadyAcquired = 210,

250 hipErrorNotMapped = 211,

251 hipErrorNotMappedAsArray = 212,

252 hipErrorNotMappedAsPointer = 213,

253 hipErrorECCNotCorrectable = 214,

254 hipErrorUnsupportedLimit = 215,

255 hipErrorContextAlreadyInUse = 216,

256 hipErrorPeerAccessUnsupported = 217,

257 hipErrorInvalidKernelFile = 218,

258 hipErrorInvalidGraphicsContext = 219,

259 hipErrorInvalidSource = 300,

260 hipErrorFileNotFound = 301,

261 hipErrorSharedObjectSymbolNotFound = 302,

262 hipErrorSharedObjectInitFailed = 303,

263 hipErrorOperatingSystem = 304,

264 hipErrorInvalidHandle = 400,

265 // Deprecated

266 hipErrorInvalidResourceHandle = 400,

267 hipErrorIllegalState = 401,

268 hipErrorNotFound = 500,

269 hipErrorNotReady = 600,

273 hipErrorIllegalAddress = 700,

274 hipErrorLaunchOutOfResources = 701,

275 hipErrorLaunchTimeOut = 702,

276 hipErrorPeerAccessAlreadyEnabled =

277 704,

278 hipErrorPeerAccessNotEnabled =

279 705,

280 hipErrorSetOnActiveProcess = 708,

281 hipErrorContextIsDestroyed = 709,

282 hipErrorAssert = 710,

283 hipErrorHostMemoryAlreadyRegistered =

284 712,

285 hipErrorHostMemoryNotRegistered =

286 713,

287 hipErrorLaunchFailure =

288 719,

289 hipErrorCooperativeLaunchTooLarge =

290 720,

293 hipErrorNotSupported = 801,

294 hipErrorStreamCaptureUnsupported = 900,

296 hipErrorStreamCaptureInvalidated = 901,

298 hipErrorStreamCaptureMerge = 902,

300 hipErrorStreamCaptureUnmatched = 903,

301 hipErrorStreamCaptureUnjoined = 904,

303 hipErrorStreamCaptureIsolation = 905,

307 hipErrorStreamCaptureImplicit = 906,

310 hipErrorCapturedEvent = 907,

312 hipErrorStreamCaptureWrongThread = 908,

316 hipErrorGraphExecUpdateFailure = 910,

320 hipErrorUnknown = 999, //< Unknown error.

321 // HSA Runtime Error Codes start here.

322 hipErrorRuntimeMemory = 1052,

324 hipErrorRuntimeOther = 1053,

326 hipErrorTbd

327} hipError_t;

328

329#undef __HIP_NODISCARD

330

331/*

332 * @brief hipDeviceAttribute_t

333 * @enum

334 * @ingroup Enumerations

335 */

336typedef enum hipDeviceAttribute_t {

337 hipDeviceAttributeCudaCompatibleBegin = 0,

338

339 hipDeviceAttributeEccEnabled = hipDeviceAttributeCudaCompatibleBegin,

340 hipDeviceAttributeAccessPolicyMaxWindowSize,

341 hipDeviceAttributeAsyncEngineCount,

342 hipDeviceAttributeCanMapHostMemory,

343 hipDeviceAttributeCanUseHostPointerForRegisteredMem,

345 hipDeviceAttributeClockRate,

346 hipDeviceAttributeComputeMode,

347 hipDeviceAttributeComputePreemptionSupported,

348 hipDeviceAttributeConcurrentKernels,

349 hipDeviceAttributeConcurrentManagedAccess,

350 hipDeviceAttributeCooperativeLaunch,

351 hipDeviceAttributeCooperativeMultiDeviceLaunch,

352 hipDeviceAttributeDeviceOverlap,

354 hipDeviceAttributeDirectManagedMemAccessFromHost,

356 hipDeviceAttributeGlobalL1CacheSupported,

357 hipDeviceAttributeHostNativeAtomicSupported,

358 hipDeviceAttributeIntegrated,

359 hipDeviceAttributeIsMultiGpuBoard,

360 hipDeviceAttributeKernelExecTimeout,

361 hipDeviceAttributeL2CacheSize,

362 hipDeviceAttributeLocalL1CacheSupported,

363 hipDeviceAttributeLuid,

364 hipDeviceAttributeLuidDeviceNodeMask,

365 hipDeviceAttributeComputeCapabilityMajor,

366 hipDeviceAttributeManagedMemory,

367 hipDeviceAttributeMaxBlocksPerMultiProcessor,

368 hipDeviceAttributeMaxBlockDimX,

369 hipDeviceAttributeMaxBlockDimY,

370 hipDeviceAttributeMaxBlockDimZ,

371 hipDeviceAttributeMaxGridDimX,

372 hipDeviceAttributeMaxGridDimY,

373 hipDeviceAttributeMaxGridDimZ,

374 hipDeviceAttributeMaxSurface1D,

375 hipDeviceAttributeMaxSurface1DLayered,

376 hipDeviceAttributeMaxSurface2D,

377 hipDeviceAttributeMaxSurface2DLayered,

378 hipDeviceAttributeMaxSurface3D,

379 hipDeviceAttributeMaxSurfaceCubemap,

380 hipDeviceAttributeMaxSurfaceCubemapLayered,

381 hipDeviceAttributeMaxTexture1DWidth,

382 hipDeviceAttributeMaxTexture1DLayered,

383 hipDeviceAttributeMaxTexture1DLinear,

385 hipDeviceAttributeMaxTexture1DMipmap,

386 hipDeviceAttributeMaxTexture2DWidth,

387 hipDeviceAttributeMaxTexture2DHeight,

388 hipDeviceAttributeMaxTexture2DGather,

389 hipDeviceAttributeMaxTexture2DLayered,

390 hipDeviceAttributeMaxTexture2DLinear,

391 hipDeviceAttributeMaxTexture2DMipmap,

392 hipDeviceAttributeMaxTexture3DWidth,

393 hipDeviceAttributeMaxTexture3DHeight,

394 hipDeviceAttributeMaxTexture3DDepth,

395 hipDeviceAttributeMaxTexture3DAlt,

396 hipDeviceAttributeMaxTextureCubemap,

397 hipDeviceAttributeMaxTextureCubemapLayered,

398 hipDeviceAttributeMaxThreadsDim,

399 hipDeviceAttributeMaxThreadsPerBlock,

400 hipDeviceAttributeMaxThreadsPerMultiProcessor,

401 hipDeviceAttributeMaxPitch,

402 hipDeviceAttributeMemoryBusWidth,

403 hipDeviceAttributeMemoryClockRate,

404 hipDeviceAttributeComputeCapabilityMinor,

405 hipDeviceAttributeMultiGpuBoardGroupID,

406 hipDeviceAttributeMultiprocessorCount,

407 hipDeviceAttributeName,

408 hipDeviceAttributePageableMemoryAccess,

410 hipDeviceAttributePageableMemoryAccessUsesHostPageTables,

411 hipDeviceAttributePciBusId,

412 hipDeviceAttributePciDeviceId,

413 hipDeviceAttributePciDomainID,

414 hipDeviceAttributePersistingL2CacheMaxSize,

415 hipDeviceAttributeMaxRegistersPerBlock,

417 hipDeviceAttributeMaxRegistersPerMultiprocessor,

418 hipDeviceAttributeReservedSharedMemPerBlock,

419 hipDeviceAttributeMaxSharedMemoryPerBlock,

420 hipDeviceAttributeSharedMemPerBlockOptin,

421 hipDeviceAttributeSharedMemPerMultiprocessor,

422 hipDeviceAttributeSingleToDoublePrecisionPerfRatio,

423 hipDeviceAttributeStreamPrioritiesSupported,

424 hipDeviceAttributeSurfaceAlignment,

425 hipDeviceAttributeTccDriver,

426 hipDeviceAttributeTextureAlignment,

427 hipDeviceAttributeTexturePitchAlignment,

428 hipDeviceAttributeTotalConstantMemory,

429 hipDeviceAttributeTotalGlobalMem,

430 hipDeviceAttributeUnifiedAddressing,

431 hipDeviceAttributeUuid,

432 hipDeviceAttributeWarpSize,

433 hipDeviceAttributeMemoryPoolsSupported,

434 hipDeviceAttributeVirtualMemoryManagementSupported,

435

436 hipDeviceAttributeCudaCompatibleEnd = 9999,

437 hipDeviceAttributeAmdSpecificBegin = 10000,

438

439 hipDeviceAttributeClockInstructionRate = hipDeviceAttributeAmdSpecificBegin,

440 hipDeviceAttributeArch,

441 hipDeviceAttributeMaxSharedMemoryPerMultiprocessor,

442 hipDeviceAttributeGcnArch,

443 hipDeviceAttributeGcnArchName,

444 hipDeviceAttributeHdpMemFlushCntl,

445 hipDeviceAttributeHdpRegFlushCntl,

446 hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc,

448 hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim,

450 hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim,

452 hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem,

454 hipDeviceAttributeIsLargeBar,

455 hipDeviceAttributeAsicRevision,

456 hipDeviceAttributeCanUseStreamWaitValue,

458 hipDeviceAttributeImageSupport,

459 hipDeviceAttributePhysicalMultiProcessorCount,

461 hipDeviceAttributeFineGrainSupport,

462 hipDeviceAttributeWallClockRate,

463

464 hipDeviceAttributeAmdSpecificEnd = 19999,

465 hipDeviceAttributeVendorSpecificBegin = 20000,

466 // Extended attributes for vendors

467} hipDeviceAttribute_t;

468

469enum hipComputeMode {

470 hipComputeModeDefault = 0,

471 hipComputeModeExclusive = 1,

472 hipComputeModeProhibited = 2,

473 hipComputeModeExclusiveProcess = 3

474};

475

480#if (defined(__HIP_PLATFORM_HCC__) || defined(__HIP_PLATFORM_AMD__)) && !(defined(__HIP_PLATFORM_NVCC__) || defined(__HIP_PLATFORM_NVIDIA__))

481

482#include <stdint.h>

483#include <stddef.h>

484#ifndef GENERIC_GRID_LAUNCH

485#define GENERIC_GRID_LAUNCH 1

486#endif

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

488#include <hip/driver_types.h>

489#include <hip/texture_types.h>

490#include <hip/surface_types.h>

491#if defined(_MSC_VER)

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

493#else // !defined(_MSC_VER)

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

495#endif // !defined(_MSC_VER)

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

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

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

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

500#ifdef __cplusplus

501 #define __dparm(x) \

502 = x

503#else

504 #define __dparm(x)

505#endif

506#ifdef __GNUC__

507#pragma GCC visibility push (default)

508#endif

509#ifdef __cplusplus

510namespace hip_impl {

511hipError_t hip_init();

512} // namespace hip_impl

513#endif

514// Structure definitions:

515#ifdef __cplusplus

516extern "C" {

517#endif

518//---

519// API-visible structures

520typedef struct ihipCtx_t* hipCtx_t;

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

522typedef int hipDevice_t;

523typedef enum hipDeviceP2PAttr {

524 hipDevP2PAttrPerformanceRank = 0,

525 hipDevP2PAttrAccessSupported,

526 hipDevP2PAttrNativeAtomicSupported,

527 hipDevP2PAttrHipArrayAccessSupported

528} hipDeviceP2PAttr;

529typedef struct ihipStream_t* hipStream_t;

530#define hipIpcMemLazyEnablePeerAccess 0

531#define HIP_IPC_HANDLE_SIZE 64

532typedef struct hipIpcMemHandle_st {

533 char reserved[HIP_IPC_HANDLE_SIZE];

534} hipIpcMemHandle_t;

535typedef struct hipIpcEventHandle_st {

536 char reserved[HIP_IPC_HANDLE_SIZE];

537} hipIpcEventHandle_t;

538typedef struct ihipModule_t* hipModule_t;

539typedef struct ihipModuleSymbol_t* hipFunction_t;

543typedef struct ihipMemPoolHandle_t* hipMemPool_t;

544

545typedef struct hipFuncAttributes {

546 int binaryVersion;

547 int cacheModeCA;

548 size_t constSizeBytes;

549 size_t localSizeBytes;

550 int maxDynamicSharedSizeBytes;

551 int maxThreadsPerBlock;

552 int numRegs;

553 int preferredShmemCarveout;

554 int ptxVersion;

555 size_t sharedSizeBytes;

556} hipFuncAttributes;

557typedef struct ihipEvent_t* hipEvent_t;

558enum hipLimit_t {

559 hipLimitStackSize = 0x0, // limit device stack size

560 hipLimitPrintfFifoSize = 0x01, // limit printf fifo size

561 hipLimitMallocHeapSize = 0x02, // limit heap size

562 hipLimitRange // supported limit range

563};

568//Flags that can be used with hipStreamCreateWithFlags.

570#define hipStreamDefault 0x00

571

573#define hipStreamNonBlocking 0x01

574

575//Flags that can be used with hipEventCreateWithFlags.

577#define hipEventDefault 0x0

578

580#define hipEventBlockingSync 0x1

581

583#define hipEventDisableTiming 0x2

584

586#define hipEventInterprocess 0x4

587

590#define hipEventReleaseToDevice 0x40000000

591

594#define hipEventReleaseToSystem 0x80000000

595

596//Flags that can be used with hipHostMalloc.

598#define hipHostMallocDefault 0x0

599

601#define hipHostMallocPortable 0x1

602

605#define hipHostMallocMapped 0x2

606

610#define hipHostMallocWriteCombined 0x4

611

613#define hipHostMallocNumaUser 0x20000000

614

616#define hipHostMallocCoherent 0x40000000

617

619#define hipHostMallocNonCoherent 0x80000000

620

622#define hipMemAttachGlobal 0x01

623

625#define hipMemAttachHost 0x02

626

628#define hipMemAttachSingle 0x04

629

630#define hipDeviceMallocDefault 0x0

631

633#define hipDeviceMallocFinegrained 0x1

634

636#define hipMallocSignalMemory 0x2

637

639#define hipDeviceMallocUncached 0x3

640

641//Flags that can be used with hipHostRegister.

643#define hipHostRegisterDefault 0x0

644

646#define hipHostRegisterPortable 0x1

647

650#define hipHostRegisterMapped 0x2

651

653#define hipHostRegisterIoMemory 0x4

654

656#define hipExtHostRegisterCoarseGrained 0x8

657

659#define hipDeviceScheduleAuto 0x0

660

663#define hipDeviceScheduleSpin 0x1

664

667#define hipDeviceScheduleYield 0x2

668#define hipDeviceScheduleBlockingSync 0x4

669#define hipDeviceScheduleMask 0x7

670#define hipDeviceMapHost 0x8

671#define hipDeviceLmemResizeToMax 0x10

673#define hipArrayDefault 0x00

674#define hipArrayLayered 0x01

675#define hipArraySurfaceLoadStore 0x02

676#define hipArrayCubemap 0x04

677#define hipArrayTextureGather 0x08

678#define hipOccupancyDefault 0x00

679#define hipOccupancyDisableCachingOverride 0x01

680#define hipCooperativeLaunchMultiDeviceNoPreSync 0x01

681#define hipCooperativeLaunchMultiDeviceNoPostSync 0x02

682#define hipCpuDeviceId ((int)-1)

683#define hipInvalidDeviceId ((int)-2)

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

686#define hipExtAnyOrderLaunch 0x01

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

688#define hipStreamWaitValueGte 0x0

689#define hipStreamWaitValueEq 0x1

690#define hipStreamWaitValueAnd 0x2

691#define hipStreamWaitValueNor 0x3

692// Stream per thread

694#define hipStreamPerThread ((hipStream_t)2)

695

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

697#define hipExternalMemoryDedicated 0x1

698/*

699 * @brief HIP Memory Advise values

700 * @enum

701 * @ingroup Enumerations

702 */

703typedef enum hipMemoryAdvise {

704 hipMemAdviseSetReadMostly = 1,

706 hipMemAdviseUnsetReadMostly = 2,

707 hipMemAdviseSetPreferredLocation = 3,

709 hipMemAdviseUnsetPreferredLocation = 4,

710 hipMemAdviseSetAccessedBy = 5,

712 hipMemAdviseUnsetAccessedBy = 6,

714 hipMemAdviseSetCoarseGrain = 100,

719 hipMemAdviseUnsetCoarseGrain = 101

720} hipMemoryAdvise;

721/*

722 * @brief HIP Coherency Mode

723 * @enum

724 * @ingroup Enumerations

725 */

726typedef enum hipMemRangeCoherencyMode {

727 hipMemRangeCoherencyModeFineGrain = 0,

729 hipMemRangeCoherencyModeCoarseGrain = 1,

731 hipMemRangeCoherencyModeIndeterminate = 2

734} hipMemRangeCoherencyMode;

735/*

736 * @brief HIP range attributes

737 * @enum

738 * @ingroup Enumerations

739 */

740typedef enum hipMemRangeAttribute {

741 hipMemRangeAttributeReadMostly = 1,

743 hipMemRangeAttributePreferredLocation = 2,

744 hipMemRangeAttributeAccessedBy = 3,

746 hipMemRangeAttributeLastPrefetchLocation = 4,

748 hipMemRangeAttributeCoherencyMode = 100,

750} hipMemRangeAttribute;

751

757typedef enum hipMemPoolAttr

758{

767 hipMemPoolReuseFollowEventDependencies = 0x1,

773 hipMemPoolReuseAllowOpportunistic = 0x2,

780 hipMemPoolReuseAllowInternalDependencies = 0x3,

789 hipMemPoolAttrReleaseThreshold = 0x4,

794 hipMemPoolAttrReservedMemCurrent = 0x5,

800 hipMemPoolAttrReservedMemHigh = 0x6,

805 hipMemPoolAttrUsedMemCurrent = 0x7,

811 hipMemPoolAttrUsedMemHigh = 0x8

812} hipMemPoolAttr;

818 typedef enum hipMemLocationType {

819 hipMemLocationTypeInvalid = 0,

820 hipMemLocationTypeDevice = 1

821} hipMemLocationType;

827typedef struct hipMemLocation {

828 hipMemLocationType type;

829 int id;

830} hipMemLocation;

836typedef enum hipMemAccessFlags {

837 hipMemAccessFlagsProtNone = 0,

838 hipMemAccessFlagsProtRead = 1,

839 hipMemAccessFlagsProtReadWrite = 3

840} hipMemAccessFlags;

844typedef struct hipMemAccessDesc {

845 hipMemLocation location;

846 hipMemAccessFlags flags;

847} hipMemAccessDesc;

853typedef enum hipMemAllocationType {

854 hipMemAllocationTypeInvalid = 0x0,

858 hipMemAllocationTypePinned = 0x1,

859 hipMemAllocationTypeMax = 0x7FFFFFFF

860} hipMemAllocationType;

866typedef enum hipMemAllocationHandleType {

867 hipMemHandleTypeNone = 0x0,

868 hipMemHandleTypePosixFileDescriptor = 0x1,

869 hipMemHandleTypeWin32 = 0x2,

870 hipMemHandleTypeWin32Kmt = 0x4

871} hipMemAllocationHandleType;

875typedef struct hipMemPoolProps {

876 hipMemAllocationType allocType;

877 hipMemAllocationHandleType handleTypes;

878 hipMemLocation location;

882 void* win32SecurityAttributes;

883 unsigned char reserved[64];

884} hipMemPoolProps;

888typedef struct hipMemPoolPtrExportData {

889 unsigned char reserved[64];

890} hipMemPoolPtrExportData;

891

892/*

893 * @brief hipJitOption

894 * @enum

895 * @ingroup Enumerations

896 */

897typedef enum hipJitOption {

898 hipJitOptionMaxRegisters = 0,

899 hipJitOptionThreadsPerBlock,

900 hipJitOptionWallTime,

901 hipJitOptionInfoLogBuffer,

902 hipJitOptionInfoLogBufferSizeBytes,

903 hipJitOptionErrorLogBuffer,

904 hipJitOptionErrorLogBufferSizeBytes,

905 hipJitOptionOptimizationLevel,

906 hipJitOptionTargetFromContext,

907 hipJitOptionTarget,

908 hipJitOptionFallbackStrategy,

909 hipJitOptionGenerateDebugInfo,

910 hipJitOptionLogVerbose,

911 hipJitOptionGenerateLineInfo,

912 hipJitOptionCacheMode,

913 hipJitOptionSm3xOpt,

914 hipJitOptionFastCompile,

915 hipJitOptionNumOptions

916} hipJitOption;

920typedef enum hipFuncAttribute {

921 hipFuncAttributeMaxDynamicSharedMemorySize = 8,

922 hipFuncAttributePreferredSharedMemoryCarveout = 9,

923 hipFuncAttributeMax

924} hipFuncAttribute;

928typedef enum hipFuncCache_t {

929 hipFuncCachePreferNone,

930 hipFuncCachePreferShared,

931 hipFuncCachePreferL1,

932 hipFuncCachePreferEqual,

933} hipFuncCache_t;

937typedef enum hipSharedMemConfig {

938 hipSharedMemBankSizeDefault,

939 hipSharedMemBankSizeFourByte,

941 hipSharedMemBankSizeEightByte

943} hipSharedMemConfig;

948typedef struct dim3 {

949 uint32_t x;

950 uint32_t y;

951 uint32_t z;

952#ifdef __cplusplus

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

954#endif

955} dim3;

956typedef struct hipLaunchParams_t {

957 void* func;

958 dim3 gridDim;

959 dim3 blockDim;

960 void **args;

961 size_t sharedMem;

962 hipStream_t stream;

963} hipLaunchParams;

964typedef struct hipFunctionLaunchParams_t {

965 hipFunction_t function;

966 unsigned int gridDimX;

967 unsigned int gridDimY;

968 unsigned int gridDimZ;

969 unsigned int blockDimX;

970 unsigned int blockDimY;

971 unsigned int blockDimZ;

972 unsigned int sharedMemBytes;

973 hipStream_t hStream;

974 void **kernelParams;

975} hipFunctionLaunchParams;

976typedef enum hipExternalMemoryHandleType_enum {

977 hipExternalMemoryHandleTypeOpaqueFd = 1,

978 hipExternalMemoryHandleTypeOpaqueWin32 = 2,

979 hipExternalMemoryHandleTypeOpaqueWin32Kmt = 3,

980 hipExternalMemoryHandleTypeD3D12Heap = 4,

981 hipExternalMemoryHandleTypeD3D12Resource = 5,

982 hipExternalMemoryHandleTypeD3D11Resource = 6,

983 hipExternalMemoryHandleTypeD3D11ResourceKmt = 7,

984} hipExternalMemoryHandleType;

985typedef struct hipExternalMemoryHandleDesc_st {

986 hipExternalMemoryHandleType type;

987 union {

988 int fd;

989 struct {

990 void *handle;

991 const void *name;

992 } win32;

993 } handle;

994 unsigned long long size;

995 unsigned int flags;

996} hipExternalMemoryHandleDesc;

997typedef struct hipExternalMemoryBufferDesc_st {

998 unsigned long long offset;

999 unsigned long long size;

1000 unsigned int flags;

1001} hipExternalMemoryBufferDesc;

1002typedef void* hipExternalMemory_t;

1003typedef enum hipExternalSemaphoreHandleType_enum {

1004 hipExternalSemaphoreHandleTypeOpaqueFd = 1,

1005 hipExternalSemaphoreHandleTypeOpaqueWin32 = 2,

1006 hipExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3,

1007 hipExternalSemaphoreHandleTypeD3D12Fence = 4

1008} hipExternalSemaphoreHandleType;

1009typedef struct hipExternalSemaphoreHandleDesc_st {

1010 hipExternalSemaphoreHandleType type;

1011 union {

1012 int fd;

1013 struct {

1014 void* handle;

1015 const void* name;

1016 } win32;

1017 } handle;

1018 unsigned int flags;

1019} hipExternalSemaphoreHandleDesc;

1020typedef void* hipExternalSemaphore_t;

1021typedef struct hipExternalSemaphoreSignalParams_st {

1022 struct {

1023 struct {

1024 unsigned long long value;

1025 } fence;

1026 struct {

1027 unsigned long long key;

1028 } keyedMutex;

1029 unsigned int reserved[12];

1030 } params;

1031 unsigned int flags;

1032 unsigned int reserved[16];

1033} hipExternalSemaphoreSignalParams;

1037typedef struct hipExternalSemaphoreWaitParams_st {

1038 struct {

1039 struct {

1040 unsigned long long value;

1041 } fence;

1042 struct {

1043 unsigned long long key;

1044 unsigned int timeoutMs;

1045 } keyedMutex;

1046 unsigned int reserved[10];

1047 } params;

1048 unsigned int flags;

1049 unsigned int reserved[16];

1050} hipExternalSemaphoreWaitParams;

1051

1052#if __HIP_HAS_GET_PCH

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

1059#endif

1060

1061/*

1062 * @brief HIP Devices used by current OpenGL Context.

1063 * @enum

1064 * @ingroup Enumerations

1065 */

1066typedef enum hipGLDeviceList {

1067 hipGLDeviceListAll = 1,

1068 hipGLDeviceListCurrentFrame = 2,

1070 hipGLDeviceListNextFrame = 3

1072} hipGLDeviceList;

1073

1074/*

1075 * @brief HIP Access falgs for Interop resources.

1076 * @enum

1077 * @ingroup Enumerations

1078 */

1079typedef enum hipGraphicsRegisterFlags {

1080 hipGraphicsRegisterFlagsNone = 0,

1081 hipGraphicsRegisterFlagsReadOnly = 1,

1082 hipGraphicsRegisterFlagsWriteDiscard =

1083 2,

1084 hipGraphicsRegisterFlagsSurfaceLoadStore = 4,

1085 hipGraphicsRegisterFlagsTextureGather =

1086 8

1087} hipGraphicsRegisterFlags;

1088

1089typedef struct _hipGraphicsResource hipGraphicsResource;

1090

1091typedef hipGraphicsResource* hipGraphicsResource_t;

1092

1096typedef struct ihipGraph* hipGraph_t;

1100typedef struct hipGraphNode* hipGraphNode_t;

1104typedef struct hipGraphExec* hipGraphExec_t;

1105

1109typedef struct hipUserObject* hipUserObject_t;

1110

1111

1117typedef enum hipGraphNodeType {

1118 hipGraphNodeTypeKernel = 0,

1119 hipGraphNodeTypeMemcpy = 1,

1120 hipGraphNodeTypeMemset = 2,

1121 hipGraphNodeTypeHost = 3,

1122 hipGraphNodeTypeGraph = 4,

1123 hipGraphNodeTypeEmpty = 5,

1124 hipGraphNodeTypeWaitEvent = 6,

1125 hipGraphNodeTypeEventRecord = 7,

1126 hipGraphNodeTypeExtSemaphoreSignal = 8,

1127 hipGraphNodeTypeExtSemaphoreWait = 9,

1128 hipGraphNodeTypeMemAlloc = 10,

1129 hipGraphNodeTypeMemFree = 11,

1130 hipGraphNodeTypeMemcpyFromSymbol = 12,

1131 hipGraphNodeTypeMemcpyToSymbol = 13,

1132 hipGraphNodeTypeCount

1133} hipGraphNodeType;

1134

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

1136typedef struct hipHostNodeParams {

1137 hipHostFn_t fn;

1138 void* userData;

1139} hipHostNodeParams;

1140typedef struct hipKernelNodeParams {

1141 dim3 blockDim;

1142 void** extra;

1143 void* func;

1144 dim3 gridDim;

1145 void** kernelParams;

1146 unsigned int sharedMemBytes;

1147} hipKernelNodeParams;

1148typedef struct hipMemsetParams {

1149 void* dst;

1150 unsigned int elementSize;

1151 size_t height;

1152 size_t pitch;

1153 unsigned int value;

1154 size_t width;

1155} hipMemsetParams;

1156

1157typedef struct hipMemAllocNodeParams {

1158 hipMemPoolProps poolProps;

1160 const hipMemAccessDesc* accessDescs;

1162 size_t accessDescCount;

1163 size_t bytesize;

1164 void* dptr;

1165} hipMemAllocNodeParams;

1166

1172typedef enum hipKernelNodeAttrID {

1173 hipKernelNodeAttributeAccessPolicyWindow = 1,

1174 hipKernelNodeAttributeCooperative = 2,

1175} hipKernelNodeAttrID;

1176typedef enum hipAccessProperty {

1177 hipAccessPropertyNormal = 0,

1178 hipAccessPropertyStreaming = 1,

1179 hipAccessPropertyPersisting = 2,

1180} hipAccessProperty;

1181typedef struct hipAccessPolicyWindow {

1182 void* base_ptr;

1183 hipAccessProperty hitProp;

1184 float hitRatio;

1185 hipAccessProperty missProp;

1186 size_t num_bytes;

1187} hipAccessPolicyWindow;

1188typedef union hipKernelNodeAttrValue {

1189 hipAccessPolicyWindow accessPolicyWindow;

1190 int cooperative;

1191} hipKernelNodeAttrValue;

1192

1198typedef enum hipGraphExecUpdateResult {

1199 hipGraphExecUpdateSuccess = 0x0,

1200 hipGraphExecUpdateError = 0x1,

1202 hipGraphExecUpdateErrorTopologyChanged = 0x2,

1203 hipGraphExecUpdateErrorNodeTypeChanged = 0x3,

1204 hipGraphExecUpdateErrorFunctionChanged =

1205 0x4,

1206 hipGraphExecUpdateErrorParametersChanged =

1207 0x5,

1208 hipGraphExecUpdateErrorNotSupported =

1209 0x6,

1210 hipGraphExecUpdateErrorUnsupportedFunctionChange = 0x7

1211} hipGraphExecUpdateResult;

1212

1213typedef enum hipStreamCaptureMode {

1214 hipStreamCaptureModeGlobal = 0,

1215 hipStreamCaptureModeThreadLocal,

1216 hipStreamCaptureModeRelaxed

1217} hipStreamCaptureMode;

1218typedef enum hipStreamCaptureStatus {

1219 hipStreamCaptureStatusNone = 0,

1220 hipStreamCaptureStatusActive,

1221 hipStreamCaptureStatusInvalidated

1223} hipStreamCaptureStatus;

1224

1225typedef enum hipStreamUpdateCaptureDependenciesFlags {

1226 hipStreamAddCaptureDependencies = 0,

1227 hipStreamSetCaptureDependencies,

1228} hipStreamUpdateCaptureDependenciesFlags;

1229

1230typedef enum hipGraphMemAttributeType {

1231 hipGraphMemAttrUsedMemCurrent = 0,

1232 hipGraphMemAttrUsedMemHigh,

1233 hipGraphMemAttrReservedMemCurrent,

1234 hipGraphMemAttrReservedMemHigh,

1235}hipGraphMemAttributeType;

1236typedef enum hipUserObjectFlags {

1237 hipUserObjectNoDestructorSync = 0x1,

1238} hipUserObjectFlags;

1239

1240typedef enum hipUserObjectRetainFlags {

1241 hipGraphUserObjectMove = 0x1,

1242} hipUserObjectRetainFlags;

1243

1244typedef enum hipGraphInstantiateFlags {

1245 hipGraphInstantiateFlagAutoFreeOnLaunch =

1246 1,

1247} hipGraphInstantiateFlags;

1248

1249enum hipGraphDebugDotFlags {

1250 hipGraphDebugDotFlagsVerbose = 1

1251 << 0,

1252 hipGraphDebugDotFlagsKernelNodeParams = 1 << 2,

1253 hipGraphDebugDotFlagsMemcpyNodeParams = 1 << 3,

1254 hipGraphDebugDotFlagsMemsetNodeParams = 1 << 4,

1255 hipGraphDebugDotFlagsHostNodeParams = 1 << 5,

1256 hipGraphDebugDotFlagsEventNodeParams = 1

1257 << 6,

1258 hipGraphDebugDotFlagsExtSemasSignalNodeParams = 1

1259 << 7,

1260 hipGraphDebugDotFlagsExtSemasWaitNodeParams = 1

1261 << 8,

1262 hipGraphDebugDotFlagsKernelNodeAttributes = 1

1263 << 9,

1264 hipGraphDebugDotFlagsHandles = 1

1265 << 10

1266};

1270typedef struct hipMemAllocationProp {

1271 hipMemAllocationType type;

1272 hipMemAllocationHandleType requestedHandleType;

1273 hipMemLocation location;

1274 void* win32HandleMetaData;

1275 struct {

1276 unsigned char compressionType;

1277 unsigned char gpuDirectRDMACapable;

1278 unsigned short usage;

1279 } allocFlags;

1280} hipMemAllocationProp;

1281

1285typedef struct ihipMemGenericAllocationHandle* hipMemGenericAllocationHandle_t;

1286

1292typedef enum hipMemAllocationGranularity_flags {

1293 hipMemAllocationGranularityMinimum = 0x0,

1294 hipMemAllocationGranularityRecommended = 0x1

1295} hipMemAllocationGranularity_flags;

1296

1302typedef enum hipMemHandleType {

1303 hipMemHandleTypeGeneric = 0x0

1304} hipMemHandleType;

1305

1311typedef enum hipMemOperationType {

1312 hipMemOperationTypeMap = 0x1,

1313 hipMemOperationTypeUnmap = 0x2

1314} hipMemOperationType;

1315

1321typedef enum hipArraySparseSubresourceType {

1322 hipArraySparseSubresourceTypeSparseLevel = 0x0,

1323 hipArraySparseSubresourceTypeMiptail = 0x1

1324} hipArraySparseSubresourceType;

1325

1329typedef struct hipArrayMapInfo {

1330 hipResourceType resourceType;

1331 union {

1332 hipMipmappedArray mipmap;

1333 hipArray_t array;

1334 } resource;

1335 hipArraySparseSubresourceType subresourceType;

1336 union {

1337 struct {

1338 unsigned int level;

1339 unsigned int layer;

1340 unsigned int offsetX;

1341 unsigned int offsetY;

1342 unsigned int offsetZ;

1343 unsigned int extentWidth;

1344 unsigned int extentHeight;

1345 unsigned int extentDepth;

1346 } sparseLevel;

1347 struct {

1348 unsigned int layer;

1349 unsigned long long offset;

1350 unsigned long long size;

1351 } miptail;

1352 } subresource;

1353 hipMemOperationType memOperationType;

1354 hipMemHandleType memHandleType;

1355 union {

1356 hipMemGenericAllocationHandle_t memHandle;

1357 } memHandle;

1358 unsigned long long offset;

1359 unsigned int deviceBitMask;

1360 unsigned int flags;

1361 unsigned int reserved[2];

1362} hipArrayMapInfo;

1363// Doxygen end group GlobalDefs

1365//-------------------------------------------------------------------------------------------------

1366// The handle allows the async commands to use the stream even if the parent hipStream_t goes

1367// out-of-scope.

1368// typedef class ihipStream_t * hipStream_t;

1369/*

1370 * Opaque structure allows the true event (pointed at by the handle) to remain "live" even if the

1371 * surrounding hipEvent_t goes out-of-scope. This is handy for cases where the hipEvent_t goes

1372 * out-of-scope but the true event is being written by some async queue or device */

1373// typedef struct hipEvent_t {

1374// struct ihipEvent_t *_handle;

1375//} hipEvent_t;

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

1395hipError_t hipInit(unsigned int flags);

1411hipError_t hipDriverGetVersion(int* driverVersion);

1426hipError_t hipRuntimeGetVersion(int* runtimeVersion);

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

1435

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

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

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

1475hipError_t hipDeviceGetP2PAttribute(int* value, hipDeviceP2PAttr attr,

1476 int srcDevice, int dstDevice);

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

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

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

1502// doxygen end initialization

1521hipError_t hipDeviceSynchronize(void);

1533hipError_t hipDeviceReset(void);

1565hipError_t hipSetDevice(int deviceId);

1579hipError_t hipGetDevice(int* deviceId);

1592hipError_t hipGetDeviceCount(int* count);

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

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

1639hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool);

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

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

1685hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig);

1696hipError_t hipDeviceGetCacheConfig(hipFuncCache_t* cacheConfig);

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

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

1733hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig* pConfig);

1741hipError_t hipGetDeviceFlags(unsigned int* flags);

1753hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config);

1778hipError_t hipSetDeviceFlags(unsigned flags);

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

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

1801// TODO: implement IPC apis

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

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

1884hipError_t hipIpcCloseMemHandle(void* devPtr);

1885

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

1901

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

1918

1919// end doxygen Device

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

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

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

1968//doxygen end execution

1990hipError_t hipGetLastError(void);

2001hipError_t hipPeekAtLastError(void);

2010const char* hipGetErrorName(hipError_t hip_error);

2019const char* hipGetErrorString(hipError_t hipError);

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

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

2040// end doxygen Error

2070hipError_t hipStreamCreate(hipStream_t* stream);

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

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

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

2137hipError_t hipStreamDestroy(hipStream_t stream);

2153hipError_t hipStreamQuery(hipStream_t stream);

2173hipError_t hipStreamSynchronize(hipStream_t stream);

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

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

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

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

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

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

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

2275 unsigned int flags);

2276// end doxygen Stream

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

2320 uint32_t mask __dparm(0xFFFFFFFF));

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

2354 uint64_t mask __dparm(0xFFFFFFFFFFFFFFFF));

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

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

2395// end doxygen Stream Memory Operations

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

2440hipError_t hipEventCreate(hipEvent_t* event);

2468#ifdef __cplusplus

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

2470#else

2471hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream);

2472#endif

2489hipError_t hipEventDestroy(hipEvent_t event);

2507hipError_t hipEventSynchronize(hipEvent_t event);

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

2552hipError_t hipEventQuery(hipEvent_t event);

2553// end doxygen Events

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

2585 hipDeviceptr_t ptr);

2586

2587

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

2616hipError_t hipPointerGetAttribute(void* data, hipPointer_attribute attribute,

2617 hipDeviceptr_t ptr);

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

2635 void** data, hipDeviceptr_t ptr);

2646hipError_t hipImportExternalSemaphore(hipExternalSemaphore_t* extSem_out,

2647 const hipExternalSemaphoreHandleDesc* semHandleDesc);

2660hipError_t hipSignalExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

2661 const hipExternalSemaphoreSignalParams* paramsArray,

2662 unsigned int numExtSems, hipStream_t stream);

2675hipError_t hipWaitExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

2676 const hipExternalSemaphoreWaitParams* paramsArray,

2677 unsigned int numExtSems, hipStream_t stream);

2687hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem);

2688

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

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

2721hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem);

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

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

2763DEPRECATED("use hipHostMalloc instead")

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

2777DEPRECATED("use hipHostMalloc instead")

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

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

2813hipError_t hipMallocManaged(void** dev_ptr,

2814 size_t size,

2815 unsigned int flags __dparm(hipMemAttachGlobal));

2826hipError_t hipMemPrefetchAsync(const void* dev_ptr,

2827 size_t count,

2828 int device,

2829 hipStream_t stream __dparm(0));

2840hipError_t hipMemAdvise(const void* dev_ptr,

2841 size_t count,

2842 hipMemoryAdvise advice,

2843 int device);

2856hipError_t hipMemRangeGetAttribute(void* data,

2857 size_t data_size,

2858 hipMemRangeAttribute attribute,

2859 const void* dev_ptr,

2860 size_t count);

2875hipError_t hipMemRangeGetAttributes(void** data,

2876 size_t* data_sizes,

2877 hipMemRangeAttribute* attributes,

2878 size_t num_attributes,

2879 const void* dev_ptr,

2880 size_t count);

2893hipError_t hipStreamAttachMemAsync(hipStream_t stream,

2894 void* dev_ptr,

2895 size_t length __dparm(0),

2896 unsigned int flags __dparm(hipMemAttachSingle));

2897// end doxygen Managed Memory

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

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

3002hipError_t hipMemPoolTrimTo(hipMemPool_t mem_pool, size_t min_bytes_to_hold);

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

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

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

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

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

3157hipError_t hipMemPoolDestroy(hipMemPool_t mem_pool);

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

3214hipError_t hipMemPoolExportToShareableHandle(

3215 void* shared_handle,

3216 hipMemPool_t mem_pool,

3217 hipMemAllocationHandleType handle_type,

3218 unsigned int flags);

3240hipError_t hipMemPoolImportFromShareableHandle(

3241 hipMemPool_t* mem_pool,

3242 void* shared_handle,

3243 hipMemAllocationHandleType handle_type,

3244 unsigned int flags);

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

3289hipError_t hipMemPoolImportPointer(

3290 void** dev_ptr,

3291 hipMemPool_t mem_pool,

3292 hipMemPoolPtrExportData* export_data);

3293// Doxygen end of ordered memory allocator

3311DEPRECATED("use hipHostMalloc instead")

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

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

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

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

3380hipError_t hipHostUnregister(void* hostPtr);

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

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

3435hipError_t hipFree(void* ptr);

3445DEPRECATED("use hipHostFree instead")

3446hipError_t hipFreeHost(void* ptr);

3460hipError_t hipHostFree(void* ptr);

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

3491// TODO: Add description

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

3493 hipMemcpyKind kind, hipStream_t stream);

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

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

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

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

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

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

3602 hipStream_t stream);

3603

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

3619 hipModule_t hmod, const char* name);

3620

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

3631

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

3642

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

3662 size_t sizeBytes, size_t offset __dparm(0),

3663 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice));

3664

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

3679 size_t sizeBytes, size_t offset,

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

3681

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

3695 size_t sizeBytes, size_t offset __dparm(0),

3696 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost));

3697

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

3712 size_t sizeBytes, size_t offset,

3713 hipMemcpyKind kind,

3714 hipStream_t stream __dparm(0));

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

3744 hipStream_t stream __dparm(0));

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

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

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

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

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

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

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

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

3849 hipStream_t stream __dparm(0));

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

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

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

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

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

3909

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

3923hipError_t hipMallocArray(hipArray** array, const hipChannelFormatDesc* desc, size_t width,

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

3925hipError_t hipArrayCreate(hipArray** pHandle, const HIP_ARRAY_DESCRIPTOR* pAllocateArray);

3926hipError_t hipArrayDestroy(hipArray* array);

3927hipError_t hipArray3DCreate(hipArray** array, const HIP_ARRAY3D_DESCRIPTOR* pAllocateArray);

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

3937hipError_t hipFreeArray(hipArray* array);

3945hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray);

3957hipError_t hipMalloc3DArray(hipArray** array, const struct hipChannelFormatDesc* desc,

3958 struct hipExtent extent, unsigned int flags);

3970hipError_t hipMallocMipmappedArray(

3971 hipMipmappedArray_t *mipmappedArray,

3972 const struct hipChannelFormatDesc* desc,

3973 struct hipExtent extent,

3974 unsigned int numLevels,

3975 unsigned int flags __dparm(0));

3985hipError_t hipGetMipmappedArrayLevel(

3986 hipArray_t *levelArray,

3987 hipMipmappedArray_const_t mipmappedArray,

3988 unsigned int level);

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

4006 size_t height, hipMemcpyKind kind);

4016hipError_t hipMemcpyParam2D(const hip_Memcpy2D* pCopy);

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

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

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

4064hipError_t hipMemcpy2DToArray(hipArray* dst, size_t wOffset, size_t hOffset, const void* src,

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

4084hipError_t hipMemcpy2DToArrayAsync(hipArray* dst, size_t wOffset, size_t hOffset, const void* src,

4085 size_t spitch, size_t width, size_t height, hipMemcpyKind kind,

4086 hipStream_t stream __dparm(0));

4102DEPRECATED(DEPRECATED_MSG)

4103hipError_t hipMemcpyToArray(hipArray* dst, size_t wOffset, size_t hOffset, const void* src,

4104 size_t count, hipMemcpyKind kind);

4120DEPRECATED(DEPRECATED_MSG)

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

4122 size_t count, hipMemcpyKind kind);

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

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

4173hipError_t hipMemcpyAtoH(void* dst, hipArray* srcArray, size_t srcOffset, size_t count);

4187hipError_t hipMemcpyHtoA(hipArray* dstArray, size_t dstOffset, const void* srcHost, size_t count);

4198hipError_t hipMemcpy3D(const struct hipMemcpy3DParms* p);

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

4221hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D* pCopy);

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

4234// doxygen end Memory

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

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

4291hipError_t hipDeviceDisablePeerAccess(int peerDeviceId);

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

4305#ifndef USE_PEER_NON_UNIFIED

4306#define USE_PEER_NON_UNIFIED 1

4307#endif

4308#if USE_PEER_NON_UNIFIED == 1

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

4321 size_t sizeBytes);

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

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

4336#endif

4337// doxygen end PeerToPeer

4367DEPRECATED(DEPRECATED_MSG)

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

4379DEPRECATED(DEPRECATED_MSG)

4380hipError_t hipCtxDestroy(hipCtx_t ctx);

4391DEPRECATED(DEPRECATED_MSG)

4392hipError_t hipCtxPopCurrent(hipCtx_t* ctx);

4403DEPRECATED(DEPRECATED_MSG)

4404hipError_t hipCtxPushCurrent(hipCtx_t ctx);

4415DEPRECATED(DEPRECATED_MSG)

4416hipError_t hipCtxSetCurrent(hipCtx_t ctx);

4427DEPRECATED(DEPRECATED_MSG)

4428hipError_t hipCtxGetCurrent(hipCtx_t* ctx);

4439DEPRECATED(DEPRECATED_MSG)

4440hipError_t hipCtxGetDevice(hipDevice_t* device);

4458DEPRECATED(DEPRECATED_MSG)

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

4473DEPRECATED(DEPRECATED_MSG)

4474hipError_t hipCtxGetCacheConfig(hipFuncCache_t* cacheConfig);

4488DEPRECATED(DEPRECATED_MSG)

4489hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig);

4503DEPRECATED(DEPRECATED_MSG)

4504hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config);

4518DEPRECATED(DEPRECATED_MSG)

4519hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig* pConfig);

4531DEPRECATED(DEPRECATED_MSG)

4532hipError_t hipCtxSynchronize(void);

4543DEPRECATED(DEPRECATED_MSG)

4544hipError_t hipCtxGetFlags(unsigned int* flags);

4564DEPRECATED(DEPRECATED_MSG)

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

4582DEPRECATED(DEPRECATED_MSG)

4583hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx);

4584// doxygen end Context deprecated

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

4613hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev);

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

4636hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev);

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

4649// doxygen end Context Management

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

4683hipError_t hipModuleUnload(hipModule_t module);

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

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

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

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

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

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

4747 hipJitOption* options, void** optionValues);

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

4777 unsigned int gridDimZ, unsigned int blockDimX,

4778 unsigned int blockDimY, unsigned int blockDimZ,

4779 unsigned int sharedMemBytes, hipStream_t stream,

4780 void** kernelParams, void** extra);

4806hipError_t hipModuleLaunchCooperativeKernel(hipFunction_t f, unsigned int gridDimX,

4807 unsigned int gridDimY, unsigned int gridDimZ,

4808 unsigned int blockDimX, unsigned int blockDimY,

4809 unsigned int blockDimZ, unsigned int sharedMemBytes,

4810 hipStream_t stream, void** kernelParams);

4825hipError_t hipModuleLaunchCooperativeKernelMultiDevice(hipFunctionLaunchParams* launchParamsList,

4826 unsigned int numDevices,

4827 unsigned int flags);

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

4847 void** kernelParams, unsigned int sharedMemBytes,

4848 hipStream_t stream);

4859hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

4860 int numDevices, unsigned int flags);

4872hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

4873 int numDevices, unsigned int flags);

4874// doxygen end Module

4899//TODO - Match CUoccupancyB2DSize

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

4901 hipFunction_t f, size_t dynSharedMemPerBlk,

4902 int blockSizeLimit);

4918//TODO - Match CUoccupancyB2DSize

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

4920 hipFunction_t f, size_t dynSharedMemPerBlk,

4921 int blockSizeLimit, unsigned int flags);

4930hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(

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

4941hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

4951hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(

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

4962hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

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

4979 const void* f, size_t dynSharedMemPerBlk,

4980 int blockSizeLimit);

4981// doxygen end Occupancy

4995// TODO - expand descriptions:

5001DEPRECATED("use roctracer/rocTX instead")

5002hipError_t hipProfilerStart();

5008DEPRECATED("use roctracer/rocTX instead")

5009hipError_t hipProfilerStop();

5010// doxygen end profiler

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

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

5057hipError_t hipLaunchByPtr(const void* func);

5074hipError_t __hipPushCallConfiguration(dim3 gridDim,

5075 dim3 blockDim,

5076 size_t sharedMem __dparm(0),

5077 hipStream_t stream __dparm(0));

5097hipError_t __hipPopCallConfiguration(dim3 *gridDim,

5098 dim3 *blockDim,

5099 size_t *sharedMem,

5100 hipStream_t *stream);

5116hipError_t hipLaunchKernel(const void* function_address,

5117 dim3 numBlocks,

5118 dim3 dimBlocks,

5119 void** args,

5120 size_t sharedMemBytes __dparm(0),

5121 hipStream_t stream __dparm(0));

5122

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

5135

5143hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D* pCopy);

5144//TODO: Move this to hip_ext.h

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

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

5167 hipEvent_t startEvent, hipEvent_t stopEvent, int flags);

5168// doxygen end Clang launch

5190hipError_t hipBindTextureToMipmappedArray(

5191 const textureReference* tex,

5192 hipMipmappedArray_const_t mipmappedArray,

5193 const hipChannelFormatDesc* desc);

5194

5209hipError_t hipCreateTextureObject(

5210 hipTextureObject_t* pTexObject,

5211 const hipResourceDesc* pResDesc,

5212 const hipTextureDesc* pTexDesc,

5213 const struct hipResourceViewDesc* pResViewDesc);

5214

5223hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject);

5224

5234hipError_t hipGetChannelDesc(

5235 hipChannelFormatDesc* desc,

5236 hipArray_const_t array);

5237

5247hipError_t hipGetTextureObjectResourceDesc(

5248 hipResourceDesc* pResDesc,

5249 hipTextureObject_t textureObject);

5250

5260hipError_t hipGetTextureObjectResourceViewDesc(

5261 struct hipResourceViewDesc* pResViewDesc,

5262 hipTextureObject_t textureObject);

5263

5273hipError_t hipGetTextureObjectTextureDesc(

5274 hipTextureDesc* pTexDesc,

5275 hipTextureObject_t textureObject);

5276

5288hipError_t hipTexObjectCreate(

5289 hipTextureObject_t* pTexObject,

5290 const HIP_RESOURCE_DESC* pResDesc,

5291 const HIP_TEXTURE_DESC* pTexDesc,

5292 const HIP_RESOURCE_VIEW_DESC* pResViewDesc);

5293

5302hipError_t hipTexObjectDestroy(

5303 hipTextureObject_t texObject);

5304

5314hipError_t hipTexObjectGetResourceDesc(

5315 HIP_RESOURCE_DESC* pResDesc,

5316 hipTextureObject_t texObject);

5317

5327hipError_t hipTexObjectGetResourceViewDesc(

5328 HIP_RESOURCE_VIEW_DESC* pResViewDesc,

5329 hipTextureObject_t texObject);

5330

5340hipError_t hipTexObjectGetTextureDesc(

5341 HIP_TEXTURE_DESC* pTexDesc,

5342 hipTextureObject_t texObject);

5343

5360DEPRECATED(DEPRECATED_MSG)

5361 hipError_t hipGetTextureReference(

5362 const textureReference** texref,

5363 const void* symbol);

5364

5365DEPRECATED(DEPRECATED_MSG)

5366hipError_t hipTexRefSetAddressMode(

5367 textureReference* texRef,

5368 int dim,

5369 enum hipTextureAddressMode am);

5370DEPRECATED(DEPRECATED_MSG)

5371hipError_t hipTexRefSetArray(

5372 textureReference* tex,

5373 hipArray_const_t array,

5374 unsigned int flags);

5375DEPRECATED(DEPRECATED_MSG)

5376hipError_t hipTexRefSetFilterMode(

5377 textureReference* texRef,

5378 enum hipTextureFilterMode fm);

5379DEPRECATED(DEPRECATED_MSG)

5380hipError_t hipTexRefSetFlags(

5381 textureReference* texRef,

5382 unsigned int Flags);

5383DEPRECATED(DEPRECATED_MSG)

5384hipError_t hipTexRefSetFormat(

5385 textureReference* texRef,

5386 hipArray_Format fmt,

5387 int NumPackedComponents);

5388DEPRECATED(DEPRECATED_MSG)

5389hipError_t hipBindTexture(

5390 size_t* offset,

5391 const textureReference* tex,

5392 const void* devPtr,

5393 const hipChannelFormatDesc* desc,

5394 size_t size __dparm(UINT_MAX));

5395DEPRECATED(DEPRECATED_MSG)

5396hipError_t hipBindTexture2D(

5397 size_t* offset,

5398 const textureReference* tex,

5399 const void* devPtr,

5400 const hipChannelFormatDesc* desc,

5401 size_t width,

5402 size_t height,

5403 size_t pitch);

5404DEPRECATED(DEPRECATED_MSG)

5405hipError_t hipBindTextureToArray(

5406 const textureReference* tex,

5407 hipArray_const_t array,

5408 const hipChannelFormatDesc* desc);

5409DEPRECATED(DEPRECATED_MSG)

5410hipError_t hipGetTextureAlignmentOffset(

5411 size_t* offset,

5412 const textureReference* texref);

5413DEPRECATED(DEPRECATED_MSG)

5414hipError_t hipUnbindTexture(const textureReference* tex);

5415DEPRECATED(DEPRECATED_MSG)

5416hipError_t hipTexRefGetAddress(

5417 hipDeviceptr_t* dev_ptr,

5418 const textureReference* texRef);

5419DEPRECATED(DEPRECATED_MSG)

5420hipError_t hipTexRefGetAddressMode(

5421 enum hipTextureAddressMode* pam,

5422 const textureReference* texRef,

5423 int dim);

5424DEPRECATED(DEPRECATED_MSG)

5425hipError_t hipTexRefGetFilterMode(

5426 enum hipTextureFilterMode* pfm,

5427 const textureReference* texRef);

5428DEPRECATED(DEPRECATED_MSG)

5429hipError_t hipTexRefGetFlags(

5430 unsigned int* pFlags,

5431 const textureReference* texRef);

5432DEPRECATED(DEPRECATED_MSG)

5433hipError_t hipTexRefGetFormat(

5434 hipArray_Format* pFormat,

5435 int* pNumChannels,

5436 const textureReference* texRef);

5437DEPRECATED(DEPRECATED_MSG)

5438hipError_t hipTexRefGetMaxAnisotropy(

5439 int* pmaxAnsio,

5440 const textureReference* texRef);

5441DEPRECATED(DEPRECATED_MSG)

5442hipError_t hipTexRefGetMipmapFilterMode(

5443 enum hipTextureFilterMode* pfm,

5444 const textureReference* texRef);

5445DEPRECATED(DEPRECATED_MSG)

5446hipError_t hipTexRefGetMipmapLevelBias(

5447 float* pbias,

5448 const textureReference* texRef);

5449DEPRECATED(DEPRECATED_MSG)

5450hipError_t hipTexRefGetMipmapLevelClamp(

5451 float* pminMipmapLevelClamp,

5452 float* pmaxMipmapLevelClamp,

5453 const textureReference* texRef);

5454DEPRECATED(DEPRECATED_MSG)

5455hipError_t hipTexRefGetMipMappedArray(

5456 hipMipmappedArray_t* pArray,

5457 const textureReference* texRef);

5458DEPRECATED(DEPRECATED_MSG)

5459hipError_t hipTexRefSetAddress(

5460 size_t* ByteOffset,

5461 textureReference* texRef,

5462 hipDeviceptr_t dptr,

5463 size_t bytes);

5464DEPRECATED(DEPRECATED_MSG)

5465hipError_t hipTexRefSetAddress2D(

5466 textureReference* texRef,

5467 const HIP_ARRAY_DESCRIPTOR* desc,

5468 hipDeviceptr_t dptr,

5469 size_t Pitch);

5470DEPRECATED(DEPRECATED_MSG)

5471hipError_t hipTexRefSetMaxAnisotropy(

5472 textureReference* texRef,

5473 unsigned int maxAniso);

5474 DEPRECATED(DEPRECATED_MSG)

5475hipError_t hipTexRefSetBorderColor(

5476 textureReference* texRef,

5477 float* pBorderColor);

5478DEPRECATED(DEPRECATED_MSG)

5479hipError_t hipTexRefSetMipmapFilterMode(

5480 textureReference* texRef,

5481 enum hipTextureFilterMode fm);

5482DEPRECATED(DEPRECATED_MSG)

5483hipError_t hipTexRefSetMipmapLevelBias(

5484 textureReference* texRef,

5485 float bias);

5486DEPRECATED(DEPRECATED_MSG)

5487hipError_t hipTexRefSetMipmapLevelClamp(

5488 textureReference* texRef,

5489 float minMipMapLevelClamp,

5490 float maxMipMapLevelClamp);

5491DEPRECATED(DEPRECATED_MSG)

5492hipError_t hipTexRefSetMipmappedArray(

5493 textureReference* texRef,

5494 struct hipMipmappedArray* mipmappedArray,

5495 unsigned int Flags);

5496

5497// doxygen end deprecated texture management

5502// The following are not supported.

5511hipError_t hipMipmappedArrayCreate(

5512 hipMipmappedArray_t* pHandle,

5513 HIP_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc,

5514 unsigned int numMipmapLevels);

5515hipError_t hipMipmappedArrayDestroy(

5516 hipMipmappedArray_t hMipmappedArray);

5517hipError_t hipMipmappedArrayGetLevel(

5518 hipArray_t* pLevelArray,

5519 hipMipmappedArray_t hMipMappedArray,

5520 unsigned int level);

5521// doxygen end unsuppported texture management

5526// doxygen end Texture management

5538// This group is for HIPrtc

5539

5540// doxygen end Runtime

5551const char* hipApiName(uint32_t id);

5552const char* hipKernelNameRef(const hipFunction_t f);

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

5554int hipGetStreamDeviceId(hipStream_t stream);

5555

5556// doxygen end Callback

5581hipError_t hipStreamBeginCapture(hipStream_t stream, hipStreamCaptureMode mode);

5582

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

5596

5610hipError_t hipStreamGetCaptureInfo(hipStream_t stream, hipStreamCaptureStatus* pCaptureStatus,

5611 unsigned long long* pId);

5612

5629hipError_t hipStreamGetCaptureInfo_v2(hipStream_t stream, hipStreamCaptureStatus* captureStatus_out,

5630 unsigned long long* id_out __dparm(0),

5631 hipGraph_t* graph_out __dparm(0),

5632 const hipGraphNode_t** dependencies_out __dparm(0),

5633 size_t* numDependencies_out __dparm(0));

5634

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

5648

5661hipError_t hipStreamUpdateCaptureDependencies(hipStream_t stream, hipGraphNode_t* dependencies,

5662 size_t numDependencies,

5663 unsigned int flags __dparm(0));

5664

5675hipError_t hipThreadExchangeStreamCaptureMode(hipStreamCaptureMode* mode);

5676

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

5690

5702hipError_t hipGraphDestroy(hipGraph_t graph);

5703

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

5718 const hipGraphNode_t* to, size_t numDependencies);

5719

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

5734 const hipGraphNode_t* to, size_t numDependencies);

5735

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

5754 size_t* numEdges);

5755

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

5773

5790hipError_t hipGraphGetRootNodes(hipGraph_t graph, hipGraphNode_t* pRootNodes,

5791 size_t* pNumRootNodes);

5792

5809hipError_t hipGraphNodeGetDependencies(hipGraphNode_t node, hipGraphNode_t* pDependencies,

5810 size_t* pNumDependencies);

5811

5829hipError_t hipGraphNodeGetDependentNodes(hipGraphNode_t node, hipGraphNode_t* pDependentNodes,

5830 size_t* pNumDependentNodes);

5831

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

5844

5855hipError_t hipGraphDestroyNode(hipGraphNode_t node);

5856

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

5869

5882hipError_t hipGraphNodeFindInClone(hipGraphNode_t* pNode, hipGraphNode_t originalNode,

5883 hipGraph_t clonedGraph);

5884

5901hipError_t hipGraphInstantiate(hipGraphExec_t* pGraphExec, hipGraph_t graph,

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

5903

5916hipError_t hipGraphInstantiateWithFlags(hipGraphExec_t* pGraphExec, hipGraph_t graph,

5917 unsigned long long flags);

5918

5929hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream);

5930

5941hipError_t hipGraphUpload(hipGraphExec_t graphExec, hipStream_t stream);

5942

5953hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec);

5954

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

5969hipError_t hipGraphExecUpdate(hipGraphExec_t hGraphExec, hipGraph_t hGraph,

5970 hipGraphNode_t* hErrorNode_out,

5971 hipGraphExecUpdateResult* updateResult_out);

5972

5985hipError_t hipGraphAddKernelNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

5986 const hipGraphNode_t* pDependencies, size_t numDependencies,

5987 const hipKernelNodeParams* pNodeParams);

5988

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

5999

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

6010

6021hipError_t hipGraphExecKernelNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

6022 const hipKernelNodeParams* pNodeParams);

6023

6036hipError_t hipGraphAddMemcpyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

6037 const hipGraphNode_t* pDependencies, size_t numDependencies,

6038 const hipMemcpy3DParms* pCopyParams);

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

6049

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

6060

6071hipError_t hipGraphKernelNodeSetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

6072 const hipKernelNodeAttrValue* value);

6083hipError_t hipGraphKernelNodeGetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

6084 hipKernelNodeAttrValue* value);

6095hipError_t hipGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

6096 hipMemcpy3DParms* pNodeParams);

6097

6113hipError_t hipGraphAddMemcpyNode1D(hipGraphNode_t* pGraphNode, hipGraph_t graph,

6114 const hipGraphNode_t* pDependencies, size_t numDependencies,

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

6116

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

6130 size_t count, hipMemcpyKind kind);

6131

6146hipError_t hipGraphExecMemcpyNodeSetParams1D(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

6148 hipMemcpyKind kind);

6149

6166hipError_t hipGraphAddMemcpyNodeFromSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

6167 const hipGraphNode_t* pDependencies,

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

6169 size_t count, size_t offset, hipMemcpyKind kind);

6170

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

6185 size_t count, size_t offset, hipMemcpyKind kind);

6186

6202hipError_t hipGraphExecMemcpyNodeSetParamsFromSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

6204 size_t offset, hipMemcpyKind kind);

6205

6222hipError_t hipGraphAddMemcpyNodeToSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

6223 const hipGraphNode_t* pDependencies,

6224 size_t numDependencies, const void* symbol,

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

6226 hipMemcpyKind kind);

6227

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

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

6243 hipMemcpyKind kind);

6244

6245

6260hipError_t hipGraphExecMemcpyNodeSetParamsToSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

6261 const void* symbol, const void* src,

6262 size_t count, size_t offset, hipMemcpyKind kind);

6263

6276hipError_t hipGraphAddMemsetNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

6277 const hipGraphNode_t* pDependencies, size_t numDependencies,

6278 const hipMemsetParams* pMemsetParams);

6279

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

6290

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

6301

6312hipError_t hipGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

6313 const hipMemsetParams* pNodeParams);

6314

6327hipError_t hipGraphAddHostNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

6328 const hipGraphNode_t* pDependencies, size_t numDependencies,

6329 const hipHostNodeParams* pNodeParams);

6330

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

6341

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

6352

6363hipError_t hipGraphExecHostNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

6364 const hipHostNodeParams* pNodeParams);

6365

6378hipError_t hipGraphAddChildGraphNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

6379 const hipGraphNode_t* pDependencies, size_t numDependencies,

6380 hipGraph_t childGraph);

6381

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

6392

6403hipError_t hipGraphExecChildGraphNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

6404 hipGraph_t childGraph);

6405

6417hipError_t hipGraphAddEmptyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

6418 const hipGraphNode_t* pDependencies, size_t numDependencies);

6419

6420

6433hipError_t hipGraphAddEventRecordNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

6434 const hipGraphNode_t* pDependencies, size_t numDependencies,

6435 hipEvent_t event);

6436

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

6447

6457hipError_t hipGraphEventRecordNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

6458

6469hipError_t hipGraphExecEventRecordNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

6470 hipEvent_t event);

6471

6484hipError_t hipGraphAddEventWaitNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

6485 const hipGraphNode_t* pDependencies, size_t numDependencies,

6486 hipEvent_t event);

6487

6488

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

6499

6509hipError_t hipGraphEventWaitNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

6510

6521hipError_t hipGraphExecEventWaitNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

6522 hipEvent_t event);

6523

6536hipError_t hipGraphAddMemAllocNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

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

6538

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

6549

6562hipError_t hipGraphAddMemFreeNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

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

6564

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

6575

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

6587

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

6599

6607hipError_t hipDeviceGraphMemTrim(int device);

6608

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

6622 unsigned int initialRefcount, unsigned int flags);

6623

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

6634

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

6645

6657hipError_t hipGraphRetainUserObject(hipGraph_t graph, hipUserObject_t object,

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

6659

6670hipError_t hipGraphReleaseUserObject(hipGraph_t graph, hipUserObject_t object,

6671 unsigned int count __dparm(1));

6672

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

6684

6699hipError_t hipGraphKernelNodeCopyAttributes(hipGraphNode_t hSrc, hipGraphNode_t hDst);

6700

6723hipError_t hipGraphNodeSetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

6724 unsigned int isEnabled);

6745hipError_t hipGraphNodeGetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

6746 unsigned int* isEnabled);

6747

6748// doxygen end graph API

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

6772

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

6786

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

6799

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

6812

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

6824

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

6836

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

6847

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

6859

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

6873

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

6885

6894hipError_t hipMemRelease(hipMemGenericAllocationHandle_t handle);

6895

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

6906

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

6919

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

6930

6931// doxygen end virtual memory management API

6943typedef unsigned int GLuint;

6944typedef unsigned int GLenum;

6945

6946// Queries devices associated with GL Context.

6947hipError_t hipGLGetDevices(unsigned int* pHipDeviceCount, int* pHipDevices,

6948 unsigned int hipDeviceCount, hipGLDeviceList deviceList);

6949// Registers a GL Buffer for interop and returns corresponding graphics resource.

6950hipError_t hipGraphicsGLRegisterBuffer(hipGraphicsResource** resource, GLuint buffer,

6951 unsigned int flags);

6952// Register a GL Image for interop and returns the corresponding graphic resource

6953hipError_t hipGraphicsGLRegisterImage(hipGraphicsResource** resource, GLuint image,

6954 GLenum target, unsigned int flags);

6955// Maps a graphics resource for hip access.

6956hipError_t hipGraphicsMapResources(int count, hipGraphicsResource_t* resources,

6957 hipStream_t stream __dparm(0) );

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

6959hipError_t hipGraphicsSubResourceGetMappedArray(hipArray_t* array, hipGraphicsResource_t resource,

6960 unsigned int arrayIndex, unsigned int mipLevel);

6961// Gets device accessible address of a graphics resource.

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

6963 hipGraphicsResource_t resource);

6964// Unmaps a graphics resource for hip access.

6965hipError_t hipGraphicsUnmapResources(int count, hipGraphicsResource_t* resources,

6966 hipStream_t stream __dparm(0));

6967// Unregisters a graphics resource.

6968hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource);

6969// doxygen end GL Interop

6975#ifdef __cplusplus

6976} /* extern "c" */

6977#endif

6978#ifdef __cplusplus

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

6980template <typename T>

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

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

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

6984}

6985template <typename T>

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

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

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

6989}

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

6991template <typename T>

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

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

6994}

6995template <typename T>

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

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

6998}

6999template <typename T>

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

7001 size_t offset __dparm(0),

7002 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice)) {

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

7004}

7005template <typename T>

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

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

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

7009}

7010template <typename T>

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

7012 size_t sizeBytes, size_t offset __dparm(0),

7013 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost)) {

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

7015}

7016template <typename T>

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

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

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

7020}

7021template <class T>

7022inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(

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

7024 return hipOccupancyMaxActiveBlocksPerMultiprocessor(

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

7026}

7027template <class T>

7028inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

7030 return hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

7032}

7052template<typename UnaryFunction, class T>

7053static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(

7054 int* min_grid_size,

7055 int* block_size,

7056 T func,

7057 UnaryFunction block_size_to_dynamic_smem_size,

7058 int block_size_limit = 0,

7059 unsigned int flags = 0) {

7060 if (min_grid_size == nullptr || block_size == nullptr ||

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

7062 return hipErrorInvalidValue;

7063 }

7064

7065 int dev;

7066 hipError_t status;

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

7068 return status;

7069 }

7070

7071 int max_threads_per_cu;

7072 if ((status = hipDeviceGetAttribute(&max_threads_per_cu,

7073 hipDeviceAttributeMaxThreadsPerMultiProcessor, dev)) != hipSuccess) {

7074 return status;

7075 }

7076

7077 int warp_size;

7078 if ((status = hipDeviceGetAttribute(&warp_size,

7079 hipDeviceAttributeWarpSize, dev)) != hipSuccess) {

7080 return status;

7081 }

7082

7083 int max_cu_count;

7084 if ((status = hipDeviceGetAttribute(&max_cu_count,

7085 hipDeviceAttributeMultiprocessorCount, dev)) != hipSuccess) {

7086 return status;

7087 }

7088

7089 struct hipFuncAttributes attr;

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

7091 return status;

7092 }

7093

7094 // Initial limits for the execution

7095 const int func_max_threads_per_block = attr.maxThreadsPerBlock;

7096 if (block_size_limit == 0) {

7097 block_size_limit = func_max_threads_per_block;

7098 }

7099

7100 if (func_max_threads_per_block < block_size_limit) {

7101 block_size_limit = func_max_threads_per_block;

7102 }

7103

7104 const int block_size_limit_aligned =

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

7106

7107 // For maximum search

7108 int max_threads = 0;

7109 int max_block_size{};

7110 int max_num_blocks{};

7111 for (int block_size_check_aligned = block_size_limit_aligned;

7112 block_size_check_aligned > 0;

7113 block_size_check_aligned -= warp_size) {

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

7115 int block_size_check = (block_size_limit < block_size_check_aligned) ?

7116 block_size_limit : block_size_check_aligned;

7117

7118 size_t dyn_smem_size = block_size_to_dynamic_smem_size(block_size_check);

7119 int optimal_blocks;

7120 if ((status = hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

7122 return status;

7123 }

7124

7125 int total_threads = block_size_check * optimal_blocks;

7126 if (total_threads > max_threads) {

7127 max_block_size = block_size_check;

7128 max_num_blocks = optimal_blocks;

7129 max_threads = total_threads;

7130 }

7131

7132 // Break if the logic reached possible maximum

7133 if (max_threads_per_cu == max_threads) {

7134 break;

7135 }

7136 }

7137

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

7139 *min_grid_size = max_num_blocks * max_cu_count;

7140 *block_size = max_block_size;

7141

7142 return status;

7143}

7144

7163template<typename UnaryFunction, class T>

7164static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMem(

7165 int* min_grid_size,

7166 int* block_size,

7167 T func,

7168 UnaryFunction block_size_to_dynamic_smem_size,

7169 int block_size_limit = 0)

7170{

7171 return hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(min_grid_size, block_size, func,

7172 block_size_to_dynamic_smem_size, block_size_limit);

7173}

7174

7175template <typename F>

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

7177 F kernel, size_t dynSharedMemPerBlk, uint32_t blockSizeLimit) {

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

7179}

7180template <class T>

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

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

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

7184 blockDim, kernelParams, sharedMemBytes, stream);

7185}

7186template <class T>

7187inline hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

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

7189 return hipLaunchCooperativeKernelMultiDevice(launchParamsList, numDevices, flags);

7190}

7191template <class T>

7192inline hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

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

7194 return hipExtLaunchMultiKernelMultiDevice(launchParamsList, numDevices, flags);

7195}

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

7197hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject);

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

7199DEPRECATED(DEPRECATED_MSG)

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

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

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

7203}

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

7205DEPRECATED(DEPRECATED_MSG)

7206static inline hipError_t

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

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

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

7210}

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

7212DEPRECATED(DEPRECATED_MSG)

7213static inline hipError_t hipBindTexture2D(

7214 size_t *offset,

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

7216 const void *devPtr,

7217 size_t width,

7218 size_t height,

7219 size_t pitch)

7220{

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

7222}

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

7224DEPRECATED(DEPRECATED_MSG)

7225static inline hipError_t hipBindTexture2D(

7226 size_t *offset,

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

7228 const void *devPtr,

7229 const struct hipChannelFormatDesc &desc,

7230 size_t width,

7231 size_t height,

7232 size_t pitch)

7233{

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

7235}

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

7237DEPRECATED(DEPRECATED_MSG)

7238static inline hipError_t hipBindTextureToArray(

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

7240 hipArray_const_t array)

7241{

7242 struct hipChannelFormatDesc desc;

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

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

7245}

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

7247DEPRECATED(DEPRECATED_MSG)

7248static inline hipError_t hipBindTextureToArray(

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

7250 hipArray_const_t array,

7251 const struct hipChannelFormatDesc &desc)

7252{

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

7254}

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

7256static inline hipError_t hipBindTextureToMipmappedArray(

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

7258 hipMipmappedArray_const_t mipmappedArray)

7259{

7260 struct hipChannelFormatDesc desc;

7261 hipArray_t levelArray;

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

7263 if (err != hipSuccess) {

7264 return err;

7265 }

7266 err = hipGetChannelDesc(&desc, levelArray);

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

7268}

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

7270static inline hipError_t hipBindTextureToMipmappedArray(

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

7272 hipMipmappedArray_const_t mipmappedArray,

7273 const struct hipChannelFormatDesc &desc)

7274{

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

7276}

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

7278DEPRECATED(DEPRECATED_MSG)

7279static inline hipError_t hipUnbindTexture(

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

7281{

7282 return hipUnbindTexture(&tex);

7283}

7291static inline hipError_t hipMallocAsync(

7292 void** dev_ptr,

7293 size_t size,

7294 hipMemPool_t mem_pool,

7295 hipStream_t stream) {

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

7297}

7298

7299template<class T>

7300static inline hipError_t hipMallocAsync(

7301 T** dev_ptr,

7302 size_t size,

7303 hipMemPool_t mem_pool,

7304 hipStream_t stream) {

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

7306}

7307

7308template<class T>

7309static inline hipError_t hipMallocAsync(

7310 T** dev_ptr,

7311 size_t size,

7312 hipStream_t stream) {

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

7314}

7315

7316template<class T>

7317static inline hipError_t hipMallocFromPoolAsync(

7318 T** dev_ptr,

7319 size_t size,

7320 hipMemPool_t mem_pool,

7321 hipStream_t stream) {

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

7323}

7324#endif // __cplusplus

7325

7326#ifdef __GNUC__

7327#pragma GCC visibility pop

7328#endif

7329// doxygen end HIP API

7334#elif !(defined(__HIP_PLATFORM_HCC__) || defined(__HIP_PLATFORM_AMD__)) && (defined(__HIP_PLATFORM_NVCC__) || defined(__HIP_PLATFORM_NVIDIA__))

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

7336#else

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

7338#endif

7339

7340

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

7353template <class T>

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

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

7356}

7357

7358// Provide an override to automatically typecast the pointer type from void**, and also provide a

7359// default for the flags.

7360template <class T>

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

7362 unsigned int flags = hipHostMallocDefault) {

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

7364}

7365

7366template <class T>

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

7368 unsigned int flags = hipMemAttachGlobal) {

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

7370}

7371

7372#endif

7373#endif

7374

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

7376

7377#if USE_PROF_API

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

7379#endif

driver_types.h

hipMemcpyKind

hipMemcpyKind

Definition driver_types.h:344

hipMemcpyDeviceToHost

@ hipMemcpyDeviceToHost

Device-to-Host Copy.

Definition driver_types.h:347

hipMemcpyHostToDevice

@ hipMemcpyHostToDevice

Host-to-Device Copy.

Definition driver_types.h:346

hipPointer_attribute

hipPointer_attribute

Definition driver_types.h:441

hipDeviceptr_t

void * hipDeviceptr_t

Definition driver_types.h:40

hipFunction_attribute

hipFunction_attribute

Definition driver_types.h:427

hipArray_Format

hipArray_Format

Definition driver_types.h:58

hipResourceType

hipResourceType

Definition driver_types.h:134

hipApiName

const char * hipApiName(uint32_t id)

hipKernelNameRef

const char * hipKernelNameRef(const hipFunction_t f)

hipKernelNameRefByPtr

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

hipGetStreamDeviceId

int hipGetStreamDeviceId(hipStream_t stream)

hipSetupArgument

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

Set a kernel argument.

__hipPopCallConfiguration

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

Pop configuration of a kernel launch.

__hipPushCallConfiguration

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

Push configuration of a kernel launch.

hipLaunchHostFunc

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

Enqueues a host function call in a stream.

hipExtLaunchKernel

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

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

hipConfigureCall

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

Configure a kernel launch.

hipLaunchByPtr

hipError_t hipLaunchByPtr(const void *func)

Launch a kernel.

hipLaunchKernel

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

C compliant kernel launch API.

hipDrvMemcpy2DUnaligned

hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D *pCopy)

hipCtxGetFlags

hipError_t hipCtxGetFlags(unsigned int *flags)

Return flags used for creating default context.

hipCtxPopCurrent

hipError_t hipCtxPopCurrent(hipCtx_t *ctx)

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

hipCtxGetSharedMemConfig

hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig *pConfig)

Get Shared memory bank configuration.

hipCtxGetCurrent

hipError_t hipCtxGetCurrent(hipCtx_t *ctx)

Get the handle of the current/ default context.

hipCtxSetCacheConfig

hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig)

Set L1/Shared cache partition.

hipCtxSetCurrent

hipError_t hipCtxSetCurrent(hipCtx_t ctx)

Set the passed context as current/default.

hipCtxEnablePeerAccess

hipError_t hipCtxEnablePeerAccess(hipCtx_t peerCtx, unsigned int flags)

Enables direct access to memory allocations in a peer context.

hipCtxGetDevice

hipError_t hipCtxGetDevice(hipDevice_t *device)

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

hipCtxDestroy

hipError_t hipCtxDestroy(hipCtx_t ctx)

Destroy a HIP context.

hipCtxPushCurrent

hipError_t hipCtxPushCurrent(hipCtx_t ctx)

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

hipCtxGetCacheConfig

hipError_t hipCtxGetCacheConfig(hipFuncCache_t *cacheConfig)

Set Cache configuration for a specific function.

hipCtxCreate

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

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

hipCtxGetApiVersion

hipError_t hipCtxGetApiVersion(hipCtx_t ctx, int *apiVersion)

Returns the approximate HIP api version.

hipCtxSynchronize

hipError_t hipCtxSynchronize(void)

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

hipCtxSetSharedMemConfig

hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config)

Set Shared memory bank configuration.

hipCtxDisablePeerAccess

hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx)

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

hipDevicePrimaryCtxSetFlags

hipError_t hipDevicePrimaryCtxSetFlags(hipDevice_t dev, unsigned int flags)

Set flags for the primary context.

hipDevicePrimaryCtxGetState

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

Get the state of the primary context.

hipDevicePrimaryCtxRelease

hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev)

Release the primary context on the GPU.

hipDevicePrimaryCtxRetain

hipError_t hipDevicePrimaryCtxRetain(hipCtx_t *pctx, hipDevice_t dev)

Retain the primary context on the GPU.

hipDevicePrimaryCtxReset

hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev)

Resets the primary context on the GPU.

hipGetDeviceFlags

hipError_t hipGetDeviceFlags(unsigned int *flags)

Gets the flags set for current device.

hipIpcGetEventHandle

hipError_t hipIpcGetEventHandle(hipIpcEventHandle_t *handle, hipEvent_t event)

Gets an opaque interprocess handle for an event.

hipDeviceGetDefaultMemPool

hipError_t hipDeviceGetDefaultMemPool(hipMemPool_t *mem_pool, int device)

Returns the default memory pool of the specified device.

hipDeviceGetSharedMemConfig

hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig *pConfig)

Returns bank width of shared memory for current device.

hipDeviceSetMemPool

hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool)

Sets the current memory pool of a device.

hipIpcOpenMemHandle

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

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

hipGetDeviceProperties

hipError_t hipGetDeviceProperties(hipDeviceProp_t *prop, int deviceId)

Returns device properties.

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 The funtion querys the size of limit value,...

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 As the input enum limit, hipLimitStackSize sets the limit valu...

hipDeviceSetCacheConfig

hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig)

Set L1/Shared cache partition.

hipIpcCloseMemHandle

hipError_t hipIpcCloseMemHandle(void *devPtr)

Close memory mapped with hipIpcOpenMemHandle.

hipIpcOpenEventHandle

hipError_t hipIpcOpenEventHandle(hipEvent_t *event, hipIpcEventHandle_t handle)

Opens an interprocess event handles.

hipDeviceSynchronize

hipError_t hipDeviceSynchronize(void)

Waits on all active streams on current device.

hipChooseDevice

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

Device which matches hipDeviceProp_t is returned.

hipIpcGetMemHandle

hipError_t hipIpcGetMemHandle(hipIpcMemHandle_t *handle, void *devPtr)

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

hipInit

hipError_t hipInit(unsigned int flags)

Explicitly initializes the HIP runtime.

hipDeviceComputeCapability

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

Returns the compute capability of the device.

hipDeviceGetName

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

Returns an identifer string for the device.

hipDeviceGetByPCIBusId

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

Returns a handle to a compute device.

hipDeviceGetUuid

hipError_t hipDeviceGetUuid(hipUUID *uuid, hipDevice_t device)

Returns an UUID for the device.[BETA].

hipDeviceTotalMem

hipError_t hipDeviceTotalMem(size_t *bytes, hipDevice_t device)

Returns the total amount of memory on the device.

hipDeviceGetPCIBusId

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

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

hipDeviceGet

hipError_t hipDeviceGet(hipDevice_t *device, int ordinal)

Returns a handle to a compute device.

hipRuntimeGetVersion

hipError_t hipRuntimeGetVersion(int *runtimeVersion)

Returns the approximate HIP Runtime version.

hipDeviceGetP2PAttribute

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

Returns a value for attribute of link between two devices.

hipDriverGetVersion

hipError_t hipDriverGetVersion(int *driverVersion)

Returns the approximate HIP driver version.

hipGetErrorString

const char * hipGetErrorString(hipError_t hipError)

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

hipPeekAtLastError

hipError_t hipPeekAtLastError(void)

Return last error returned by any HIP runtime API call.

hipDrvGetErrorString

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

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

hipGetLastError

hipError_t hipGetLastError(void)

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

hipDrvGetErrorName

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

Return hip error as text string form.

hipGetErrorName

const char * hipGetErrorName(hipError_t hip_error)

Return hip error as text string form.

hipEventSynchronize

hipError_t hipEventSynchronize(hipEvent_t event)

Wait for an event to complete.

hipEventRecord

hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream)

Record an event in the specified stream.

hipEventQuery

hipError_t hipEventQuery(hipEvent_t event)

Query event status.

hipEventCreate

hipError_t hipEventCreate(hipEvent_t *event)

hipEventDestroy

hipError_t hipEventDestroy(hipEvent_t event)

Destroy the specified event.

hipEventElapsedTime

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

Return the elapsed time between two events.

hipEventCreateWithFlags

hipError_t hipEventCreateWithFlags(hipEvent_t *event, unsigned flags)

Create an event with the specified flags.

hipFuncSetSharedMemConfig

hipError_t hipFuncSetSharedMemConfig(const void *func, hipSharedMemConfig config)

Set shared memory configuation for a specific function.

hipFuncSetAttribute

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

Set attribute for a specific function.

hipFuncSetCacheConfig

hipError_t hipFuncSetCacheConfig(const void *func, hipFuncCache_t config)

Set Cache configuration for a specific function.

hipGLGetDevices

hipError_t hipGLGetDevices(unsigned int *pHipDeviceCount, int *pHipDevices, unsigned int hipDeviceCount, hipGLDeviceList deviceList)

hipGraphicsGLRegisterImage

hipError_t hipGraphicsGLRegisterImage(hipGraphicsResource **resource, GLuint image, GLenum target, unsigned int flags)

hipGraphicsUnregisterResource

hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource)

hipGraphicsGLRegisterBuffer

hipError_t hipGraphicsGLRegisterBuffer(hipGraphicsResource **resource, GLuint buffer, unsigned int flags)

hipGraphicsMapResources

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

GLenum

unsigned int GLenum

Definition hip_runtime_api.h:6944

hipGraphicsSubResourceGetMappedArray

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

GLuint

unsigned int GLuint

Definition hip_runtime_api.h:6943

hipGraphicsUnmapResources

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

hipGraphicsResourceGetMappedPointer

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

hipMemAllocationHandleType

hipMemAllocationHandleType

Definition hip_runtime_api.h:866

hipGraphicsResource_t

hipGraphicsResource * hipGraphicsResource_t

Definition hip_runtime_api.h:1091

hipGLDeviceList

hipGLDeviceList

Definition hip_runtime_api.h:1066

hipAccessProperty

hipAccessProperty

Definition hip_runtime_api.h:1176

hipMemRangeAttribute

hipMemRangeAttribute

Definition hip_runtime_api.h:740

hipMemAttachSingle

#define hipMemAttachSingle

Definition hip_runtime_api.h:628

hipMemoryAdvise

hipMemoryAdvise

Definition hip_runtime_api.h:703

hipArrayDefault

#define hipArrayDefault

Definition hip_runtime_api.h:673

hipSharedMemConfig

hipSharedMemConfig

Definition hip_runtime_api.h:937

hipComputeMode

hipComputeMode

Definition hip_runtime_api.h:469

hipStreamCaptureMode

hipStreamCaptureMode

Definition hip_runtime_api.h:1213

hipGraphNodeType

hipGraphNodeType

Definition hip_runtime_api.h:1117

hipExternalMemoryHandleType

hipExternalMemoryHandleType

Definition hip_runtime_api.h:976

hipMemAttachGlobal

#define hipMemAttachGlobal

Definition hip_runtime_api.h:622

hipFuncAttribute

hipFuncAttribute

Definition hip_runtime_api.h:920

hipExternalSemaphoreHandleType

hipExternalSemaphoreHandleType

Definition hip_runtime_api.h:1003

hipJitOption

hipJitOption

Definition hip_runtime_api.h:897

hipGraphDebugDotFlags

hipGraphDebugDotFlags

Definition hip_runtime_api.h:1249

hipUserObjectRetainFlags

hipUserObjectRetainFlags

Definition hip_runtime_api.h:1240

hipError_t

enum __HIP_NODISCARD hipError_t hipError_t

Definition hip_runtime_api.h:213

hipHostFn_t

void(* hipHostFn_t)(void *userData)

Definition hip_runtime_api.h:1135

hipOccupancyDefault

#define hipOccupancyDefault

Definition hip_runtime_api.h:678

hipStreamUpdateCaptureDependenciesFlags

hipStreamUpdateCaptureDependenciesFlags

Definition hip_runtime_api.h:1225

hipGraph_t

struct ihipGraph * hipGraph_t

Definition hip_runtime_api.h:1096

hipMemHandleType

hipMemHandleType

Definition hip_runtime_api.h:1302

hipFuncCache_t

hipFuncCache_t

Definition hip_runtime_api.h:928

hipUserObjectFlags

hipUserObjectFlags

Definition hip_runtime_api.h:1236

__HIP_NODISCARD

#define __HIP_NODISCARD

Definition hip_runtime_api.h:202

hipGraphMemAttributeType

hipGraphMemAttributeType

Definition hip_runtime_api.h:1230

hipMemPoolAttr

hipMemPoolAttr

Definition hip_runtime_api.h:758

hipUserObject_t

struct hipUserObject * hipUserObject_t

Definition hip_runtime_api.h:1109

hipMemOperationType

hipMemOperationType

Definition hip_runtime_api.h:1311

hipExternalSemaphore_t

void * hipExternalSemaphore_t

Definition hip_runtime_api.h:1020

hipGraphicsRegisterFlags

hipGraphicsRegisterFlags

Definition hip_runtime_api.h:1079

hipMemRangeCoherencyMode

hipMemRangeCoherencyMode

Definition hip_runtime_api.h:726

hipMemAccessFlags

hipMemAccessFlags

Definition hip_runtime_api.h:836

hipMemAllocationGranularity_flags

hipMemAllocationGranularity_flags

Definition hip_runtime_api.h:1292

hipGraphExec_t

struct hipGraphExec * hipGraphExec_t

Definition hip_runtime_api.h:1104

hipGraphExecUpdateResult

hipGraphExecUpdateResult

Definition hip_runtime_api.h:1198

hipExternalMemory_t

void * hipExternalMemory_t

Definition hip_runtime_api.h:1002

hipStreamCaptureStatus

hipStreamCaptureStatus

Definition hip_runtime_api.h:1218

hipDeviceAttribute_t

hipDeviceAttribute_t

Definition hip_runtime_api.h:336

hipHostMallocDefault

#define hipHostMallocDefault

Definition hip_runtime_api.h:598

hipGraphicsResource

struct _hipGraphicsResource hipGraphicsResource

Definition hip_runtime_api.h:1089

hipMemAllocationType

hipMemAllocationType

Definition hip_runtime_api.h:853

hipGraphNode_t

struct hipGraphNode * hipGraphNode_t

Definition hip_runtime_api.h:1100

hipMemGenericAllocationHandle_t

struct ihipMemGenericAllocationHandle * hipMemGenericAllocationHandle_t

Definition hip_runtime_api.h:1285

hipGraphInstantiateFlags

hipGraphInstantiateFlags

Definition hip_runtime_api.h:1244

hipKernelNodeAttrID

hipKernelNodeAttrID

Definition hip_runtime_api.h:1172

hipMemLocationType

hipMemLocationType

Definition hip_runtime_api.h:818

hipArraySparseSubresourceType

hipArraySparseSubresourceType

Definition hip_runtime_api.h:1321

hipMemHandleTypeWin32

@ hipMemHandleTypeWin32

Allows a Win32 NT handle for exporting. (HANDLE)

Definition hip_runtime_api.h:869

hipMemHandleTypeWin32Kmt

@ hipMemHandleTypeWin32Kmt

Allows a Win32 KMT handle for exporting. (D3DKMT_HANDLE)

Definition hip_runtime_api.h:870

hipMemHandleTypeNone

@ hipMemHandleTypeNone

Does not allow any export mechanism.

Definition hip_runtime_api.h:867

hipMemHandleTypePosixFileDescriptor

@ hipMemHandleTypePosixFileDescriptor

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

Definition hip_runtime_api.h:868

hipGLDeviceListNextFrame

@ hipGLDeviceListNextFrame

frame.

Definition hip_runtime_api.h:1070

hipGLDeviceListAll

@ hipGLDeviceListAll

All hip devices used by current OpenGL context.

Definition hip_runtime_api.h:1067

hipGLDeviceListCurrentFrame

@ hipGLDeviceListCurrentFrame

frame

Definition hip_runtime_api.h:1068

hipAccessPropertyNormal

@ hipAccessPropertyNormal

Definition hip_runtime_api.h:1177

hipAccessPropertyPersisting

@ hipAccessPropertyPersisting

Definition hip_runtime_api.h:1179

hipAccessPropertyStreaming

@ hipAccessPropertyStreaming

Definition hip_runtime_api.h:1178

hipMemRangeAttributeLastPrefetchLocation

@ hipMemRangeAttributeLastPrefetchLocation

prefetched

Definition hip_runtime_api.h:746

hipMemRangeAttributePreferredLocation

@ hipMemRangeAttributePreferredLocation

The preferred location of the range.

Definition hip_runtime_api.h:743

hipMemRangeAttributeAccessedBy

@ hipMemRangeAttributeAccessedBy

Definition hip_runtime_api.h:744

hipMemRangeAttributeReadMostly

@ hipMemRangeAttributeReadMostly

Definition hip_runtime_api.h:741

hipMemRangeAttributeCoherencyMode

@ hipMemRangeAttributeCoherencyMode

Definition hip_runtime_api.h:748

hipMemAdviseUnsetAccessedBy

@ hipMemAdviseUnsetAccessedBy

Definition hip_runtime_api.h:712

hipMemAdviseUnsetCoarseGrain

@ hipMemAdviseUnsetCoarseGrain

Restores cache coherency policy back to fine-grain.

Definition hip_runtime_api.h:719

hipMemAdviseSetCoarseGrain

@ hipMemAdviseSetCoarseGrain

Definition hip_runtime_api.h:714

hipMemAdviseUnsetPreferredLocation

@ hipMemAdviseUnsetPreferredLocation

Clear the preferred location for the data.

Definition hip_runtime_api.h:709

hipMemAdviseSetAccessedBy

@ hipMemAdviseSetAccessedBy

Definition hip_runtime_api.h:710

hipMemAdviseSetPreferredLocation

@ hipMemAdviseSetPreferredLocation

Definition hip_runtime_api.h:707

hipMemAdviseSetReadMostly

@ hipMemAdviseSetReadMostly

Definition hip_runtime_api.h:704

hipMemAdviseUnsetReadMostly

@ hipMemAdviseUnsetReadMostly

Undo the effect of hipMemAdviseSetReadMostly.

Definition hip_runtime_api.h:706

hipSharedMemBankSizeFourByte

@ hipSharedMemBankSizeFourByte

Definition hip_runtime_api.h:939

hipSharedMemBankSizeEightByte

@ hipSharedMemBankSizeEightByte

Definition hip_runtime_api.h:941

hipSharedMemBankSizeDefault

@ hipSharedMemBankSizeDefault

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

Definition hip_runtime_api.h:938

hipComputeModeProhibited

@ hipComputeModeProhibited

Definition hip_runtime_api.h:472

hipComputeModeExclusive

@ hipComputeModeExclusive

Definition hip_runtime_api.h:471

hipComputeModeDefault

@ hipComputeModeDefault

Definition hip_runtime_api.h:470

hipComputeModeExclusiveProcess

@ hipComputeModeExclusiveProcess

Definition hip_runtime_api.h:473

hipStreamCaptureModeRelaxed

@ hipStreamCaptureModeRelaxed

Definition hip_runtime_api.h:1216

hipStreamCaptureModeThreadLocal

@ hipStreamCaptureModeThreadLocal

Definition hip_runtime_api.h:1215

hipStreamCaptureModeGlobal

@ hipStreamCaptureModeGlobal

Definition hip_runtime_api.h:1214

hipGraphNodeTypeGraph

@ hipGraphNodeTypeGraph

Node which executes an embedded graph.

Definition hip_runtime_api.h:1122

hipGraphNodeTypeMemset

@ hipGraphNodeTypeMemset

Memset node.

Definition hip_runtime_api.h:1120

hipGraphNodeTypeEventRecord

@ hipGraphNodeTypeEventRecord

External event record node.

Definition hip_runtime_api.h:1125

hipGraphNodeTypeExtSemaphoreSignal

@ hipGraphNodeTypeExtSemaphoreSignal

External Semaphore signal node.

Definition hip_runtime_api.h:1126

hipGraphNodeTypeMemcpy

@ hipGraphNodeTypeMemcpy

Memcpy node.

Definition hip_runtime_api.h:1119

hipGraphNodeTypeWaitEvent

@ hipGraphNodeTypeWaitEvent

External event wait node.

Definition hip_runtime_api.h:1124

hipGraphNodeTypeCount

@ hipGraphNodeTypeCount

Definition hip_runtime_api.h:1132

hipGraphNodeTypeKernel

@ hipGraphNodeTypeKernel

GPU kernel node.

Definition hip_runtime_api.h:1118

hipGraphNodeTypeHost

@ hipGraphNodeTypeHost

Host (executable) node.

Definition hip_runtime_api.h:1121

hipGraphNodeTypeMemAlloc

@ hipGraphNodeTypeMemAlloc

Memory alloc node.

Definition hip_runtime_api.h:1128

hipGraphNodeTypeMemFree

@ hipGraphNodeTypeMemFree

Memory free node.

Definition hip_runtime_api.h:1129

hipGraphNodeTypeMemcpyFromSymbol

@ hipGraphNodeTypeMemcpyFromSymbol

MemcpyFromSymbol node.

Definition hip_runtime_api.h:1130

hipGraphNodeTypeMemcpyToSymbol

@ hipGraphNodeTypeMemcpyToSymbol

MemcpyToSymbol node.

Definition hip_runtime_api.h:1131

hipGraphNodeTypeEmpty

@ hipGraphNodeTypeEmpty

Empty (no-op) node.

Definition hip_runtime_api.h:1123

hipGraphNodeTypeExtSemaphoreWait

@ hipGraphNodeTypeExtSemaphoreWait

External Semaphore wait node.

Definition hip_runtime_api.h:1127

hipExternalMemoryHandleTypeD3D11Resource

@ hipExternalMemoryHandleTypeD3D11Resource

Definition hip_runtime_api.h:982

hipExternalMemoryHandleTypeD3D12Resource

@ hipExternalMemoryHandleTypeD3D12Resource

Definition hip_runtime_api.h:981

hipExternalMemoryHandleTypeOpaqueFd

@ hipExternalMemoryHandleTypeOpaqueFd

Definition hip_runtime_api.h:977

hipExternalMemoryHandleTypeD3D12Heap

@ hipExternalMemoryHandleTypeD3D12Heap

Definition hip_runtime_api.h:980

hipExternalMemoryHandleTypeOpaqueWin32Kmt

@ hipExternalMemoryHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:979

hipExternalMemoryHandleTypeOpaqueWin32

@ hipExternalMemoryHandleTypeOpaqueWin32

Definition hip_runtime_api.h:978

hipExternalMemoryHandleTypeD3D11ResourceKmt

@ hipExternalMemoryHandleTypeD3D11ResourceKmt

Definition hip_runtime_api.h:983

hipFuncAttributePreferredSharedMemoryCarveout

@ hipFuncAttributePreferredSharedMemoryCarveout

Definition hip_runtime_api.h:922

hipFuncAttributeMaxDynamicSharedMemorySize

@ hipFuncAttributeMaxDynamicSharedMemorySize

Definition hip_runtime_api.h:921

hipFuncAttributeMax

@ hipFuncAttributeMax

Definition hip_runtime_api.h:923

hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

@ hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:1006

hipExternalSemaphoreHandleTypeOpaqueFd

@ hipExternalSemaphoreHandleTypeOpaqueFd

Definition hip_runtime_api.h:1004

hipExternalSemaphoreHandleTypeOpaqueWin32

@ hipExternalSemaphoreHandleTypeOpaqueWin32

Definition hip_runtime_api.h:1005

hipExternalSemaphoreHandleTypeD3D12Fence

@ hipExternalSemaphoreHandleTypeD3D12Fence

Definition hip_runtime_api.h:1007

hipJitOptionCacheMode

@ hipJitOptionCacheMode

Definition hip_runtime_api.h:912

hipJitOptionFastCompile

@ hipJitOptionFastCompile

Definition hip_runtime_api.h:914

hipJitOptionInfoLogBuffer

@ hipJitOptionInfoLogBuffer

Definition hip_runtime_api.h:901

hipJitOptionErrorLogBuffer

@ hipJitOptionErrorLogBuffer

Definition hip_runtime_api.h:903

hipJitOptionTarget

@ hipJitOptionTarget

Definition hip_runtime_api.h:907

hipJitOptionThreadsPerBlock

@ hipJitOptionThreadsPerBlock

Definition hip_runtime_api.h:899

hipJitOptionNumOptions

@ hipJitOptionNumOptions

Definition hip_runtime_api.h:915

hipJitOptionGenerateLineInfo

@ hipJitOptionGenerateLineInfo

Definition hip_runtime_api.h:911

hipJitOptionOptimizationLevel

@ hipJitOptionOptimizationLevel

Definition hip_runtime_api.h:905

hipJitOptionErrorLogBufferSizeBytes

@ hipJitOptionErrorLogBufferSizeBytes

Definition hip_runtime_api.h:904

hipJitOptionWallTime

@ hipJitOptionWallTime

Definition hip_runtime_api.h:900

hipJitOptionInfoLogBufferSizeBytes

@ hipJitOptionInfoLogBufferSizeBytes

Definition hip_runtime_api.h:902

hipJitOptionTargetFromContext

@ hipJitOptionTargetFromContext

Definition hip_runtime_api.h:906

hipJitOptionGenerateDebugInfo

@ hipJitOptionGenerateDebugInfo

Definition hip_runtime_api.h:909

hipJitOptionLogVerbose

@ hipJitOptionLogVerbose

Definition hip_runtime_api.h:910

hipJitOptionMaxRegisters

@ hipJitOptionMaxRegisters

Definition hip_runtime_api.h:898

hipJitOptionSm3xOpt

@ hipJitOptionSm3xOpt

Definition hip_runtime_api.h:913

hipJitOptionFallbackStrategy

@ hipJitOptionFallbackStrategy

Definition hip_runtime_api.h:908

hipGraphDebugDotFlagsKernelNodeAttributes

@ hipGraphDebugDotFlagsKernelNodeAttributes

Definition hip_runtime_api.h:1262

hipGraphDebugDotFlagsMemsetNodeParams

@ hipGraphDebugDotFlagsMemsetNodeParams

Definition hip_runtime_api.h:1254

hipGraphDebugDotFlagsKernelNodeParams

@ hipGraphDebugDotFlagsKernelNodeParams

Definition hip_runtime_api.h:1252

hipGraphDebugDotFlagsExtSemasWaitNodeParams

@ hipGraphDebugDotFlagsExtSemasWaitNodeParams

Definition hip_runtime_api.h:1260

hipGraphDebugDotFlagsHandles

@ hipGraphDebugDotFlagsHandles

Definition hip_runtime_api.h:1264

hipGraphDebugDotFlagsExtSemasSignalNodeParams

@ hipGraphDebugDotFlagsExtSemasSignalNodeParams

Definition hip_runtime_api.h:1258

hipGraphDebugDotFlagsHostNodeParams

@ hipGraphDebugDotFlagsHostNodeParams

Definition hip_runtime_api.h:1255

hipGraphDebugDotFlagsEventNodeParams

@ hipGraphDebugDotFlagsEventNodeParams

Definition hip_runtime_api.h:1256

hipGraphDebugDotFlagsVerbose

@ hipGraphDebugDotFlagsVerbose

Definition hip_runtime_api.h:1250

hipGraphDebugDotFlagsMemcpyNodeParams

@ hipGraphDebugDotFlagsMemcpyNodeParams

Definition hip_runtime_api.h:1253

hipGraphUserObjectMove

@ hipGraphUserObjectMove

Add new reference or retain.

Definition hip_runtime_api.h:1241

hipStreamAddCaptureDependencies

@ hipStreamAddCaptureDependencies

Add new nodes to the dependency set.

Definition hip_runtime_api.h:1226

hipStreamSetCaptureDependencies

@ hipStreamSetCaptureDependencies

Replace the dependency set with the new nodes.

Definition hip_runtime_api.h:1227

hipMemHandleTypeGeneric

@ hipMemHandleTypeGeneric

Generic handle type.

Definition hip_runtime_api.h:1303

hipFuncCachePreferNone

@ hipFuncCachePreferNone

no preference for shared memory or L1 (default)

Definition hip_runtime_api.h:929

hipFuncCachePreferEqual

@ hipFuncCachePreferEqual

prefer equal size L1 cache and shared memory

Definition hip_runtime_api.h:932

hipFuncCachePreferL1

@ hipFuncCachePreferL1

prefer larger L1 cache and smaller shared memory

Definition hip_runtime_api.h:931

hipFuncCachePreferShared

@ hipFuncCachePreferShared

prefer larger shared memory and smaller L1 cache

Definition hip_runtime_api.h:930

hipUserObjectNoDestructorSync

@ hipUserObjectNoDestructorSync

Destructor execution is not synchronized.

Definition hip_runtime_api.h:1237

hipGraphMemAttrReservedMemHigh

@ hipGraphMemAttrReservedMemHigh

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

Definition hip_runtime_api.h:1234

hipGraphMemAttrUsedMemCurrent

@ hipGraphMemAttrUsedMemCurrent

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

Definition hip_runtime_api.h:1231

hipGraphMemAttrUsedMemHigh

@ hipGraphMemAttrUsedMemHigh

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

Definition hip_runtime_api.h:1232

hipGraphMemAttrReservedMemCurrent

@ hipGraphMemAttrReservedMemCurrent

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

Definition hip_runtime_api.h:1233

hipMemPoolAttrUsedMemCurrent

@ hipMemPoolAttrUsedMemCurrent

Definition hip_runtime_api.h:805

hipMemPoolAttrReservedMemHigh

@ hipMemPoolAttrReservedMemHigh

Definition hip_runtime_api.h:800

hipMemPoolAttrReservedMemCurrent

@ hipMemPoolAttrReservedMemCurrent

Definition hip_runtime_api.h:794

hipMemPoolAttrReleaseThreshold

@ hipMemPoolAttrReleaseThreshold

Definition hip_runtime_api.h:789

hipMemPoolAttrUsedMemHigh

@ hipMemPoolAttrUsedMemHigh

Definition hip_runtime_api.h:811

hipMemPoolReuseAllowInternalDependencies

@ hipMemPoolReuseAllowInternalDependencies

Definition hip_runtime_api.h:780

hipMemPoolReuseFollowEventDependencies

@ hipMemPoolReuseFollowEventDependencies

Definition hip_runtime_api.h:767

hipMemPoolReuseAllowOpportunistic

@ hipMemPoolReuseAllowOpportunistic

Definition hip_runtime_api.h:773

hipMemOperationTypeMap

@ hipMemOperationTypeMap

Map operation.

Definition hip_runtime_api.h:1312

hipMemOperationTypeUnmap

@ hipMemOperationTypeUnmap

Unmap operation.

Definition hip_runtime_api.h:1313

hipGraphicsRegisterFlagsReadOnly

@ hipGraphicsRegisterFlagsReadOnly

HIP will not write to this registered resource.

Definition hip_runtime_api.h:1081

hipGraphicsRegisterFlagsTextureGather

@ hipGraphicsRegisterFlagsTextureGather

HIP will perform texture gather operations on this registered resource.

Definition hip_runtime_api.h:1085

hipGraphicsRegisterFlagsWriteDiscard

@ hipGraphicsRegisterFlagsWriteDiscard

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

Definition hip_runtime_api.h:1082

hipGraphicsRegisterFlagsNone

@ hipGraphicsRegisterFlagsNone

Definition hip_runtime_api.h:1080

hipGraphicsRegisterFlagsSurfaceLoadStore

@ hipGraphicsRegisterFlagsSurfaceLoadStore

HIP will bind this resource to a surface.

Definition hip_runtime_api.h:1084

hipMemRangeCoherencyModeFineGrain

@ hipMemRangeCoherencyModeFineGrain

Definition hip_runtime_api.h:727

hipMemRangeCoherencyModeIndeterminate

@ hipMemRangeCoherencyModeIndeterminate

Definition hip_runtime_api.h:731

hipMemRangeCoherencyModeCoarseGrain

@ hipMemRangeCoherencyModeCoarseGrain

Definition hip_runtime_api.h:729

hipMemAccessFlagsProtRead

@ hipMemAccessFlagsProtRead

Set the address range read accessible.

Definition hip_runtime_api.h:838

hipMemAccessFlagsProtNone

@ hipMemAccessFlagsProtNone

Default, make the address range not accessible.

Definition hip_runtime_api.h:837

hipMemAccessFlagsProtReadWrite

@ hipMemAccessFlagsProtReadWrite

Set the address range read-write accessible.

Definition hip_runtime_api.h:839

hipMemAllocationGranularityMinimum

@ hipMemAllocationGranularityMinimum

Minimum granularity.

Definition hip_runtime_api.h:1293

hipMemAllocationGranularityRecommended

@ hipMemAllocationGranularityRecommended

Recommended granularity for performance.

Definition hip_runtime_api.h:1294

hipGraphExecUpdateErrorNotSupported

@ hipGraphExecUpdateErrorNotSupported

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

Definition hip_runtime_api.h:1208

hipGraphExecUpdateErrorNodeTypeChanged

@ hipGraphExecUpdateErrorNodeTypeChanged

The update failed because a node type changed.

Definition hip_runtime_api.h:1203

hipGraphExecUpdateErrorTopologyChanged

@ hipGraphExecUpdateErrorTopologyChanged

The update failed because the topology changed.

Definition hip_runtime_api.h:1202

hipGraphExecUpdateErrorUnsupportedFunctionChange

@ hipGraphExecUpdateErrorUnsupportedFunctionChange

Definition hip_runtime_api.h:1210

hipGraphExecUpdateError

@ hipGraphExecUpdateError

Definition hip_runtime_api.h:1200

hipGraphExecUpdateErrorFunctionChanged

@ hipGraphExecUpdateErrorFunctionChanged

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

Definition hip_runtime_api.h:1204

hipGraphExecUpdateSuccess

@ hipGraphExecUpdateSuccess

The update succeeded.

Definition hip_runtime_api.h:1199

hipGraphExecUpdateErrorParametersChanged

@ hipGraphExecUpdateErrorParametersChanged

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

Definition hip_runtime_api.h:1206

hipStreamCaptureStatusInvalidated

@ hipStreamCaptureStatusInvalidated

Definition hip_runtime_api.h:1221

hipStreamCaptureStatusNone

@ hipStreamCaptureStatusNone

Stream is not capturing.

Definition hip_runtime_api.h:1219

hipStreamCaptureStatusActive

@ hipStreamCaptureStatusActive

Stream is actively capturing.

Definition hip_runtime_api.h:1220

hipDeviceAttributeDirectManagedMemAccessFromHost

@ hipDeviceAttributeDirectManagedMemAccessFromHost

Definition hip_runtime_api.h:354

hipDeviceAttributeSurfaceAlignment

@ hipDeviceAttributeSurfaceAlignment

Cuda only. Alignment requirement for surfaces.

Definition hip_runtime_api.h:424

hipDeviceAttributeMaxGridDimX

@ hipDeviceAttributeMaxGridDimX

Max grid size in width.

Definition hip_runtime_api.h:371

hipDeviceAttributeMaxSurfaceCubemapLayered

@ hipDeviceAttributeMaxSurfaceCubemapLayered

Cuda only. Maximum dimension of Cubemap layered surface.

Definition hip_runtime_api.h:380

hipDeviceAttributeMaxSurface3D

@ hipDeviceAttributeMaxSurface3D

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

Definition hip_runtime_api.h:378

hipDeviceAttributeMaxPitch

@ hipDeviceAttributeMaxPitch

Maximum pitch in bytes allowed by memory copies.

Definition hip_runtime_api.h:401

hipDeviceAttributeTccDriver

@ hipDeviceAttributeTccDriver

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

Definition hip_runtime_api.h:425

hipDeviceAttributeHostNativeAtomicSupported

@ hipDeviceAttributeHostNativeAtomicSupported

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

Definition hip_runtime_api.h:357

hipDeviceAttributePageableMemoryAccessUsesHostPageTables

@ hipDeviceAttributePageableMemoryAccessUsesHostPageTables

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

Definition hip_runtime_api.h:410

hipDeviceAttributeMaxBlockDimY

@ hipDeviceAttributeMaxBlockDimY

Max block size in height.

Definition hip_runtime_api.h:369

hipDeviceAttributeMaxSurfaceCubemap

@ hipDeviceAttributeMaxSurfaceCubemap

Cuda only. Maximum dimensions of Cubemap surface.

Definition hip_runtime_api.h:379

hipDeviceAttributeName

@ hipDeviceAttributeName

Device name.

Definition hip_runtime_api.h:407

hipDeviceAttributePageableMemoryAccess

@ hipDeviceAttributePageableMemoryAccess

Definition hip_runtime_api.h:408

hipDeviceAttributeClockRate

@ hipDeviceAttributeClockRate

Peak clock frequency in kilohertz.

Definition hip_runtime_api.h:345

hipDeviceAttributeCudaCompatibleEnd

@ hipDeviceAttributeCudaCompatibleEnd

Definition hip_runtime_api.h:436

hipDeviceAttributeMaxTexture1DMipmap

@ hipDeviceAttributeMaxTexture1DMipmap

Cuda only. Maximum size of 1D mipmapped texture.

Definition hip_runtime_api.h:385

hipDeviceAttributeComputeCapabilityMajor

@ hipDeviceAttributeComputeCapabilityMajor

Major compute capability version number.

Definition hip_runtime_api.h:365

hipDeviceAttributeGlobalL1CacheSupported

@ hipDeviceAttributeGlobalL1CacheSupported

Cuda only. Device supports caching globals in L1.

Definition hip_runtime_api.h:356

hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

Definition hip_runtime_api.h:452

hipDeviceAttributeAccessPolicyMaxWindowSize

@ hipDeviceAttributeAccessPolicyMaxWindowSize

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

Definition hip_runtime_api.h:340

hipDeviceAttributeMaxTexture3DHeight

@ hipDeviceAttributeMaxTexture3DHeight

Maximum dimension height of 3D texture.

Definition hip_runtime_api.h:393

hipDeviceAttributeComputeCapabilityMinor

@ hipDeviceAttributeComputeCapabilityMinor

Minor compute capability version number.

Definition hip_runtime_api.h:404

hipDeviceAttributeMaxTextureCubemap

@ hipDeviceAttributeMaxTextureCubemap

Cuda only. Maximum dimensions of Cubemap texture.

Definition hip_runtime_api.h:396

hipDeviceAttributeDeviceOverlap

@ hipDeviceAttributeDeviceOverlap

Definition hip_runtime_api.h:352

hipDeviceAttributeMaxTexture2DLinear

@ hipDeviceAttributeMaxTexture2DLinear

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

Definition hip_runtime_api.h:390

hipDeviceAttributeMaxSurface2D

@ hipDeviceAttributeMaxSurface2D

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

Definition hip_runtime_api.h:376

hipDeviceAttributeMaxSurface1DLayered

@ hipDeviceAttributeMaxSurface1DLayered

Cuda only. Maximum dimensions of 1D layered surface.

Definition hip_runtime_api.h:375

hipDeviceAttributeHdpRegFlushCntl

@ hipDeviceAttributeHdpRegFlushCntl

Address of the HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:445

hipDeviceAttributeComputeMode

@ hipDeviceAttributeComputeMode

Compute mode that device is currently in.

Definition hip_runtime_api.h:346

hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

Definition hip_runtime_api.h:446

hipDeviceAttributeAsicRevision

@ hipDeviceAttributeAsicRevision

Revision of the GPU in this device.

Definition hip_runtime_api.h:455

hipDeviceAttributeCooperativeMultiDeviceLaunch

@ hipDeviceAttributeCooperativeMultiDeviceLaunch

Support cooperative launch on multiple devices.

Definition hip_runtime_api.h:351

hipDeviceAttributeMaxTexture2DHeight

@ hipDeviceAttributeMaxTexture2DHeight

Maximum dimension hight of 2D texture.

Definition hip_runtime_api.h:387

hipDeviceAttributePersistingL2CacheMaxSize

@ hipDeviceAttributePersistingL2CacheMaxSize

Cuda11 only. Maximum l2 persisting lines capacity in bytes.

Definition hip_runtime_api.h:414

hipDeviceAttributeEccEnabled

@ hipDeviceAttributeEccEnabled

Whether ECC support is enabled.

Definition hip_runtime_api.h:339

hipDeviceAttributeCanUseHostPointerForRegisteredMem

@ hipDeviceAttributeCanUseHostPointerForRegisteredMem

Definition hip_runtime_api.h:343

hipDeviceAttributePciBusId

@ hipDeviceAttributePciBusId

PCI Bus ID.

Definition hip_runtime_api.h:411

hipDeviceAttributeL2CacheSize

@ hipDeviceAttributeL2CacheSize

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

Definition hip_runtime_api.h:361

hipDeviceAttributeKernelExecTimeout

@ hipDeviceAttributeKernelExecTimeout

Run time limit for kernels executed on the device.

Definition hip_runtime_api.h:360

hipDeviceAttributeMaxThreadsDim

@ hipDeviceAttributeMaxThreadsDim

Maximum dimension of a block.

Definition hip_runtime_api.h:398

hipDeviceAttributeSingleToDoublePrecisionPerfRatio

@ hipDeviceAttributeSingleToDoublePrecisionPerfRatio

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

Definition hip_runtime_api.h:422

hipDeviceAttributeMaxGridDimY

@ hipDeviceAttributeMaxGridDimY

Max grid size in height.

Definition hip_runtime_api.h:372

hipDeviceAttributeMultiprocessorCount

@ hipDeviceAttributeMultiprocessorCount

Number of multiprocessors on the device.

Definition hip_runtime_api.h:406

hipDeviceAttributeUuid

@ hipDeviceAttributeUuid

Cuda only. Unique ID in 16 byte.

Definition hip_runtime_api.h:431

hipDeviceAttributeAmdSpecificBegin

@ hipDeviceAttributeAmdSpecificBegin

Definition hip_runtime_api.h:437

hipDeviceAttributeMaxRegistersPerMultiprocessor

@ hipDeviceAttributeMaxRegistersPerMultiprocessor

32-bit registers available per block.

Definition hip_runtime_api.h:417

hipDeviceAttributeGcnArchName

@ hipDeviceAttributeGcnArchName

Device gcnArch name in 256 bytes.

Definition hip_runtime_api.h:443

hipDeviceAttributeIsMultiGpuBoard

@ hipDeviceAttributeIsMultiGpuBoard

Multiple GPU devices.

Definition hip_runtime_api.h:359

hipDeviceAttributeSharedMemPerBlockOptin

@ hipDeviceAttributeSharedMemPerBlockOptin

Cuda only. Maximum shared memory per block usable by special opt in.

Definition hip_runtime_api.h:420

hipDeviceAttributeMaxSurface2DLayered

@ hipDeviceAttributeMaxSurface2DLayered

Cuda only. Maximum dimensions of 2D layered surface.

Definition hip_runtime_api.h:377

hipDeviceAttributeAmdSpecificEnd

@ hipDeviceAttributeAmdSpecificEnd

Definition hip_runtime_api.h:464

hipDeviceAttributeMemoryClockRate

@ hipDeviceAttributeMemoryClockRate

Peak memory clock frequency in kilohertz.

Definition hip_runtime_api.h:403

hipDeviceAttributeGcnArch

@ hipDeviceAttributeGcnArch

Device gcn architecture.

Definition hip_runtime_api.h:442

hipDeviceAttributeMaxGridDimZ

@ hipDeviceAttributeMaxGridDimZ

Max grid size in depth.

Definition hip_runtime_api.h:373

hipDeviceAttributeHdpMemFlushCntl

@ hipDeviceAttributeHdpMemFlushCntl

Address of the HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:444

hipDeviceAttributeFineGrainSupport

@ hipDeviceAttributeFineGrainSupport

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

Definition hip_runtime_api.h:461

hipDeviceAttributeCooperativeLaunch

@ hipDeviceAttributeCooperativeLaunch

Support cooperative launch.

Definition hip_runtime_api.h:350

hipDeviceAttributeUnifiedAddressing

@ hipDeviceAttributeUnifiedAddressing

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

Definition hip_runtime_api.h:430

hipDeviceAttributeAsyncEngineCount

@ hipDeviceAttributeAsyncEngineCount

Cuda only. Asynchronous engines number.

Definition hip_runtime_api.h:341

hipDeviceAttributeMultiGpuBoardGroupID

@ hipDeviceAttributeMultiGpuBoardGroupID

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

Definition hip_runtime_api.h:405

hipDeviceAttributeStreamPrioritiesSupported

@ hipDeviceAttributeStreamPrioritiesSupported

Cuda only. Whether to support stream priorities.

Definition hip_runtime_api.h:423

hipDeviceAttributeMaxSharedMemoryPerBlock

@ hipDeviceAttributeMaxSharedMemoryPerBlock

Maximum shared memory available per block in bytes.

Definition hip_runtime_api.h:419

hipDeviceAttributeLocalL1CacheSupported

@ hipDeviceAttributeLocalL1CacheSupported

caching locals in L1 is supported

Definition hip_runtime_api.h:362

hipDeviceAttributeCanUseStreamWaitValue

@ hipDeviceAttributeCanUseStreamWaitValue

Definition hip_runtime_api.h:456

hipDeviceAttributeMaxRegistersPerBlock

@ hipDeviceAttributeMaxRegistersPerBlock

Definition hip_runtime_api.h:415

hipDeviceAttributeMaxThreadsPerBlock

@ hipDeviceAttributeMaxThreadsPerBlock

Maximum number of threads per block.

Definition hip_runtime_api.h:399

hipDeviceAttributeMemoryBusWidth

@ hipDeviceAttributeMemoryBusWidth

Global memory bus width in bits.

Definition hip_runtime_api.h:402

hipDeviceAttributeComputePreemptionSupported

@ hipDeviceAttributeComputePreemptionSupported

Cuda only. Device supports Compute Preemption.

Definition hip_runtime_api.h:347

hipDeviceAttributeMaxSurface1D

@ hipDeviceAttributeMaxSurface1D

Maximum size of 1D surface.

Definition hip_runtime_api.h:374

hipDeviceAttributeMaxTexture3DAlt

@ hipDeviceAttributeMaxTexture3DAlt

Cuda only. Maximum dimensions of alternate 3D texture.

Definition hip_runtime_api.h:395

hipDeviceAttributeMaxTexture1DLinear

@ hipDeviceAttributeMaxTexture1DLinear

Definition hip_runtime_api.h:383

hipDeviceAttributeMaxTexture2DGather

@ hipDeviceAttributeMaxTexture2DGather

Cuda only. Maximum dimensions of 2D texture if gather operations performed.

Definition hip_runtime_api.h:388

hipDeviceAttributeWallClockRate

@ hipDeviceAttributeWallClockRate

Constant frequency of wall clock in kilohertz.

Definition hip_runtime_api.h:462

hipDeviceAttributePciDeviceId

@ hipDeviceAttributePciDeviceId

PCI Device ID.

Definition hip_runtime_api.h:412

hipDeviceAttributeCanMapHostMemory

@ hipDeviceAttributeCanMapHostMemory

Whether host memory can be mapped into device address space.

Definition hip_runtime_api.h:342

hipDeviceAttributeMaxTexture1DWidth

@ hipDeviceAttributeMaxTexture1DWidth

Maximum size of 1D texture.

Definition hip_runtime_api.h:381

hipDeviceAttributeConcurrentManagedAccess

@ hipDeviceAttributeConcurrentManagedAccess

Device can coherently access managed memory concurrently with the CPU.

Definition hip_runtime_api.h:349

hipDeviceAttributeVendorSpecificBegin

@ hipDeviceAttributeVendorSpecificBegin

Definition hip_runtime_api.h:465

hipDeviceAttributeArch

@ hipDeviceAttributeArch

Device architecture.

Definition hip_runtime_api.h:440

hipDeviceAttributeManagedMemory

@ hipDeviceAttributeManagedMemory

Device supports allocating managed memory on this system.

Definition hip_runtime_api.h:366

hipDeviceAttributeIntegrated

@ hipDeviceAttributeIntegrated

Device is integrated GPU.

Definition hip_runtime_api.h:358

hipDeviceAttributeMaxTexture2DLayered

@ hipDeviceAttributeMaxTexture2DLayered

Cuda only. Maximum dimensions of 2D layered texture.

Definition hip_runtime_api.h:389

hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

Definition hip_runtime_api.h:448

hipDeviceAttributeMaxTexture3DDepth

@ hipDeviceAttributeMaxTexture3DDepth

Maximum dimension depth of 3D texture.

Definition hip_runtime_api.h:394

hipDeviceAttributeImageSupport

@ hipDeviceAttributeImageSupport

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

Definition hip_runtime_api.h:458

hipDeviceAttributeTotalGlobalMem

@ hipDeviceAttributeTotalGlobalMem

Global memory available on devicice.

Definition hip_runtime_api.h:429

hipDeviceAttributeMaxBlocksPerMultiProcessor

@ hipDeviceAttributeMaxBlocksPerMultiProcessor

Cuda only. Max block size per multiprocessor.

Definition hip_runtime_api.h:367

hipDeviceAttributeIsLargeBar

@ hipDeviceAttributeIsLargeBar

Whether it is LargeBar.

Definition hip_runtime_api.h:454

hipDeviceAttributeMaxTexture2DWidth

@ hipDeviceAttributeMaxTexture2DWidth

Maximum dimension width of 2D texture.

Definition hip_runtime_api.h:386

hipDeviceAttributeMaxBlockDimX

@ hipDeviceAttributeMaxBlockDimX

Max block size in width.

Definition hip_runtime_api.h:368

hipDeviceAttributeMaxTexture3DWidth

@ hipDeviceAttributeMaxTexture3DWidth

Maximum dimension width of 3D texture.

Definition hip_runtime_api.h:392

hipDeviceAttributeTotalConstantMemory

@ hipDeviceAttributeTotalConstantMemory

Constant memory size in bytes.

Definition hip_runtime_api.h:428

hipDeviceAttributeTextureAlignment

@ hipDeviceAttributeTextureAlignment

Alignment requirement for textures.

Definition hip_runtime_api.h:426

hipDeviceAttributeMaxTexture1DLayered

@ hipDeviceAttributeMaxTexture1DLayered

Cuda only. Maximum dimensions of 1D layered texture.

Definition hip_runtime_api.h:382

hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

@ hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

Maximum Shared Memory PerMultiprocessor.

Definition hip_runtime_api.h:441

hipDeviceAttributeReservedSharedMemPerBlock

@ hipDeviceAttributeReservedSharedMemPerBlock

Cuda11 only. Shared memory reserved by CUDA driver per block.

Definition hip_runtime_api.h:418

hipDeviceAttributeCudaCompatibleBegin

@ hipDeviceAttributeCudaCompatibleBegin

Definition hip_runtime_api.h:337

hipDeviceAttributeConcurrentKernels

@ hipDeviceAttributeConcurrentKernels

Device can possibly execute multiple kernels concurrently.

Definition hip_runtime_api.h:348

hipDeviceAttributeLuid

@ hipDeviceAttributeLuid

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

Definition hip_runtime_api.h:363

hipDeviceAttributePciDomainID

@ hipDeviceAttributePciDomainID

PCI Domain ID.

Definition hip_runtime_api.h:413

hipDeviceAttributeMaxThreadsPerMultiProcessor

@ hipDeviceAttributeMaxThreadsPerMultiProcessor

Maximum resident threads per multiprocessor.

Definition hip_runtime_api.h:400

hipDeviceAttributeTexturePitchAlignment

@ hipDeviceAttributeTexturePitchAlignment

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

Definition hip_runtime_api.h:427

hipDeviceAttributePhysicalMultiProcessorCount

@ hipDeviceAttributePhysicalMultiProcessorCount

Definition hip_runtime_api.h:459

hipDeviceAttributeSharedMemPerMultiprocessor

@ hipDeviceAttributeSharedMemPerMultiprocessor

Cuda only. Shared memory available per multiprocessor.

Definition hip_runtime_api.h:421

hipDeviceAttributeLuidDeviceNodeMask

@ hipDeviceAttributeLuidDeviceNodeMask

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

Definition hip_runtime_api.h:364

hipDeviceAttributeMaxTextureCubemapLayered

@ hipDeviceAttributeMaxTextureCubemapLayered

Cuda only. Maximum dimensions of Cubemap layered texture.

Definition hip_runtime_api.h:397

hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

Definition hip_runtime_api.h:450

hipDeviceAttributeVirtualMemoryManagementSupported

@ hipDeviceAttributeVirtualMemoryManagementSupported

Device supports HIP virtual memory management.

Definition hip_runtime_api.h:434

hipDeviceAttributeMemoryPoolsSupported

@ hipDeviceAttributeMemoryPoolsSupported

Device supports HIP Stream Ordered Memory Allocator.

Definition hip_runtime_api.h:433

hipDeviceAttributeClockInstructionRate

@ hipDeviceAttributeClockInstructionRate

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

Definition hip_runtime_api.h:439

hipDeviceAttributeMaxTexture2DMipmap

@ hipDeviceAttributeMaxTexture2DMipmap

Cuda only. Maximum dimensions of 2D mipmapped texture.

Definition hip_runtime_api.h:391

hipDeviceAttributeMaxBlockDimZ

@ hipDeviceAttributeMaxBlockDimZ

Max block size in depth.

Definition hip_runtime_api.h:370

hipDeviceAttributeWarpSize

@ hipDeviceAttributeWarpSize

Warp size in threads.

Definition hip_runtime_api.h:432

hipMemAllocationTypeMax

@ hipMemAllocationTypeMax

Definition hip_runtime_api.h:859

hipMemAllocationTypePinned

@ hipMemAllocationTypePinned

Definition hip_runtime_api.h:858

hipMemAllocationTypeInvalid

@ hipMemAllocationTypeInvalid

Definition hip_runtime_api.h:854

hipGraphInstantiateFlagAutoFreeOnLaunch

@ hipGraphInstantiateFlagAutoFreeOnLaunch

Automatically free memory allocated in a graph before relaunching.

Definition hip_runtime_api.h:1245

hipKernelNodeAttributeCooperative

@ hipKernelNodeAttributeCooperative

Definition hip_runtime_api.h:1174

hipKernelNodeAttributeAccessPolicyWindow

@ hipKernelNodeAttributeAccessPolicyWindow

Definition hip_runtime_api.h:1173

hipMemLocationTypeInvalid

@ hipMemLocationTypeInvalid

Definition hip_runtime_api.h:819

hipMemLocationTypeDevice

@ hipMemLocationTypeDevice

Device location, thus it's HIP device ID.

Definition hip_runtime_api.h:820

hipArraySparseSubresourceTypeSparseLevel

@ hipArraySparseSubresourceTypeSparseLevel

Sparse level.

Definition hip_runtime_api.h:1322

hipArraySparseSubresourceTypeMiptail

@ hipArraySparseSubresourceTypeMiptail

Miptail.

Definition hip_runtime_api.h:1323

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.

hipDeviceSetGraphMemAttribute

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

Set the mem attribute for graphs.

hipGraphMemcpyNodeSetParams

hipError_t hipGraphMemcpyNodeSetParams(hipGraphNode_t node, const hipMemcpy3DParms *pNodeParams)

Sets a memcpy node's parameters.

hipUserObjectCreate

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

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

hipGraphExecUpdate

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

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

hipGraphNodeFindInClone

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

Finds a cloned version of a node.

hipGraphAddEventWaitNode

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

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

hipGraphMemcpyNodeSetParamsToSymbol

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

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

hipGraphRetainUserObject

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

Retain user object for graphs.

hipStreamIsCapturing

hipError_t hipStreamIsCapturing(hipStream_t stream, hipStreamCaptureStatus *pCaptureStatus)

Get stream's capture state.

hipGraphNodeGetEnabled

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

Query whether a node in the given graphExec is enabled.

hipGraphAddChildGraphNode

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

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

hipGraphDestroyNode

hipError_t hipGraphDestroyNode(hipGraphNode_t node)

Remove a node from the graph.

hipGraphMemcpyNodeSetParamsFromSymbol

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

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

hipGraphRemoveDependencies

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

Removes dependency edges from a graph.

hipGraphMemcpyNodeSetParams1D

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

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

hipGraphExecMemcpyNodeSetParams1D

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

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

hipGraphExecDestroy

hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec)

Destroys an executable graph.

hipGraphExecHostNodeSetParams

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

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

hipGraphExecChildGraphNodeSetParams

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

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

hipStreamGetCaptureInfo

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

Get capture status of a stream.

hipGraphAddDependencies

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

Adds dependency edges to a graph.

hipGraphExecKernelNodeSetParams

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

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

hipGraphNodeGetDependentNodes

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

Returns a node's dependent nodes.

hipDeviceGetGraphMemAttribute

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

Get the mem attribute for graphs.

hipGraphHostNodeGetParams

hipError_t hipGraphHostNodeGetParams(hipGraphNode_t node, hipHostNodeParams *pNodeParams)

Returns a host node's parameters.

hipGraphInstantiateWithFlags

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

Creates an executable graph from a graph.

hipGraphUpload

hipError_t hipGraphUpload(hipGraphExec_t graphExec, hipStream_t stream)

uploads an executable graph in a stream

hipGraphExecMemcpyNodeSetParamsToSymbol

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

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

hipGraphKernelNodeGetParams

hipError_t hipGraphKernelNodeGetParams(hipGraphNode_t node, hipKernelNodeParams *pNodeParams)

Gets kernel node's parameters.

hipGraphAddMemcpyNodeFromSymbol

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

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

hipGraphKernelNodeCopyAttributes

hipError_t hipGraphKernelNodeCopyAttributes(hipGraphNode_t hSrc, hipGraphNode_t hDst)

Copies attributes from source node to destination node.

hipGraphAddMemFreeNode

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

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

hipUserObjectRelease

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

Release number of references to resource.

hipGraphMemcpyNodeGetParams

hipError_t hipGraphMemcpyNodeGetParams(hipGraphNode_t node, hipMemcpy3DParms *pNodeParams)

Gets a memcpy node's parameters.

hipGraphAddEventRecordNode

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

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

hipStreamUpdateCaptureDependencies

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

Update the set of dependencies in a capturing stream.

hipStreamBeginCapture

hipError_t hipStreamBeginCapture(hipStream_t stream, hipStreamCaptureMode mode)

Begins graph capture on a stream.

hipStreamEndCapture

hipError_t hipStreamEndCapture(hipStream_t stream, hipGraph_t *pGraph)

Ends capture on a stream, returning the captured graph.

hipGraphNodeGetType

hipError_t hipGraphNodeGetType(hipGraphNode_t node, hipGraphNodeType *pType)

Returns a node's type.

hipGraphNodeSetEnabled

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

Enables or disables the specified node in the given graphExec.

hipGraphExecMemcpyNodeSetParams

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

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

hipGraphHostNodeSetParams

hipError_t hipGraphHostNodeSetParams(hipGraphNode_t node, const hipHostNodeParams *pNodeParams)

Sets a host node's parameters.

hipGraphMemAllocNodeGetParams

hipError_t hipGraphMemAllocNodeGetParams(hipGraphNode_t node, hipMemAllocNodeParams *pNodeParams)

Returns parameters for memory allocation node.

hipUserObjectRetain

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

Retain number of references to resource.

hipGraphExecEventRecordNodeSetEvent

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

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

hipGraphMemsetNodeGetParams

hipError_t hipGraphMemsetNodeGetParams(hipGraphNode_t node, hipMemsetParams *pNodeParams)

Gets a memset node's parameters.

hipGraphChildGraphNodeGetGraph

hipError_t hipGraphChildGraphNodeGetGraph(hipGraphNode_t node, hipGraph_t *pGraph)

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

hipGraphKernelNodeGetAttribute

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

Gets a node attribute.

hipThreadExchangeStreamCaptureMode

hipError_t hipThreadExchangeStreamCaptureMode(hipStreamCaptureMode *mode)

Swaps the stream capture mode of a thread.

hipGraphLaunch

hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream)

launches an executable graph in a stream

hipGraphDebugDotPrint

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

Write a DOT file describing graph structure.

hipGraphExecMemsetNodeSetParams

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

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

hipGraphGetEdges

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

Returns a graph's dependency edges.

hipGraphAddKernelNode

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

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

hipGraphExecEventWaitNodeSetEvent

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

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

hipGraphEventWaitNodeSetEvent

hipError_t hipGraphEventWaitNodeSetEvent(hipGraphNode_t node, hipEvent_t event)

Sets an event wait node's event.

hipGraphEventRecordNodeSetEvent

hipError_t hipGraphEventRecordNodeSetEvent(hipGraphNode_t node, hipEvent_t event)

Sets an event record node's event.

hipGraphEventWaitNodeGetEvent

hipError_t hipGraphEventWaitNodeGetEvent(hipGraphNode_t node, hipEvent_t *event_out)

Returns the event associated with an event wait node.

hipGraphKernelNodeSetAttribute

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

Sets a node attribute.

hipGraphMemsetNodeSetParams

hipError_t hipGraphMemsetNodeSetParams(hipGraphNode_t node, const hipMemsetParams *pNodeParams)

Sets a memset node's parameters.

hipGraphEventRecordNodeGetEvent

hipError_t hipGraphEventRecordNodeGetEvent(hipGraphNode_t node, hipEvent_t *event_out)

Returns the event associated with an event record node.

hipGraphAddEmptyNode

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

Creates an empty node and adds it to a graph.

hipGraphAddMemcpyNodeToSymbol

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

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

hipGraphDestroy

hipError_t hipGraphDestroy(hipGraph_t graph)

Destroys a graph.

hipGraphExecMemcpyNodeSetParamsFromSymbol

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

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

hipGraphAddMemAllocNode

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

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

hipGraphAddHostNode

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

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

hipGraphGetNodes

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

Returns graph nodes.

hipGraphAddMemsetNode

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

Creates a memset node and adds it to a graph.

hipGraphInstantiate

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

Creates an executable graph from a graph.

hipDeviceGraphMemTrim

hipError_t hipDeviceGraphMemTrim(int device)

Free unused memory on specific device used for graph back to OS.

hipGraphClone

hipError_t hipGraphClone(hipGraph_t *pGraphClone, hipGraph_t originalGraph)

Clones a graph.

hipGraphGetRootNodes

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

Returns graph's root nodes.

hipGraphAddMemcpyNode

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

Creates a memcpy node and adds it to a graph.

hipStreamGetCaptureInfo_v2

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

Get stream's capture state.

hipGraphReleaseUserObject

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

Release user object from graphs.

hipFreeMipmappedArray

hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray)

Frees a mipmapped array on the device.

hipMemcpyToSymbol

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

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

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.

hipMemcpyAtoH

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

Copies data between host and device.

hipHostAlloc

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

Allocate device accessible page locked host memory [Deprecated].

hipMemcpy2DToArrayAsync

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

Copies data between host and device.

hipGetMipmappedArrayLevel

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

Gets a mipmap level of a HIP mipmapped array.

hipMemsetD16Async

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

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

hipFreeHost

hipError_t hipFreeHost(void *ptr)

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

hipMemcpyFromSymbol

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

Copies data from the given symbol on the device.

hipHostFree

hipError_t hipHostFree(void *ptr)

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

hipMemcpyToArray

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

Copies data between host and device.

hipMemcpy2DFromArrayAsync

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

Copies data between host and device asynchronously.

hipMemGetInfo

hipError_t hipMemGetInfo(size_t *free, size_t *total)

Query memory info.

hipExtMallocWithFlags

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

Allocate memory on the default accelerator.

hipImportExternalMemory

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

Imports an external memory object.

hipMemcpy3D

hipError_t hipMemcpy3D(const struct hipMemcpy3DParms *p)

Copies data between host and device.

hipMemcpy3DAsync

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

Copies data between host and device asynchronously.

hipMemset3D

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

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

hipModuleGetGlobal

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

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

hipMemsetD16

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

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

hipMemcpyFromSymbolAsync

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

Copies data from the given symbol on the device asynchronously.

hipMalloc

hipError_t hipMalloc(void **ptr, size_t size)

Allocate memory on the default accelerator.

hipHostUnregister

hipError_t hipHostUnregister(void *hostPtr)

Un-register host pointer.

hipHostGetFlags

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

Return flags associated with host pointer.

hipMemsetD32

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

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

hipDrvMemcpy3DAsync

hipError_t hipDrvMemcpy3DAsync(const HIP_MEMCPY3D *pCopy, hipStream_t stream)

Copies data between host and device asynchronously.

hipMallocHost

hipError_t hipMallocHost(void **ptr, size_t size)

Allocate pinned host memory [Deprecated].

hipMalloc3DArray

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

Allocate an array on the device.

hipFree

hipError_t hipFree(void *ptr)

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

hipMemcpyToSymbolAsync

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

Copies data to the given symbol on the device asynchronously.

hipPointerGetAttributes

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

Return attributes for the specified pointer.

hipMallocPitch

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

hipMemcpyDtoD

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

Copy data from Device to Device.

hipMemcpy2D

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

Copies data between host and device.

hipMemcpyFromArray

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

Copies data between host and device.

hipHostGetDevicePointer

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

Get Device pointer from Host Pointer allocated through hipHostMalloc.

hipMemcpyParam2DAsync

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

Copies memory for 2D arrays.

hipDestroyExternalSemaphore

hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem)

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

hipMemsetD8Async

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

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

hipMemcpy2DFromArray

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

Copies data between host and device.

hipDrvMemcpy3D

hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D *pCopy)

Copies data between host and device.

hipMemcpyHtoD

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

Copy data from Host to Device.

hipMemcpyParam2D

hipError_t hipMemcpyParam2D(const hip_Memcpy2D *pCopy)

Copies memory for 2D arrays.

hipMemsetAsync

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

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

hipMemset3DAsync

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

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

hipHostMalloc

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

Allocate device accessible page locked host memory.

hipMemcpy2DToArray

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

Copies data between host and device.

hipMemcpyAsync

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

Copy data from src to dst asynchronously.

hipArray3DCreate

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

hipHostRegister

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

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

hipMemcpy

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

Copy data from src to dst.

hipMemset

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

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

hipMemcpy2DAsync

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

Copies data between host and device.

hipDrvPointerGetAttributes

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

Returns information about the specified pointer.[BETA].

hipMalloc3D

hipError_t hipMalloc3D(hipPitchedPtr *pitchedDevPtr, hipExtent extent)

hipMallocArray

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

Allocate an array on the device.

hipPointerSetAttribute

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

Sets information on the specified pointer.[BETA].

hipMemcpyDtoDAsync

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

Copy data from Device to Device asynchronously.

hipMemAllocPitch

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

hipMemsetD8

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

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

hipMemcpyDtoHAsync

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

Copy data from Device to Host asynchronously.

hipMemset2DAsync

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

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

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.

hipMallocMipmappedArray

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

Allocate a mipmapped array on the device.

hipMemset2D

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

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

hipFreeArray

hipError_t hipFreeArray(hipArray *array)

Frees an array on the device.

hipMemcpyHtoDAsync

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

Copy data from Host to Device asynchronously.

hipGetSymbolSize

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

Gets the size of the given symbol on the device.

hipMemcpyDtoH

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

Copy data from Device to Host.

hipMemcpyWithStream

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

hipSignalExternalSemaphoresAsync

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

Signals a set of external semaphore objects.

hipGetSymbolAddress

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

Gets device pointer associated with symbol on the device.

hipArrayCreate

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

hipMemAllocHost

hipError_t hipMemAllocHost(void **ptr, size_t size)

Allocate pinned host memory [Deprecated].

hipPointerGetAttribute

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

Returns information about the specified pointer.[BETA].

hipArrayDestroy

hipError_t hipArrayDestroy(hipArray *array)

hipMemcpyHtoA

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

Copies data between host and device.

hipMemPtrGetInfo

hipError_t hipMemPtrGetInfo(void *ptr, size_t *size)

hipMemsetD32Async

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

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

hipExternalMemoryGetMappedBuffer

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

Maps a buffer onto an imported memory object.

hipStreamAttachMemAsync

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

Attach memory to a stream asynchronously in HIP.

hipMemRangeGetAttributes

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

Query attributes of a given memory range in HIP.

hipMemAdvise

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

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

hipMemPrefetchAsync

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

Prefetches memory to the specified destination device using HIP.

hipMemRangeGetAttribute

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

Query an attribute of a given memory range in HIP.

hipMallocManaged

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

Allocates memory that will be automatically managed by HIP.

hipModuleLaunchCooperativeKernelMultiDevice

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

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

hipFuncGetAttributes

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

Find out attributes for a given function.

hipModuleGetTexRef

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

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

hipExtLaunchMultiKernelMultiDevice

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

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

hipModuleLaunchKernel

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

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

hipModuleLoad

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

Loads code object from file into a hipModule_t.

hipModuleLoadDataEx

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

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

hipFuncGetAttribute

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

Find out a specific attribute for a given function.

hipLaunchCooperativeKernelMultiDevice

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

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

hipModuleLaunchCooperativeKernel

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

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

hipModuleGetFunction

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

Function with kname will be extracted if present in module.

hipLaunchCooperativeKernel

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

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

hipModuleLoadData

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

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

hipModuleUnload

hipError_t hipModuleUnload(hipModule_t module)

Frees the module.

hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags

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

Returns occupancy for a device function.

hipModuleOccupancyMaxPotentialBlockSize

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

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

hipOccupancyMaxActiveBlocksPerMultiprocessor

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

Returns occupancy for a device function.

hipOccupancyMaxPotentialBlockSize

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

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

hipModuleOccupancyMaxActiveBlocksPerMultiprocessor

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

Returns occupancy for a device function.

hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags

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

Returns occupancy for a device function.

hipModuleOccupancyMaxPotentialBlockSizeWithFlags

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

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

hipDeviceCanAccessPeer

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

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

hipDeviceEnablePeerAccess

hipError_t hipDeviceEnablePeerAccess(int peerDeviceId, unsigned int flags)

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

hipDeviceDisablePeerAccess

hipError_t hipDeviceDisablePeerAccess(int peerDeviceId)

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

hipMemGetAddressRange

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

Get information on memory allocations.

hipProfilerStart

hipError_t hipProfilerStart()

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

hipProfilerStop

hipError_t hipProfilerStop()

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

hipDeviceGetStreamPriorityRange

hipError_t hipDeviceGetStreamPriorityRange(int *leastPriority, int *greatestPriority)

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

hipStreamDestroy

hipError_t hipStreamDestroy(hipStream_t stream)

Destroys the specified stream.

hipStreamGetFlags

hipError_t hipStreamGetFlags(hipStream_t stream, unsigned int *flags)

Return flags associated with this stream.

hipStreamAddCallback

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

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

hipStreamCallback_t

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

Definition hip_runtime_api.h:2258

hipStreamQuery

hipError_t hipStreamQuery(hipStream_t stream)

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

hipStreamSynchronize

hipError_t hipStreamSynchronize(hipStream_t stream)

Wait for all commands in stream to complete.

hipStreamWaitEvent

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

Make the specified compute stream wait for an event.

hipStreamCreateWithPriority

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

Create an asynchronous stream with the specified priority.

hipExtStreamCreateWithCUMask

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

Create an asynchronous stream with the specified CU mask.

hipStreamGetPriority

hipError_t hipStreamGetPriority(hipStream_t stream, int *priority)

Query the priority of a stream.

hipExtStreamGetCUMask

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

Get CU mask associated with an asynchronous stream.

hipStreamCreateWithFlags

hipError_t hipStreamCreateWithFlags(hipStream_t *stream, unsigned int flags)

Create an asynchronous stream.

hipStreamCreate

hipError_t hipStreamCreate(hipStream_t *stream)

Create an asynchronous stream.

hipStreamWriteValue64

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

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

hipStreamWriteValue32

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

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

hipStreamWaitValue32

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

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

hipStreamWaitValue64

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

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

hipMemPoolImportPointer

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

Import a memory pool allocation from another process.

hipMemPoolImportFromShareableHandle

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

Imports a memory pool from a shared handle.

hipMallocFromPoolAsync

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

Allocates memory from a specified pool with stream ordered semantics.

hipFreeAsync

hipError_t hipFreeAsync(void *dev_ptr, hipStream_t stream)

Frees memory with stream ordered semantics.

hipMemPoolTrimTo

hipError_t hipMemPoolTrimTo(hipMemPool_t mem_pool, size_t min_bytes_to_hold)

Releases freed memory back to the OS.

hipMemPoolCreate

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

Creates a memory pool.

hipMemPoolSetAccess

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

Controls visibility of the specified pool between devices.

hipMemPoolDestroy

hipError_t hipMemPoolDestroy(hipMemPool_t mem_pool)

Destroys the specified memory pool.

hipMemPoolSetAttribute

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

Sets attributes of a memory pool.

hipMemPoolGetAttribute

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

Gets attributes of a memory pool.

hipMemPoolExportToShareableHandle

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

Exports a memory pool to the requested handle type.

hipMemPoolExportPointer

hipError_t hipMemPoolExportPointer(hipMemPoolPtrExportData *export_data, void *dev_ptr)

Export data to share a memory pool allocation between processes.

hipMallocAsync

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

Allocates memory with stream ordered semantics.

hipMemPoolGetAccess

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

Returns the accessibility of a pool from a device.

hipTexRefGetFilterMode

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

hipTexRefGetMipmapLevelClamp

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

hipTexRefGetAddressMode

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

hipTexRefGetFlags

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

hipTexRefSetAddress

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

hipTexRefSetFilterMode

hipError_t hipTexRefSetFilterMode(textureReference *texRef, enum hipTextureFilterMode fm)

hipTexRefSetMipmappedArray

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

hipTexRefGetMipmapFilterMode

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

hipGetTextureAlignmentOffset

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

hipBindTexture2D

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

hipTexRefGetMaxAnisotropy

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

hipUnbindTexture

hipError_t hipUnbindTexture(const textureReference *tex)

hipTexRefSetFormat

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

hipTexRefGetAddress

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

hipTexRefSetFlags

hipError_t hipTexRefSetFlags(textureReference *texRef, unsigned int Flags)

hipTexRefSetAddressMode

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

hipTexRefGetMipMappedArray

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

hipTexRefSetMaxAnisotropy

hipError_t hipTexRefSetMaxAnisotropy(textureReference *texRef, unsigned int maxAniso)

hipTexRefSetMipmapLevelClamp

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

hipTexRefSetBorderColor

hipError_t hipTexRefSetBorderColor(textureReference *texRef, float *pBorderColor)

hipTexRefSetArray

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

hipTexRefSetMipmapLevelBias

hipError_t hipTexRefSetMipmapLevelBias(textureReference *texRef, float bias)

hipTexRefGetMipmapLevelBias

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

hipBindTextureToArray

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

hipBindTexture

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

hipGetTextureReference

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

Gets the texture reference related with the symbol.

hipTexRefSetAddress2D

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

hipTexRefSetMipmapFilterMode

hipError_t hipTexRefSetMipmapFilterMode(textureReference *texRef, enum hipTextureFilterMode fm)

hipTexRefGetFormat

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

hipBindTextureToMipmappedArray

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

Binds a mipmapped array to a texture.

hipTexObjectCreate

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

Creates a texture object.

hipGetTextureObjectResourceDesc

hipError_t hipGetTextureObjectResourceDesc(hipResourceDesc *pResDesc, hipTextureObject_t textureObject)

Gets resource descriptor for the texture object.

hipGetTextureObjectResourceViewDesc

hipError_t hipGetTextureObjectResourceViewDesc(struct hipResourceViewDesc *pResViewDesc, hipTextureObject_t textureObject)

Gets resource view descriptor for the texture object.

hipTexObjectGetTextureDesc

hipError_t hipTexObjectGetTextureDesc(HIP_TEXTURE_DESC *pTexDesc, hipTextureObject_t texObject)

Gets texture descriptor of a texture object.

hipCreateTextureObject

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

Creates a texture object.

hipTexObjectDestroy

hipError_t hipTexObjectDestroy(hipTextureObject_t texObject)

Destroys a texture object.

hipGetChannelDesc

hipError_t hipGetChannelDesc(hipChannelFormatDesc *desc, hipArray_const_t array)

Gets the channel descriptor in an array.

hipTexObjectGetResourceDesc

hipError_t hipTexObjectGetResourceDesc(HIP_RESOURCE_DESC *pResDesc, hipTextureObject_t texObject)

Gets resource descriptor of a texture object.

hipTexObjectGetResourceViewDesc

hipError_t hipTexObjectGetResourceViewDesc(HIP_RESOURCE_VIEW_DESC *pResViewDesc, hipTextureObject_t texObject)

Gets resource view descriptor of a texture object.

hipDestroyTextureObject

hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject)

Destroys a texture object.

hipGetTextureObjectTextureDesc

hipError_t hipGetTextureObjectTextureDesc(hipTextureDesc *pTexDesc, hipTextureObject_t textureObject)

Gets texture descriptor for the texture object.

hipMipmappedArrayGetLevel

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

hipMipmappedArrayDestroy

hipError_t hipMipmappedArrayDestroy(hipMipmappedArray_t hMipmappedArray)

hipMipmappedArrayCreate

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

hipMemAddressFree

hipError_t hipMemAddressFree(void *devPtr, size_t size)

Frees an address range reservation made via hipMemAddressReserve.

hipMemExportToShareableHandle

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

Exports an allocation to a requested shareable handle type.

hipMemGetAccess

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

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

hipMemSetAccess

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

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

hipMemRelease

hipError_t hipMemRelease(hipMemGenericAllocationHandle_t handle)

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

hipMemUnmap

hipError_t hipMemUnmap(void *ptr, size_t size)

Unmap memory allocation of a given address range.

hipMemGetAllocationGranularity

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

Calculates either the minimal or recommended granularity.

hipMemRetainAllocationHandle

hipError_t hipMemRetainAllocationHandle(hipMemGenericAllocationHandle_t *handle, void *addr)

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

hipMemCreate

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

Creates a memory allocation described by the properties and size.

hipMemMap

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

Maps an allocation handle to a reserved virtual address range.

hipMemAddressReserve

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

Reserves an address range.

hipMemGetAllocationPropertiesFromHandle

hipError_t hipMemGetAllocationPropertiesFromHandle(hipMemAllocationProp *prop, hipMemGenericAllocationHandle_t handle)

Retrieve the property structure of the given handle.

hipMemMapArrayAsync

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

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

hipMemImportFromShareableHandle

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

Imports an allocation from a requested shareable handle type.

hip_common.h

hipLimit_t

hipLimit_t

Definition hip_runtime_api.h:558

hipLimitMallocHeapSize

@ hipLimitMallocHeapSize

Definition hip_runtime_api.h:561

hipLimitStackSize

@ hipLimitStackSize

Definition hip_runtime_api.h:559

hipLimitRange

@ hipLimitRange

Definition hip_runtime_api.h:562

hipLimitPrintfFifoSize

@ hipLimitPrintfFifoSize

Definition hip_runtime_api.h:560

hipErrorIllegalAddress

hipErrorIllegalAddress

Definition hip_runtime_api.h:273

hipErrorMemoryAllocation

hipErrorMemoryAllocation

Memory allocation error.

Definition hip_runtime_api.h:219

hipErrorNotFound

hipErrorNotFound

Definition hip_runtime_api.h:268

hipCtx_t

struct ihipCtx_t * hipCtx_t

Definition hip_runtime_api.h:520

hipErrorProfilerDisabled

hipErrorProfilerDisabled

Definition hip_runtime_api.h:224

__dparm

#define __dparm(x)

Definition hip_runtime_api.h:504

hipStream_t

struct ihipStream_t * hipStream_t

Definition hip_runtime_api.h:529

hipErrorInvalidDevicePointer

hipErrorInvalidDevicePointer

Invalid Device Pointer.

Definition hip_runtime_api.h:231

hipDevice_t

int hipDevice_t

Definition hip_runtime_api.h:522

hipErrorRuntimeMemory

hipErrorRuntimeMemory

Definition hip_runtime_api.h:322

hipErrorInvalidImage

hipErrorInvalidImage

Definition hip_runtime_api.h:239

hipErrorPeerAccessUnsupported

hipErrorPeerAccessUnsupported

Definition hip_runtime_api.h:256

hipErrorArrayIsMapped

hipErrorArrayIsMapped

Definition hip_runtime_api.h:246

hipErrorStreamCaptureIsolation

hipErrorStreamCaptureIsolation

Definition hip_runtime_api.h:303

hipErrorInvalidKernelFile

hipErrorInvalidKernelFile

In CUDA DRV, it is CUDA_ERROR_INVALID_PTX.

Definition hip_runtime_api.h:257

hipErrorNotMapped

hipErrorNotMapped

Definition hip_runtime_api.h:250

hipEvent_t

struct ihipEvent_t * hipEvent_t

Definition hip_runtime_api.h:557

hipErrorGraphExecUpdateFailure

hipErrorGraphExecUpdateFailure

Definition hip_runtime_api.h:316

hipErrorNotInitialized

hipErrorNotInitialized

Definition hip_runtime_api.h:220

hipErrorInvalidResourceHandle

hipErrorInvalidResourceHandle

Resource handle (hipEvent_t or hipStream_t) invalid.

Definition hip_runtime_api.h:266

hipErrorSharedObjectInitFailed

hipErrorSharedObjectInitFailed

Definition hip_runtime_api.h:262

hipErrorInvalidPitchValue

hipErrorInvalidPitchValue

Definition hip_runtime_api.h:229

hipErrorNoBinaryForGpu

hipErrorNoBinaryForGpu

Definition hip_runtime_api.h:248

hipErrorInvalidContext

hipErrorInvalidContext

Produced when input context is invalid.

Definition hip_runtime_api.h:240

hipDeviceP2PAttr

hipDeviceP2PAttr

Definition hip_runtime_api.h:523

hipDevP2PAttrAccessSupported

@ hipDevP2PAttrAccessSupported

Definition hip_runtime_api.h:525

hipDevP2PAttrHipArrayAccessSupported

@ hipDevP2PAttrHipArrayAccessSupported

Definition hip_runtime_api.h:527

hipDevP2PAttrNativeAtomicSupported

@ hipDevP2PAttrNativeAtomicSupported

Definition hip_runtime_api.h:526

hipDevP2PAttrPerformanceRank

@ hipDevP2PAttrPerformanceRank

Definition hip_runtime_api.h:524

hipErrorStreamCaptureUnsupported

hipErrorStreamCaptureUnsupported

Definition hip_runtime_api.h:294

hipErrorPeerAccessNotEnabled

hipErrorPeerAccessNotEnabled

Peer access was never enabled from the current device.

Definition hip_runtime_api.h:278

hipErrorOperatingSystem

hipErrorOperatingSystem

Definition hip_runtime_api.h:263

hipErrorStreamCaptureUnjoined

hipErrorStreamCaptureUnjoined

Definition hip_runtime_api.h:301

hipErrorInitializationError

hipErrorInitializationError

Definition hip_runtime_api.h:222

hipErrorNotMappedAsPointer

hipErrorNotMappedAsPointer

Definition hip_runtime_api.h:252

hipErrorPriorLaunchFailure

hipErrorPriorLaunchFailure

Definition hip_runtime_api.h:235

hipErrorContextIsDestroyed

hipErrorContextIsDestroyed

Definition hip_runtime_api.h:281

hipErrorInvalidValue

hipErrorInvalidValue

Definition hip_runtime_api.h:215

hipErrorLaunchTimeOut

hipErrorLaunchTimeOut

Definition hip_runtime_api.h:275

hipErrorUnmapFailed

hipErrorUnmapFailed

Definition hip_runtime_api.h:245

hipErrorSetOnActiveProcess

hipErrorSetOnActiveProcess

Definition hip_runtime_api.h:280

hipErrorFileNotFound

hipErrorFileNotFound

Definition hip_runtime_api.h:260

hipErrorLaunchFailure

hipErrorLaunchFailure

An exception occurred on the device while executing a kernel.

Definition hip_runtime_api.h:287

hipErrorInvalidDevice

hipErrorInvalidDevice

DeviceID must be in range 0...#compute-devices.

Definition hip_runtime_api.h:238

hipErrorUnsupportedLimit

hipErrorUnsupportedLimit

Definition hip_runtime_api.h:254

hipErrorMapBufferObjectFailed

hipErrorMapBufferObjectFailed

Produced when the IPC memory attach failed from ROCr.

Definition hip_runtime_api.h:244

hipErrorHostMemoryAlreadyRegistered

hipErrorHostMemoryAlreadyRegistered

Produced when trying to lock a page-locked memory.

Definition hip_runtime_api.h:283

hipErrorMissingConfiguration

hipErrorMissingConfiguration

Definition hip_runtime_api.h:234

hipErrorSharedObjectSymbolNotFound

hipErrorSharedObjectSymbolNotFound

Definition hip_runtime_api.h:261

hipErrorECCNotCorrectable

hipErrorECCNotCorrectable

Definition hip_runtime_api.h:253

hipErrorStreamCaptureWrongThread

hipErrorStreamCaptureWrongThread

Definition hip_runtime_api.h:312

hipErrorAssert

hipErrorAssert

Produced when the kernel calls assert.

Definition hip_runtime_api.h:282

DEPRECATED_MSG

#define DEPRECATED_MSG

Definition hip_runtime_api.h:496

hipErrorContextAlreadyInUse

hipErrorContextAlreadyInUse

Definition hip_runtime_api.h:255

hipErrorNotReady

hipErrorNotReady

Definition hip_runtime_api.h:269

hipErrorInvalidSource

hipErrorInvalidSource

Definition hip_runtime_api.h:259

hipErrorLaunchOutOfResources

hipErrorLaunchOutOfResources

Out of resources error.

Definition hip_runtime_api.h:274

hipErrorInvalidDeviceFunction

hipErrorInvalidDeviceFunction

Definition hip_runtime_api.h:236

hipErrorCooperativeLaunchTooLarge

hipErrorCooperativeLaunchTooLarge

Definition hip_runtime_api.h:289

hipErrorAlreadyMapped

hipErrorAlreadyMapped

Definition hip_runtime_api.h:247

hipModule_t

struct ihipModule_t * hipModule_t

Definition hip_runtime_api.h:538

hipErrorProfilerNotInitialized

hipErrorProfilerNotInitialized

Definition hip_runtime_api.h:225

hipErrorProfilerAlreadyStarted

hipErrorProfilerAlreadyStarted

Definition hip_runtime_api.h:226

hipErrorNoDevice

hipErrorNoDevice

Call to hipGetDeviceCount returned 0 devices.

Definition hip_runtime_api.h:237

HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

@ HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

Definition hip_runtime_api.h:42

HIP_ERROR_INVALID_VALUE

@ HIP_ERROR_INVALID_VALUE

Definition hip_runtime_api.h:40

HIP_SUCCESS

@ HIP_SUCCESS

Definition hip_runtime_api.h:39

HIP_ERROR_NOT_INITIALIZED

@ HIP_ERROR_NOT_INITIALIZED

Definition hip_runtime_api.h:41

hipErrorMapFailed

hipErrorMapFailed

Definition hip_runtime_api.h:242

hipErrorStreamCaptureInvalidated

hipErrorStreamCaptureInvalidated

Definition hip_runtime_api.h:296

hipFunction_t

struct ihipModuleSymbol_t * hipFunction_t

Definition hip_runtime_api.h:539

hipErrorProfilerAlreadyStopped

hipErrorProfilerAlreadyStopped

Definition hip_runtime_api.h:227

hipErrorDeinitialized

hipErrorDeinitialized

Definition hip_runtime_api.h:223

hipErrorPeerAccessAlreadyEnabled

hipErrorPeerAccessAlreadyEnabled

Peer access was already enabled from the current device.

Definition hip_runtime_api.h:276

hipErrorNotMappedAsArray

hipErrorNotMappedAsArray

Definition hip_runtime_api.h:251

DEPRECATED

#define DEPRECATED(msg)

Definition hip_runtime_api.h:494

hipErrorNotSupported

hipErrorNotSupported

Produced when the hip API is not supported/implemented.

Definition hip_runtime_api.h:293

hipErrorInvalidConfiguration

hipErrorInvalidConfiguration

Definition hip_runtime_api.h:228

hipErrorStreamCaptureImplicit

hipErrorStreamCaptureImplicit

Definition hip_runtime_api.h:307

hipErrorStreamCaptureMerge

hipErrorStreamCaptureMerge

Definition hip_runtime_api.h:298

hipErrorInvalidGraphicsContext

hipErrorInvalidGraphicsContext

Definition hip_runtime_api.h:258

hipErrorIllegalState

hipErrorIllegalState

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

Definition hip_runtime_api.h:267

hipErrorOutOfMemory

hipErrorOutOfMemory

Definition hip_runtime_api.h:217

hipErrorInvalidSymbol

hipErrorInvalidSymbol

Definition hip_runtime_api.h:230

hipSuccess

hipSuccess

Successful completion.

Definition hip_runtime_api.h:214

hipErrorUnknown

hipErrorUnknown

Definition hip_runtime_api.h:320

hipMemoryType

hipMemoryType

Definition hip_runtime_api.h:161

hipMemoryTypeDevice

@ hipMemoryTypeDevice

Definition hip_runtime_api.h:163

hipMemoryTypeHost

@ hipMemoryTypeHost

Memory is physically located on host.

Definition hip_runtime_api.h:162

hipMemoryTypeArray

@ hipMemoryTypeArray

Definition hip_runtime_api.h:165

hipMemoryTypeManaged

@ hipMemoryTypeManaged

Definition hip_runtime_api.h:168

hipMemoryTypeUnified

@ hipMemoryTypeUnified

Not used currently.

Definition hip_runtime_api.h:167

hipErrorInvalidHandle

hipErrorInvalidHandle

Definition hip_runtime_api.h:264

hipErrorStreamCaptureUnmatched

hipErrorStreamCaptureUnmatched

The capture was not initiated in this stream.

Definition hip_runtime_api.h:300

hipErrorCapturedEvent

hipErrorCapturedEvent

Definition hip_runtime_api.h:310

hipErrorAlreadyAcquired

hipErrorAlreadyAcquired

Definition hip_runtime_api.h:249

hipErrorInsufficientDriver

hipErrorInsufficientDriver

Definition hip_runtime_api.h:233

hipErrorHostMemoryNotRegistered

hipErrorHostMemoryNotRegistered

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

Definition hip_runtime_api.h:285

HIP_IPC_HANDLE_SIZE

#define HIP_IPC_HANDLE_SIZE

Definition hip_runtime_api.h:531

hipMemPool_t

struct ihipMemPoolHandle_t * hipMemPool_t

Definition hip_runtime_api.h:543

hipErrorRuntimeOther

hipErrorRuntimeOther

Definition hip_runtime_api.h:324

hipErrorContextAlreadyCurrent

hipErrorContextAlreadyCurrent

Definition hip_runtime_api.h:241

hipErrorInvalidMemcpyDirection

hipErrorInvalidMemcpyDirection

Invalid memory copy direction.

Definition hip_runtime_api.h:232

HIP_ARRAY3D_DESCRIPTOR

Definition driver_types.h:74

HIP_ARRAY_DESCRIPTOR

Definition driver_types.h:68

HIP_MEMCPY3D

Definition driver_types.h:379

HIP_RESOURCE_DESC

Definition driver_types.h:282

HIP_RESOURCE_VIEW_DESC

Definition driver_types.h:328

HIP_TEXTURE_DESC

Definition driver_types.h:165

dim3

Definition hip_runtime_api.h:948

dim3::y

uint32_t y

y

Definition hip_runtime_api.h:950

dim3::z

uint32_t z

z

Definition hip_runtime_api.h:951

dim3::x

uint32_t x

x

Definition hip_runtime_api.h:949

hip_Memcpy2D

Definition driver_types.h:95

hipAccessPolicyWindow

Definition hip_runtime_api.h:1181

hipAccessPolicyWindow::hitProp

hipAccessProperty hitProp

Definition hip_runtime_api.h:1183

hipAccessPolicyWindow::missProp

hipAccessProperty missProp

Definition hip_runtime_api.h:1185

hipAccessPolicyWindow::hitRatio

float hitRatio

Definition hip_runtime_api.h:1184

hipAccessPolicyWindow::base_ptr

void * base_ptr

Definition hip_runtime_api.h:1182

hipAccessPolicyWindow::num_bytes

size_t num_bytes

Definition hip_runtime_api.h:1186

hipArray

Definition driver_types.h:82

hipArrayMapInfo

Definition hip_runtime_api.h:1329

hipArrayMapInfo::level

unsigned int level

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

Definition hip_runtime_api.h:1338

hipArrayMapInfo::sparseLevel

struct hipArrayMapInfo::@26::@28 sparseLevel

hipArrayMapInfo::flags

unsigned int flags

flags for future use, must be zero now.

Definition hip_runtime_api.h:1360

hipArrayMapInfo::resource

union hipArrayMapInfo::@25 resource

hipArrayMapInfo::subresourceType

hipArraySparseSubresourceType subresourceType

Sparse subresource type.

Definition hip_runtime_api.h:1335

hipArrayMapInfo::extentDepth

unsigned int extentDepth

Depth in elements.

Definition hip_runtime_api.h:1345

hipArrayMapInfo::offsetX

unsigned int offsetX

X offset in elements.

Definition hip_runtime_api.h:1340

hipArrayMapInfo::array

hipArray_t array

Definition hip_runtime_api.h:1333

hipArrayMapInfo::resourceType

hipResourceType resourceType

Resource type.

Definition hip_runtime_api.h:1330

hipArrayMapInfo::memOperationType

hipMemOperationType memOperationType

Memory operation type.

Definition hip_runtime_api.h:1353

hipArrayMapInfo::reserved

unsigned int reserved[2]

Reserved for future use, must be zero now.

Definition hip_runtime_api.h:1361

hipArrayMapInfo::extentWidth

unsigned int extentWidth

Width in elements.

Definition hip_runtime_api.h:1343

hipArrayMapInfo::subresource

union hipArrayMapInfo::@26 subresource

hipArrayMapInfo::extentHeight

unsigned int extentHeight

Height in elements.

Definition hip_runtime_api.h:1344

hipArrayMapInfo::offsetY

unsigned int offsetY

Y offset in elements.

Definition hip_runtime_api.h:1341

hipArrayMapInfo::memHandleType

hipMemHandleType memHandleType

Memory handle type.

Definition hip_runtime_api.h:1354

hipArrayMapInfo::miptail

struct hipArrayMapInfo::@26::@29 miptail

hipArrayMapInfo::memHandle

hipMemGenericAllocationHandle_t memHandle

Definition hip_runtime_api.h:1356

hipArrayMapInfo::mipmap

hipMipmappedArray mipmap

Definition hip_runtime_api.h:1332

hipArrayMapInfo::layer

unsigned int layer

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

Definition hip_runtime_api.h:1339

hipArrayMapInfo::deviceBitMask

unsigned int deviceBitMask

Device ordinal bit mask.

Definition hip_runtime_api.h:1359

hipArrayMapInfo::size

unsigned long long size

Extent in bytes.

Definition hip_runtime_api.h:1350

hipArrayMapInfo::offset

unsigned long long offset

Offset within mip tail.

Definition hip_runtime_api.h:1349

hipArrayMapInfo::offsetZ

unsigned int offsetZ

Z offset in elements.

Definition hip_runtime_api.h:1342

hipChannelFormatDesc

Definition driver_types.h:47

hipDeviceArch_t

Definition hip_runtime_api.h:45

hipDeviceArch_t::hasSharedInt64Atomics

unsigned hasSharedInt64Atomics

64-bit integer atomics for shared memory.

Definition hip_runtime_api.h:55

hipDeviceArch_t::hasSharedInt32Atomics

unsigned hasSharedInt32Atomics

32-bit integer atomics for shared memory.

Definition hip_runtime_api.h:49

hipDeviceArch_t::hasFloatAtomicAdd

unsigned hasFloatAtomicAdd

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

Definition hip_runtime_api.h:51

hipDeviceArch_t::hasDoubles

unsigned hasDoubles

Double-precision floating point.

Definition hip_runtime_api.h:58

hipDeviceArch_t::hasWarpVote

unsigned hasWarpVote

Warp vote instructions (__any, __all).

Definition hip_runtime_api.h:61

hipDeviceArch_t::hasWarpShuffle

unsigned hasWarpShuffle

Warp shuffle operations. (__shfl_*).

Definition hip_runtime_api.h:63

hipDeviceArch_t::hasGlobalInt32Atomics

unsigned hasGlobalInt32Atomics

32-bit integer atomics for global memory.

Definition hip_runtime_api.h:47

hipDeviceArch_t::hasGlobalFloatAtomicExch

unsigned hasGlobalFloatAtomicExch

32-bit float atomic exch for global memory.

Definition hip_runtime_api.h:48

hipDeviceArch_t::hasDynamicParallelism

unsigned hasDynamicParallelism

Dynamic parallelism.

Definition hip_runtime_api.h:73

hipDeviceArch_t::hasSurfaceFuncs

unsigned hasSurfaceFuncs

Surface functions.

Definition hip_runtime_api.h:71

hipDeviceArch_t::has3dGrid

unsigned has3dGrid

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

Definition hip_runtime_api.h:72

hipDeviceArch_t::hasFunnelShift

unsigned hasFunnelShift

Funnel two words into one with shift&mask caps.

Definition hip_runtime_api.h:64

hipDeviceArch_t::hasThreadFenceSystem

unsigned hasThreadFenceSystem

__threadfence_system.

Definition hip_runtime_api.h:67

hipDeviceArch_t::hasGlobalInt64Atomics

unsigned hasGlobalInt64Atomics

64-bit integer atomics for global memory.

Definition hip_runtime_api.h:54

hipDeviceArch_t::hasSyncThreadsExt

unsigned hasSyncThreadsExt

__syncthreads_count, syncthreads_and, syncthreads_or.

Definition hip_runtime_api.h:68

hipDeviceArch_t::hasWarpBallot

unsigned hasWarpBallot

Warp ballot instructions (__ballot).

Definition hip_runtime_api.h:62

hipDeviceArch_t::hasSharedFloatAtomicExch

unsigned hasSharedFloatAtomicExch

32-bit float atomic exch for shared memory.

Definition hip_runtime_api.h:50

hipDeviceProp_t

Definition hip_runtime_api.h:87

hipDeviceProp_t::ECCEnabled

int ECCEnabled

Device has ECC support enabled.

Definition hip_runtime_api.h:135

hipDeviceProp_t::maxTexture1DLinear

int maxTexture1DLinear

Maximum size for 1D textures bound to linear memory.

Definition hip_runtime_api.h:125

hipDeviceProp_t::pciBusID

int pciBusID

PCI Bus ID.

Definition hip_runtime_api.h:115

hipDeviceProp_t::maxTexture1D

int maxTexture1D

Maximum number of elements in 1D images.

Definition hip_runtime_api.h:126

hipDeviceProp_t::memoryBusWidth

int memoryBusWidth

Global memory bus width in bits.

Definition hip_runtime_api.h:98

hipDeviceProp_t::clockRate

int clockRate

Max clock frequency of the multiProcessors in khz.

Definition hip_runtime_api.h:96

hipDeviceProp_t::maxThreadsPerMultiProcessor

int maxThreadsPerMultiProcessor

Maximum resident threads per multi-processor.

Definition hip_runtime_api.h:108

hipDeviceProp_t::l2CacheSize

int l2CacheSize

L2 cache size.

Definition hip_runtime_api.h:107

hipDeviceProp_t::totalConstMem

size_t totalConstMem

Size of shared memory region (in bytes).

Definition hip_runtime_api.h:99

hipDeviceProp_t::memPitch

size_t memPitch

Maximum pitch in bytes allowed by memory copies.

Definition hip_runtime_api.h:131

hipDeviceProp_t::sharedMemPerBlock

size_t sharedMemPerBlock

Size of shared memory region (in bytes).

Definition hip_runtime_api.h:90

hipDeviceProp_t::cooperativeMultiDeviceLaunch

int cooperativeMultiDeviceLaunch

HIP device supports cooperative launch on multiple devices.

Definition hip_runtime_api.h:124

hipDeviceProp_t::pageableMemoryAccess

int pageableMemoryAccess

Definition hip_runtime_api.h:150

hipDeviceProp_t::name

char name[256]

Device name.

Definition hip_runtime_api.h:88

hipDeviceProp_t::textureAlignment

size_t textureAlignment

Alignment requirement for textures.

Definition hip_runtime_api.h:132

hipDeviceProp_t::memoryClockRate

int memoryClockRate

Max global memory clock frequency in khz.

Definition hip_runtime_api.h:97

hipDeviceProp_t::clockInstructionRate

int clockInstructionRate

Definition hip_runtime_api.h:110

hipDeviceProp_t::regsPerBlock

int regsPerBlock

Registers per block.

Definition hip_runtime_api.h:91

hipDeviceProp_t::maxTexture2D

int maxTexture2D[2]

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

Definition hip_runtime_api.h:127

hipDeviceProp_t::cooperativeLaunch

int cooperativeLaunch

HIP device supports cooperative launch.

Definition hip_runtime_api.h:123

hipDeviceProp_t::maxTexture3D

int maxTexture3D[3]

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

Definition hip_runtime_api.h:128

hipDeviceProp_t::directManagedMemAccessFromHost

int directManagedMemAccessFromHost

Host can directly access managed memory on the device without migration.

Definition hip_runtime_api.h:148

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedFunc

int cooperativeMultiDeviceUnmatchedFunc

Definition hip_runtime_api.h:137

hipDeviceProp_t::pageableMemoryAccessUsesHostPageTables

int pageableMemoryAccessUsesHostPageTables

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

Definition hip_runtime_api.h:152

hipDeviceProp_t::hdpRegFlushCntl

unsigned int * hdpRegFlushCntl

Addres of HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:130

hipDeviceProp_t::maxThreadsDim

int maxThreadsDim[3]

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

Definition hip_runtime_api.h:94

hipDeviceProp_t::isMultiGpuBoard

int isMultiGpuBoard

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

Definition hip_runtime_api.h:118

hipDeviceProp_t::pciDomainID

int pciDomainID

PCI Domain ID.

Definition hip_runtime_api.h:114

hipDeviceProp_t::maxSharedMemoryPerMultiProcessor

size_t maxSharedMemoryPerMultiProcessor

Maximum Shared Memory Per Multiprocessor.

Definition hip_runtime_api.h:117

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedGridDim

int cooperativeMultiDeviceUnmatchedGridDim

Definition hip_runtime_api.h:139

hipDeviceProp_t::minor

int minor

Definition hip_runtime_api.h:103

hipDeviceProp_t::gcnArchName

char gcnArchName[256]

AMD GCN Arch Name.

Definition hip_runtime_api.h:121

hipDeviceProp_t::kernelExecTimeoutEnabled

int kernelExecTimeoutEnabled

Run time limit for kernels executed on the device.

Definition hip_runtime_api.h:134

hipDeviceProp_t::hdpMemFlushCntl

unsigned int * hdpMemFlushCntl

Addres of HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:129

hipDeviceProp_t::concurrentManagedAccess

int concurrentManagedAccess

Device can coherently access managed memory concurrently with the CPU.

Definition hip_runtime_api.h:149

hipDeviceProp_t::integrated

int integrated

APU vs dGPU.

Definition hip_runtime_api.h:122

hipDeviceProp_t::canMapHostMemory

int canMapHostMemory

Check whether HIP can map host memory.

Definition hip_runtime_api.h:119

hipDeviceProp_t::asicRevision

int asicRevision

Revision of the GPU in this device.

Definition hip_runtime_api.h:146

hipDeviceProp_t::totalGlobalMem

size_t totalGlobalMem

Size of global memory region (in bytes).

Definition hip_runtime_api.h:89

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedBlockDim

int cooperativeMultiDeviceUnmatchedBlockDim

Definition hip_runtime_api.h:141

hipDeviceProp_t::concurrentKernels

int concurrentKernels

Device can possibly execute multiple kernels concurrently.

Definition hip_runtime_api.h:113

hipDeviceProp_t::isLargeBar

int isLargeBar

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

Definition hip_runtime_api.h:145

hipDeviceProp_t::gcnArch

int gcnArch

DEPRECATED: use gcnArchName instead.

Definition hip_runtime_api.h:120

hipDeviceProp_t::multiProcessorCount

int multiProcessorCount

Number of multi-processors (compute units).

Definition hip_runtime_api.h:106

hipDeviceProp_t::maxGridSize

int maxGridSize[3]

Max grid dimensions (XYZ).

Definition hip_runtime_api.h:95

hipDeviceProp_t::pciDeviceID

int pciDeviceID

PCI Device ID.

Definition hip_runtime_api.h:116

hipDeviceProp_t::computeMode

int computeMode

Compute mode.

Definition hip_runtime_api.h:109

hipDeviceProp_t::major

int major

Definition hip_runtime_api.h:100

hipDeviceProp_t::warpSize

int warpSize

Warp size.

Definition hip_runtime_api.h:92

hipDeviceProp_t::tccDriver

int tccDriver

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

Definition hip_runtime_api.h:136

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedSharedMem

int cooperativeMultiDeviceUnmatchedSharedMem

Definition hip_runtime_api.h:143

hipDeviceProp_t::maxThreadsPerBlock

int maxThreadsPerBlock

Max work items per work group or workgroup max size.

Definition hip_runtime_api.h:93

hipDeviceProp_t::arch

hipDeviceArch_t arch

Architectural feature flags. New for HIP.

Definition hip_runtime_api.h:112

hipDeviceProp_t::managedMemory

int managedMemory

Device supports allocating managed memory on this system.

Definition hip_runtime_api.h:147

hipDeviceProp_t::texturePitchAlignment

size_t texturePitchAlignment

Pitch alignment requirement for texture references bound to pitched memory.

Definition hip_runtime_api.h:133

hipExtent

Definition driver_types.h:358

hipExternalMemoryBufferDesc

Definition hip_runtime_api.h:997

hipExternalMemoryBufferDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1000

hipExternalMemoryBufferDesc::offset

unsigned long long offset

Definition hip_runtime_api.h:998

hipExternalMemoryBufferDesc::size

unsigned long long size

Definition hip_runtime_api.h:999

hipExternalMemoryHandleDesc

Definition hip_runtime_api.h:985

hipExternalMemoryHandleDesc::flags

unsigned int flags

Definition hip_runtime_api.h:995

hipExternalMemoryHandleDesc::name

const void * name

Definition hip_runtime_api.h:991

hipExternalMemoryHandleDesc::fd

int fd

Definition hip_runtime_api.h:988

hipExternalMemoryHandleDesc::size

unsigned long long size

Definition hip_runtime_api.h:994

hipExternalMemoryHandleDesc::type

hipExternalMemoryHandleType type

Definition hip_runtime_api.h:986

hipExternalMemoryHandleDesc::handle

void * handle

Definition hip_runtime_api.h:990

hipExternalSemaphoreHandleDesc

Definition hip_runtime_api.h:1009

hipExternalSemaphoreHandleDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1018

hipExternalSemaphoreHandleDesc::name

const void * name

Definition hip_runtime_api.h:1015

hipExternalSemaphoreHandleDesc::type

hipExternalSemaphoreHandleType type

Definition hip_runtime_api.h:1010

hipExternalSemaphoreHandleDesc::handle

void * handle

Definition hip_runtime_api.h:1014

hipExternalSemaphoreHandleDesc::fd

int fd

Definition hip_runtime_api.h:1012

hipExternalSemaphoreSignalParams

Definition hip_runtime_api.h:1021

hipExternalSemaphoreSignalParams::value

unsigned long long value

Definition hip_runtime_api.h:1024

hipExternalSemaphoreSignalParams::flags

unsigned int flags

Definition hip_runtime_api.h:1031

hipExternalSemaphoreSignalParams::key

unsigned long long key

Definition hip_runtime_api.h:1027

hipExternalSemaphoreWaitParams

Definition hip_runtime_api.h:1037

hipExternalSemaphoreWaitParams::value

unsigned long long value

Definition hip_runtime_api.h:1040

hipExternalSemaphoreWaitParams::timeoutMs

unsigned int timeoutMs

Definition hip_runtime_api.h:1044

hipExternalSemaphoreWaitParams::key

unsigned long long key

Definition hip_runtime_api.h:1043

hipExternalSemaphoreWaitParams::flags

unsigned int flags

Definition hip_runtime_api.h:1048

hipFuncAttributes

Definition hip_runtime_api.h:545

hipFuncAttributes::cacheModeCA

int cacheModeCA

Definition hip_runtime_api.h:547

hipFuncAttributes::binaryVersion

int binaryVersion

Definition hip_runtime_api.h:546

hipFuncAttributes::constSizeBytes

size_t constSizeBytes

Definition hip_runtime_api.h:548

hipFuncAttributes::preferredShmemCarveout

int preferredShmemCarveout

Definition hip_runtime_api.h:553

hipFuncAttributes::sharedSizeBytes

size_t sharedSizeBytes

Definition hip_runtime_api.h:555

hipFuncAttributes::maxDynamicSharedSizeBytes

int maxDynamicSharedSizeBytes

Definition hip_runtime_api.h:550

hipFuncAttributes::ptxVersion

int ptxVersion

Definition hip_runtime_api.h:554

hipFuncAttributes::numRegs

int numRegs

Definition hip_runtime_api.h:552

hipFuncAttributes::localSizeBytes

size_t localSizeBytes

Definition hip_runtime_api.h:549

hipFuncAttributes::maxThreadsPerBlock

int maxThreadsPerBlock

Definition hip_runtime_api.h:551

hipFunctionLaunchParams

Definition hip_runtime_api.h:964

hipFunctionLaunchParams::gridDimX

unsigned int gridDimX

Width(X) of grid in blocks.

Definition hip_runtime_api.h:966

hipFunctionLaunchParams::blockDimX

unsigned int blockDimX

X dimension of each thread block.

Definition hip_runtime_api.h:969

hipFunctionLaunchParams::function

hipFunction_t function

Kernel to launch.

Definition hip_runtime_api.h:965

hipFunctionLaunchParams::hStream

hipStream_t hStream

Stream identifier.

Definition hip_runtime_api.h:973

hipFunctionLaunchParams::blockDimY

unsigned int blockDimY

Y dimension of each thread block.

Definition hip_runtime_api.h:970

hipFunctionLaunchParams::gridDimY

unsigned int gridDimY

Height(Y) of grid in blocks.

Definition hip_runtime_api.h:967

hipFunctionLaunchParams::gridDimZ

unsigned int gridDimZ

Depth(Z) of grid in blocks.

Definition hip_runtime_api.h:968

hipFunctionLaunchParams::sharedMemBytes

unsigned int sharedMemBytes

Shared memory.

Definition hip_runtime_api.h:972

hipFunctionLaunchParams::blockDimZ

unsigned int blockDimZ

Z dimension of each thread block.

Definition hip_runtime_api.h:971

hipFunctionLaunchParams::kernelParams

void ** kernelParams

Kernel parameters.

Definition hip_runtime_api.h:974

hipHostNodeParams

Definition hip_runtime_api.h:1136

hipHostNodeParams::fn

hipHostFn_t fn

Definition hip_runtime_api.h:1137

hipHostNodeParams::userData

void * userData

Definition hip_runtime_api.h:1138

hipIpcEventHandle_t

Definition hip_runtime_api.h:535

hipIpcMemHandle_t

Definition hip_runtime_api.h:532

hipKernelNodeParams

Definition hip_runtime_api.h:1140

hipKernelNodeParams::gridDim

dim3 gridDim

Definition hip_runtime_api.h:1144

hipKernelNodeParams::sharedMemBytes

unsigned int sharedMemBytes

Definition hip_runtime_api.h:1146

hipKernelNodeParams::blockDim

dim3 blockDim

Definition hip_runtime_api.h:1141

hipKernelNodeParams::kernelParams

void ** kernelParams

Definition hip_runtime_api.h:1145

hipKernelNodeParams::extra

void ** extra

Definition hip_runtime_api.h:1142

hipKernelNodeParams::func

void * func

Definition hip_runtime_api.h:1143

hipLaunchParams

Definition hip_runtime_api.h:956

hipLaunchParams::sharedMem

size_t sharedMem

Shared memory.

Definition hip_runtime_api.h:961

hipLaunchParams::args

void ** args

Arguments.

Definition hip_runtime_api.h:960

hipLaunchParams::blockDim

dim3 blockDim

Block dimentions.

Definition hip_runtime_api.h:959

hipLaunchParams::gridDim

dim3 gridDim

Grid dimentions.

Definition hip_runtime_api.h:958

hipLaunchParams::func

void * func

Device function symbol.

Definition hip_runtime_api.h:957

hipLaunchParams::stream

hipStream_t stream

Stream identifier.

Definition hip_runtime_api.h:962

hipMemAccessDesc

Definition hip_runtime_api.h:844

hipMemAccessDesc::flags

hipMemAccessFlags flags

Accessibility flags to set.

Definition hip_runtime_api.h:846

hipMemAccessDesc::location

hipMemLocation location

Location on which the accessibility has to change.

Definition hip_runtime_api.h:845

hipMemAllocNodeParams

Definition hip_runtime_api.h:1157

hipMemAllocNodeParams::accessDescs

const hipMemAccessDesc * accessDescs

Definition hip_runtime_api.h:1160

hipMemAllocNodeParams::bytesize

size_t bytesize

The size of the requested allocation in bytes.

Definition hip_runtime_api.h:1163

hipMemAllocNodeParams::poolProps

hipMemPoolProps poolProps

Definition hip_runtime_api.h:1158

hipMemAllocNodeParams::accessDescCount

size_t accessDescCount

The number of access descriptors.

Definition hip_runtime_api.h:1162

hipMemAllocNodeParams::dptr

void * dptr

Returned device address of the allocation.

Definition hip_runtime_api.h:1164

hipMemAllocationProp

Definition hip_runtime_api.h:1270

hipMemAllocationProp::win32HandleMetaData

void * win32HandleMetaData

Metadata for Win32 handles.

Definition hip_runtime_api.h:1274

hipMemAllocationProp::type

hipMemAllocationType type

Memory allocation type.

Definition hip_runtime_api.h:1271

hipMemAllocationProp::gpuDirectRDMACapable

unsigned char gpuDirectRDMACapable

RDMA capable.

Definition hip_runtime_api.h:1277

hipMemAllocationProp::allocFlags

struct hipMemAllocationProp::@24 allocFlags

hipMemAllocationProp::usage

unsigned short usage

Usage.

Definition hip_runtime_api.h:1278

hipMemAllocationProp::requestedHandleType

hipMemAllocationHandleType requestedHandleType

Requested handle type.

Definition hip_runtime_api.h:1272

hipMemAllocationProp::location

hipMemLocation location

Memory location.

Definition hip_runtime_api.h:1273

hipMemAllocationProp::compressionType

unsigned char compressionType

Compression type.

Definition hip_runtime_api.h:1276

hipMemLocation

Definition hip_runtime_api.h:827

hipMemLocation::id

int id

Identifier for the provided location type hipMemLocationType.

Definition hip_runtime_api.h:829

hipMemLocation::type

hipMemLocationType type

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

Definition hip_runtime_api.h:828

hipMemPoolProps

Definition hip_runtime_api.h:875

hipMemPoolProps::location

hipMemLocation location

Location where allocations should reside.

Definition hip_runtime_api.h:878

hipMemPoolProps::handleTypes

hipMemAllocationHandleType handleTypes

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

Definition hip_runtime_api.h:877

hipMemPoolProps::allocType

hipMemAllocationType allocType

Allocation type. Currently must be specified as hipMemAllocationTypePinned.

Definition hip_runtime_api.h:876

hipMemPoolProps::reserved

unsigned char reserved[64]

Reserved for future use, must be 0.

Definition hip_runtime_api.h:883

hipMemPoolProps::win32SecurityAttributes

void * win32SecurityAttributes

Definition hip_runtime_api.h:882

hipMemPoolPtrExportData

Definition hip_runtime_api.h:888

hipMemPoolPtrExportData::reserved

unsigned char reserved[64]

Definition hip_runtime_api.h:889

hipMemcpy3DParms

Definition driver_types.h:369

hipMemsetParams

Definition hip_runtime_api.h:1148

hipMemsetParams::dst

void * dst

Definition hip_runtime_api.h:1149

hipMemsetParams::value

unsigned int value

Definition hip_runtime_api.h:1153

hipMemsetParams::elementSize

unsigned int elementSize

Definition hip_runtime_api.h:1150

hipMemsetParams::width

size_t width

Definition hip_runtime_api.h:1154

hipMemsetParams::pitch

size_t pitch

Definition hip_runtime_api.h:1152

hipMemsetParams::height

size_t height

Definition hip_runtime_api.h:1151

hipMipmappedArray

Definition driver_types.h:117

hipPitchedPtr

Definition driver_types.h:352

hipPointerAttribute_t

Definition hip_runtime_api.h:175

hipPointerAttribute_t::device

int device

Definition hip_runtime_api.h:181

hipPointerAttribute_t::memoryType

enum hipMemoryType memoryType

Definition hip_runtime_api.h:178

hipPointerAttribute_t::hostPointer

void * hostPointer

Definition hip_runtime_api.h:183

hipPointerAttribute_t::type

enum hipMemoryType type

Definition hip_runtime_api.h:179

hipPointerAttribute_t::isManaged

int isManaged

Definition hip_runtime_api.h:184

hipPointerAttribute_t::devicePointer

void * devicePointer

Definition hip_runtime_api.h:182

hipPointerAttribute_t::allocationFlags

unsigned allocationFlags

Definition hip_runtime_api.h:185

hipResourceDesc

Definition driver_types.h:258

hipResourceViewDesc

Definition driver_types.h:314

hipTextureDesc

Definition texture_types.h:109

hipUUID

Definition hip_runtime_api.h:76

textureReference

Definition texture_types.h:88

surface_types.h

Defines surface types for HIP runtime.

hipSurfaceObject_t

struct __hip_surface * hipSurfaceObject_t

Definition surface_types.h:34

texture_types.h

hipTextureObject_t

struct __hip_texture * hipTextureObject_t

Definition texture_types.h:63

hipTextureAddressMode

hipTextureAddressMode

Definition texture_types.h:68

hipTextureFilterMode

hipTextureFilterMode

Definition texture_types.h:78

hipKernelNodeAttrValue

Definition hip_runtime_api.h:1188

hipKernelNodeAttrValue::cooperative

int cooperative

Definition hip_runtime_api.h:1190

hipKernelNodeAttrValue::accessPolicyWindow

hipAccessPolicyWindow accessPolicyWindow

Definition hip_runtime_api.h:1189