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

• include
• hip

hip_runtime_api.h

Go to the documentation of this file.

1/*

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

3

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

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

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

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

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

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

10

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

12all copies or substantial portions of the Software.

13

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

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

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

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

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

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

20THE SOFTWARE.

21*/

22

30#ifndef HIP_INCLUDE_HIP_HIP_RUNTIME_API_H

31#define HIP_INCLUDE_HIP_HIP_RUNTIME_API_H

32

33

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// hack to get these to show up in Doxygen:

54typedef struct {

55 // 32-bit Atomics

56 unsigned hasGlobalInt32Atomics : 1;

57 unsigned hasGlobalFloatAtomicExch : 1;

58 unsigned hasSharedInt32Atomics : 1;

59 unsigned hasSharedFloatAtomicExch : 1;

60 unsigned hasFloatAtomicAdd : 1;

61

62 // 64-bit Atomics

63 unsigned hasGlobalInt64Atomics : 1;

64 unsigned hasSharedInt64Atomics : 1;

65

66 // Doubles

67 unsigned hasDoubles : 1;

68

69 // Warp cross-lane operations

70 unsigned hasWarpVote : 1;

71 unsigned hasWarpBallot : 1;

72 unsigned hasWarpShuffle : 1;

73 unsigned hasFunnelShift : 1;

74

75 // Sync

76 unsigned hasThreadFenceSystem : 1;

77 unsigned hasSyncThreadsExt : 1;

78

79 // Misc

80 unsigned hasSurfaceFuncs : 1;

81 unsigned has3dGrid : 1;

82 unsigned hasDynamicParallelism : 1;

83} hipDeviceArch_t;

84

85typedef struct hipUUID_t {

86 char bytes[16];

87} hipUUID;

88

89//---

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

91

96typedef struct hipDeviceProp_t {

97 char name[256];

98 size_t totalGlobalMem;

99 size_t sharedMemPerBlock;

100 int regsPerBlock;

101 int warpSize;

102 int maxThreadsPerBlock;

103 int maxThreadsDim[3];

104 int maxGridSize[3];

105 int clockRate;

106 int memoryClockRate;

107 int memoryBusWidth;

108 size_t totalConstMem;

109 int major;

112 int minor;

115 int multiProcessorCount;

116 int l2CacheSize;

117 int maxThreadsPerMultiProcessor;

118 int computeMode;

119 int clockInstructionRate;

121 hipDeviceArch_t arch;

122 int concurrentKernels;

123 int pciDomainID;

124 int pciBusID;

125 int pciDeviceID;

126 size_t maxSharedMemoryPerMultiProcessor;

127 int isMultiGpuBoard;

128 int canMapHostMemory;

129 int gcnArch;

130 char gcnArchName[256];

131 int integrated;

132 int cooperativeLaunch;

133 int cooperativeMultiDeviceLaunch;

134 int maxTexture1DLinear;

135 int maxTexture1D;

136 int maxTexture2D[2];

137 int maxTexture3D[3];

138 unsigned int* hdpMemFlushCntl;

139 unsigned int* hdpRegFlushCntl;

140 size_t memPitch;

141 size_t textureAlignment;

142 size_t texturePitchAlignment;

143 int kernelExecTimeoutEnabled;

144 int ECCEnabled;

145 int tccDriver;

146 int cooperativeMultiDeviceUnmatchedFunc;

148 int cooperativeMultiDeviceUnmatchedGridDim;

150 int cooperativeMultiDeviceUnmatchedBlockDim;

152 int cooperativeMultiDeviceUnmatchedSharedMem;

154 int isLargeBar;

155 int asicRevision;

156 int managedMemory;

157 int directManagedMemAccessFromHost;

158 int concurrentManagedAccess;

159 int pageableMemoryAccess;

161 int pageableMemoryAccessUsesHostPageTables;

162} hipDeviceProp_t;

163

175typedef enum hipMemoryType {

176 hipMemoryTypeHost = 0,

177 hipMemoryTypeDevice = 1,

179 hipMemoryTypeArray = 2,

181 hipMemoryTypeUnified = 3,

182 hipMemoryTypeManaged = 4

184} hipMemoryType;

185

189typedef struct hipPointerAttribute_t {

190 union {

191 // Deprecated, use instead type

192 enum hipMemoryType memoryType;

193 enum hipMemoryType type;

194 };

195 int device;

196 void* devicePointer;

197 void* hostPointer;

198 int isManaged;

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

200 /* peers? */

201} hipPointerAttribute_t;

202

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

204// we can make that yield a warning

205#if __cplusplus >= 201703L

206#define __HIP_NODISCARD [[nodiscard]]

207#else

208#define __HIP_NODISCARD

209#endif

210

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

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

217

218typedef enum __HIP_NODISCARD hipError_t {

219 hipSuccess = 0,

220 hipErrorInvalidValue = 1,

222 hipErrorOutOfMemory = 2,

223 // Deprecated

224 hipErrorMemoryAllocation = 2,

225 hipErrorNotInitialized = 3,

226 // Deprecated

227 hipErrorInitializationError = 3,

228 hipErrorDeinitialized = 4,

229 hipErrorProfilerDisabled = 5,

230 hipErrorProfilerNotInitialized = 6,

231 hipErrorProfilerAlreadyStarted = 7,

232 hipErrorProfilerAlreadyStopped = 8,

233 hipErrorInvalidConfiguration = 9,

234 hipErrorInvalidPitchValue = 12,

235 hipErrorInvalidSymbol = 13,

236 hipErrorInvalidDevicePointer = 17,

237 hipErrorInvalidMemcpyDirection = 21,

238 hipErrorInsufficientDriver = 35,

239 hipErrorMissingConfiguration = 52,

240 hipErrorPriorLaunchFailure = 53,

241 hipErrorInvalidDeviceFunction = 98,

242 hipErrorNoDevice = 100,

243 hipErrorInvalidDevice = 101,

244 hipErrorInvalidImage = 200,

245 hipErrorInvalidContext = 201,

246 hipErrorContextAlreadyCurrent = 202,

247 hipErrorMapFailed = 205,

248 // Deprecated

249 hipErrorMapBufferObjectFailed = 205,

250 hipErrorUnmapFailed = 206,

251 hipErrorArrayIsMapped = 207,

252 hipErrorAlreadyMapped = 208,

253 hipErrorNoBinaryForGpu = 209,

254 hipErrorAlreadyAcquired = 210,

255 hipErrorNotMapped = 211,

256 hipErrorNotMappedAsArray = 212,

257 hipErrorNotMappedAsPointer = 213,

258 hipErrorECCNotCorrectable = 214,

259 hipErrorUnsupportedLimit = 215,

260 hipErrorContextAlreadyInUse = 216,

261 hipErrorPeerAccessUnsupported = 217,

262 hipErrorInvalidKernelFile = 218,

263 hipErrorInvalidGraphicsContext = 219,

264 hipErrorInvalidSource = 300,

265 hipErrorFileNotFound = 301,

266 hipErrorSharedObjectSymbolNotFound = 302,

267 hipErrorSharedObjectInitFailed = 303,

268 hipErrorOperatingSystem = 304,

269 hipErrorInvalidHandle = 400,

270 // Deprecated

271 hipErrorInvalidResourceHandle = 400,

272 hipErrorIllegalState = 401,

273 hipErrorNotFound = 500,

274 hipErrorNotReady = 600,

278 hipErrorIllegalAddress = 700,

279 hipErrorLaunchOutOfResources = 701,

280 hipErrorLaunchTimeOut = 702,

281 hipErrorPeerAccessAlreadyEnabled =

282 704,

283 hipErrorPeerAccessNotEnabled =

284 705,

285 hipErrorSetOnActiveProcess = 708,

286 hipErrorContextIsDestroyed = 709,

287 hipErrorAssert = 710,

288 hipErrorHostMemoryAlreadyRegistered =

289 712,

290 hipErrorHostMemoryNotRegistered =

291 713,

292 hipErrorLaunchFailure =

293 719,

294 hipErrorCooperativeLaunchTooLarge =

295 720,

298 hipErrorNotSupported = 801,

299 hipErrorStreamCaptureUnsupported = 900,

301 hipErrorStreamCaptureInvalidated = 901,

303 hipErrorStreamCaptureMerge = 902,

305 hipErrorStreamCaptureUnmatched = 903,

306 hipErrorStreamCaptureUnjoined = 904,

308 hipErrorStreamCaptureIsolation = 905,

312 hipErrorStreamCaptureImplicit = 906,

315 hipErrorCapturedEvent = 907,

317 hipErrorStreamCaptureWrongThread = 908,

321 hipErrorGraphExecUpdateFailure = 910,

325 hipErrorUnknown = 999,

326 // HSA Runtime Error Codes start here.

327 hipErrorRuntimeMemory = 1052,

329 hipErrorRuntimeOther = 1053,

331 hipErrorTbd

332} hipError_t;

333

334#undef __HIP_NODISCARD

335

340typedef enum hipDeviceAttribute_t {

341 hipDeviceAttributeCudaCompatibleBegin = 0,

342

343 hipDeviceAttributeEccEnabled = hipDeviceAttributeCudaCompatibleBegin,

344 hipDeviceAttributeAccessPolicyMaxWindowSize,

345 hipDeviceAttributeAsyncEngineCount,

346 hipDeviceAttributeCanMapHostMemory,

347 hipDeviceAttributeCanUseHostPointerForRegisteredMem,

349 hipDeviceAttributeClockRate,

350 hipDeviceAttributeComputeMode,

351 hipDeviceAttributeComputePreemptionSupported,

352 hipDeviceAttributeConcurrentKernels,

353 hipDeviceAttributeConcurrentManagedAccess,

354 hipDeviceAttributeCooperativeLaunch,

355 hipDeviceAttributeCooperativeMultiDeviceLaunch,

356 hipDeviceAttributeDeviceOverlap,

358 hipDeviceAttributeDirectManagedMemAccessFromHost,

360 hipDeviceAttributeGlobalL1CacheSupported,

361 hipDeviceAttributeHostNativeAtomicSupported,

362 hipDeviceAttributeIntegrated,

363 hipDeviceAttributeIsMultiGpuBoard,

364 hipDeviceAttributeKernelExecTimeout,

365 hipDeviceAttributeL2CacheSize,

366 hipDeviceAttributeLocalL1CacheSupported,

367 hipDeviceAttributeLuid,

368 hipDeviceAttributeLuidDeviceNodeMask,

369 hipDeviceAttributeComputeCapabilityMajor,

370 hipDeviceAttributeManagedMemory,

371 hipDeviceAttributeMaxBlocksPerMultiProcessor,

372 hipDeviceAttributeMaxBlockDimX,

373 hipDeviceAttributeMaxBlockDimY,

374 hipDeviceAttributeMaxBlockDimZ,

375 hipDeviceAttributeMaxGridDimX,

376 hipDeviceAttributeMaxGridDimY,

377 hipDeviceAttributeMaxGridDimZ,

378 hipDeviceAttributeMaxSurface1D,

379 hipDeviceAttributeMaxSurface1DLayered,

380 hipDeviceAttributeMaxSurface2D,

381 hipDeviceAttributeMaxSurface2DLayered,

382 hipDeviceAttributeMaxSurface3D,

383 hipDeviceAttributeMaxSurfaceCubemap,

384 hipDeviceAttributeMaxSurfaceCubemapLayered,

385 hipDeviceAttributeMaxTexture1DWidth,

386 hipDeviceAttributeMaxTexture1DLayered,

387 hipDeviceAttributeMaxTexture1DLinear,

389 hipDeviceAttributeMaxTexture1DMipmap,

390 hipDeviceAttributeMaxTexture2DWidth,

391 hipDeviceAttributeMaxTexture2DHeight,

392 hipDeviceAttributeMaxTexture2DGather,

393 hipDeviceAttributeMaxTexture2DLayered,

394 hipDeviceAttributeMaxTexture2DLinear,

395 hipDeviceAttributeMaxTexture2DMipmap,

396 hipDeviceAttributeMaxTexture3DWidth,

397 hipDeviceAttributeMaxTexture3DHeight,

398 hipDeviceAttributeMaxTexture3DDepth,

399 hipDeviceAttributeMaxTexture3DAlt,

400 hipDeviceAttributeMaxTextureCubemap,

401 hipDeviceAttributeMaxTextureCubemapLayered,

402 hipDeviceAttributeMaxThreadsDim,

403 hipDeviceAttributeMaxThreadsPerBlock,

404 hipDeviceAttributeMaxThreadsPerMultiProcessor,

405 hipDeviceAttributeMaxPitch,

406 hipDeviceAttributeMemoryBusWidth,

407 hipDeviceAttributeMemoryClockRate,

408 hipDeviceAttributeComputeCapabilityMinor,

409 hipDeviceAttributeMultiGpuBoardGroupID,

410 hipDeviceAttributeMultiprocessorCount,

411 hipDeviceAttributeName,

412 hipDeviceAttributePageableMemoryAccess,

414 hipDeviceAttributePageableMemoryAccessUsesHostPageTables,

415 hipDeviceAttributePciBusId,

416 hipDeviceAttributePciDeviceId,

417 hipDeviceAttributePciDomainID,

418 hipDeviceAttributePersistingL2CacheMaxSize,

419 hipDeviceAttributeMaxRegistersPerBlock,

421 hipDeviceAttributeMaxRegistersPerMultiprocessor,

422 hipDeviceAttributeReservedSharedMemPerBlock,

423 hipDeviceAttributeMaxSharedMemoryPerBlock,

424 hipDeviceAttributeSharedMemPerBlockOptin,

425 hipDeviceAttributeSharedMemPerMultiprocessor,

426 hipDeviceAttributeSingleToDoublePrecisionPerfRatio,

427 hipDeviceAttributeStreamPrioritiesSupported,

428 hipDeviceAttributeSurfaceAlignment,

429 hipDeviceAttributeTccDriver,

430 hipDeviceAttributeTextureAlignment,

431 hipDeviceAttributeTexturePitchAlignment,

432 hipDeviceAttributeTotalConstantMemory,

433 hipDeviceAttributeTotalGlobalMem,

434 hipDeviceAttributeUnifiedAddressing,

435 hipDeviceAttributeUuid,

436 hipDeviceAttributeWarpSize,

437 hipDeviceAttributeMemoryPoolsSupported,

438 hipDeviceAttributeVirtualMemoryManagementSupported,

439

440 hipDeviceAttributeCudaCompatibleEnd = 9999,

441 hipDeviceAttributeAmdSpecificBegin = 10000,

442

443 hipDeviceAttributeClockInstructionRate = hipDeviceAttributeAmdSpecificBegin,

444 hipDeviceAttributeArch,

445 hipDeviceAttributeMaxSharedMemoryPerMultiprocessor,

446 hipDeviceAttributeGcnArch,

447 hipDeviceAttributeGcnArchName,

448 hipDeviceAttributeHdpMemFlushCntl,

449 hipDeviceAttributeHdpRegFlushCntl,

450 hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc,

452 hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim,

454 hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim,

456 hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem,

458 hipDeviceAttributeIsLargeBar,

459 hipDeviceAttributeAsicRevision,

460 hipDeviceAttributeCanUseStreamWaitValue,

462 hipDeviceAttributeImageSupport,

463 hipDeviceAttributePhysicalMultiProcessorCount,

465 hipDeviceAttributeFineGrainSupport,

466 hipDeviceAttributeWallClockRate,

467

468 hipDeviceAttributeAmdSpecificEnd = 19999,

469 hipDeviceAttributeVendorSpecificBegin = 20000,

470 // Extended attributes for vendors

471} hipDeviceAttribute_t;

472

473enum hipComputeMode {

474 hipComputeModeDefault = 0,

475 hipComputeModeExclusive = 1,

476 hipComputeModeProhibited = 2,

477 hipComputeModeExclusiveProcess = 3

478};

479

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,

560 hipLimitPrintfFifoSize = 0x01,

561 hipLimitMallocHeapSize = 0x02,

562 hipLimitRange

563};

567//Flags that can be used with hipStreamCreateWithFlags.

569#define hipStreamDefault 0x00

570

572#define hipStreamNonBlocking 0x01

573

574//Flags that can be used with hipEventCreateWithFlags.

576#define hipEventDefault 0x0

577

579#define hipEventBlockingSync 0x1

580

582#define hipEventDisableTiming 0x2

583

585#define hipEventInterprocess 0x4

586

595#define hipEventDisableSystemFence 0x20000000

596

599#define hipEventReleaseToDevice 0x40000000

600

603#define hipEventReleaseToSystem 0x80000000

604

605//Flags that can be used with hipHostMalloc.

607#define hipHostMallocDefault 0x0

608

610#define hipHostMallocPortable 0x1

611

614#define hipHostMallocMapped 0x2

615

619#define hipHostMallocWriteCombined 0x4

620

625#define hipHostMallocNumaUser 0x20000000

626

628#define hipHostMallocCoherent 0x40000000

629

631#define hipHostMallocNonCoherent 0x80000000

632

634#define hipMemAttachGlobal 0x01

635

637#define hipMemAttachHost 0x02

638

640#define hipMemAttachSingle 0x04

641

642#define hipDeviceMallocDefault 0x0

643

645#define hipDeviceMallocFinegrained 0x1

646

648#define hipMallocSignalMemory 0x2

649

651#define hipDeviceMallocUncached 0x3

652

653//Flags that can be used with hipHostRegister.

655#define hipHostRegisterDefault 0x0

656

658#define hipHostRegisterPortable 0x1

659

662#define hipHostRegisterMapped 0x2

663

665#define hipHostRegisterIoMemory 0x4

666

668#define hipHostRegisterReadOnly 0x08

669

671#define hipExtHostRegisterCoarseGrained 0x8

672

674#define hipDeviceScheduleAuto 0x0

675

678#define hipDeviceScheduleSpin 0x1

679

682#define hipDeviceScheduleYield 0x2

683#define hipDeviceScheduleBlockingSync 0x4

684#define hipDeviceScheduleMask 0x7

685#define hipDeviceMapHost 0x8

686#define hipDeviceLmemResizeToMax 0x10

688#define hipArrayDefault 0x00

689#define hipArrayLayered 0x01

690#define hipArraySurfaceLoadStore 0x02

691#define hipArrayCubemap 0x04

692#define hipArrayTextureGather 0x08

693#define hipOccupancyDefault 0x00

694#define hipOccupancyDisableCachingOverride 0x01

695#define hipCooperativeLaunchMultiDeviceNoPreSync 0x01

696#define hipCooperativeLaunchMultiDeviceNoPostSync 0x02

697#define hipCpuDeviceId ((int)-1)

698#define hipInvalidDeviceId ((int)-2)

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

701#define hipExtAnyOrderLaunch 0x01

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

703#define hipStreamWaitValueGte 0x0

704#define hipStreamWaitValueEq 0x1

705#define hipStreamWaitValueAnd 0x2

706#define hipStreamWaitValueNor 0x3

707// Stream per thread

709#define hipStreamPerThread ((hipStream_t)2)

710

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

712#define hipExternalMemoryDedicated 0x1

718typedef enum hipMemoryAdvise {

719 hipMemAdviseSetReadMostly = 1,

721 hipMemAdviseUnsetReadMostly = 2,

722 hipMemAdviseSetPreferredLocation = 3,

724 hipMemAdviseUnsetPreferredLocation = 4,

725 hipMemAdviseSetAccessedBy = 5,

727 hipMemAdviseUnsetAccessedBy = 6,

729 hipMemAdviseSetCoarseGrain = 100,

734 hipMemAdviseUnsetCoarseGrain = 101

735} hipMemoryAdvise;

739typedef enum hipMemRangeCoherencyMode {

740 hipMemRangeCoherencyModeFineGrain = 0,

742 hipMemRangeCoherencyModeCoarseGrain = 1,

744 hipMemRangeCoherencyModeIndeterminate = 2

747} hipMemRangeCoherencyMode;

751typedef enum hipMemRangeAttribute {

752 hipMemRangeAttributeReadMostly = 1,

754 hipMemRangeAttributePreferredLocation = 2,

755 hipMemRangeAttributeAccessedBy = 3,

757 hipMemRangeAttributeLastPrefetchLocation = 4,

759 hipMemRangeAttributeCoherencyMode = 100,

761} hipMemRangeAttribute;

762

766typedef enum hipMemPoolAttr

767{

776 hipMemPoolReuseFollowEventDependencies = 0x1,

782 hipMemPoolReuseAllowOpportunistic = 0x2,

789 hipMemPoolReuseAllowInternalDependencies = 0x3,

798 hipMemPoolAttrReleaseThreshold = 0x4,

803 hipMemPoolAttrReservedMemCurrent = 0x5,

809 hipMemPoolAttrReservedMemHigh = 0x6,

814 hipMemPoolAttrUsedMemCurrent = 0x7,

820 hipMemPoolAttrUsedMemHigh = 0x8

821} hipMemPoolAttr;

825 typedef enum hipMemLocationType {

826 hipMemLocationTypeInvalid = 0,

827 hipMemLocationTypeDevice = 1

828} hipMemLocationType;

834typedef struct hipMemLocation {

835 hipMemLocationType type;

836 int id;

837} hipMemLocation;

842typedef enum hipMemAccessFlags {

843 hipMemAccessFlagsProtNone = 0,

844 hipMemAccessFlagsProtRead = 1,

845 hipMemAccessFlagsProtReadWrite = 3

846} hipMemAccessFlags;

850typedef struct hipMemAccessDesc {

851 hipMemLocation location;

852 hipMemAccessFlags flags;

853} hipMemAccessDesc;

857typedef enum hipMemAllocationType {

858 hipMemAllocationTypeInvalid = 0x0,

862 hipMemAllocationTypePinned = 0x1,

863 hipMemAllocationTypeMax = 0x7FFFFFFF

864} hipMemAllocationType;

869typedef enum hipMemAllocationHandleType {

870 hipMemHandleTypeNone = 0x0,

871 hipMemHandleTypePosixFileDescriptor = 0x1,

872 hipMemHandleTypeWin32 = 0x2,

873 hipMemHandleTypeWin32Kmt = 0x4

874} hipMemAllocationHandleType;

878typedef struct hipMemPoolProps {

879 hipMemAllocationType allocType;

880 hipMemAllocationHandleType handleTypes;

881 hipMemLocation location;

885 void* win32SecurityAttributes;

886 unsigned char reserved[64];

887} hipMemPoolProps;

891typedef struct hipMemPoolPtrExportData {

892 unsigned char reserved[64];

893} hipMemPoolPtrExportData;

894

898typedef enum hipJitOption {

899 hipJitOptionMaxRegisters = 0,

900 hipJitOptionThreadsPerBlock,

901 hipJitOptionWallTime,

902 hipJitOptionInfoLogBuffer,

903 hipJitOptionInfoLogBufferSizeBytes,

904 hipJitOptionErrorLogBuffer,

905 hipJitOptionErrorLogBufferSizeBytes,

906 hipJitOptionOptimizationLevel,

907 hipJitOptionTargetFromContext,

908 hipJitOptionTarget,

909 hipJitOptionFallbackStrategy,

910 hipJitOptionGenerateDebugInfo,

911 hipJitOptionLogVerbose,

912 hipJitOptionGenerateLineInfo,

913 hipJitOptionCacheMode,

914 hipJitOptionSm3xOpt,

915 hipJitOptionFastCompile,

916 hipJitOptionNumOptions

917} hipJitOption;

921typedef enum hipFuncAttribute {

922 hipFuncAttributeMaxDynamicSharedMemorySize = 8,

923 hipFuncAttributePreferredSharedMemoryCarveout = 9,

924 hipFuncAttributeMax

925} hipFuncAttribute;

929typedef enum hipFuncCache_t {

930 hipFuncCachePreferNone,

931 hipFuncCachePreferShared,

932 hipFuncCachePreferL1,

933 hipFuncCachePreferEqual,

934} hipFuncCache_t;

938typedef enum hipSharedMemConfig {

939 hipSharedMemBankSizeDefault,

940 hipSharedMemBankSizeFourByte,

942 hipSharedMemBankSizeEightByte

944} 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;

959typedef struct hipLaunchParams_t {

960 void* func;

961 dim3 gridDim;

962 dim3 blockDim;

963 void **args;

964 size_t sharedMem;

965 hipStream_t stream;

966} hipLaunchParams;

970typedef struct hipFunctionLaunchParams_t {

971 hipFunction_t function;

972 unsigned int gridDimX;

973 unsigned int gridDimY;

974 unsigned int gridDimZ;

975 unsigned int blockDimX;

976 unsigned int blockDimY;

977 unsigned int blockDimZ;

978 unsigned int sharedMemBytes;

979 hipStream_t hStream;

980 void **kernelParams;

981} hipFunctionLaunchParams;

982typedef enum hipExternalMemoryHandleType_enum {

983 hipExternalMemoryHandleTypeOpaqueFd = 1,

984 hipExternalMemoryHandleTypeOpaqueWin32 = 2,

985 hipExternalMemoryHandleTypeOpaqueWin32Kmt = 3,

986 hipExternalMemoryHandleTypeD3D12Heap = 4,

987 hipExternalMemoryHandleTypeD3D12Resource = 5,

988 hipExternalMemoryHandleTypeD3D11Resource = 6,

989 hipExternalMemoryHandleTypeD3D11ResourceKmt = 7,

990} hipExternalMemoryHandleType;

991typedef struct hipExternalMemoryHandleDesc_st {

992 hipExternalMemoryHandleType type;

993 union {

994 int fd;

995 struct {

996 void *handle;

997 const void *name;

998 } win32;

999 } handle;

1000 unsigned long long size;

1001 unsigned int flags;

1002} hipExternalMemoryHandleDesc;

1003typedef struct hipExternalMemoryBufferDesc_st {

1004 unsigned long long offset;

1005 unsigned long long size;

1006 unsigned int flags;

1007} hipExternalMemoryBufferDesc;

1008typedef void* hipExternalMemory_t;

1009typedef enum hipExternalSemaphoreHandleType_enum {

1010 hipExternalSemaphoreHandleTypeOpaqueFd = 1,

1011 hipExternalSemaphoreHandleTypeOpaqueWin32 = 2,

1012 hipExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3,

1013 hipExternalSemaphoreHandleTypeD3D12Fence = 4

1014} hipExternalSemaphoreHandleType;

1015typedef struct hipExternalSemaphoreHandleDesc_st {

1016 hipExternalSemaphoreHandleType type;

1017 union {

1018 int fd;

1019 struct {

1020 void* handle;

1021 const void* name;

1022 } win32;

1023 } handle;

1024 unsigned int flags;

1025} hipExternalSemaphoreHandleDesc;

1026typedef void* hipExternalSemaphore_t;

1027typedef struct hipExternalSemaphoreSignalParams_st {

1028 struct {

1029 struct {

1030 unsigned long long value;

1031 } fence;

1032 struct {

1033 unsigned long long key;

1034 } keyedMutex;

1035 unsigned int reserved[12];

1036 } params;

1037 unsigned int flags;

1038 unsigned int reserved[16];

1039} hipExternalSemaphoreSignalParams;

1043typedef struct hipExternalSemaphoreWaitParams_st {

1044 struct {

1045 struct {

1046 unsigned long long value;

1047 } fence;

1048 struct {

1049 unsigned long long key;

1050 unsigned int timeoutMs;

1051 } keyedMutex;

1052 unsigned int reserved[10];

1053 } params;

1054 unsigned int flags;

1055 unsigned int reserved[16];

1056} hipExternalSemaphoreWaitParams;

1057

1058#if __HIP_HAS_GET_PCH

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

1064#endif

1065

1069typedef enum hipGLDeviceList {

1070 hipGLDeviceListAll = 1,

1071 hipGLDeviceListCurrentFrame = 2,

1073 hipGLDeviceListNextFrame = 3

1075} hipGLDeviceList;

1076

1080typedef enum hipGraphicsRegisterFlags {

1081 hipGraphicsRegisterFlagsNone = 0,

1082 hipGraphicsRegisterFlagsReadOnly = 1,

1083 hipGraphicsRegisterFlagsWriteDiscard =

1084 2,

1085 hipGraphicsRegisterFlagsSurfaceLoadStore = 4,

1086 hipGraphicsRegisterFlagsTextureGather =

1087 8

1088} hipGraphicsRegisterFlags;

1089

1090typedef struct _hipGraphicsResource hipGraphicsResource;

1091

1092typedef hipGraphicsResource* hipGraphicsResource_t;

1093

1097typedef struct ihipGraph* hipGraph_t;

1101typedef struct hipGraphNode* hipGraphNode_t;

1105typedef struct hipGraphExec* hipGraphExec_t;

1106

1110typedef struct hipUserObject* hipUserObject_t;

1111

1112

1116typedef enum hipGraphNodeType {

1117 hipGraphNodeTypeKernel = 0,

1118 hipGraphNodeTypeMemcpy = 1,

1119 hipGraphNodeTypeMemset = 2,

1120 hipGraphNodeTypeHost = 3,

1121 hipGraphNodeTypeGraph = 4,

1122 hipGraphNodeTypeEmpty = 5,

1123 hipGraphNodeTypeWaitEvent = 6,

1124 hipGraphNodeTypeEventRecord = 7,

1125 hipGraphNodeTypeExtSemaphoreSignal = 8,

1126 hipGraphNodeTypeExtSemaphoreWait = 9,

1127 hipGraphNodeTypeMemAlloc = 10,

1128 hipGraphNodeTypeMemFree = 11,

1129 hipGraphNodeTypeMemcpyFromSymbol = 12,

1130 hipGraphNodeTypeMemcpyToSymbol = 13,

1131 hipGraphNodeTypeCount

1132} hipGraphNodeType;

1133

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

1135typedef struct hipHostNodeParams {

1136 hipHostFn_t fn;

1137 void* userData;

1138} hipHostNodeParams;

1139typedef struct hipKernelNodeParams {

1140 dim3 blockDim;

1141 void** extra;

1142 void* func;

1143 dim3 gridDim;

1144 void** kernelParams;

1145 unsigned int sharedMemBytes;

1146} hipKernelNodeParams;

1147typedef struct hipMemsetParams {

1148 void* dst;

1149 unsigned int elementSize;

1150 size_t height;

1151 size_t pitch;

1152 unsigned int value;

1153 size_t width;

1154} hipMemsetParams;

1155

1156typedef struct hipMemAllocNodeParams {

1157 hipMemPoolProps poolProps;

1159 const hipMemAccessDesc* accessDescs;

1161 size_t accessDescCount;

1162 size_t bytesize;

1163 void* dptr;

1164} hipMemAllocNodeParams;

1165

1169typedef enum hipKernelNodeAttrID {

1170 hipKernelNodeAttributeAccessPolicyWindow = 1,

1171 hipKernelNodeAttributeCooperative = 2,

1172} hipKernelNodeAttrID;

1173typedef enum hipAccessProperty {

1174 hipAccessPropertyNormal = 0,

1175 hipAccessPropertyStreaming = 1,

1176 hipAccessPropertyPersisting = 2,

1177} hipAccessProperty;

1178typedef struct hipAccessPolicyWindow {

1179 void* base_ptr;

1180 hipAccessProperty hitProp;

1181 float hitRatio;

1182 hipAccessProperty missProp;

1183 size_t num_bytes;

1184} hipAccessPolicyWindow;

1185typedef union hipKernelNodeAttrValue {

1186 hipAccessPolicyWindow accessPolicyWindow;

1187 int cooperative;

1188} hipKernelNodeAttrValue;

1189

1193typedef enum hipGraphExecUpdateResult {

1194 hipGraphExecUpdateSuccess = 0x0,

1195 hipGraphExecUpdateError = 0x1,

1197 hipGraphExecUpdateErrorTopologyChanged = 0x2,

1198 hipGraphExecUpdateErrorNodeTypeChanged = 0x3,

1199 hipGraphExecUpdateErrorFunctionChanged =

1200 0x4,

1201 hipGraphExecUpdateErrorParametersChanged =

1202 0x5,

1203 hipGraphExecUpdateErrorNotSupported =

1204 0x6,

1205 hipGraphExecUpdateErrorUnsupportedFunctionChange = 0x7

1206} hipGraphExecUpdateResult;

1207

1208typedef enum hipStreamCaptureMode {

1209 hipStreamCaptureModeGlobal = 0,

1210 hipStreamCaptureModeThreadLocal,

1211 hipStreamCaptureModeRelaxed

1212} hipStreamCaptureMode;

1213typedef enum hipStreamCaptureStatus {

1214 hipStreamCaptureStatusNone = 0,

1215 hipStreamCaptureStatusActive,

1216 hipStreamCaptureStatusInvalidated

1218} hipStreamCaptureStatus;

1219

1220typedef enum hipStreamUpdateCaptureDependenciesFlags {

1221 hipStreamAddCaptureDependencies = 0,

1222 hipStreamSetCaptureDependencies,

1223} hipStreamUpdateCaptureDependenciesFlags;

1224

1225typedef enum hipGraphMemAttributeType {

1226 hipGraphMemAttrUsedMemCurrent = 0,

1227 hipGraphMemAttrUsedMemHigh,

1228 hipGraphMemAttrReservedMemCurrent,

1229 hipGraphMemAttrReservedMemHigh,

1230}hipGraphMemAttributeType;

1231typedef enum hipUserObjectFlags {

1232 hipUserObjectNoDestructorSync = 0x1,

1233} hipUserObjectFlags;

1234

1235typedef enum hipUserObjectRetainFlags {

1236 hipGraphUserObjectMove = 0x1,

1237} hipUserObjectRetainFlags;

1238

1239typedef enum hipGraphInstantiateFlags {

1240 hipGraphInstantiateFlagAutoFreeOnLaunch =

1241 1,

1242 hipGraphInstantiateFlagUpload =

1243 2,

1244 hipGraphInstantiateFlagDeviceLaunch =

1245 4,

1246 hipGraphInstantiateFlagUseNodePriority =

1247 8,

1248} hipGraphInstantiateFlags;

1249

1250enum hipGraphDebugDotFlags {

1251 hipGraphDebugDotFlagsVerbose = 1

1252 << 0,

1253 hipGraphDebugDotFlagsKernelNodeParams = 1 << 2,

1254 hipGraphDebugDotFlagsMemcpyNodeParams = 1 << 3,

1255 hipGraphDebugDotFlagsMemsetNodeParams = 1 << 4,

1256 hipGraphDebugDotFlagsHostNodeParams = 1 << 5,

1257 hipGraphDebugDotFlagsEventNodeParams = 1

1258 << 6,

1259 hipGraphDebugDotFlagsExtSemasSignalNodeParams = 1

1260 << 7,

1261 hipGraphDebugDotFlagsExtSemasWaitNodeParams = 1

1262 << 8,

1263 hipGraphDebugDotFlagsKernelNodeAttributes = 1

1264 << 9,

1265 hipGraphDebugDotFlagsHandles = 1

1266 << 10

1267};

1271typedef struct hipMemAllocationProp {

1272 hipMemAllocationType type;

1273 hipMemAllocationHandleType requestedHandleType;

1274 hipMemLocation location;

1275 void* win32HandleMetaData;

1276 struct {

1277 unsigned char compressionType;

1278 unsigned char gpuDirectRDMACapable;

1279 unsigned short usage;

1280 } allocFlags;

1281} hipMemAllocationProp;

1282

1286typedef struct hipExternalSemaphoreSignalNodeParams {

1288 hipExternalSemaphore_t* extSemArray;

1290 const hipExternalSemaphoreSignalParams* paramsArray;

1292 unsigned int numExtSems;

1293} hipExternalSemaphoreSignalNodeParams;

1294

1298typedef struct hipExternalSemaphoreWaitNodeParams {

1300 hipExternalSemaphore_t* extSemArray;

1302 const hipExternalSemaphoreWaitParams* paramsArray;

1304 unsigned int numExtSems;

1305} hipExternalSemaphoreWaitNodeParams;

1306

1310typedef struct ihipMemGenericAllocationHandle* hipMemGenericAllocationHandle_t;

1311

1315typedef enum hipMemAllocationGranularity_flags {

1316 hipMemAllocationGranularityMinimum = 0x0,

1317 hipMemAllocationGranularityRecommended = 0x1

1318} hipMemAllocationGranularity_flags;

1319

1323typedef enum hipMemHandleType {

1324 hipMemHandleTypeGeneric = 0x0

1325} hipMemHandleType;

1326

1330typedef enum hipMemOperationType {

1331 hipMemOperationTypeMap = 0x1,

1332 hipMemOperationTypeUnmap = 0x2

1333} hipMemOperationType;

1334

1338typedef enum hipArraySparseSubresourceType {

1339 hipArraySparseSubresourceTypeSparseLevel = 0x0,

1340 hipArraySparseSubresourceTypeMiptail = 0x1

1341} hipArraySparseSubresourceType;

1342

1346typedef struct hipArrayMapInfo {

1347 hipResourceType resourceType;

1348 union {

1349 hipMipmappedArray mipmap;

1350 hipArray_t array;

1351 } resource;

1352 hipArraySparseSubresourceType subresourceType;

1353 union {

1354 struct {

1355 unsigned int level;

1356 unsigned int layer;

1357 unsigned int offsetX;

1358 unsigned int offsetY;

1359 unsigned int offsetZ;

1360 unsigned int extentWidth;

1361 unsigned int extentHeight;

1362 unsigned int extentDepth;

1363 } sparseLevel;

1364 struct {

1365 unsigned int layer;

1366 unsigned long long offset;

1367 unsigned long long size;

1368 } miptail;

1369 } subresource;

1370 hipMemOperationType memOperationType;

1371 hipMemHandleType memHandleType;

1372 union {

1373 hipMemGenericAllocationHandle_t memHandle;

1374 } memHandle;

1375 unsigned long long offset;

1376 unsigned int deviceBitMask;

1377 unsigned int flags;

1378 unsigned int reserved[2];

1379} hipArrayMapInfo;

1380// Doxygen end group GlobalDefs

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

1403hipError_t hipInit(unsigned int flags);

1419hipError_t hipDriverGetVersion(int* driverVersion);

1434hipError_t hipRuntimeGetVersion(int* runtimeVersion);

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

1443

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

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

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

1483hipError_t hipDeviceGetP2PAttribute(int* value, hipDeviceP2PAttr attr,

1484 int srcDevice, int dstDevice);

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

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

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

1510// doxygen end initialization

1529hipError_t hipDeviceSynchronize(void);

1541hipError_t hipDeviceReset(void);

1573hipError_t hipSetDevice(int deviceId);

1587hipError_t hipGetDevice(int* deviceId);

1600hipError_t hipGetDeviceCount(int* count);

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

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

1647hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool);

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

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

1693hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig);

1704hipError_t hipDeviceGetCacheConfig(hipFuncCache_t* cacheConfig);

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

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

1741hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig* pConfig);

1749hipError_t hipGetDeviceFlags(unsigned int* flags);

1761hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config);

1786hipError_t hipSetDeviceFlags(unsigned flags);

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

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

1809// TODO: implement IPC apis

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

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

1897hipError_t hipIpcCloseMemHandle(void* devPtr);

1898

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

1916

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

1935

1936// end doxygen Device

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

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

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

1986//doxygen end execution

2008hipError_t hipGetLastError(void);

2019hipError_t hipPeekAtLastError(void);

2028const char* hipGetErrorName(hipError_t hip_error);

2037const char* hipGetErrorString(hipError_t hipError);

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

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

2058// end doxygen Error

2088hipError_t hipStreamCreate(hipStream_t* stream);

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

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

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

2155hipError_t hipStreamDestroy(hipStream_t stream);

2171hipError_t hipStreamQuery(hipStream_t stream);

2191hipError_t hipStreamSynchronize(hipStream_t stream);

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

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

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

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

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

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

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

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

2304 unsigned int flags);

2305// end doxygen Stream

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

2349 uint32_t mask __dparm(0xFFFFFFFF));

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

2383 uint64_t mask __dparm(0xFFFFFFFFFFFFFFFF));

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

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

2424// end doxygen Stream Memory Operations

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

2472hipError_t hipEventCreate(hipEvent_t* event);

2500#ifdef __cplusplus

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

2502#else

2503hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream);

2504#endif

2521hipError_t hipEventDestroy(hipEvent_t event);

2539hipError_t hipEventSynchronize(hipEvent_t event);

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

2584hipError_t hipEventQuery(hipEvent_t event);

2585// end doxygen Events

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

2617 hipDeviceptr_t ptr);

2618

2619

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

2653hipError_t hipPointerGetAttribute(void* data, hipPointer_attribute attribute,

2654 hipDeviceptr_t ptr);

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

2672 void** data, hipDeviceptr_t ptr);

2693hipError_t hipImportExternalSemaphore(hipExternalSemaphore_t* extSem_out,

2694 const hipExternalSemaphoreHandleDesc* semHandleDesc);

2707hipError_t hipSignalExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

2708 const hipExternalSemaphoreSignalParams* paramsArray,

2709 unsigned int numExtSems, hipStream_t stream);

2722hipError_t hipWaitExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

2723 const hipExternalSemaphoreWaitParams* paramsArray,

2724 unsigned int numExtSems, hipStream_t stream);

2734hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem);

2735

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

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

2768hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem);

2782 // end of external resource

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

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

2814DEPRECATED("use hipHostMalloc instead")

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

2828DEPRECATED("use hipHostMalloc instead")

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

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

2894hipError_t hipMallocManaged(void** dev_ptr,

2895 size_t size,

2896 unsigned int flags __dparm(hipMemAttachGlobal));

2909hipError_t hipMemPrefetchAsync(const void* dev_ptr,

2910 size_t count,

2911 int device,

2912 hipStream_t stream __dparm(0));

2931hipError_t hipMemAdvise(const void* dev_ptr,

2932 size_t count,

2933 hipMemoryAdvise advice,

2934 int device);

2949hipError_t hipMemRangeGetAttribute(void* data,

2950 size_t data_size,

2951 hipMemRangeAttribute attribute,

2952 const void* dev_ptr,

2953 size_t count);

2970hipError_t hipMemRangeGetAttributes(void** data,

2971 size_t* data_sizes,

2972 hipMemRangeAttribute* attributes,

2973 size_t num_attributes,

2974 const void* dev_ptr,

2975 size_t count);

2990hipError_t hipStreamAttachMemAsync(hipStream_t stream,

2991 void* dev_ptr,

2992 size_t length __dparm(0),

2993 unsigned int flags __dparm(hipMemAttachSingle));

2994// end doxygen Managed Memory

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

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

3107hipError_t hipMemPoolTrimTo(hipMemPool_t mem_pool, size_t min_bytes_to_hold);

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

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

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

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

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

3274hipError_t hipMemPoolDestroy(hipMemPool_t mem_pool);

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

3335hipError_t hipMemPoolExportToShareableHandle(

3336 void* shared_handle,

3337 hipMemPool_t mem_pool,

3338 hipMemAllocationHandleType handle_type,

3339 unsigned int flags);

3363hipError_t hipMemPoolImportFromShareableHandle(

3364 hipMemPool_t* mem_pool,

3365 void* shared_handle,

3366 hipMemAllocationHandleType handle_type,

3367 unsigned int flags);

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

3416hipError_t hipMemPoolImportPointer(

3417 void** dev_ptr,

3418 hipMemPool_t mem_pool,

3419 hipMemPoolPtrExportData* export_data);

3420// Doxygen end of ordered memory allocator

3438DEPRECATED("use hipHostMalloc instead")

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

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

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

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

3507hipError_t hipHostUnregister(void* hostPtr);

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

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

3562hipError_t hipFree(void* ptr);

3572DEPRECATED("use hipHostFree instead")

3573hipError_t hipFreeHost(void* ptr);

3587hipError_t hipHostFree(void* ptr);

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

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

3633 hipMemcpyKind kind, hipStream_t stream);

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

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

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

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

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

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

3742 hipStream_t stream);

3743

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

3759 hipModule_t hmod, const char* name);

3760

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

3771

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

3782

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

3802 size_t sizeBytes, size_t offset __dparm(0),

3803 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice));

3804

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

3819 size_t sizeBytes, size_t offset,

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

3821

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

3835 size_t sizeBytes, size_t offset __dparm(0),

3836 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost));

3837

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

3852 size_t sizeBytes, size_t offset,

3853 hipMemcpyKind kind,

3854 hipStream_t stream __dparm(0));

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

3884 hipStream_t stream __dparm(0));

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

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

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

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

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

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

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

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

3989 hipStream_t stream __dparm(0));

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

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

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

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

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

4049

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

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

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

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

4096hipError_t hipArrayDestroy(hipArray* array);

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

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

4127hipError_t hipFreeArray(hipArray* array);

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

4140 struct hipExtent extent, unsigned int flags);

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

4154 hipArray* array);

4172hipError_t hipArrayGetDescriptor(HIP_ARRAY_DESCRIPTOR* pArrayDescriptor, hipArray* array);

4190hipError_t hipArray3DGetDescriptor(HIP_ARRAY3D_DESCRIPTOR* pArrayDescriptor, hipArray* array);

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

4208 size_t height, hipMemcpyKind kind);

4218hipError_t hipMemcpyParam2D(const hip_Memcpy2D* pCopy);

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

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

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

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

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

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

4287 size_t spitch, size_t width, size_t height, hipMemcpyKind kind,

4288 hipStream_t stream __dparm(0));

4306DEPRECATED(DEPRECATED_MSG)

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

4308 size_t count, hipMemcpyKind kind);

4326DEPRECATED(DEPRECATED_MSG)

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

4328 size_t count, hipMemcpyKind kind);

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

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

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

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

4404hipError_t hipMemcpy3D(const struct hipMemcpy3DParms* p);

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

4427hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D* pCopy);

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

4440// doxygen end Memory

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

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

4497hipError_t hipDeviceDisablePeerAccess(int peerDeviceId);

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

4511#ifndef USE_PEER_NON_UNIFIED

4512#define USE_PEER_NON_UNIFIED 1

4513#endif

4514#if USE_PEER_NON_UNIFIED == 1

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

4527 size_t sizeBytes);

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

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

4542#endif

4543// doxygen end PeerToPeer

4575DEPRECATED(DEPRECATED_MSG)

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

4589DEPRECATED(DEPRECATED_MSG)

4590hipError_t hipCtxDestroy(hipCtx_t ctx);

4603DEPRECATED(DEPRECATED_MSG)

4604hipError_t hipCtxPopCurrent(hipCtx_t* ctx);

4617DEPRECATED(DEPRECATED_MSG)

4618hipError_t hipCtxPushCurrent(hipCtx_t ctx);

4631DEPRECATED(DEPRECATED_MSG)

4632hipError_t hipCtxSetCurrent(hipCtx_t ctx);

4645DEPRECATED(DEPRECATED_MSG)

4646hipError_t hipCtxGetCurrent(hipCtx_t* ctx);

4659DEPRECATED(DEPRECATED_MSG)

4660hipError_t hipCtxGetDevice(hipDevice_t* device);

4680DEPRECATED(DEPRECATED_MSG)

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

4697DEPRECATED(DEPRECATED_MSG)

4698hipError_t hipCtxGetCacheConfig(hipFuncCache_t* cacheConfig);

4714DEPRECATED(DEPRECATED_MSG)

4715hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig);

4731DEPRECATED(DEPRECATED_MSG)

4732hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config);

4748DEPRECATED(DEPRECATED_MSG)

4749hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig* pConfig);

4763DEPRECATED(DEPRECATED_MSG)

4764hipError_t hipCtxSynchronize(void);

4777DEPRECATED(DEPRECATED_MSG)

4778hipError_t hipCtxGetFlags(unsigned int* flags);

4800DEPRECATED(DEPRECATED_MSG)

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

4820DEPRECATED(DEPRECATED_MSG)

4821hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx);

4822// doxygen end Context deprecated

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

4851hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev);

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

4875hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev);

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

4888// doxygen end Context Management

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

4925hipError_t hipModuleUnload(hipModule_t module);

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

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

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

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

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

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

4989 hipJitOption* options, void** optionValues);

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

5019 unsigned int gridDimZ, unsigned int blockDimX,

5020 unsigned int blockDimY, unsigned int blockDimZ,

5021 unsigned int sharedMemBytes, hipStream_t stream,

5022 void** kernelParams, void** extra);

5048hipError_t hipModuleLaunchCooperativeKernel(hipFunction_t f, unsigned int gridDimX,

5049 unsigned int gridDimY, unsigned int gridDimZ,

5050 unsigned int blockDimX, unsigned int blockDimY,

5051 unsigned int blockDimZ, unsigned int sharedMemBytes,

5052 hipStream_t stream, void** kernelParams);

5067hipError_t hipModuleLaunchCooperativeKernelMultiDevice(hipFunctionLaunchParams* launchParamsList,

5068 unsigned int numDevices,

5069 unsigned int flags);

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

5089 void** kernelParams, unsigned int sharedMemBytes,

5090 hipStream_t stream);

5101hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

5102 int numDevices, unsigned int flags);

5114hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

5115 int numDevices, unsigned int flags);

5116// doxygen end Module

5143//TODO - Match CUoccupancyB2DSize

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

5145 hipFunction_t f, size_t dynSharedMemPerBlk,

5146 int blockSizeLimit);

5162//TODO - Match CUoccupancyB2DSize

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

5164 hipFunction_t f, size_t dynSharedMemPerBlk,

5165 int blockSizeLimit, unsigned int flags);

5174hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(

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

5185hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

5195hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(

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

5206hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

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

5223 const void* f, size_t dynSharedMemPerBlk,

5224 int blockSizeLimit);

5225// doxygen end Occupancy

5239// TODO - expand descriptions:

5245DEPRECATED("use roctracer/rocTX instead")

5246hipError_t hipProfilerStart();

5252DEPRECATED("use roctracer/rocTX instead")

5253hipError_t hipProfilerStop();

5254// doxygen end profiler

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

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

5301hipError_t hipLaunchByPtr(const void* func);

5318hipError_t __hipPushCallConfiguration(dim3 gridDim,

5319 dim3 blockDim,

5320 size_t sharedMem __dparm(0),

5321 hipStream_t stream __dparm(0));

5341hipError_t __hipPopCallConfiguration(dim3 *gridDim,

5342 dim3 *blockDim,

5343 size_t *sharedMem,

5344 hipStream_t *stream);

5360hipError_t hipLaunchKernel(const void* function_address,

5361 dim3 numBlocks,

5362 dim3 dimBlocks,

5363 void** args,

5364 size_t sharedMemBytes __dparm(0),

5365 hipStream_t stream __dparm(0));

5366

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

5379

5387hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D* pCopy);

5388//TODO: Move this to hip_ext.h

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

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

5411 hipEvent_t startEvent, hipEvent_t stopEvent, int flags);

5412// doxygen end Clang launch

5438hipError_t hipCreateTextureObject(

5439 hipTextureObject_t* pTexObject,

5440 const hipResourceDesc* pResDesc,

5441 const hipTextureDesc* pTexDesc,

5442 const struct hipResourceViewDesc* pResViewDesc);

5443

5452hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject);

5453

5463hipError_t hipGetChannelDesc(

5464 hipChannelFormatDesc* desc,

5465 hipArray_const_t array);

5466

5476hipError_t hipGetTextureObjectResourceDesc(

5477 hipResourceDesc* pResDesc,

5478 hipTextureObject_t textureObject);

5479

5489hipError_t hipGetTextureObjectResourceViewDesc(

5490 struct hipResourceViewDesc* pResViewDesc,

5491 hipTextureObject_t textureObject);

5492

5502hipError_t hipGetTextureObjectTextureDesc(

5503 hipTextureDesc* pTexDesc,

5504 hipTextureObject_t textureObject);

5505

5517hipError_t hipTexObjectCreate(

5518 hipTextureObject_t* pTexObject,

5519 const HIP_RESOURCE_DESC* pResDesc,

5520 const HIP_TEXTURE_DESC* pTexDesc,

5521 const HIP_RESOURCE_VIEW_DESC* pResViewDesc);

5522

5531hipError_t hipTexObjectDestroy(

5532 hipTextureObject_t texObject);

5533

5543hipError_t hipTexObjectGetResourceDesc(

5544 HIP_RESOURCE_DESC* pResDesc,

5545 hipTextureObject_t texObject);

5546

5556hipError_t hipTexObjectGetResourceViewDesc(

5557 HIP_RESOURCE_VIEW_DESC* pResViewDesc,

5558 hipTextureObject_t texObject);

5559

5569hipError_t hipTexObjectGetTextureDesc(

5570 HIP_TEXTURE_DESC* pTexDesc,

5571 hipTextureObject_t texObject);

5572

5587hipError_t hipMallocMipmappedArray(

5588 hipMipmappedArray_t *mipmappedArray,

5589 const struct hipChannelFormatDesc* desc,

5590 struct hipExtent extent,

5591 unsigned int numLevels,

5592 unsigned int flags __dparm(0));

5593

5604hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray);

5605

5618hipError_t hipGetMipmappedArrayLevel(

5619 hipArray_t *levelArray,

5620 hipMipmappedArray_const_t mipmappedArray,

5621 unsigned int level);

5622

5634hipError_t hipMipmappedArrayCreate(

5635 hipMipmappedArray_t* pHandle,

5636 HIP_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc,

5637 unsigned int numMipmapLevels);

5638

5649hipError_t hipMipmappedArrayDestroy(hipMipmappedArray_t hMipmappedArray);

5650

5663hipError_t hipMipmappedArrayGetLevel(

5664 hipArray_t* pLevelArray,

5665 hipMipmappedArray_t hMipMappedArray,

5666 unsigned int level);

5667

5686DEPRECATED(DEPRECATED_MSG)

5687hipError_t hipBindTextureToMipmappedArray(

5688 const textureReference* tex,

5689 hipMipmappedArray_const_t mipmappedArray,

5690 const hipChannelFormatDesc* desc);

5691

5702DEPRECATED(DEPRECATED_MSG)

5703 hipError_t hipGetTextureReference(

5704 const textureReference** texref,

5705 const void* symbol);

5717DEPRECATED(DEPRECATED_MSG)

5718hipError_t hipTexRefSetAddressMode(

5719 textureReference* texRef,

5720 int dim,

5721 enum hipTextureAddressMode am);

5734DEPRECATED(DEPRECATED_MSG)

5735hipError_t hipTexRefSetArray(

5736 textureReference* tex,

5737 hipArray_const_t array,

5738 unsigned int flags);

5750DEPRECATED(DEPRECATED_MSG)

5751hipError_t hipTexRefSetFilterMode(

5752 textureReference* texRef,

5753 enum hipTextureFilterMode fm);

5765DEPRECATED(DEPRECATED_MSG)

5766hipError_t hipTexRefSetFlags(

5767 textureReference* texRef,

5768 unsigned int Flags);

5781DEPRECATED(DEPRECATED_MSG)

5782hipError_t hipTexRefSetFormat(

5783 textureReference* texRef,

5784 hipArray_Format fmt,

5785 int NumPackedComponents);

5798DEPRECATED(DEPRECATED_MSG)

5799hipError_t hipBindTexture(

5800 size_t* offset,

5801 const textureReference* tex,

5802 const void* devPtr,

5803 const hipChannelFormatDesc* desc,

5804 size_t size __dparm(UINT_MAX));

5819DEPRECATED(DEPRECATED_MSG)

5820hipError_t hipBindTexture2D(

5821 size_t* offset,

5822 const textureReference* tex,

5823 const void* devPtr,

5824 const hipChannelFormatDesc* desc,

5825 size_t width,

5826 size_t height,

5827 size_t pitch);

5838DEPRECATED(DEPRECATED_MSG)

5839hipError_t hipBindTextureToArray(

5840 const textureReference* tex,

5841 hipArray_const_t array,

5842 const hipChannelFormatDesc* desc);

5852DEPRECATED(DEPRECATED_MSG)

5853hipError_t hipGetTextureAlignmentOffset(

5854 size_t* offset,

5855 const textureReference* texref);

5864DEPRECATED(DEPRECATED_MSG)

5865hipError_t hipUnbindTexture(const textureReference* tex);

5875DEPRECATED(DEPRECATED_MSG)

5876hipError_t hipTexRefGetAddress(

5877 hipDeviceptr_t* dev_ptr,

5878 const textureReference* texRef);

5889DEPRECATED(DEPRECATED_MSG)

5890hipError_t hipTexRefGetAddressMode(

5891 enum hipTextureAddressMode* pam,

5892 const textureReference* texRef,

5893 int dim);

5903DEPRECATED(DEPRECATED_MSG)

5904hipError_t hipTexRefGetFilterMode(

5905 enum hipTextureFilterMode* pfm,

5906 const textureReference* texRef);

5916DEPRECATED(DEPRECATED_MSG)

5917hipError_t hipTexRefGetFlags(

5918 unsigned int* pFlags,

5919 const textureReference* texRef);

5930DEPRECATED(DEPRECATED_MSG)

5931hipError_t hipTexRefGetFormat(

5932 hipArray_Format* pFormat,

5933 int* pNumChannels,

5934 const textureReference* texRef);

5944DEPRECATED(DEPRECATED_MSG)

5945hipError_t hipTexRefGetMaxAnisotropy(

5946 int* pmaxAnsio,

5947 const textureReference* texRef);

5957DEPRECATED(DEPRECATED_MSG)

5958hipError_t hipTexRefGetMipmapFilterMode(

5959 enum hipTextureFilterMode* pfm,

5960 const textureReference* texRef);

5970DEPRECATED(DEPRECATED_MSG)

5971hipError_t hipTexRefGetMipmapLevelBias(

5972 float* pbias,

5973 const textureReference* texRef);

5984DEPRECATED(DEPRECATED_MSG)

5985hipError_t hipTexRefGetMipmapLevelClamp(

5986 float* pminMipmapLevelClamp,

5987 float* pmaxMipmapLevelClamp,

5988 const textureReference* texRef);

5998DEPRECATED(DEPRECATED_MSG)

5999hipError_t hipTexRefGetMipMappedArray(

6000 hipMipmappedArray_t* pArray,

6001 const textureReference* texRef);

6013DEPRECATED(DEPRECATED_MSG)

6014hipError_t hipTexRefSetAddress(

6015 size_t* ByteOffset,

6016 textureReference* texRef,

6017 hipDeviceptr_t dptr,

6018 size_t bytes);

6030DEPRECATED(DEPRECATED_MSG)

6031hipError_t hipTexRefSetAddress2D(

6032 textureReference* texRef,

6033 const HIP_ARRAY_DESCRIPTOR* desc,

6034 hipDeviceptr_t dptr,

6035 size_t Pitch);

6045DEPRECATED(DEPRECATED_MSG)

6046hipError_t hipTexRefSetMaxAnisotropy(

6047 textureReference* texRef,

6048 unsigned int maxAniso);

6058DEPRECATED(DEPRECATED_MSG)

6059hipError_t hipTexRefSetBorderColor(

6060 textureReference* texRef,

6061 float* pBorderColor);

6071DEPRECATED(DEPRECATED_MSG)

6072hipError_t hipTexRefSetMipmapFilterMode(

6073 textureReference* texRef,

6074 enum hipTextureFilterMode fm);

6084DEPRECATED(DEPRECATED_MSG)

6085hipError_t hipTexRefSetMipmapLevelBias(

6086 textureReference* texRef,

6087 float bias);

6098DEPRECATED(DEPRECATED_MSG)

6099hipError_t hipTexRefSetMipmapLevelClamp(

6100 textureReference* texRef,

6101 float minMipMapLevelClamp,

6102 float maxMipMapLevelClamp);

6113DEPRECATED(DEPRECATED_MSG)

6114hipError_t hipTexRefSetMipmappedArray(

6115 textureReference* texRef,

6116 struct hipMipmappedArray* mipmappedArray,

6117 unsigned int Flags);

6118

6119// doxygen end deprecated texture management

6124// doxygen end Texture management

6136// This group is for HIPrtc

6137

6138// doxygen end Runtime

6157const char* hipApiName(uint32_t id);

6166const char* hipKernelNameRef(const hipFunction_t f);

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

6185int hipGetStreamDeviceId(hipStream_t stream);

6186

6187// doxygen end Callback

6212hipError_t hipStreamBeginCapture(hipStream_t stream, hipStreamCaptureMode mode);

6213

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

6227

6241hipError_t hipStreamGetCaptureInfo(hipStream_t stream, hipStreamCaptureStatus* pCaptureStatus,

6242 unsigned long long* pId);

6243

6260hipError_t hipStreamGetCaptureInfo_v2(hipStream_t stream, hipStreamCaptureStatus* captureStatus_out,

6261 unsigned long long* id_out __dparm(0),

6262 hipGraph_t* graph_out __dparm(0),

6263 const hipGraphNode_t** dependencies_out __dparm(0),

6264 size_t* numDependencies_out __dparm(0));

6265

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

6279

6292hipError_t hipStreamUpdateCaptureDependencies(hipStream_t stream, hipGraphNode_t* dependencies,

6293 size_t numDependencies,

6294 unsigned int flags __dparm(0));

6295

6306hipError_t hipThreadExchangeStreamCaptureMode(hipStreamCaptureMode* mode);

6307

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

6321

6333hipError_t hipGraphDestroy(hipGraph_t graph);

6334

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

6349 const hipGraphNode_t* to, size_t numDependencies);

6350

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

6365 const hipGraphNode_t* to, size_t numDependencies);

6366

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

6385 size_t* numEdges);

6386

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

6404

6421hipError_t hipGraphGetRootNodes(hipGraph_t graph, hipGraphNode_t* pRootNodes,

6422 size_t* pNumRootNodes);

6423

6440hipError_t hipGraphNodeGetDependencies(hipGraphNode_t node, hipGraphNode_t* pDependencies,

6441 size_t* pNumDependencies);

6442

6460hipError_t hipGraphNodeGetDependentNodes(hipGraphNode_t node, hipGraphNode_t* pDependentNodes,

6461 size_t* pNumDependentNodes);

6462

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

6475

6486hipError_t hipGraphDestroyNode(hipGraphNode_t node);

6487

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

6500

6513hipError_t hipGraphNodeFindInClone(hipGraphNode_t* pNode, hipGraphNode_t originalNode,

6514 hipGraph_t clonedGraph);

6515

6532hipError_t hipGraphInstantiate(hipGraphExec_t* pGraphExec, hipGraph_t graph,

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

6534

6547hipError_t hipGraphInstantiateWithFlags(hipGraphExec_t* pGraphExec, hipGraph_t graph,

6548 unsigned long long flags);

6549

6560hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream);

6561

6572hipError_t hipGraphUpload(hipGraphExec_t graphExec, hipStream_t stream);

6573

6584hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec);

6585

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

6600hipError_t hipGraphExecUpdate(hipGraphExec_t hGraphExec, hipGraph_t hGraph,

6601 hipGraphNode_t* hErrorNode_out,

6602 hipGraphExecUpdateResult* updateResult_out);

6603

6616hipError_t hipGraphAddKernelNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

6617 const hipGraphNode_t* pDependencies, size_t numDependencies,

6618 const hipKernelNodeParams* pNodeParams);

6619

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

6630

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

6641

6652hipError_t hipGraphExecKernelNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

6653 const hipKernelNodeParams* pNodeParams);

6654

6667hipError_t hipGraphAddMemcpyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

6668 const hipGraphNode_t* pDependencies, size_t numDependencies,

6669 const hipMemcpy3DParms* pCopyParams);

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

6680

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

6691

6702hipError_t hipGraphKernelNodeSetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

6703 const hipKernelNodeAttrValue* value);

6714hipError_t hipGraphKernelNodeGetAttribute(hipGraphNode_t hNode, hipKernelNodeAttrID attr,

6715 hipKernelNodeAttrValue* value);

6726hipError_t hipGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

6727 hipMemcpy3DParms* pNodeParams);

6728

6744hipError_t hipGraphAddMemcpyNode1D(hipGraphNode_t* pGraphNode, hipGraph_t graph,

6745 const hipGraphNode_t* pDependencies, size_t numDependencies,

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

6747

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

6761 size_t count, hipMemcpyKind kind);

6762

6777hipError_t hipGraphExecMemcpyNodeSetParams1D(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

6779 hipMemcpyKind kind);

6780

6797hipError_t hipGraphAddMemcpyNodeFromSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

6798 const hipGraphNode_t* pDependencies,

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

6800 size_t count, size_t offset, hipMemcpyKind kind);

6801

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

6816 size_t count, size_t offset, hipMemcpyKind kind);

6817

6833hipError_t hipGraphExecMemcpyNodeSetParamsFromSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

6835 size_t offset, hipMemcpyKind kind);

6836

6853hipError_t hipGraphAddMemcpyNodeToSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

6854 const hipGraphNode_t* pDependencies,

6855 size_t numDependencies, const void* symbol,

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

6857 hipMemcpyKind kind);

6858

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

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

6874 hipMemcpyKind kind);

6875

6876

6891hipError_t hipGraphExecMemcpyNodeSetParamsToSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

6892 const void* symbol, const void* src,

6893 size_t count, size_t offset, hipMemcpyKind kind);

6894

6907hipError_t hipGraphAddMemsetNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

6908 const hipGraphNode_t* pDependencies, size_t numDependencies,

6909 const hipMemsetParams* pMemsetParams);

6910

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

6921

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

6932

6943hipError_t hipGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

6944 const hipMemsetParams* pNodeParams);

6945

6958hipError_t hipGraphAddHostNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

6959 const hipGraphNode_t* pDependencies, size_t numDependencies,

6960 const hipHostNodeParams* pNodeParams);

6961

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

6972

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

6983

6994hipError_t hipGraphExecHostNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

6995 const hipHostNodeParams* pNodeParams);

6996

7009hipError_t hipGraphAddChildGraphNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7010 const hipGraphNode_t* pDependencies, size_t numDependencies,

7011 hipGraph_t childGraph);

7012

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

7023

7034hipError_t hipGraphExecChildGraphNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

7035 hipGraph_t childGraph);

7036

7048hipError_t hipGraphAddEmptyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7049 const hipGraphNode_t* pDependencies, size_t numDependencies);

7050

7051

7064hipError_t hipGraphAddEventRecordNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7065 const hipGraphNode_t* pDependencies, size_t numDependencies,

7066 hipEvent_t event);

7067

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

7078

7088hipError_t hipGraphEventRecordNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

7089

7100hipError_t hipGraphExecEventRecordNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

7101 hipEvent_t event);

7102

7115hipError_t hipGraphAddEventWaitNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7116 const hipGraphNode_t* pDependencies, size_t numDependencies,

7117 hipEvent_t event);

7118

7119

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

7130

7140hipError_t hipGraphEventWaitNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

7141

7152hipError_t hipGraphExecEventWaitNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

7153 hipEvent_t event);

7154

7167hipError_t hipGraphAddMemAllocNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

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

7169

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

7180

7193hipError_t hipGraphAddMemFreeNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

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

7195

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

7206

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

7218

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

7230

7238hipError_t hipDeviceGraphMemTrim(int device);

7239

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

7253 unsigned int initialRefcount, unsigned int flags);

7254

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

7265

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

7276

7288hipError_t hipGraphRetainUserObject(hipGraph_t graph, hipUserObject_t object,

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

7290

7301hipError_t hipGraphReleaseUserObject(hipGraph_t graph, hipUserObject_t object,

7302 unsigned int count __dparm(1));

7303

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

7315

7330hipError_t hipGraphKernelNodeCopyAttributes(hipGraphNode_t hSrc, hipGraphNode_t hDst);

7331

7354hipError_t hipGraphNodeSetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

7355 unsigned int isEnabled);

7376hipError_t hipGraphNodeGetEnabled(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

7377 unsigned int* isEnabled);

7378

7391hipError_t hipGraphAddExternalSemaphoresWaitNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7392 const hipGraphNode_t* pDependencies, size_t numDependencies,

7393 const hipExternalSemaphoreWaitNodeParams* nodeParams);

7394

7407hipError_t hipGraphAddExternalSemaphoresSignalNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

7408 const hipGraphNode_t* pDependencies, size_t numDependencies,

7409 const hipExternalSemaphoreSignalNodeParams* nodeParams);

7419hipError_t hipGraphExternalSemaphoresSignalNodeSetParams(hipGraphNode_t hNode,

7420 const hipExternalSemaphoreSignalNodeParams* nodeParams);

7430hipError_t hipGraphExternalSemaphoresWaitNodeSetParams(hipGraphNode_t hNode,

7431 const hipExternalSemaphoreWaitNodeParams* nodeParams);

7441hipError_t hipGraphExternalSemaphoresSignalNodeGetParams(hipGraphNode_t hNode,

7442 const hipExternalSemaphoreSignalNodeParams* params_out);

7452hipError_t hipGraphExternalSemaphoresWaitNodeGetParams(hipGraphNode_t hNode,

7453 const hipExternalSemaphoreWaitNodeParams* params_out);

7464hipError_t hipGraphExecExternalSemaphoresSignalNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

7465 const hipExternalSemaphoreSignalNodeParams* nodeParams);

7476hipError_t hipGraphExecExternalSemaphoresWaitNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

7477 const hipExternalSemaphoreWaitNodeParams* nodeParams);

7478// doxygen end graph API

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

7507

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

7523

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

7538

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

7553

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

7567

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

7582

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

7595

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

7609

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

7625

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

7639

7650hipError_t hipMemRelease(hipMemGenericAllocationHandle_t handle);

7651

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

7664

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

7679

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

7692

7693// doxygen end virtual memory management API

7706typedef unsigned int GLuint;

7708typedef unsigned int GLenum;

7709

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

7724 unsigned int hipDeviceCount, hipGLDeviceList deviceList);

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

7736 unsigned int flags);

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

7749 GLenum target, unsigned int flags);

7760hipError_t hipGraphicsMapResources(int count, hipGraphicsResource_t* resources,

7761 hipStream_t stream __dparm(0) );

7775hipError_t hipGraphicsSubResourceGetMappedArray(hipArray_t* array, hipGraphicsResource_t resource,

7776 unsigned int arrayIndex, unsigned int mipLevel);

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

7788 hipGraphicsResource_t resource);

7799hipError_t hipGraphicsUnmapResources(int count, hipGraphicsResource_t* resources,

7800 hipStream_t stream __dparm(0));

7809hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource);

7810// doxygen end GL Interop

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

7844hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject);

7845// end of surface

7849#ifdef __cplusplus

7850} /* extern "c" */

7851#endif

7852#ifdef __cplusplus

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

7854template <typename T>

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

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

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

7858}

7859template <typename T>

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

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

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

7863}

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

7865

7875template <typename T>

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

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

7878}

7889template <typename T>

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

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

7892}

7893

7902template <typename T>

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

7904 size_t offset __dparm(0),

7905 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice)) {

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

7907}

7916template <typename T>

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

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

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

7920}

7928template <typename T>

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

7930 size_t sizeBytes, size_t offset __dparm(0),

7931 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost)) {

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

7933}

7941template <typename T>

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

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

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

7945}

7946

7958template <class T>

7959inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(

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

7961 return hipOccupancyMaxActiveBlocksPerMultiprocessor(

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

7963}

7977template <class T>

7978inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

7980 return hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

7982}

8003template<typename UnaryFunction, class T>

8004static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(

8005 int* min_grid_size,

8006 int* block_size,

8007 T func,

8008 UnaryFunction block_size_to_dynamic_smem_size,

8009 int block_size_limit = 0,

8010 unsigned int flags = 0) {

8011 if (min_grid_size == nullptr || block_size == nullptr ||

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

8013 return hipErrorInvalidValue;

8014 }

8015

8016 int dev;

8017 hipError_t status;

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

8019 return status;

8020 }

8021

8022 int max_threads_per_cu;

8023 if ((status = hipDeviceGetAttribute(&max_threads_per_cu,

8024 hipDeviceAttributeMaxThreadsPerMultiProcessor, dev)) != hipSuccess) {

8025 return status;

8026 }

8027

8028 int warp_size;

8029 if ((status = hipDeviceGetAttribute(&warp_size,

8030 hipDeviceAttributeWarpSize, dev)) != hipSuccess) {

8031 return status;

8032 }

8033

8034 int max_cu_count;

8035 if ((status = hipDeviceGetAttribute(&max_cu_count,

8036 hipDeviceAttributeMultiprocessorCount, dev)) != hipSuccess) {

8037 return status;

8038 }

8039

8040 struct hipFuncAttributes attr;

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

8042 return status;

8043 }

8044

8045 // Initial limits for the execution

8046 const int func_max_threads_per_block = attr.maxThreadsPerBlock;

8047 if (block_size_limit == 0) {

8048 block_size_limit = func_max_threads_per_block;

8049 }

8050

8051 if (func_max_threads_per_block < block_size_limit) {

8052 block_size_limit = func_max_threads_per_block;

8053 }

8054

8055 const int block_size_limit_aligned =

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

8057

8058 // For maximum search

8059 int max_threads = 0;

8060 int max_block_size{};

8061 int max_num_blocks{};

8062 for (int block_size_check_aligned = block_size_limit_aligned;

8063 block_size_check_aligned > 0;

8064 block_size_check_aligned -= warp_size) {

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

8066 int block_size_check = (block_size_limit < block_size_check_aligned) ?

8067 block_size_limit : block_size_check_aligned;

8068

8069 size_t dyn_smem_size = block_size_to_dynamic_smem_size(block_size_check);

8070 int optimal_blocks;

8071 if ((status = hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

8073 return status;

8074 }

8075

8076 int total_threads = block_size_check * optimal_blocks;

8077 if (total_threads > max_threads) {

8078 max_block_size = block_size_check;

8079 max_num_blocks = optimal_blocks;

8080 max_threads = total_threads;

8081 }

8082

8083 // Break if the logic reached possible maximum

8084 if (max_threads_per_cu == max_threads) {

8085 break;

8086 }

8087 }

8088

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

8090 *min_grid_size = max_num_blocks * max_cu_count;

8091 *block_size = max_block_size;

8092

8093 return status;

8094}

8095

8115template<typename UnaryFunction, class T>

8116static hipError_t __host__ inline hipOccupancyMaxPotentialBlockSizeVariableSMem(

8117 int* min_grid_size,

8118 int* block_size,

8119 T func,

8120 UnaryFunction block_size_to_dynamic_smem_size,

8121 int block_size_limit = 0)

8122{

8123 return hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags(min_grid_size, block_size, func,

8124 block_size_to_dynamic_smem_size, block_size_limit);

8125}

8140template <typename F>

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

8142 F kernel, size_t dynSharedMemPerBlk, uint32_t blockSizeLimit) {

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

8144}

8161template <class T>

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

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

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

8165 blockDim, kernelParams, sharedMemBytes, stream);

8166}

8181template <class T>

8182inline hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

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

8184 return hipLaunchCooperativeKernelMultiDevice(launchParamsList, numDevices, flags);

8185}

8200template <class T>

8201inline hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

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

8203 return hipExtLaunchMultiKernelMultiDevice(launchParamsList, numDevices, flags);

8204}

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

8217DEPRECATED(DEPRECATED_MSG)

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

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

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

8221}

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

8235DEPRECATED(DEPRECATED_MSG)

8236static inline hipError_t

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

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

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

8240}

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

8255DEPRECATED(DEPRECATED_MSG)

8256static inline hipError_t hipBindTexture2D(

8257 size_t *offset,

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

8259 const void *devPtr,

8260 size_t width,

8261 size_t height,

8262 size_t pitch)

8263{

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

8265}

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

8281DEPRECATED(DEPRECATED_MSG)

8282static inline hipError_t hipBindTexture2D(

8283 size_t *offset,

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

8285 const void *devPtr,

8286 const struct hipChannelFormatDesc &desc,

8287 size_t width,

8288 size_t height,

8289 size_t pitch)

8290{

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

8292}

8293

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

8304DEPRECATED(DEPRECATED_MSG)

8305static inline hipError_t hipBindTextureToArray(

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

8307 hipArray_const_t array)

8308{

8309 struct hipChannelFormatDesc desc;

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

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

8312}

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

8324DEPRECATED(DEPRECATED_MSG)

8325static inline hipError_t hipBindTextureToArray(

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

8327 hipArray_const_t array,

8328 const struct hipChannelFormatDesc &desc)

8329{

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

8331}

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

8342DEPRECATED(DEPRECATED_MSG)

8343static inline hipError_t hipBindTextureToMipmappedArray(

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

8345 hipMipmappedArray_const_t mipmappedArray)

8346{

8347 struct hipChannelFormatDesc desc;

8348 hipArray_t levelArray;

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

8350 if (err != hipSuccess) {

8351 return err;

8352 }

8353 err = hipGetChannelDesc(&desc, levelArray);

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

8355}

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

8367DEPRECATED(DEPRECATED_MSG)

8368static inline hipError_t hipBindTextureToMipmappedArray(

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

8370 hipMipmappedArray_const_t mipmappedArray,

8371 const struct hipChannelFormatDesc &desc)

8372{

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

8374}

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

8384DEPRECATED(DEPRECATED_MSG)

8385static inline hipError_t hipUnbindTexture(

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

8387{

8388 return hipUnbindTexture(&tex);

8389}

8413static inline hipError_t hipMallocAsync(

8414 void** dev_ptr,

8415 size_t size,

8416 hipMemPool_t mem_pool,

8417 hipStream_t stream) {

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

8419}

8430template<class T>

8431static inline hipError_t hipMallocAsync(

8432 T** dev_ptr,

8433 size_t size,

8434 hipMemPool_t mem_pool,

8435 hipStream_t stream) {

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

8437}

8448template<class T>

8449static inline hipError_t hipMallocAsync(

8450 T** dev_ptr,

8451 size_t size,

8452 hipStream_t stream) {

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

8454}

8465template<class T>

8466static inline hipError_t hipMallocFromPoolAsync(

8467 T** dev_ptr,

8468 size_t size,

8469 hipMemPool_t mem_pool,

8470 hipStream_t stream) {

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

8472}

8476#endif // __cplusplus

8477

8478#ifdef __GNUC__

8479#pragma GCC visibility pop

8480#endif

8481

8482

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

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

8485#else

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

8487#endif

8488

8489

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

8502template <class T>

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

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

8505}

8518template <class T>

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

8520 unsigned int flags = hipHostMallocDefault) {

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

8522}

8537template <class T>

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

8539 unsigned int flags = hipMemAttachGlobal) {

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

8541}

8542

8543#endif

8544#endif

8545// doxygen end HIP API

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

8550

8551#if USE_PROF_API

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

8553#endif

driver_types.h

hipMemcpyKind

hipMemcpyKind

Definition driver_types.h:349

hipMemcpyDeviceToHost

@ hipMemcpyDeviceToHost

Device-to-Host Copy.

Definition driver_types.h:352

hipMemcpyHostToDevice

@ hipMemcpyHostToDevice

Host-to-Device Copy.

Definition driver_types.h:351

hipPointer_attribute

hipPointer_attribute

Definition driver_types.h:446

hipDeviceptr_t

void * hipDeviceptr_t

Definition driver_types.h:42

hipFunction_attribute

hipFunction_attribute

Definition driver_types.h:432

hipArray_Format

hipArray_Format

Definition driver_types.h:60

hipResourceType

hipResourceType

Definition driver_types.h:139

hipApiName

const char * hipApiName(uint32_t id)

Returns HIP API name by ID.

hipKernelNameRef

const char * hipKernelNameRef(const hipFunction_t f)

Returns kernel name reference by function name.

hipKernelNameRefByPtr

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

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

hipGetStreamDeviceId

int hipGetStreamDeviceId(hipStream_t stream)

Returns device ID on the stream.

hipSetupArgument

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

Set a kernel argument.

__hipPopCallConfiguration

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

Pop configuration of a kernel launch.

__hipPushCallConfiguration

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

Push configuration of a kernel launch.

hipLaunchHostFunc

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

Enqueues a host function call in a stream.

hipExtLaunchKernel

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

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

hipConfigureCall

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

Configure a kernel launch.

hipLaunchByPtr

hipError_t hipLaunchByPtr(const void *func)

Launch a kernel.

hipLaunchKernel

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

C compliant kernel launch API.

hipDrvMemcpy2DUnaligned

hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D *pCopy)

hipCtxGetFlags

hipError_t hipCtxGetFlags(unsigned int *flags)

Return flags used for creating default context.

hipCtxPopCurrent

hipError_t hipCtxPopCurrent(hipCtx_t *ctx)

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

hipCtxGetSharedMemConfig

hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig *pConfig)

Get Shared memory bank configuration.

hipCtxGetCurrent

hipError_t hipCtxGetCurrent(hipCtx_t *ctx)

Get the handle of the current/ default context.

hipCtxSetCacheConfig

hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig)

Set L1/Shared cache partition.

hipCtxSetCurrent

hipError_t hipCtxSetCurrent(hipCtx_t ctx)

Set the passed context as current/default.

hipCtxEnablePeerAccess

hipError_t hipCtxEnablePeerAccess(hipCtx_t peerCtx, unsigned int flags)

Enables direct access to memory allocations in a peer context.

hipCtxGetDevice

hipError_t hipCtxGetDevice(hipDevice_t *device)

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

hipCtxDestroy

hipError_t hipCtxDestroy(hipCtx_t ctx)

Destroy a HIP context.

hipCtxPushCurrent

hipError_t hipCtxPushCurrent(hipCtx_t ctx)

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

hipCtxGetCacheConfig

hipError_t hipCtxGetCacheConfig(hipFuncCache_t *cacheConfig)

Get Cache configuration for a specific function.

hipCtxCreate

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

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

hipCtxGetApiVersion

hipError_t hipCtxGetApiVersion(hipCtx_t ctx, int *apiVersion)

Returns the approximate HIP api version.

hipCtxSynchronize

hipError_t hipCtxSynchronize(void)

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

hipCtxSetSharedMemConfig

hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config)

Set Shared memory bank configuration.

hipCtxDisablePeerAccess

hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx)

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

hipDevicePrimaryCtxSetFlags

hipError_t hipDevicePrimaryCtxSetFlags(hipDevice_t dev, unsigned int flags)

Set flags for the primary context.

hipDevicePrimaryCtxGetState

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

Get the state of the primary context.

hipDevicePrimaryCtxRelease

hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev)

Release the primary context on the GPU.

hipDevicePrimaryCtxRetain

hipError_t hipDevicePrimaryCtxRetain(hipCtx_t *pctx, hipDevice_t dev)

Retain the primary context on the GPU.

hipDevicePrimaryCtxReset

hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev)

Resets the primary context on the GPU.

hipGetDeviceFlags

hipError_t hipGetDeviceFlags(unsigned int *flags)

Gets the flags set for current device.

hipIpcGetEventHandle

hipError_t hipIpcGetEventHandle(hipIpcEventHandle_t *handle, hipEvent_t event)

Gets an opaque interprocess handle for an event.

hipDeviceGetDefaultMemPool

hipError_t hipDeviceGetDefaultMemPool(hipMemPool_t *mem_pool, int device)

Returns the default memory pool of the specified device.

hipDeviceGetSharedMemConfig

hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig *pConfig)

Returns bank width of shared memory for current device.

hipDeviceSetMemPool

hipError_t hipDeviceSetMemPool(int device, hipMemPool_t mem_pool)

Sets the current memory pool of a device.

hipIpcOpenMemHandle

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

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

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.

hipDestroyExternalMemory

hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem)

Destroys an external memory object.

hipImportExternalSemaphore

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

Imports an external semaphore.

hipImportExternalMemory

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

Imports an external memory object.

hipDestroyExternalSemaphore

hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem)

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

hipWaitExternalSemaphoresAsync

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

Waits on a set of external semaphore objects.

hipSignalExternalSemaphoresAsync

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

Signals a set of external semaphore objects.

hipExternalMemoryGetMappedBuffer

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

Maps a buffer onto an imported memory object.

hipGLGetDevices

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

Queries devices associated with the current OpenGL context.

hipGraphicsGLRegisterImage

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

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

hipGraphicsUnregisterResource

hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource)

Unregisters a graphics resource.

hipGraphicsGLRegisterBuffer

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

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

hipGraphicsMapResources

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

Maps a graphics resource for access.

GLenum

unsigned int GLenum

Definition hip_runtime_api.h:7708

hipGraphicsSubResourceGetMappedArray

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

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

GLuint

unsigned int GLuint

Definition hip_runtime_api.h:7706

hipGraphicsUnmapResources

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

Unmaps graphics resources.

hipGraphicsResourceGetMappedPointer

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

Gets device accessible address of a graphics resource.

hipLimit_t

hipLimit_t

Definition hip_runtime_api.h:558

hipMemAllocationHandleType

hipMemAllocationHandleType

Definition hip_runtime_api.h:869

hipGraphicsResource_t

hipGraphicsResource * hipGraphicsResource_t

Definition hip_runtime_api.h:1092

hipCtx_t

struct ihipCtx_t * hipCtx_t

Definition hip_runtime_api.h:520

__dparm

#define __dparm(x)

Definition hip_runtime_api.h:504

hipStream_t

struct ihipStream_t * hipStream_t

Definition hip_runtime_api.h:529

hipGLDeviceList

hipGLDeviceList

Definition hip_runtime_api.h:1069

hipDevice_t

int hipDevice_t

Definition hip_runtime_api.h:522

hipAccessProperty

hipAccessProperty

Definition hip_runtime_api.h:1173

hipMemRangeAttribute

hipMemRangeAttribute

Definition hip_runtime_api.h:751

hipMemAttachSingle

#define hipMemAttachSingle

Definition hip_runtime_api.h:640

hipMemoryAdvise

hipMemoryAdvise

Definition hip_runtime_api.h:718

hipArrayDefault

#define hipArrayDefault

Definition hip_runtime_api.h:688

hipSharedMemConfig

hipSharedMemConfig

Definition hip_runtime_api.h:938

hipComputeMode

hipComputeMode

Definition hip_runtime_api.h:473

hipEvent_t

struct ihipEvent_t * hipEvent_t

Definition hip_runtime_api.h:557

hipStreamCaptureMode

hipStreamCaptureMode

Definition hip_runtime_api.h:1208

hipGraphNodeType

hipGraphNodeType

Definition hip_runtime_api.h:1116

hipExternalMemoryHandleType

hipExternalMemoryHandleType

Definition hip_runtime_api.h:982

hipMemAttachGlobal

#define hipMemAttachGlobal

Definition hip_runtime_api.h:634

hipFuncAttribute

hipFuncAttribute

Definition hip_runtime_api.h:921

hipExternalSemaphoreHandleType

hipExternalSemaphoreHandleType

Definition hip_runtime_api.h:1009

hipJitOption

hipJitOption

Definition hip_runtime_api.h:898

hipDeviceP2PAttr

hipDeviceP2PAttr

Definition hip_runtime_api.h:523

hipGraphDebugDotFlags

hipGraphDebugDotFlags

Definition hip_runtime_api.h:1250

hipUserObjectRetainFlags

hipUserObjectRetainFlags

Definition hip_runtime_api.h:1235

hipError_t

enum __HIP_NODISCARD hipError_t hipError_t

Definition hip_runtime_api.h:218

hipHostFn_t

void(* hipHostFn_t)(void *userData)

Definition hip_runtime_api.h:1134

hipOccupancyDefault

#define hipOccupancyDefault

Definition hip_runtime_api.h:693

hipStreamUpdateCaptureDependenciesFlags

hipStreamUpdateCaptureDependenciesFlags

Definition hip_runtime_api.h:1220

hipGraph_t

struct ihipGraph * hipGraph_t

Definition hip_runtime_api.h:1097

hipMemHandleType

hipMemHandleType

Definition hip_runtime_api.h:1323

hipFuncCache_t

hipFuncCache_t

Definition hip_runtime_api.h:929

hipUserObjectFlags

hipUserObjectFlags

Definition hip_runtime_api.h:1231

__HIP_NODISCARD

#define __HIP_NODISCARD

Definition hip_runtime_api.h:208

DEPRECATED_MSG

#define DEPRECATED_MSG

Definition hip_runtime_api.h:496

hipGraphMemAttributeType

hipGraphMemAttributeType

Definition hip_runtime_api.h:1225

hipMemPoolAttr

hipMemPoolAttr

Definition hip_runtime_api.h:767

hipModule_t

struct ihipModule_t * hipModule_t

Definition hip_runtime_api.h:538

hipUserObject_t

struct hipUserObject * hipUserObject_t

Definition hip_runtime_api.h:1110

hipMemOperationType

hipMemOperationType

Definition hip_runtime_api.h:1330

hipExternalSemaphore_t

void * hipExternalSemaphore_t

Definition hip_runtime_api.h:1026

hipGraphicsRegisterFlags

hipGraphicsRegisterFlags

Definition hip_runtime_api.h:1080

hipMemRangeCoherencyMode

hipMemRangeCoherencyMode

Definition hip_runtime_api.h:739

hipMemAccessFlags

hipMemAccessFlags

Definition hip_runtime_api.h:842

hipMemAllocationGranularity_flags

hipMemAllocationGranularity_flags

Definition hip_runtime_api.h:1315

hipGraphExec_t

struct hipGraphExec * hipGraphExec_t

Definition hip_runtime_api.h:1105

hipGraphExecUpdateResult

hipGraphExecUpdateResult

Definition hip_runtime_api.h:1193

hipFunction_t

struct ihipModuleSymbol_t * hipFunction_t

Definition hip_runtime_api.h:539

hipExternalMemory_t

void * hipExternalMemory_t

Definition hip_runtime_api.h:1008

hipStreamCaptureStatus

hipStreamCaptureStatus

Definition hip_runtime_api.h:1213

hipDeviceAttribute_t

hipDeviceAttribute_t

Definition hip_runtime_api.h:340

DEPRECATED

#define DEPRECATED(msg)

Definition hip_runtime_api.h:494

hipHostMallocDefault

#define hipHostMallocDefault

Definition hip_runtime_api.h:607

hipGraphicsResource

struct _hipGraphicsResource hipGraphicsResource

Definition hip_runtime_api.h:1090

hipMemAllocationType

hipMemAllocationType

Definition hip_runtime_api.h:857

hipGraphNode_t

struct hipGraphNode * hipGraphNode_t

Definition hip_runtime_api.h:1101

hipMemGenericAllocationHandle_t

struct ihipMemGenericAllocationHandle * hipMemGenericAllocationHandle_t

Definition hip_runtime_api.h:1310

hipMemoryType

hipMemoryType

Definition hip_runtime_api.h:175

hipGraphInstantiateFlags

hipGraphInstantiateFlags

Definition hip_runtime_api.h:1239

hipKernelNodeAttrID

hipKernelNodeAttrID

Definition hip_runtime_api.h:1169

hipMemLocationType

hipMemLocationType

Definition hip_runtime_api.h:825

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

hipArraySparseSubresourceType

hipArraySparseSubresourceType

Definition hip_runtime_api.h:1338

hipLimitMallocHeapSize

@ hipLimitMallocHeapSize

limit of heap size in bytes on the current device

Definition hip_runtime_api.h:561

hipLimitStackSize

@ hipLimitStackSize

limit of stack size in bytes on the current device

Definition hip_runtime_api.h:559

hipLimitRange

@ hipLimitRange

supported limit range

Definition hip_runtime_api.h:562

hipLimitPrintfFifoSize

@ hipLimitPrintfFifoSize

size limit in bytes of fifo used by printf call on the device

Definition hip_runtime_api.h:560

hipMemHandleTypeWin32

@ hipMemHandleTypeWin32

Allows a Win32 NT handle for exporting. (HANDLE)

Definition hip_runtime_api.h:872

hipMemHandleTypeWin32Kmt

@ hipMemHandleTypeWin32Kmt

Allows a Win32 KMT handle for exporting. (D3DKMT_HANDLE)

Definition hip_runtime_api.h:873

hipMemHandleTypeNone

@ hipMemHandleTypeNone

Does not allow any export mechanism.

Definition hip_runtime_api.h:870

hipMemHandleTypePosixFileDescriptor

@ hipMemHandleTypePosixFileDescriptor

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

Definition hip_runtime_api.h:871

hipGLDeviceListNextFrame

@ hipGLDeviceListNextFrame

frame.

Definition hip_runtime_api.h:1073

hipGLDeviceListAll

@ hipGLDeviceListAll

All hip devices used by current OpenGL context.

Definition hip_runtime_api.h:1070

hipGLDeviceListCurrentFrame

@ hipGLDeviceListCurrentFrame

frame

Definition hip_runtime_api.h:1071

hipAccessPropertyNormal

@ hipAccessPropertyNormal

Definition hip_runtime_api.h:1174

hipAccessPropertyPersisting

@ hipAccessPropertyPersisting

Definition hip_runtime_api.h:1176

hipAccessPropertyStreaming

@ hipAccessPropertyStreaming

Definition hip_runtime_api.h:1175

hipMemRangeAttributeLastPrefetchLocation

@ hipMemRangeAttributeLastPrefetchLocation

prefetched

Definition hip_runtime_api.h:757

hipMemRangeAttributePreferredLocation

@ hipMemRangeAttributePreferredLocation

The preferred location of the range.

Definition hip_runtime_api.h:754

hipMemRangeAttributeAccessedBy

@ hipMemRangeAttributeAccessedBy

Definition hip_runtime_api.h:755

hipMemRangeAttributeReadMostly

@ hipMemRangeAttributeReadMostly

Definition hip_runtime_api.h:752

hipMemRangeAttributeCoherencyMode

@ hipMemRangeAttributeCoherencyMode

Definition hip_runtime_api.h:759

hipMemAdviseUnsetAccessedBy

@ hipMemAdviseUnsetAccessedBy

Definition hip_runtime_api.h:727

hipMemAdviseUnsetCoarseGrain

@ hipMemAdviseUnsetCoarseGrain

Restores cache coherency policy back to fine-grain.

Definition hip_runtime_api.h:734

hipMemAdviseSetCoarseGrain

@ hipMemAdviseSetCoarseGrain

Definition hip_runtime_api.h:729

hipMemAdviseUnsetPreferredLocation

@ hipMemAdviseUnsetPreferredLocation

Clear the preferred location for the data.

Definition hip_runtime_api.h:724

hipMemAdviseSetAccessedBy

@ hipMemAdviseSetAccessedBy

Definition hip_runtime_api.h:725

hipMemAdviseSetPreferredLocation

@ hipMemAdviseSetPreferredLocation

Definition hip_runtime_api.h:722

hipMemAdviseSetReadMostly

@ hipMemAdviseSetReadMostly

Definition hip_runtime_api.h:719

hipMemAdviseUnsetReadMostly

@ hipMemAdviseUnsetReadMostly

Undo the effect of hipMemAdviseSetReadMostly.

Definition hip_runtime_api.h:721

hipSharedMemBankSizeFourByte

@ hipSharedMemBankSizeFourByte

Definition hip_runtime_api.h:940

hipSharedMemBankSizeEightByte

@ hipSharedMemBankSizeEightByte

Definition hip_runtime_api.h:942

hipSharedMemBankSizeDefault

@ hipSharedMemBankSizeDefault

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

Definition hip_runtime_api.h:939

hipComputeModeProhibited

@ hipComputeModeProhibited

Definition hip_runtime_api.h:476

hipComputeModeExclusive

@ hipComputeModeExclusive

Definition hip_runtime_api.h:475

hipComputeModeDefault

@ hipComputeModeDefault

Definition hip_runtime_api.h:474

hipComputeModeExclusiveProcess

@ hipComputeModeExclusiveProcess

Definition hip_runtime_api.h:477

hipStreamCaptureModeRelaxed

@ hipStreamCaptureModeRelaxed

Definition hip_runtime_api.h:1211

hipStreamCaptureModeThreadLocal

@ hipStreamCaptureModeThreadLocal

Definition hip_runtime_api.h:1210

hipStreamCaptureModeGlobal

@ hipStreamCaptureModeGlobal

Definition hip_runtime_api.h:1209

hipGraphNodeTypeGraph

@ hipGraphNodeTypeGraph

Node which executes an embedded graph.

Definition hip_runtime_api.h:1121

hipGraphNodeTypeMemset

@ hipGraphNodeTypeMemset

Memset node.

Definition hip_runtime_api.h:1119

hipGraphNodeTypeEventRecord

@ hipGraphNodeTypeEventRecord

External event record node.

Definition hip_runtime_api.h:1124

hipGraphNodeTypeExtSemaphoreSignal

@ hipGraphNodeTypeExtSemaphoreSignal

External Semaphore signal node.

Definition hip_runtime_api.h:1125

hipGraphNodeTypeMemcpy

@ hipGraphNodeTypeMemcpy

Memcpy node.

Definition hip_runtime_api.h:1118

hipGraphNodeTypeWaitEvent

@ hipGraphNodeTypeWaitEvent

External event wait node.

Definition hip_runtime_api.h:1123

hipGraphNodeTypeCount

@ hipGraphNodeTypeCount

Definition hip_runtime_api.h:1131

hipGraphNodeTypeKernel

@ hipGraphNodeTypeKernel

GPU kernel node.

Definition hip_runtime_api.h:1117

hipGraphNodeTypeHost

@ hipGraphNodeTypeHost

Host (executable) node.

Definition hip_runtime_api.h:1120

hipGraphNodeTypeMemAlloc

@ hipGraphNodeTypeMemAlloc

Memory alloc node.

Definition hip_runtime_api.h:1127

hipGraphNodeTypeMemFree

@ hipGraphNodeTypeMemFree

Memory free node.

Definition hip_runtime_api.h:1128

hipGraphNodeTypeMemcpyFromSymbol

@ hipGraphNodeTypeMemcpyFromSymbol

MemcpyFromSymbol node.

Definition hip_runtime_api.h:1129

hipGraphNodeTypeMemcpyToSymbol

@ hipGraphNodeTypeMemcpyToSymbol

MemcpyToSymbol node.

Definition hip_runtime_api.h:1130

hipGraphNodeTypeEmpty

@ hipGraphNodeTypeEmpty

Empty (no-op) node.

Definition hip_runtime_api.h:1122

hipGraphNodeTypeExtSemaphoreWait

@ hipGraphNodeTypeExtSemaphoreWait

External Semaphore wait node.

Definition hip_runtime_api.h:1126

hipExternalMemoryHandleTypeD3D11Resource

@ hipExternalMemoryHandleTypeD3D11Resource

Definition hip_runtime_api.h:988

hipExternalMemoryHandleTypeD3D12Resource

@ hipExternalMemoryHandleTypeD3D12Resource

Definition hip_runtime_api.h:987

hipExternalMemoryHandleTypeOpaqueFd

@ hipExternalMemoryHandleTypeOpaqueFd

Definition hip_runtime_api.h:983

hipExternalMemoryHandleTypeD3D12Heap

@ hipExternalMemoryHandleTypeD3D12Heap

Definition hip_runtime_api.h:986

hipExternalMemoryHandleTypeOpaqueWin32Kmt

@ hipExternalMemoryHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:985

hipExternalMemoryHandleTypeOpaqueWin32

@ hipExternalMemoryHandleTypeOpaqueWin32

Definition hip_runtime_api.h:984

hipExternalMemoryHandleTypeD3D11ResourceKmt

@ hipExternalMemoryHandleTypeD3D11ResourceKmt

Definition hip_runtime_api.h:989

hipFuncAttributePreferredSharedMemoryCarveout

@ hipFuncAttributePreferredSharedMemoryCarveout

Definition hip_runtime_api.h:923

hipFuncAttributeMaxDynamicSharedMemorySize

@ hipFuncAttributeMaxDynamicSharedMemorySize

Definition hip_runtime_api.h:922

hipFuncAttributeMax

@ hipFuncAttributeMax

Definition hip_runtime_api.h:924

hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

@ hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:1012

hipExternalSemaphoreHandleTypeOpaqueFd

@ hipExternalSemaphoreHandleTypeOpaqueFd

Definition hip_runtime_api.h:1010

hipExternalSemaphoreHandleTypeOpaqueWin32

@ hipExternalSemaphoreHandleTypeOpaqueWin32

Definition hip_runtime_api.h:1011

hipExternalSemaphoreHandleTypeD3D12Fence

@ hipExternalSemaphoreHandleTypeD3D12Fence

Definition hip_runtime_api.h:1013

hipJitOptionCacheMode

@ hipJitOptionCacheMode

Definition hip_runtime_api.h:913

hipJitOptionFastCompile

@ hipJitOptionFastCompile

Definition hip_runtime_api.h:915

hipJitOptionInfoLogBuffer

@ hipJitOptionInfoLogBuffer

Definition hip_runtime_api.h:902

hipJitOptionErrorLogBuffer

@ hipJitOptionErrorLogBuffer

Definition hip_runtime_api.h:904

hipJitOptionTarget

@ hipJitOptionTarget

Definition hip_runtime_api.h:908

hipJitOptionThreadsPerBlock

@ hipJitOptionThreadsPerBlock

Definition hip_runtime_api.h:900

hipJitOptionNumOptions

@ hipJitOptionNumOptions

Definition hip_runtime_api.h:916

hipJitOptionGenerateLineInfo

@ hipJitOptionGenerateLineInfo

Definition hip_runtime_api.h:912

hipJitOptionOptimizationLevel

@ hipJitOptionOptimizationLevel

Definition hip_runtime_api.h:906

hipJitOptionErrorLogBufferSizeBytes

@ hipJitOptionErrorLogBufferSizeBytes

Definition hip_runtime_api.h:905

hipJitOptionWallTime

@ hipJitOptionWallTime

Definition hip_runtime_api.h:901

hipJitOptionInfoLogBufferSizeBytes

@ hipJitOptionInfoLogBufferSizeBytes

Definition hip_runtime_api.h:903

hipJitOptionTargetFromContext

@ hipJitOptionTargetFromContext

Definition hip_runtime_api.h:907

hipJitOptionGenerateDebugInfo

@ hipJitOptionGenerateDebugInfo

Definition hip_runtime_api.h:910

hipJitOptionLogVerbose

@ hipJitOptionLogVerbose

Definition hip_runtime_api.h:911

hipJitOptionMaxRegisters

@ hipJitOptionMaxRegisters

Definition hip_runtime_api.h:899

hipJitOptionSm3xOpt

@ hipJitOptionSm3xOpt

Definition hip_runtime_api.h:914

hipJitOptionFallbackStrategy

@ hipJitOptionFallbackStrategy

Definition hip_runtime_api.h:909

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

hipGraphDebugDotFlagsKernelNodeAttributes

@ hipGraphDebugDotFlagsKernelNodeAttributes

Definition hip_runtime_api.h:1263

hipGraphDebugDotFlagsMemsetNodeParams

@ hipGraphDebugDotFlagsMemsetNodeParams

Definition hip_runtime_api.h:1255

hipGraphDebugDotFlagsKernelNodeParams

@ hipGraphDebugDotFlagsKernelNodeParams

Definition hip_runtime_api.h:1253

hipGraphDebugDotFlagsExtSemasWaitNodeParams

@ hipGraphDebugDotFlagsExtSemasWaitNodeParams

Definition hip_runtime_api.h:1261

hipGraphDebugDotFlagsHandles

@ hipGraphDebugDotFlagsHandles

Definition hip_runtime_api.h:1265

hipGraphDebugDotFlagsExtSemasSignalNodeParams

@ hipGraphDebugDotFlagsExtSemasSignalNodeParams

Definition hip_runtime_api.h:1259

hipGraphDebugDotFlagsHostNodeParams

@ hipGraphDebugDotFlagsHostNodeParams

Definition hip_runtime_api.h:1256

hipGraphDebugDotFlagsEventNodeParams

@ hipGraphDebugDotFlagsEventNodeParams

Definition hip_runtime_api.h:1257

hipGraphDebugDotFlagsVerbose

@ hipGraphDebugDotFlagsVerbose

Definition hip_runtime_api.h:1251

hipGraphDebugDotFlagsMemcpyNodeParams

@ hipGraphDebugDotFlagsMemcpyNodeParams

Definition hip_runtime_api.h:1254

hipGraphUserObjectMove

@ hipGraphUserObjectMove

Add new reference or retain.

Definition hip_runtime_api.h:1236

hipStreamAddCaptureDependencies

@ hipStreamAddCaptureDependencies

Add new nodes to the dependency set.

Definition hip_runtime_api.h:1221

hipStreamSetCaptureDependencies

@ hipStreamSetCaptureDependencies

Replace the dependency set with the new nodes.

Definition hip_runtime_api.h:1222

hipMemHandleTypeGeneric

@ hipMemHandleTypeGeneric

Generic handle type.

Definition hip_runtime_api.h:1324

hipFuncCachePreferNone

@ hipFuncCachePreferNone

no preference for shared memory or L1 (default)

Definition hip_runtime_api.h:930

hipFuncCachePreferEqual

@ hipFuncCachePreferEqual

prefer equal size L1 cache and shared memory

Definition hip_runtime_api.h:933

hipFuncCachePreferL1

@ hipFuncCachePreferL1

prefer larger L1 cache and smaller shared memory

Definition hip_runtime_api.h:932

hipFuncCachePreferShared

@ hipFuncCachePreferShared

prefer larger shared memory and smaller L1 cache

Definition hip_runtime_api.h:931

hipUserObjectNoDestructorSync

@ hipUserObjectNoDestructorSync

Destructor execution is not synchronized.

Definition hip_runtime_api.h:1232

hipGraphMemAttrReservedMemHigh

@ hipGraphMemAttrReservedMemHigh

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

Definition hip_runtime_api.h:1229

hipGraphMemAttrUsedMemCurrent

@ hipGraphMemAttrUsedMemCurrent

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

Definition hip_runtime_api.h:1226

hipGraphMemAttrUsedMemHigh

@ hipGraphMemAttrUsedMemHigh

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

Definition hip_runtime_api.h:1227

hipGraphMemAttrReservedMemCurrent

@ hipGraphMemAttrReservedMemCurrent

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

Definition hip_runtime_api.h:1228

hipMemPoolAttrUsedMemCurrent

@ hipMemPoolAttrUsedMemCurrent

Definition hip_runtime_api.h:814

hipMemPoolAttrReservedMemHigh

@ hipMemPoolAttrReservedMemHigh

Definition hip_runtime_api.h:809

hipMemPoolAttrReservedMemCurrent

@ hipMemPoolAttrReservedMemCurrent

Definition hip_runtime_api.h:803

hipMemPoolAttrReleaseThreshold

@ hipMemPoolAttrReleaseThreshold

Definition hip_runtime_api.h:798

hipMemPoolAttrUsedMemHigh

@ hipMemPoolAttrUsedMemHigh

Definition hip_runtime_api.h:820

hipMemPoolReuseAllowInternalDependencies

@ hipMemPoolReuseAllowInternalDependencies

Definition hip_runtime_api.h:789

hipMemPoolReuseFollowEventDependencies

@ hipMemPoolReuseFollowEventDependencies

Definition hip_runtime_api.h:776

hipMemPoolReuseAllowOpportunistic

@ hipMemPoolReuseAllowOpportunistic

Definition hip_runtime_api.h:782

hipMemOperationTypeMap

@ hipMemOperationTypeMap

Map operation.

Definition hip_runtime_api.h:1331

hipMemOperationTypeUnmap

@ hipMemOperationTypeUnmap

Unmap operation.

Definition hip_runtime_api.h:1332

hipGraphicsRegisterFlagsReadOnly

@ hipGraphicsRegisterFlagsReadOnly

HIP will not write to this registered resource.

Definition hip_runtime_api.h:1082

hipGraphicsRegisterFlagsTextureGather

@ hipGraphicsRegisterFlagsTextureGather

HIP will perform texture gather operations on this registered resource.

Definition hip_runtime_api.h:1086

hipGraphicsRegisterFlagsWriteDiscard

@ hipGraphicsRegisterFlagsWriteDiscard

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

Definition hip_runtime_api.h:1083

hipGraphicsRegisterFlagsNone

@ hipGraphicsRegisterFlagsNone

Definition hip_runtime_api.h:1081

hipGraphicsRegisterFlagsSurfaceLoadStore

@ hipGraphicsRegisterFlagsSurfaceLoadStore

HIP will bind this resource to a surface.

Definition hip_runtime_api.h:1085

hipMemRangeCoherencyModeFineGrain

@ hipMemRangeCoherencyModeFineGrain

Definition hip_runtime_api.h:740

hipMemRangeCoherencyModeIndeterminate

@ hipMemRangeCoherencyModeIndeterminate

Definition hip_runtime_api.h:744

hipMemRangeCoherencyModeCoarseGrain

@ hipMemRangeCoherencyModeCoarseGrain

Definition hip_runtime_api.h:742

hipMemAccessFlagsProtRead

@ hipMemAccessFlagsProtRead

Set the address range read accessible.

Definition hip_runtime_api.h:844

hipMemAccessFlagsProtNone

@ hipMemAccessFlagsProtNone

Default, make the address range not accessible.

Definition hip_runtime_api.h:843

hipMemAccessFlagsProtReadWrite

@ hipMemAccessFlagsProtReadWrite

Set the address range read-write accessible.

Definition hip_runtime_api.h:845

hipMemAllocationGranularityMinimum

@ hipMemAllocationGranularityMinimum

Minimum granularity.

Definition hip_runtime_api.h:1316

hipMemAllocationGranularityRecommended

@ hipMemAllocationGranularityRecommended

Recommended granularity for performance.

Definition hip_runtime_api.h:1317

hipGraphExecUpdateErrorNotSupported

@ hipGraphExecUpdateErrorNotSupported

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

Definition hip_runtime_api.h:1203

hipGraphExecUpdateErrorNodeTypeChanged

@ hipGraphExecUpdateErrorNodeTypeChanged

The update failed because a node type changed.

Definition hip_runtime_api.h:1198

hipGraphExecUpdateErrorTopologyChanged

@ hipGraphExecUpdateErrorTopologyChanged

The update failed because the topology changed.

Definition hip_runtime_api.h:1197

hipGraphExecUpdateErrorUnsupportedFunctionChange

@ hipGraphExecUpdateErrorUnsupportedFunctionChange

Definition hip_runtime_api.h:1205

hipGraphExecUpdateError

@ hipGraphExecUpdateError

Definition hip_runtime_api.h:1195

hipGraphExecUpdateErrorFunctionChanged

@ hipGraphExecUpdateErrorFunctionChanged

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

Definition hip_runtime_api.h:1199

hipGraphExecUpdateSuccess

@ hipGraphExecUpdateSuccess

The update succeeded.

Definition hip_runtime_api.h:1194

hipGraphExecUpdateErrorParametersChanged

@ hipGraphExecUpdateErrorParametersChanged

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

Definition hip_runtime_api.h:1201

hipStreamCaptureStatusInvalidated

@ hipStreamCaptureStatusInvalidated

Definition hip_runtime_api.h:1216

hipStreamCaptureStatusNone

@ hipStreamCaptureStatusNone

Stream is not capturing.

Definition hip_runtime_api.h:1214

hipStreamCaptureStatusActive

@ hipStreamCaptureStatusActive

Stream is actively capturing.

Definition hip_runtime_api.h:1215

hipDeviceAttributeDirectManagedMemAccessFromHost

@ hipDeviceAttributeDirectManagedMemAccessFromHost

Definition hip_runtime_api.h:358

hipDeviceAttributeSurfaceAlignment

@ hipDeviceAttributeSurfaceAlignment

Cuda only. Alignment requirement for surfaces.

Definition hip_runtime_api.h:428

hipDeviceAttributeMaxGridDimX

@ hipDeviceAttributeMaxGridDimX

Max grid size in width.

Definition hip_runtime_api.h:375

hipDeviceAttributeMaxSurfaceCubemapLayered

@ hipDeviceAttributeMaxSurfaceCubemapLayered

Cuda only. Maximum dimension of Cubemap layered surface.

Definition hip_runtime_api.h:384

hipDeviceAttributeMaxSurface3D

@ hipDeviceAttributeMaxSurface3D

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

Definition hip_runtime_api.h:382

hipDeviceAttributeMaxPitch

@ hipDeviceAttributeMaxPitch

Maximum pitch in bytes allowed by memory copies.

Definition hip_runtime_api.h:405

hipDeviceAttributeTccDriver

@ hipDeviceAttributeTccDriver

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

Definition hip_runtime_api.h:429

hipDeviceAttributeHostNativeAtomicSupported

@ hipDeviceAttributeHostNativeAtomicSupported

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

Definition hip_runtime_api.h:361

hipDeviceAttributePageableMemoryAccessUsesHostPageTables

@ hipDeviceAttributePageableMemoryAccessUsesHostPageTables

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

Definition hip_runtime_api.h:414

hipDeviceAttributeMaxBlockDimY

@ hipDeviceAttributeMaxBlockDimY

Max block size in height.

Definition hip_runtime_api.h:373

hipDeviceAttributeMaxSurfaceCubemap

@ hipDeviceAttributeMaxSurfaceCubemap

Cuda only. Maximum dimensions of Cubemap surface.

Definition hip_runtime_api.h:383

hipDeviceAttributeName

@ hipDeviceAttributeName

Device name.

Definition hip_runtime_api.h:411

hipDeviceAttributePageableMemoryAccess

@ hipDeviceAttributePageableMemoryAccess

Definition hip_runtime_api.h:412

hipDeviceAttributeClockRate

@ hipDeviceAttributeClockRate

Peak clock frequency in kilohertz.

Definition hip_runtime_api.h:349

hipDeviceAttributeCudaCompatibleEnd

@ hipDeviceAttributeCudaCompatibleEnd

Definition hip_runtime_api.h:440

hipDeviceAttributeMaxTexture1DMipmap

@ hipDeviceAttributeMaxTexture1DMipmap

Cuda only. Maximum size of 1D mipmapped texture.

Definition hip_runtime_api.h:389

hipDeviceAttributeComputeCapabilityMajor

@ hipDeviceAttributeComputeCapabilityMajor

Major compute capability version number.

Definition hip_runtime_api.h:369

hipDeviceAttributeGlobalL1CacheSupported

@ hipDeviceAttributeGlobalL1CacheSupported

Cuda only. Device supports caching globals in L1.

Definition hip_runtime_api.h:360

hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

Definition hip_runtime_api.h:456

hipDeviceAttributeAccessPolicyMaxWindowSize

@ hipDeviceAttributeAccessPolicyMaxWindowSize

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

Definition hip_runtime_api.h:344

hipDeviceAttributeMaxTexture3DHeight

@ hipDeviceAttributeMaxTexture3DHeight

Maximum dimension height of 3D texture.

Definition hip_runtime_api.h:397

hipDeviceAttributeComputeCapabilityMinor

@ hipDeviceAttributeComputeCapabilityMinor

Minor compute capability version number.

Definition hip_runtime_api.h:408

hipDeviceAttributeMaxTextureCubemap

@ hipDeviceAttributeMaxTextureCubemap

Cuda only. Maximum dimensions of Cubemap texture.

Definition hip_runtime_api.h:400

hipDeviceAttributeDeviceOverlap

@ hipDeviceAttributeDeviceOverlap

Definition hip_runtime_api.h:356

hipDeviceAttributeMaxTexture2DLinear

@ hipDeviceAttributeMaxTexture2DLinear

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

Definition hip_runtime_api.h:394

hipDeviceAttributeMaxSurface2D

@ hipDeviceAttributeMaxSurface2D

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

Definition hip_runtime_api.h:380

hipDeviceAttributeMaxSurface1DLayered

@ hipDeviceAttributeMaxSurface1DLayered

Cuda only. Maximum dimensions of 1D layered surface.

Definition hip_runtime_api.h:379

hipDeviceAttributeHdpRegFlushCntl

@ hipDeviceAttributeHdpRegFlushCntl

Address of the HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:449

hipDeviceAttributeComputeMode

@ hipDeviceAttributeComputeMode

Compute mode that device is currently in.

Definition hip_runtime_api.h:350

hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

Definition hip_runtime_api.h:450

hipDeviceAttributeAsicRevision

@ hipDeviceAttributeAsicRevision

Revision of the GPU in this device.

Definition hip_runtime_api.h:459

hipDeviceAttributeCooperativeMultiDeviceLaunch

@ hipDeviceAttributeCooperativeMultiDeviceLaunch

Support cooperative launch on multiple devices.

Definition hip_runtime_api.h:355

hipDeviceAttributeMaxTexture2DHeight

@ hipDeviceAttributeMaxTexture2DHeight

Maximum dimension hight of 2D texture.

Definition hip_runtime_api.h:391

hipDeviceAttributePersistingL2CacheMaxSize

@ hipDeviceAttributePersistingL2CacheMaxSize

Cuda11 only. Maximum l2 persisting lines capacity in bytes.

Definition hip_runtime_api.h:418

hipDeviceAttributeEccEnabled

@ hipDeviceAttributeEccEnabled

Whether ECC support is enabled.

Definition hip_runtime_api.h:343

hipDeviceAttributeCanUseHostPointerForRegisteredMem

@ hipDeviceAttributeCanUseHostPointerForRegisteredMem

Definition hip_runtime_api.h:347

hipDeviceAttributePciBusId

@ hipDeviceAttributePciBusId

PCI Bus ID.

Definition hip_runtime_api.h:415

hipDeviceAttributeL2CacheSize

@ hipDeviceAttributeL2CacheSize

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

Definition hip_runtime_api.h:365

hipDeviceAttributeKernelExecTimeout

@ hipDeviceAttributeKernelExecTimeout

Run time limit for kernels executed on the device.

Definition hip_runtime_api.h:364

hipDeviceAttributeMaxThreadsDim

@ hipDeviceAttributeMaxThreadsDim

Maximum dimension of a block.

Definition hip_runtime_api.h:402

hipDeviceAttributeSingleToDoublePrecisionPerfRatio

@ hipDeviceAttributeSingleToDoublePrecisionPerfRatio

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

Definition hip_runtime_api.h:426

hipDeviceAttributeMaxGridDimY

@ hipDeviceAttributeMaxGridDimY

Max grid size in height.

Definition hip_runtime_api.h:376

hipDeviceAttributeMultiprocessorCount

@ hipDeviceAttributeMultiprocessorCount

Number of multiprocessors on the device.

Definition hip_runtime_api.h:410

hipDeviceAttributeUuid

@ hipDeviceAttributeUuid

Cuda only. Unique ID in 16 byte.

Definition hip_runtime_api.h:435

hipDeviceAttributeAmdSpecificBegin

@ hipDeviceAttributeAmdSpecificBegin

Definition hip_runtime_api.h:441

hipDeviceAttributeMaxRegistersPerMultiprocessor

@ hipDeviceAttributeMaxRegistersPerMultiprocessor

32-bit registers available per block.

Definition hip_runtime_api.h:421

hipDeviceAttributeGcnArchName

@ hipDeviceAttributeGcnArchName

Device gcnArch name in 256 bytes.

Definition hip_runtime_api.h:447

hipDeviceAttributeIsMultiGpuBoard

@ hipDeviceAttributeIsMultiGpuBoard

Multiple GPU devices.

Definition hip_runtime_api.h:363

hipDeviceAttributeSharedMemPerBlockOptin

@ hipDeviceAttributeSharedMemPerBlockOptin

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

Definition hip_runtime_api.h:424

hipDeviceAttributeMaxSurface2DLayered

@ hipDeviceAttributeMaxSurface2DLayered

Cuda only. Maximum dimensions of 2D layered surface.

Definition hip_runtime_api.h:381

hipDeviceAttributeAmdSpecificEnd

@ hipDeviceAttributeAmdSpecificEnd

Definition hip_runtime_api.h:468

hipDeviceAttributeMemoryClockRate

@ hipDeviceAttributeMemoryClockRate

Peak memory clock frequency in kilohertz.

Definition hip_runtime_api.h:407

hipDeviceAttributeGcnArch

@ hipDeviceAttributeGcnArch

Device gcn architecture.

Definition hip_runtime_api.h:446

hipDeviceAttributeMaxGridDimZ

@ hipDeviceAttributeMaxGridDimZ

Max grid size in depth.

Definition hip_runtime_api.h:377

hipDeviceAttributeHdpMemFlushCntl

@ hipDeviceAttributeHdpMemFlushCntl

Address of the HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:448

hipDeviceAttributeFineGrainSupport

@ hipDeviceAttributeFineGrainSupport

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

Definition hip_runtime_api.h:465

hipDeviceAttributeCooperativeLaunch

@ hipDeviceAttributeCooperativeLaunch

Support cooperative launch.

Definition hip_runtime_api.h:354

hipDeviceAttributeUnifiedAddressing

@ hipDeviceAttributeUnifiedAddressing

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

Definition hip_runtime_api.h:434

hipDeviceAttributeAsyncEngineCount

@ hipDeviceAttributeAsyncEngineCount

Cuda only. Asynchronous engines number.

Definition hip_runtime_api.h:345

hipDeviceAttributeMultiGpuBoardGroupID

@ hipDeviceAttributeMultiGpuBoardGroupID

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

Definition hip_runtime_api.h:409

hipDeviceAttributeStreamPrioritiesSupported

@ hipDeviceAttributeStreamPrioritiesSupported

Cuda only. Whether to support stream priorities.

Definition hip_runtime_api.h:427

hipDeviceAttributeMaxSharedMemoryPerBlock

@ hipDeviceAttributeMaxSharedMemoryPerBlock

Maximum shared memory available per block in bytes.

Definition hip_runtime_api.h:423

hipDeviceAttributeLocalL1CacheSupported

@ hipDeviceAttributeLocalL1CacheSupported

caching locals in L1 is supported

Definition hip_runtime_api.h:366

hipDeviceAttributeCanUseStreamWaitValue

@ hipDeviceAttributeCanUseStreamWaitValue

Definition hip_runtime_api.h:460

hipDeviceAttributeMaxRegistersPerBlock

@ hipDeviceAttributeMaxRegistersPerBlock

Definition hip_runtime_api.h:419

hipDeviceAttributeMaxThreadsPerBlock

@ hipDeviceAttributeMaxThreadsPerBlock

Maximum number of threads per block.

Definition hip_runtime_api.h:403

hipDeviceAttributeMemoryBusWidth

@ hipDeviceAttributeMemoryBusWidth

Global memory bus width in bits.

Definition hip_runtime_api.h:406

hipDeviceAttributeComputePreemptionSupported

@ hipDeviceAttributeComputePreemptionSupported

Cuda only. Device supports Compute Preemption.

Definition hip_runtime_api.h:351

hipDeviceAttributeMaxSurface1D

@ hipDeviceAttributeMaxSurface1D

Maximum size of 1D surface.

Definition hip_runtime_api.h:378

hipDeviceAttributeMaxTexture3DAlt

@ hipDeviceAttributeMaxTexture3DAlt

Cuda only. Maximum dimensions of alternate 3D texture.

Definition hip_runtime_api.h:399

hipDeviceAttributeMaxTexture1DLinear

@ hipDeviceAttributeMaxTexture1DLinear

Definition hip_runtime_api.h:387

hipDeviceAttributeMaxTexture2DGather

@ hipDeviceAttributeMaxTexture2DGather

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

Definition hip_runtime_api.h:392

hipDeviceAttributeWallClockRate

@ hipDeviceAttributeWallClockRate

Constant frequency of wall clock in kilohertz.

Definition hip_runtime_api.h:466

hipDeviceAttributePciDeviceId

@ hipDeviceAttributePciDeviceId

PCI Device ID.

Definition hip_runtime_api.h:416

hipDeviceAttributeCanMapHostMemory

@ hipDeviceAttributeCanMapHostMemory

Whether host memory can be mapped into device address space.

Definition hip_runtime_api.h:346

hipDeviceAttributeMaxTexture1DWidth

@ hipDeviceAttributeMaxTexture1DWidth

Maximum size of 1D texture.

Definition hip_runtime_api.h:385

hipDeviceAttributeConcurrentManagedAccess

@ hipDeviceAttributeConcurrentManagedAccess

Device can coherently access managed memory concurrently with the CPU.

Definition hip_runtime_api.h:353

hipDeviceAttributeVendorSpecificBegin

@ hipDeviceAttributeVendorSpecificBegin

Definition hip_runtime_api.h:469

hipDeviceAttributeArch

@ hipDeviceAttributeArch

Device architecture.

Definition hip_runtime_api.h:444

hipDeviceAttributeManagedMemory

@ hipDeviceAttributeManagedMemory

Device supports allocating managed memory on this system.

Definition hip_runtime_api.h:370

hipDeviceAttributeIntegrated

@ hipDeviceAttributeIntegrated

Device is integrated GPU.

Definition hip_runtime_api.h:362

hipDeviceAttributeMaxTexture2DLayered

@ hipDeviceAttributeMaxTexture2DLayered

Cuda only. Maximum dimensions of 2D layered texture.

Definition hip_runtime_api.h:393

hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

Definition hip_runtime_api.h:452

hipDeviceAttributeMaxTexture3DDepth

@ hipDeviceAttributeMaxTexture3DDepth

Maximum dimension depth of 3D texture.

Definition hip_runtime_api.h:398

hipDeviceAttributeImageSupport

@ hipDeviceAttributeImageSupport

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

Definition hip_runtime_api.h:462

hipDeviceAttributeTotalGlobalMem

@ hipDeviceAttributeTotalGlobalMem

Global memory available on devicice.

Definition hip_runtime_api.h:433

hipDeviceAttributeMaxBlocksPerMultiProcessor

@ hipDeviceAttributeMaxBlocksPerMultiProcessor

Cuda only. Max block size per multiprocessor.

Definition hip_runtime_api.h:371

hipDeviceAttributeIsLargeBar

@ hipDeviceAttributeIsLargeBar

Whether it is LargeBar.

Definition hip_runtime_api.h:458

hipDeviceAttributeMaxTexture2DWidth

@ hipDeviceAttributeMaxTexture2DWidth

Maximum dimension width of 2D texture.

Definition hip_runtime_api.h:390

hipDeviceAttributeMaxBlockDimX

@ hipDeviceAttributeMaxBlockDimX

Max block size in width.

Definition hip_runtime_api.h:372

hipDeviceAttributeMaxTexture3DWidth

@ hipDeviceAttributeMaxTexture3DWidth

Maximum dimension width of 3D texture.

Definition hip_runtime_api.h:396

hipDeviceAttributeTotalConstantMemory

@ hipDeviceAttributeTotalConstantMemory

Constant memory size in bytes.

Definition hip_runtime_api.h:432

hipDeviceAttributeTextureAlignment

@ hipDeviceAttributeTextureAlignment

Alignment requirement for textures.

Definition hip_runtime_api.h:430

hipDeviceAttributeMaxTexture1DLayered

@ hipDeviceAttributeMaxTexture1DLayered

Cuda only. Maximum dimensions of 1D layered texture.

Definition hip_runtime_api.h:386

hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

@ hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

Maximum Shared Memory PerMultiprocessor.

Definition hip_runtime_api.h:445

hipDeviceAttributeReservedSharedMemPerBlock

@ hipDeviceAttributeReservedSharedMemPerBlock

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

Definition hip_runtime_api.h:422

hipDeviceAttributeCudaCompatibleBegin

@ hipDeviceAttributeCudaCompatibleBegin

Definition hip_runtime_api.h:341

hipDeviceAttributeConcurrentKernels

@ hipDeviceAttributeConcurrentKernels

Device can possibly execute multiple kernels concurrently.

Definition hip_runtime_api.h:352

hipDeviceAttributeLuid

@ hipDeviceAttributeLuid

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

Definition hip_runtime_api.h:367

hipDeviceAttributePciDomainID

@ hipDeviceAttributePciDomainID

PCI Domain ID.

Definition hip_runtime_api.h:417

hipDeviceAttributeMaxThreadsPerMultiProcessor

@ hipDeviceAttributeMaxThreadsPerMultiProcessor

Maximum resident threads per multiprocessor.

Definition hip_runtime_api.h:404

hipDeviceAttributeTexturePitchAlignment

@ hipDeviceAttributeTexturePitchAlignment

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

Definition hip_runtime_api.h:431

hipDeviceAttributePhysicalMultiProcessorCount

@ hipDeviceAttributePhysicalMultiProcessorCount

Definition hip_runtime_api.h:463

hipDeviceAttributeSharedMemPerMultiprocessor

@ hipDeviceAttributeSharedMemPerMultiprocessor

Cuda only. Shared memory available per multiprocessor.

Definition hip_runtime_api.h:425

hipDeviceAttributeLuidDeviceNodeMask

@ hipDeviceAttributeLuidDeviceNodeMask

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

Definition hip_runtime_api.h:368

hipDeviceAttributeMaxTextureCubemapLayered

@ hipDeviceAttributeMaxTextureCubemapLayered

Cuda only. Maximum dimensions of Cubemap layered texture.

Definition hip_runtime_api.h:401

hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

Definition hip_runtime_api.h:454

hipDeviceAttributeVirtualMemoryManagementSupported

@ hipDeviceAttributeVirtualMemoryManagementSupported

Device supports HIP virtual memory management.

Definition hip_runtime_api.h:438

hipDeviceAttributeMemoryPoolsSupported

@ hipDeviceAttributeMemoryPoolsSupported

Device supports HIP Stream Ordered Memory Allocator.

Definition hip_runtime_api.h:437

hipDeviceAttributeClockInstructionRate

@ hipDeviceAttributeClockInstructionRate

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

Definition hip_runtime_api.h:443

hipDeviceAttributeMaxTexture2DMipmap

@ hipDeviceAttributeMaxTexture2DMipmap

Cuda only. Maximum dimensions of 2D mipmapped texture.

Definition hip_runtime_api.h:395

hipDeviceAttributeMaxBlockDimZ

@ hipDeviceAttributeMaxBlockDimZ

Max block size in depth.

Definition hip_runtime_api.h:374

hipDeviceAttributeWarpSize

@ hipDeviceAttributeWarpSize

Warp size in threads.

Definition hip_runtime_api.h:436

hipMemAllocationTypeMax

@ hipMemAllocationTypeMax

Definition hip_runtime_api.h:863

hipMemAllocationTypePinned

@ hipMemAllocationTypePinned

Definition hip_runtime_api.h:862

hipMemAllocationTypeInvalid

@ hipMemAllocationTypeInvalid

Definition hip_runtime_api.h:858

hipMemoryTypeDevice

@ hipMemoryTypeDevice

Definition hip_runtime_api.h:177

hipMemoryTypeHost

@ hipMemoryTypeHost

Memory is physically located on host.

Definition hip_runtime_api.h:176

hipMemoryTypeArray

@ hipMemoryTypeArray

Definition hip_runtime_api.h:179

hipMemoryTypeManaged

@ hipMemoryTypeManaged

Definition hip_runtime_api.h:182

hipMemoryTypeUnified

@ hipMemoryTypeUnified

Not used currently.

Definition hip_runtime_api.h:181

hipGraphInstantiateFlagAutoFreeOnLaunch

@ hipGraphInstantiateFlagAutoFreeOnLaunch

Automatically free memory allocated in a graph before relaunching.

Definition hip_runtime_api.h:1240

hipGraphInstantiateFlagUseNodePriority

@ hipGraphInstantiateFlagUseNodePriority

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

Definition hip_runtime_api.h:1246

hipGraphInstantiateFlagUpload

@ hipGraphInstantiateFlagUpload

Automatically upload the graph after instantiaton.

Definition hip_runtime_api.h:1242

hipGraphInstantiateFlagDeviceLaunch

@ hipGraphInstantiateFlagDeviceLaunch

Instantiate the graph to be launchable from the device.

Definition hip_runtime_api.h:1244

hipKernelNodeAttributeCooperative

@ hipKernelNodeAttributeCooperative

Definition hip_runtime_api.h:1171

hipKernelNodeAttributeAccessPolicyWindow

@ hipKernelNodeAttributeAccessPolicyWindow

Definition hip_runtime_api.h:1170

hipMemLocationTypeInvalid

@ hipMemLocationTypeInvalid

Definition hip_runtime_api.h:826

hipMemLocationTypeDevice

@ hipMemLocationTypeDevice

Device location, thus it's HIP device ID.

Definition hip_runtime_api.h:827

hipArraySparseSubresourceTypeSparseLevel

@ hipArraySparseSubresourceTypeSparseLevel

Sparse level.

Definition hip_runtime_api.h:1339

hipArraySparseSubresourceTypeMiptail

@ hipArraySparseSubresourceTypeMiptail

Miptail.

Definition hip_runtime_api.h:1340

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.

hipGraphExternalSemaphoresSignalNodeSetParams

hipError_t hipGraphExternalSemaphoresSignalNodeSetParams(hipGraphNode_t hNode, const hipExternalSemaphoreSignalNodeParams *nodeParams)

Updates node parameters in the external semaphore signal node.

hipGraphDestroyNode

hipError_t hipGraphDestroyNode(hipGraphNode_t node)

Remove a node from the graph.

hipGraphMemcpyNodeSetParamsFromSymbol

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

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

hipGraphRemoveDependencies

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

Removes dependency edges from a graph.

hipGraphMemcpyNodeSetParams1D

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

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

hipGraphExecMemcpyNodeSetParams1D

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

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

hipGraphExecDestroy

hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec)

Destroys an executable graph.

hipGraphAddExternalSemaphoresSignalNode

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

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

hipGraphExecExternalSemaphoresWaitNodeSetParams

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

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

hipGraphExecHostNodeSetParams

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

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

hipGraphExecChildGraphNodeSetParams

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

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

hipStreamGetCaptureInfo

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

Get capture status of a stream.

hipGraphAddDependencies

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

Adds dependency edges to a graph.

hipGraphExecKernelNodeSetParams

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

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

hipGraphNodeGetDependentNodes

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

Returns a node's dependent nodes.

hipDeviceGetGraphMemAttribute

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

Get the mem attribute for graphs.

hipGraphHostNodeGetParams

hipError_t hipGraphHostNodeGetParams(hipGraphNode_t node, hipHostNodeParams *pNodeParams)

Returns a host node's parameters.

hipGraphInstantiateWithFlags

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

Creates an executable graph from a graph.

hipGraphExternalSemaphoresWaitNodeGetParams

hipError_t hipGraphExternalSemaphoresWaitNodeGetParams(hipGraphNode_t hNode, const hipExternalSemaphoreWaitNodeParams *params_out)

Returns external semaphore wait node params.

hipGraphUpload

hipError_t hipGraphUpload(hipGraphExec_t graphExec, hipStream_t stream)

uploads an executable graph in a stream

hipGraphExecExternalSemaphoresSignalNodeSetParams

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

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

hipGraphExecMemcpyNodeSetParamsToSymbol

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

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

hipGraphKernelNodeGetParams

hipError_t hipGraphKernelNodeGetParams(hipGraphNode_t node, hipKernelNodeParams *pNodeParams)

Gets kernel node's parameters.

hipGraphExternalSemaphoresSignalNodeGetParams

hipError_t hipGraphExternalSemaphoresSignalNodeGetParams(hipGraphNode_t hNode, const hipExternalSemaphoreSignalNodeParams *params_out)

Returns external semaphore signal node params.

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.

hipGraphExternalSemaphoresWaitNodeSetParams

hipError_t hipGraphExternalSemaphoresWaitNodeSetParams(hipGraphNode_t hNode, const hipExternalSemaphoreWaitNodeParams *nodeParams)

Updates node parameters in the external semaphore wait node.

hipGraphMemsetNodeGetParams

hipError_t hipGraphMemsetNodeGetParams(hipGraphNode_t node, hipMemsetParams *pNodeParams)

Gets a memset node's parameters.

hipGraphChildGraphNodeGetGraph

hipError_t hipGraphChildGraphNodeGetGraph(hipGraphNode_t node, hipGraph_t *pGraph)

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

hipGraphKernelNodeGetAttribute

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

Gets a node attribute.

hipThreadExchangeStreamCaptureMode

hipError_t hipThreadExchangeStreamCaptureMode(hipStreamCaptureMode *mode)

Swaps the stream capture mode of a thread.

hipGraphLaunch

hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream)

launches an executable graph in a stream

hipGraphDebugDotPrint

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

Write a DOT file describing graph structure.

hipGraphExecMemsetNodeSetParams

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

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

hipGraphGetEdges

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

Returns a graph's dependency edges.

hipGraphAddKernelNode

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

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

hipGraphExecEventWaitNodeSetEvent

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

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

hipGraphAddExternalSemaphoresWaitNode

hipError_t hipGraphAddExternalSemaphoresWaitNode(hipGraphNode_t *pGraphNode, hipGraph_t graph, const hipGraphNode_t *pDependencies, size_t numDependencies, const hipExternalSemaphoreWaitNodeParams *nodeParams)

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

hipGraphEventWaitNodeSetEvent

hipError_t hipGraphEventWaitNodeSetEvent(hipGraphNode_t node, hipEvent_t event)

Sets an event wait node's event.

hipGraphEventRecordNodeSetEvent

hipError_t hipGraphEventRecordNodeSetEvent(hipGraphNode_t node, hipEvent_t event)

Sets an event record node's event.

hipGraphEventWaitNodeGetEvent

hipError_t hipGraphEventWaitNodeGetEvent(hipGraphNode_t node, hipEvent_t *event_out)

Returns the event associated with an event wait node.

hipGraphKernelNodeSetAttribute

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

Sets a node attribute.

hipGraphMemsetNodeSetParams

hipError_t hipGraphMemsetNodeSetParams(hipGraphNode_t node, const hipMemsetParams *pNodeParams)

Sets a memset node's parameters.

hipGraphEventRecordNodeGetEvent

hipError_t hipGraphEventRecordNodeGetEvent(hipGraphNode_t node, hipEvent_t *event_out)

Returns the event associated with an event record node.

hipGraphAddEmptyNode

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

Creates an empty node and adds it to a graph.

hipGraphAddMemcpyNodeToSymbol

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

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

hipGraphDestroy

hipError_t hipGraphDestroy(hipGraph_t graph)

Destroys a graph.

hipGraphExecMemcpyNodeSetParamsFromSymbol

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

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

hipGraphAddMemAllocNode

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

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

hipGraphAddHostNode

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

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

hipGraphGetNodes

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

Returns graph nodes.

hipGraphAddMemsetNode

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

Creates a memset node and adds it to a graph.

hipGraphInstantiate

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

Creates an executable graph from a graph.

hipDeviceGraphMemTrim

hipError_t hipDeviceGraphMemTrim(int device)

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

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.

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

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.

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.

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)

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

hipArrayGetDescriptor

hipError_t hipArrayGetDescriptor(HIP_ARRAY_DESCRIPTOR *pArrayDescriptor, hipArray *array)

Gets a 1D or 2D array descriptor.

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.

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)

Allocates device accessible page locked (pinned) 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)

Create a 3D array memory pointer on the device.

hipHostRegister

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

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

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)

Create a 3D memory pointer on the device.

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.

hipArrayGetInfo

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

Gets info about the specified array.

hipArray3DGetDescriptor

hipError_t hipArray3DGetDescriptor(HIP_ARRAY3D_DESCRIPTOR *pArrayDescriptor, hipArray *array)

Gets a 3D array descriptor.

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)

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

hipGetSymbolAddress

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

Gets device pointer associated with symbol on the device.

hipArrayCreate

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

Create an array memory pointer on the device.

hipMemAllocHost

hipError_t hipMemAllocHost(void **ptr, size_t size)

Allocate pinned host memory [Deprecated].

hipPointerGetAttribute

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

Returns information about the specified pointer.[BETA].

hipArrayDestroy

hipError_t hipArrayDestroy(hipArray *array)

Destroy an array memory pointer on the device.

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)

Get allocated memory size via memory pointer.

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

hipStreamAttachMemAsync

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

Attach memory to a stream asynchronously in HIP.

hipMemRangeGetAttributes

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

Query attributes of a given memory range in HIP.

hipMemAdvise

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

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

hipMemPrefetchAsync

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

Prefetches memory to the specified destination device using HIP.

hipMemRangeGetAttribute

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

Query an attribute of a given memory range in HIP.

hipMallocManaged

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

Allocates memory that will be automatically managed by HIP.

hipModuleLaunchCooperativeKernelMultiDevice

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

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

hipFuncGetAttributes

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

Find out attributes for a given function.

hipModuleGetTexRef

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

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

hipExtLaunchMultiKernelMultiDevice

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

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

hipModuleLaunchKernel

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

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

hipModuleLoad

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

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

hipModuleLoadDataEx

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

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

hipFuncGetAttribute

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

Find out a specific attribute for a given function.

hipLaunchCooperativeKernelMultiDevice

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

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

hipModuleLaunchCooperativeKernel

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

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

hipModuleGetFunction

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

Function with kname will be extracted if present in module.

hipLaunchCooperativeKernel

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

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

hipModuleLoadData

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

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

hipModuleUnload

hipError_t hipModuleUnload(hipModule_t module)

Frees the module.

hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags

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

Returns occupancy for a device function.

hipModuleOccupancyMaxPotentialBlockSize

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

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

hipOccupancyMaxActiveBlocksPerMultiprocessor

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

Returns occupancy for a device function.

hipOccupancyMaxPotentialBlockSize

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

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

hipModuleOccupancyMaxActiveBlocksPerMultiprocessor

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

Returns occupancy for a device function.

hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags

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

Returns occupancy for a device function.

hipModuleOccupancyMaxPotentialBlockSizeWithFlags

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

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

hipDeviceCanAccessPeer

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

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

hipDeviceEnablePeerAccess

hipError_t hipDeviceEnablePeerAccess(int peerDeviceId, unsigned int flags)

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

hipDeviceDisablePeerAccess

hipError_t hipDeviceDisablePeerAccess(int peerDeviceId)

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

hipMemGetAddressRange

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

Get information on memory allocations.

hipProfilerStart

hipError_t hipProfilerStart()

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

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

hipStreamGetDevice

hipError_t hipStreamGetDevice(hipStream_t stream, hipDevice_t *device)

Get the device assocaited with the stream.

hipStreamQuery

hipError_t hipStreamQuery(hipStream_t stream)

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

hipStreamSynchronize

hipError_t hipStreamSynchronize(hipStream_t stream)

Wait for all commands in stream to complete.

hipStreamWaitEvent

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

Make the specified compute stream wait for an event.

hipStreamCreateWithPriority

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

Create an asynchronous stream with the specified priority.

hipExtStreamCreateWithCUMask

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

Create an asynchronous stream with the specified CU mask.

hipStreamGetPriority

hipError_t hipStreamGetPriority(hipStream_t stream, int *priority)

Query the priority of a stream.

hipExtStreamGetCUMask

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

Get CU mask associated with an asynchronous stream.

hipStreamCreateWithFlags

hipError_t hipStreamCreateWithFlags(hipStream_t *stream, unsigned int flags)

Create an asynchronous stream.

hipStreamCreate

hipError_t hipStreamCreate(hipStream_t *stream)

Create an asynchronous stream.

hipStreamWriteValue64

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

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

hipStreamWriteValue32

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

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

hipStreamWaitValue32

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

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

hipStreamWaitValue64

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

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

hipMemPoolImportPointer

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

Import a memory pool allocation from another process.

hipMemPoolImportFromShareableHandle

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

Imports a memory pool from a shared handle.

hipMallocFromPoolAsync

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

Allocates memory from a specified pool with stream ordered semantics.

hipFreeAsync

hipError_t hipFreeAsync(void *dev_ptr, hipStream_t stream)

Frees memory with stream ordered semantics.

hipMemPoolTrimTo

hipError_t hipMemPoolTrimTo(hipMemPool_t mem_pool, size_t min_bytes_to_hold)

Releases freed memory back to the OS.

hipMemPoolCreate

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

Creates a memory pool.

hipMemPoolSetAccess

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

Controls visibility of the specified pool between devices.

hipMemPoolDestroy

hipError_t hipMemPoolDestroy(hipMemPool_t mem_pool)

Destroys the specified memory pool.

hipMemPoolSetAttribute

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

Sets attributes of a memory pool.

hipMemPoolGetAttribute

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

Gets attributes of a memory pool.

hipMemPoolExportToShareableHandle

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

Exports a memory pool to the requested handle type.

hipMemPoolExportPointer

hipError_t hipMemPoolExportPointer(hipMemPoolPtrExportData *export_data, void *dev_ptr)

Export data to share a memory pool allocation between processes.

hipMallocAsync

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

Allocates memory with stream ordered semantics.

hipMemPoolGetAccess

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

Returns the accessibility of a pool from a device.

hipDestroySurfaceObject

hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject)

Destroy a surface object.

hipCreateSurfaceObject

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

Create a surface object.

hipTexRefGetFilterMode

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

Gets filter mode for a texture reference.

hipBindTextureToMipmappedArray

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

Binds a mipmapped array to a texture.

hipTexRefGetMipmapLevelClamp

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

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

hipTexRefGetAddressMode

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

Gets the address mode for a texture reference.

hipTexRefGetFlags

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

Gets flags for a texture reference.

hipTexRefSetAddress

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

Sets an bound address for a texture reference.

hipTexRefSetFilterMode

hipError_t hipTexRefSetFilterMode(textureReference *texRef, enum hipTextureFilterMode fm)

Set filter mode for a texture reference.

hipTexRefSetMipmappedArray

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

Binds mipmapped array to a texture reference.

hipTexRefGetMipmapFilterMode

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

Gets the mipmap filter mode for a texture reference.

hipGetTextureAlignmentOffset

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

Get the offset of the alignment in a texture.

hipBindTexture2D

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

Binds a 2D memory area to a texture.

hipTexRefGetMaxAnisotropy

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

Gets the maximum anisotropy for a texture reference.

hipUnbindTexture

hipError_t hipUnbindTexture(const textureReference *tex)

Unbinds a texture.

hipTexRefSetFormat

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

Set format for a texture reference.

hipTexRefGetAddress

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

Gets the the address for a texture reference.

hipTexRefSetFlags

hipError_t hipTexRefSetFlags(textureReference *texRef, unsigned int Flags)

Set flags for a texture reference.

hipTexRefSetAddressMode

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

Sets address mode for a texture reference.

hipTexRefGetMipMappedArray

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

Gets the mipmapped array bound to a texture reference.

hipTexRefSetMaxAnisotropy

hipError_t hipTexRefSetMaxAnisotropy(textureReference *texRef, unsigned int maxAniso)

Sets the maximum anisotropy for a texture reference.

hipTexRefSetMipmapLevelClamp

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

Sets mipmap level clamp for a texture reference.

hipTexRefSetBorderColor

hipError_t hipTexRefSetBorderColor(textureReference *texRef, float *pBorderColor)

Sets border color for a texture reference.

hipTexRefSetArray

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

Binds an array as a texture reference.

hipTexRefSetMipmapLevelBias

hipError_t hipTexRefSetMipmapLevelBias(textureReference *texRef, float bias)

Sets mipmap level bias for a texture reference.

hipTexRefGetMipmapLevelBias

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

Gets the mipmap level bias for a texture reference.

hipBindTextureToArray

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

Binds a memory area to a texture.

hipBindTexture

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

Binds a memory area to a texture.

hipGetTextureReference

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

Gets the texture reference related with the symbol.

hipTexRefSetAddress2D

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

Set a bind an address as a 2D texture reference.

hipTexRefSetMipmapFilterMode

hipError_t hipTexRefSetMipmapFilterMode(textureReference *texRef, enum hipTextureFilterMode fm)

Sets mipmap filter mode for a texture reference.

hipTexRefGetFormat

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

Gets texture format for a texture reference.

hipFreeMipmappedArray

hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray)

Frees a mipmapped array on the device.

hipGetMipmappedArrayLevel

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

Gets a mipmap level of a HIP mipmapped array.

hipMipmappedArrayGetLevel

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

Get a mipmapped array on a mipmapped level.

hipMipmappedArrayDestroy

hipError_t hipMipmappedArrayDestroy(hipMipmappedArray_t hMipmappedArray)

Destroy a mipmapped array.

hipTexObjectCreate

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

Creates a texture object.

hipGetTextureObjectResourceDesc

hipError_t hipGetTextureObjectResourceDesc(hipResourceDesc *pResDesc, hipTextureObject_t textureObject)

Gets resource descriptor for the texture object.

hipGetTextureObjectResourceViewDesc

hipError_t hipGetTextureObjectResourceViewDesc(struct hipResourceViewDesc *pResViewDesc, hipTextureObject_t textureObject)

Gets resource view descriptor for the texture object.

hipTexObjectGetTextureDesc

hipError_t hipTexObjectGetTextureDesc(HIP_TEXTURE_DESC *pTexDesc, hipTextureObject_t texObject)

Gets texture descriptor of a texture object.

hipCreateTextureObject

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

Creates a texture object.

hipTexObjectDestroy

hipError_t hipTexObjectDestroy(hipTextureObject_t texObject)

Destroys a texture object.

hipMipmappedArrayCreate

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

Create a mipmapped array.

hipGetChannelDesc

hipError_t hipGetChannelDesc(hipChannelFormatDesc *desc, hipArray_const_t array)

Gets the channel descriptor in an array.

hipTexObjectGetResourceDesc

hipError_t hipTexObjectGetResourceDesc(HIP_RESOURCE_DESC *pResDesc, hipTextureObject_t texObject)

Gets resource descriptor of a texture object.

hipTexObjectGetResourceViewDesc

hipError_t hipTexObjectGetResourceViewDesc(HIP_RESOURCE_VIEW_DESC *pResViewDesc, hipTextureObject_t texObject)

Gets resource view descriptor of a texture object.

hipDestroyTextureObject

hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject)

Destroys a texture object.

hipMallocMipmappedArray

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

Allocate a mipmapped array on the device.

hipGetTextureObjectTextureDesc

hipError_t hipGetTextureObjectTextureDesc(hipTextureDesc *pTexDesc, hipTextureObject_t textureObject)

Gets texture descriptor for the texture object.

hipMemAddressFree

hipError_t hipMemAddressFree(void *devPtr, size_t size)

Frees an address range reservation made via hipMemAddressReserve.

hipMemExportToShareableHandle

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

Exports an allocation to a requested shareable handle type.

hipMemGetAccess

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

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

hipMemSetAccess

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

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

hipMemRelease

hipError_t hipMemRelease(hipMemGenericAllocationHandle_t handle)

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

hipMemUnmap

hipError_t hipMemUnmap(void *ptr, size_t size)

Unmap memory allocation of a given address range.

hipMemGetAllocationGranularity

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

Calculates either the minimal or recommended granularity.

hipMemRetainAllocationHandle

hipError_t hipMemRetainAllocationHandle(hipMemGenericAllocationHandle_t *handle, void *addr)

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

hipMemCreate

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

Creates a memory allocation described by the properties and size.

hipMemMap

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

Maps an allocation handle to a reserved virtual address range.

hipMemAddressReserve

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

Reserves an address range.

hipMemGetAllocationPropertiesFromHandle

hipError_t hipMemGetAllocationPropertiesFromHandle(hipMemAllocationProp *prop, hipMemGenericAllocationHandle_t handle)

Retrieve the property structure of the given handle.

hipMemMapArrayAsync

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

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

hipMemImportFromShareableHandle

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

Imports an allocation from a requested shareable handle type.

hip_common.h

hipErrorIllegalAddress

hipErrorIllegalAddress

Definition hip_runtime_api.h:278

hipErrorMemoryAllocation

hipErrorMemoryAllocation

Memory allocation error.

Definition hip_runtime_api.h:224

hipErrorNotFound

hipErrorNotFound

Not found.

Definition hip_runtime_api.h:273

hipErrorProfilerDisabled

hipErrorProfilerDisabled

Definition hip_runtime_api.h:229

hipErrorInvalidDevicePointer

hipErrorInvalidDevicePointer

Invalid Device Pointer.

Definition hip_runtime_api.h:236

hipErrorRuntimeMemory

hipErrorRuntimeMemory

Definition hip_runtime_api.h:327

hipErrorInvalidImage

hipErrorInvalidImage

Invalid image.

Definition hip_runtime_api.h:244

hipErrorPeerAccessUnsupported

hipErrorPeerAccessUnsupported

Definition hip_runtime_api.h:261

hipErrorArrayIsMapped

hipErrorArrayIsMapped

Definition hip_runtime_api.h:251

hipErrorStreamCaptureIsolation

hipErrorStreamCaptureIsolation

Definition hip_runtime_api.h:308

hipErrorInvalidKernelFile

hipErrorInvalidKernelFile

In CUDA DRV, it is CUDA_ERROR_INVALID_PTX.

Definition hip_runtime_api.h:262

hipErrorNotMapped

hipErrorNotMapped

Definition hip_runtime_api.h:255

hipErrorGraphExecUpdateFailure

hipErrorGraphExecUpdateFailure

Definition hip_runtime_api.h:321

hipErrorNotInitialized

hipErrorNotInitialized

Invalid not initialized.

Definition hip_runtime_api.h:225

hipErrorInvalidResourceHandle

hipErrorInvalidResourceHandle

Resource handle (hipEvent_t or hipStream_t) invalid.

Definition hip_runtime_api.h:271

hipErrorSharedObjectInitFailed

hipErrorSharedObjectInitFailed

Failed to initialize shared object.

Definition hip_runtime_api.h:267

hipErrorInvalidPitchValue

hipErrorInvalidPitchValue

Invalid pitch value.

Definition hip_runtime_api.h:234

hipErrorNoBinaryForGpu

hipErrorNoBinaryForGpu

Definition hip_runtime_api.h:253

hipErrorInvalidContext

hipErrorInvalidContext

Produced when input context is invalid.

Definition hip_runtime_api.h:245

hipErrorStreamCaptureUnsupported

hipErrorStreamCaptureUnsupported

Definition hip_runtime_api.h:299

hipErrorPeerAccessNotEnabled

hipErrorPeerAccessNotEnabled

Peer access was never enabled from the current device.

Definition hip_runtime_api.h:283

hipErrorOperatingSystem

hipErrorOperatingSystem

Not the correct operating system.

Definition hip_runtime_api.h:268

hipErrorStreamCaptureUnjoined

hipErrorStreamCaptureUnjoined

Definition hip_runtime_api.h:306

hipErrorInitializationError

hipErrorInitializationError

Definition hip_runtime_api.h:227

hipErrorNotMappedAsPointer

hipErrorNotMappedAsPointer

Definition hip_runtime_api.h:257

hipErrorPriorLaunchFailure

hipErrorPriorLaunchFailure

Definition hip_runtime_api.h:240

hipErrorContextIsDestroyed

hipErrorContextIsDestroyed

The context is already destroyed.

Definition hip_runtime_api.h:286

hipErrorInvalidValue

hipErrorInvalidValue

Definition hip_runtime_api.h:220

hipErrorLaunchTimeOut

hipErrorLaunchTimeOut

Timeout for the launch.

Definition hip_runtime_api.h:280

hipErrorUnmapFailed

hipErrorUnmapFailed

Definition hip_runtime_api.h:250

hipErrorSetOnActiveProcess

hipErrorSetOnActiveProcess

The process is active.

Definition hip_runtime_api.h:285

hipErrorFileNotFound

hipErrorFileNotFound

the file is not found.

Definition hip_runtime_api.h:265

hipErrorLaunchFailure

hipErrorLaunchFailure

An exception occurred on the device while executing a kernel.

Definition hip_runtime_api.h:292

hipErrorInvalidDevice

hipErrorInvalidDevice

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

Definition hip_runtime_api.h:243

hipErrorUnsupportedLimit

hipErrorUnsupportedLimit

Unsupported limit.

Definition hip_runtime_api.h:259

hipErrorMapBufferObjectFailed

hipErrorMapBufferObjectFailed

Produced when the IPC memory attach failed from ROCr.

Definition hip_runtime_api.h:249

hipErrorHostMemoryAlreadyRegistered

hipErrorHostMemoryAlreadyRegistered

Produced when trying to lock a page-locked memory.

Definition hip_runtime_api.h:288

hipErrorMissingConfiguration

hipErrorMissingConfiguration

Definition hip_runtime_api.h:239

hipErrorSharedObjectSymbolNotFound

hipErrorSharedObjectSymbolNotFound

Definition hip_runtime_api.h:266

hipErrorECCNotCorrectable

hipErrorECCNotCorrectable

Definition hip_runtime_api.h:258

hipErrorStreamCaptureWrongThread

hipErrorStreamCaptureWrongThread

Definition hip_runtime_api.h:317

hipErrorAssert

hipErrorAssert

Produced when the kernel calls assert.

Definition hip_runtime_api.h:287

hipErrorContextAlreadyInUse

hipErrorContextAlreadyInUse

The context is already in use.

Definition hip_runtime_api.h:260

hipErrorNotReady

hipErrorNotReady

Definition hip_runtime_api.h:274

hipErrorInvalidSource

hipErrorInvalidSource

Invalid source.

Definition hip_runtime_api.h:264

hipErrorLaunchOutOfResources

hipErrorLaunchOutOfResources

Out of resources error.

Definition hip_runtime_api.h:279

hipErrorInvalidDeviceFunction

hipErrorInvalidDeviceFunction

Invalid device function.

Definition hip_runtime_api.h:241

hipErrorCooperativeLaunchTooLarge

hipErrorCooperativeLaunchTooLarge

Definition hip_runtime_api.h:294

hipErrorAlreadyMapped

hipErrorAlreadyMapped

Definition hip_runtime_api.h:252

hipErrorProfilerNotInitialized

hipErrorProfilerNotInitialized

Definition hip_runtime_api.h:230

hipErrorProfilerAlreadyStarted

hipErrorProfilerAlreadyStarted

Definition hip_runtime_api.h:231

hipErrorNoDevice

hipErrorNoDevice

Call to hipGetDeviceCount returned 0 devices.

Definition hip_runtime_api.h:242

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

hipErrorStreamCaptureInvalidated

hipErrorStreamCaptureInvalidated

Definition hip_runtime_api.h:301

hipErrorProfilerAlreadyStopped

hipErrorProfilerAlreadyStopped

Definition hip_runtime_api.h:232

hipErrorDeinitialized

hipErrorDeinitialized

Deinitialized.

Definition hip_runtime_api.h:228

hipErrorPeerAccessAlreadyEnabled

hipErrorPeerAccessAlreadyEnabled

Peer access was already enabled from the current device.

Definition hip_runtime_api.h:281

hipErrorNotMappedAsArray

hipErrorNotMappedAsArray

Definition hip_runtime_api.h:256

hipErrorNotSupported

hipErrorNotSupported

Produced when the hip API is not supported/implemented.

Definition hip_runtime_api.h:298

hipErrorInvalidConfiguration

hipErrorInvalidConfiguration

Invalide configuration.

Definition hip_runtime_api.h:233

hipErrorStreamCaptureImplicit

hipErrorStreamCaptureImplicit

Definition hip_runtime_api.h:312

hipErrorStreamCaptureMerge

hipErrorStreamCaptureMerge

Definition hip_runtime_api.h:303

hipErrorInvalidGraphicsContext

hipErrorInvalidGraphicsContext

Definition hip_runtime_api.h:263

hipErrorIllegalState

hipErrorIllegalState

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

Definition hip_runtime_api.h:272

hipErrorOutOfMemory

hipErrorOutOfMemory

out of memory range.

Definition hip_runtime_api.h:222

hipErrorInvalidSymbol

hipErrorInvalidSymbol

Invalid symbol.

Definition hip_runtime_api.h:235

hipSuccess

hipSuccess

Successful completion.

Definition hip_runtime_api.h:219

hipErrorUnknown

hipErrorUnknown

Unknown error.

Definition hip_runtime_api.h:325

hipErrorInvalidHandle

hipErrorInvalidHandle

Invalide handle.

Definition hip_runtime_api.h:269

hipErrorStreamCaptureUnmatched

hipErrorStreamCaptureUnmatched

The capture was not initiated in this stream.

Definition hip_runtime_api.h:305

hipErrorCapturedEvent

hipErrorCapturedEvent

Definition hip_runtime_api.h:315

hipErrorAlreadyAcquired

hipErrorAlreadyAcquired

Definition hip_runtime_api.h:254

hipErrorInsufficientDriver

hipErrorInsufficientDriver

Definition hip_runtime_api.h:238

hipErrorHostMemoryNotRegistered

hipErrorHostMemoryNotRegistered

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

Definition hip_runtime_api.h:290

hipErrorRuntimeOther

hipErrorRuntimeOther

Definition hip_runtime_api.h:329

hipErrorContextAlreadyCurrent

hipErrorContextAlreadyCurrent

Definition hip_runtime_api.h:246

hipErrorInvalidMemcpyDirection

hipErrorInvalidMemcpyDirection

Invalid memory copy direction.

Definition hip_runtime_api.h:237

HIP_ARRAY3D_DESCRIPTOR

Definition driver_types.h:76

HIP_ARRAY_DESCRIPTOR

Definition driver_types.h:70

HIP_MEMCPY3D

Definition driver_types.h:384

HIP_RESOURCE_DESC

Definition driver_types.h:287

HIP_RESOURCE_VIEW_DESC

Definition driver_types.h:333

HIP_TEXTURE_DESC

Definition driver_types.h:170

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

hipAccessPolicyWindow

Definition hip_runtime_api.h:1178

hipAccessPolicyWindow::hitProp

hipAccessProperty hitProp

Definition hip_runtime_api.h:1180

hipAccessPolicyWindow::missProp

hipAccessProperty missProp

Definition hip_runtime_api.h:1182

hipAccessPolicyWindow::hitRatio

float hitRatio

Definition hip_runtime_api.h:1181

hipAccessPolicyWindow::base_ptr

void * base_ptr

Definition hip_runtime_api.h:1179

hipAccessPolicyWindow::num_bytes

size_t num_bytes

Definition hip_runtime_api.h:1183

hipArray

Definition driver_types.h:84

hipArrayMapInfo

Definition hip_runtime_api.h:1346

hipArrayMapInfo::level

unsigned int level

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

Definition hip_runtime_api.h:1355

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

hipArrayMapInfo::resource

union hipArrayMapInfo::@25 resource

hipArrayMapInfo::subresourceType

hipArraySparseSubresourceType subresourceType

Sparse subresource type.

Definition hip_runtime_api.h:1352

hipArrayMapInfo::extentDepth

unsigned int extentDepth

Depth in elements.

Definition hip_runtime_api.h:1362

hipArrayMapInfo::offsetX

unsigned int offsetX

X offset in elements.

Definition hip_runtime_api.h:1357

hipArrayMapInfo::array

hipArray_t array

Definition hip_runtime_api.h:1350

hipArrayMapInfo::resourceType

hipResourceType resourceType

Resource type.

Definition hip_runtime_api.h:1347

hipArrayMapInfo::memOperationType

hipMemOperationType memOperationType

Memory operation type.

Definition hip_runtime_api.h:1370

hipArrayMapInfo::reserved

unsigned int reserved[2]

Reserved for future use, must be zero now.

Definition hip_runtime_api.h:1378

hipArrayMapInfo::extentWidth

unsigned int extentWidth

Width in elements.

Definition hip_runtime_api.h:1360

hipArrayMapInfo::subresource

union hipArrayMapInfo::@26 subresource

hipArrayMapInfo::extentHeight

unsigned int extentHeight

Height in elements.

Definition hip_runtime_api.h:1361

hipArrayMapInfo::offsetY

unsigned int offsetY

Y offset in elements.

Definition hip_runtime_api.h:1358

hipArrayMapInfo::memHandleType

hipMemHandleType memHandleType

Memory handle type.

Definition hip_runtime_api.h:1371

hipArrayMapInfo::miptail

struct hipArrayMapInfo::@26::@29 miptail

hipArrayMapInfo::memHandle

hipMemGenericAllocationHandle_t memHandle

Definition hip_runtime_api.h:1373

hipArrayMapInfo::mipmap

hipMipmappedArray mipmap

Definition hip_runtime_api.h:1349

hipArrayMapInfo::layer

unsigned int layer

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

Definition hip_runtime_api.h:1356

hipArrayMapInfo::deviceBitMask

unsigned int deviceBitMask

Device ordinal bit mask.

Definition hip_runtime_api.h:1376

hipArrayMapInfo::size

unsigned long long size

Extent in bytes.

Definition hip_runtime_api.h:1367

hipArrayMapInfo::offset

unsigned long long offset

Offset within mip tail.

Definition hip_runtime_api.h:1366

hipArrayMapInfo::offsetZ

unsigned int offsetZ

Z offset in elements.

Definition hip_runtime_api.h:1359

hipChannelFormatDesc

Definition driver_types.h:49

hipDeviceArch_t

Definition hip_runtime_api.h:54

hipDeviceArch_t::hasSharedInt64Atomics

unsigned hasSharedInt64Atomics

64-bit integer atomics for shared memory.

Definition hip_runtime_api.h:64

hipDeviceArch_t::hasSharedInt32Atomics

unsigned hasSharedInt32Atomics

32-bit integer atomics for shared memory.

Definition hip_runtime_api.h:58

hipDeviceArch_t::hasFloatAtomicAdd

unsigned hasFloatAtomicAdd

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

Definition hip_runtime_api.h:60

hipDeviceArch_t::hasDoubles

unsigned hasDoubles

Double-precision floating point.

Definition hip_runtime_api.h:67

hipDeviceArch_t::hasWarpVote

unsigned hasWarpVote

Warp vote instructions (__any, __all).

Definition hip_runtime_api.h:70

hipDeviceArch_t::hasWarpShuffle

unsigned hasWarpShuffle

Warp shuffle operations. (__shfl_*).

Definition hip_runtime_api.h:72

hipDeviceArch_t::hasGlobalInt32Atomics

unsigned hasGlobalInt32Atomics

32-bit integer atomics for global memory.

Definition hip_runtime_api.h:56

hipDeviceArch_t::hasGlobalFloatAtomicExch

unsigned hasGlobalFloatAtomicExch

32-bit float atomic exch for global memory.

Definition hip_runtime_api.h:57

hipDeviceArch_t::hasDynamicParallelism

unsigned hasDynamicParallelism

Dynamic parallelism.

Definition hip_runtime_api.h:82

hipDeviceArch_t::hasSurfaceFuncs

unsigned hasSurfaceFuncs

Surface functions.

Definition hip_runtime_api.h:80

hipDeviceArch_t::has3dGrid

unsigned has3dGrid

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

Definition hip_runtime_api.h:81

hipDeviceArch_t::hasFunnelShift

unsigned hasFunnelShift

Funnel two words into one with shift&mask caps.

Definition hip_runtime_api.h:73

hipDeviceArch_t::hasThreadFenceSystem

unsigned hasThreadFenceSystem

__threadfence_system.

Definition hip_runtime_api.h:76

hipDeviceArch_t::hasGlobalInt64Atomics

unsigned hasGlobalInt64Atomics

64-bit integer atomics for global memory.

Definition hip_runtime_api.h:63

hipDeviceArch_t::hasSyncThreadsExt

unsigned hasSyncThreadsExt

__syncthreads_count, syncthreads_and, syncthreads_or.

Definition hip_runtime_api.h:77

hipDeviceArch_t::hasWarpBallot

unsigned hasWarpBallot

Warp ballot instructions (__ballot).

Definition hip_runtime_api.h:71

hipDeviceArch_t::hasSharedFloatAtomicExch

unsigned hasSharedFloatAtomicExch

32-bit float atomic exch for shared memory.

Definition hip_runtime_api.h:59

hipDeviceProp_t

Definition hip_runtime_api.h:96

hipDeviceProp_t::ECCEnabled

int ECCEnabled

Device has ECC support enabled.

Definition hip_runtime_api.h:144

hipDeviceProp_t::maxTexture1DLinear

int maxTexture1DLinear

Maximum size for 1D textures bound to linear memory.

Definition hip_runtime_api.h:134

hipDeviceProp_t::pciBusID

int pciBusID

PCI Bus ID.

Definition hip_runtime_api.h:124

hipDeviceProp_t::maxTexture1D

int maxTexture1D

Maximum number of elements in 1D images.

Definition hip_runtime_api.h:135

hipDeviceProp_t::memoryBusWidth

int memoryBusWidth

Global memory bus width in bits.

Definition hip_runtime_api.h:107

hipDeviceProp_t::clockRate

int clockRate

Max clock frequency of the multiProcessors in khz.

Definition hip_runtime_api.h:105

hipDeviceProp_t::maxThreadsPerMultiProcessor

int maxThreadsPerMultiProcessor

Maximum resident threads per multi-processor.

Definition hip_runtime_api.h:117

hipDeviceProp_t::l2CacheSize

int l2CacheSize

L2 cache size.

Definition hip_runtime_api.h:116

hipDeviceProp_t::totalConstMem

size_t totalConstMem

Size of shared memory region (in bytes).

Definition hip_runtime_api.h:108

hipDeviceProp_t::memPitch

size_t memPitch

Maximum pitch in bytes allowed by memory copies.

Definition hip_runtime_api.h:140

hipDeviceProp_t::sharedMemPerBlock

size_t sharedMemPerBlock

Size of shared memory region (in bytes).

Definition hip_runtime_api.h:99

hipDeviceProp_t::cooperativeMultiDeviceLaunch

int cooperativeMultiDeviceLaunch

HIP device supports cooperative launch on multiple devices.

Definition hip_runtime_api.h:133

hipDeviceProp_t::pageableMemoryAccess

int pageableMemoryAccess

Definition hip_runtime_api.h:159

hipDeviceProp_t::name

char name[256]

Device name.

Definition hip_runtime_api.h:97

hipDeviceProp_t::textureAlignment

size_t textureAlignment

Alignment requirement for textures.

Definition hip_runtime_api.h:141

hipDeviceProp_t::memoryClockRate

int memoryClockRate

Max global memory clock frequency in khz.

Definition hip_runtime_api.h:106

hipDeviceProp_t::clockInstructionRate

int clockInstructionRate

Definition hip_runtime_api.h:119

hipDeviceProp_t::regsPerBlock

int regsPerBlock

Registers per block.

Definition hip_runtime_api.h:100

hipDeviceProp_t::maxTexture2D

int maxTexture2D[2]

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

Definition hip_runtime_api.h:136

hipDeviceProp_t::cooperativeLaunch

int cooperativeLaunch

HIP device supports cooperative launch.

Definition hip_runtime_api.h:132

hipDeviceProp_t::maxTexture3D

int maxTexture3D[3]

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

Definition hip_runtime_api.h:137

hipDeviceProp_t::directManagedMemAccessFromHost

int directManagedMemAccessFromHost

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

Definition hip_runtime_api.h:157

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedFunc

int cooperativeMultiDeviceUnmatchedFunc

Definition hip_runtime_api.h:146

hipDeviceProp_t::pageableMemoryAccessUsesHostPageTables

int pageableMemoryAccessUsesHostPageTables

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

Definition hip_runtime_api.h:161

hipDeviceProp_t::hdpRegFlushCntl

unsigned int * hdpRegFlushCntl

Addres of HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:139

hipDeviceProp_t::maxThreadsDim

int maxThreadsDim[3]

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

Definition hip_runtime_api.h:103

hipDeviceProp_t::isMultiGpuBoard

int isMultiGpuBoard

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

Definition hip_runtime_api.h:127

hipDeviceProp_t::pciDomainID

int pciDomainID

PCI Domain ID.

Definition hip_runtime_api.h:123

hipDeviceProp_t::maxSharedMemoryPerMultiProcessor

size_t maxSharedMemoryPerMultiProcessor

Maximum Shared Memory Per Multiprocessor.

Definition hip_runtime_api.h:126

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedGridDim

int cooperativeMultiDeviceUnmatchedGridDim

Definition hip_runtime_api.h:148

hipDeviceProp_t::minor

int minor

Definition hip_runtime_api.h:112

hipDeviceProp_t::gcnArchName

char gcnArchName[256]

AMD GCN Arch Name.

Definition hip_runtime_api.h:130

hipDeviceProp_t::kernelExecTimeoutEnabled

int kernelExecTimeoutEnabled

Run time limit for kernels executed on the device.

Definition hip_runtime_api.h:143

hipDeviceProp_t::hdpMemFlushCntl

unsigned int * hdpMemFlushCntl

Addres of HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:138

hipDeviceProp_t::concurrentManagedAccess

int concurrentManagedAccess

Device can coherently access managed memory concurrently with the CPU.

Definition hip_runtime_api.h:158

hipDeviceProp_t::integrated

int integrated

APU vs dGPU.

Definition hip_runtime_api.h:131

hipDeviceProp_t::canMapHostMemory

int canMapHostMemory

Check whether HIP can map host memory.

Definition hip_runtime_api.h:128

hipDeviceProp_t::asicRevision

int asicRevision

Revision of the GPU in this device.

Definition hip_runtime_api.h:155

hipDeviceProp_t::totalGlobalMem

size_t totalGlobalMem

Size of global memory region (in bytes).

Definition hip_runtime_api.h:98

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedBlockDim

int cooperativeMultiDeviceUnmatchedBlockDim

Definition hip_runtime_api.h:150

hipDeviceProp_t::concurrentKernels

int concurrentKernels

Device can possibly execute multiple kernels concurrently.

Definition hip_runtime_api.h:122

hipDeviceProp_t::isLargeBar

int isLargeBar

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

Definition hip_runtime_api.h:154

hipDeviceProp_t::gcnArch

int gcnArch

DEPRECATED: use gcnArchName instead.

Definition hip_runtime_api.h:129

hipDeviceProp_t::multiProcessorCount

int multiProcessorCount

Number of multi-processors (compute units).

Definition hip_runtime_api.h:115

hipDeviceProp_t::maxGridSize

int maxGridSize[3]

Max grid dimensions (XYZ).

Definition hip_runtime_api.h:104

hipDeviceProp_t::pciDeviceID

int pciDeviceID

PCI Device ID.

Definition hip_runtime_api.h:125

hipDeviceProp_t::computeMode

int computeMode

Compute mode.

Definition hip_runtime_api.h:118

hipDeviceProp_t::major

int major

Definition hip_runtime_api.h:109

hipDeviceProp_t::warpSize

int warpSize

Warp size.

Definition hip_runtime_api.h:101

hipDeviceProp_t::tccDriver

int tccDriver

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

Definition hip_runtime_api.h:145

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedSharedMem

int cooperativeMultiDeviceUnmatchedSharedMem

Definition hip_runtime_api.h:152

hipDeviceProp_t::maxThreadsPerBlock

int maxThreadsPerBlock

Max work items per work group or workgroup max size.

Definition hip_runtime_api.h:102

hipDeviceProp_t::arch

hipDeviceArch_t arch

Architectural feature flags. New for HIP.

Definition hip_runtime_api.h:121

hipDeviceProp_t::managedMemory

int managedMemory

Device supports allocating managed memory on this system.

Definition hip_runtime_api.h:156

hipDeviceProp_t::texturePitchAlignment

size_t texturePitchAlignment

Pitch alignment requirement for texture references bound to pitched memory.

Definition hip_runtime_api.h:142

hipExtent

Definition driver_types.h:363

hipExternalMemoryBufferDesc

Definition hip_runtime_api.h:1003

hipExternalMemoryBufferDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1006

hipExternalMemoryBufferDesc::offset

unsigned long long offset

Definition hip_runtime_api.h:1004

hipExternalMemoryBufferDesc::size

unsigned long long size

Definition hip_runtime_api.h:1005

hipExternalMemoryHandleDesc

Definition hip_runtime_api.h:991

hipExternalMemoryHandleDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1001

hipExternalMemoryHandleDesc::name

const void * name

Definition hip_runtime_api.h:997

hipExternalMemoryHandleDesc::fd

int fd

Definition hip_runtime_api.h:994

hipExternalMemoryHandleDesc::size

unsigned long long size

Definition hip_runtime_api.h:1000

hipExternalMemoryHandleDesc::type

hipExternalMemoryHandleType type

Definition hip_runtime_api.h:992

hipExternalMemoryHandleDesc::handle

void * handle

Definition hip_runtime_api.h:996

hipExternalSemaphoreHandleDesc

Definition hip_runtime_api.h:1015

hipExternalSemaphoreHandleDesc::flags

unsigned int flags

Definition hip_runtime_api.h:1024

hipExternalSemaphoreHandleDesc::name

const void * name

Definition hip_runtime_api.h:1021

hipExternalSemaphoreHandleDesc::type

hipExternalSemaphoreHandleType type

Definition hip_runtime_api.h:1016

hipExternalSemaphoreHandleDesc::handle

void * handle

Definition hip_runtime_api.h:1020

hipExternalSemaphoreHandleDesc::fd

int fd

Definition hip_runtime_api.h:1018

hipExternalSemaphoreSignalNodeParams

Definition hip_runtime_api.h:1286

hipExternalSemaphoreSignalNodeParams::paramsArray

const hipExternalSemaphoreSignalParams * paramsArray

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

Definition hip_runtime_api.h:1290

hipExternalSemaphoreSignalNodeParams::extSemArray

hipExternalSemaphore_t * extSemArray

< Array containing external semaphore handles.

Definition hip_runtime_api.h:1288

hipExternalSemaphoreSignalNodeParams::numExtSems

unsigned int numExtSems

Definition hip_runtime_api.h:1292

hipExternalSemaphoreSignalParams

Definition hip_runtime_api.h:1027

hipExternalSemaphoreSignalParams::value

unsigned long long value

Definition hip_runtime_api.h:1030

hipExternalSemaphoreSignalParams::flags

unsigned int flags

Definition hip_runtime_api.h:1037

hipExternalSemaphoreSignalParams::key

unsigned long long key

Definition hip_runtime_api.h:1033

hipExternalSemaphoreWaitNodeParams

Definition hip_runtime_api.h:1298

hipExternalSemaphoreWaitNodeParams::numExtSems

unsigned int numExtSems

Definition hip_runtime_api.h:1304

hipExternalSemaphoreWaitNodeParams::paramsArray

const hipExternalSemaphoreWaitParams * paramsArray

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

Definition hip_runtime_api.h:1302

hipExternalSemaphoreWaitNodeParams::extSemArray

hipExternalSemaphore_t * extSemArray

< Array containing external semaphore handles.

Definition hip_runtime_api.h:1300

hipExternalSemaphoreWaitParams

Definition hip_runtime_api.h:1043

hipExternalSemaphoreWaitParams::value

unsigned long long value

Definition hip_runtime_api.h:1046

hipExternalSemaphoreWaitParams::timeoutMs

unsigned int timeoutMs

Definition hip_runtime_api.h:1050

hipExternalSemaphoreWaitParams::key

unsigned long long key

Definition hip_runtime_api.h:1049

hipExternalSemaphoreWaitParams::flags

unsigned int flags

Definition hip_runtime_api.h:1054

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

hipFunctionLaunchParams::gridDimX

unsigned int gridDimX

Width(X) of grid in blocks.

Definition hip_runtime_api.h:972

hipFunctionLaunchParams::blockDimX

unsigned int blockDimX

X dimension of each thread block.

Definition hip_runtime_api.h:975

hipFunctionLaunchParams::function

hipFunction_t function

Kernel to launch.

Definition hip_runtime_api.h:971

hipFunctionLaunchParams::hStream

hipStream_t hStream

Stream identifier.

Definition hip_runtime_api.h:979

hipFunctionLaunchParams::blockDimY

unsigned int blockDimY

Y dimension of each thread block.

Definition hip_runtime_api.h:976

hipFunctionLaunchParams::gridDimY

unsigned int gridDimY

Height(Y) of grid in blocks.

Definition hip_runtime_api.h:973

hipFunctionLaunchParams::gridDimZ

unsigned int gridDimZ

Depth(Z) of grid in blocks.

Definition hip_runtime_api.h:974

hipFunctionLaunchParams::sharedMemBytes

unsigned int sharedMemBytes

Shared memory.

Definition hip_runtime_api.h:978

hipFunctionLaunchParams::blockDimZ

unsigned int blockDimZ

Z dimension of each thread block.

Definition hip_runtime_api.h:977

hipFunctionLaunchParams::kernelParams

void ** kernelParams

Kernel parameters.

Definition hip_runtime_api.h:980

hipHostNodeParams

Definition hip_runtime_api.h:1135

hipHostNodeParams::fn

hipHostFn_t fn

Definition hip_runtime_api.h:1136

hipHostNodeParams::userData

void * userData

Definition hip_runtime_api.h:1137

hipIpcEventHandle_t

Definition hip_runtime_api.h:535

hipIpcMemHandle_t

Definition hip_runtime_api.h:532

hipKernelNodeParams

Definition hip_runtime_api.h:1139

hipKernelNodeParams::gridDim

dim3 gridDim

Definition hip_runtime_api.h:1143

hipKernelNodeParams::sharedMemBytes

unsigned int sharedMemBytes

Definition hip_runtime_api.h:1145

hipKernelNodeParams::blockDim

dim3 blockDim

Definition hip_runtime_api.h:1140

hipKernelNodeParams::kernelParams

void ** kernelParams

Definition hip_runtime_api.h:1144

hipKernelNodeParams::extra

void ** extra

Definition hip_runtime_api.h:1141

hipKernelNodeParams::func

void * func

Definition hip_runtime_api.h:1142

hipLaunchParams

Definition hip_runtime_api.h:959

hipLaunchParams::sharedMem

size_t sharedMem

Shared memory.

Definition hip_runtime_api.h:964

hipLaunchParams::args

void ** args

Arguments.

Definition hip_runtime_api.h:963

hipLaunchParams::blockDim

dim3 blockDim

Block dimentions.

Definition hip_runtime_api.h:962

hipLaunchParams::gridDim

dim3 gridDim

Grid dimentions.

Definition hip_runtime_api.h:961

hipLaunchParams::func

void * func

Device function symbol.

Definition hip_runtime_api.h:960

hipLaunchParams::stream

hipStream_t stream

Stream identifier.

Definition hip_runtime_api.h:965

hipMemAccessDesc

Definition hip_runtime_api.h:850

hipMemAccessDesc::flags

hipMemAccessFlags flags

Accessibility flags to set.

Definition hip_runtime_api.h:852

hipMemAccessDesc::location

hipMemLocation location

Location on which the accessibility has to change.

Definition hip_runtime_api.h:851

hipMemAllocNodeParams

Definition hip_runtime_api.h:1156

hipMemAllocNodeParams::accessDescs

const hipMemAccessDesc * accessDescs

Definition hip_runtime_api.h:1159

hipMemAllocNodeParams::bytesize

size_t bytesize

The size of the requested allocation in bytes.

Definition hip_runtime_api.h:1162

hipMemAllocNodeParams::poolProps

hipMemPoolProps poolProps

Definition hip_runtime_api.h:1157

hipMemAllocNodeParams::accessDescCount

size_t accessDescCount

The number of access descriptors.

Definition hip_runtime_api.h:1161

hipMemAllocNodeParams::dptr

void * dptr

Returned device address of the allocation.

Definition hip_runtime_api.h:1163

hipMemAllocationProp

Definition hip_runtime_api.h:1271

hipMemAllocationProp::win32HandleMetaData

void * win32HandleMetaData

Metadata for Win32 handles.

Definition hip_runtime_api.h:1275

hipMemAllocationProp::type

hipMemAllocationType type

Memory allocation type.

Definition hip_runtime_api.h:1272

hipMemAllocationProp::gpuDirectRDMACapable

unsigned char gpuDirectRDMACapable

RDMA capable.

Definition hip_runtime_api.h:1278

hipMemAllocationProp::allocFlags

struct hipMemAllocationProp::@24 allocFlags

hipMemAllocationProp::usage

unsigned short usage

Usage.

Definition hip_runtime_api.h:1279

hipMemAllocationProp::requestedHandleType

hipMemAllocationHandleType requestedHandleType

Requested handle type.

Definition hip_runtime_api.h:1273

hipMemAllocationProp::location

hipMemLocation location

Memory location.

Definition hip_runtime_api.h:1274

hipMemAllocationProp::compressionType

unsigned char compressionType

Compression type.

Definition hip_runtime_api.h:1277

hipMemLocation

Definition hip_runtime_api.h:834

hipMemLocation::id

int id

Identifier for the provided location type hipMemLocationType.

Definition hip_runtime_api.h:836

hipMemLocation::type

hipMemLocationType type

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

Definition hip_runtime_api.h:835

hipMemPoolProps

Definition hip_runtime_api.h:878

hipMemPoolProps::location

hipMemLocation location

Location where allocations should reside.

Definition hip_runtime_api.h:881

hipMemPoolProps::handleTypes

hipMemAllocationHandleType handleTypes

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

Definition hip_runtime_api.h:880

hipMemPoolProps::allocType

hipMemAllocationType allocType

Allocation type. Currently must be specified as hipMemAllocationTypePinned.

Definition hip_runtime_api.h:879

hipMemPoolProps::reserved

unsigned char reserved[64]

Reserved for future use, must be 0.

Definition hip_runtime_api.h:886

hipMemPoolProps::win32SecurityAttributes

void * win32SecurityAttributes

Definition hip_runtime_api.h:885

hipMemPoolPtrExportData

Definition hip_runtime_api.h:891

hipMemPoolPtrExportData::reserved

unsigned char reserved[64]

Definition hip_runtime_api.h:892

hipMemcpy3DParms

Definition driver_types.h:374

hipMemsetParams

Definition hip_runtime_api.h:1147

hipMemsetParams::dst

void * dst

Definition hip_runtime_api.h:1148

hipMemsetParams::value

unsigned int value

Definition hip_runtime_api.h:1152

hipMemsetParams::elementSize

unsigned int elementSize

Definition hip_runtime_api.h:1149

hipMemsetParams::width

size_t width

Definition hip_runtime_api.h:1153

hipMemsetParams::pitch

size_t pitch

Definition hip_runtime_api.h:1151

hipMemsetParams::height

size_t height

Definition hip_runtime_api.h:1150

hipMipmappedArray

Definition driver_types.h:120

hipPitchedPtr

Definition driver_types.h:357

hipPointerAttribute_t

Definition hip_runtime_api.h:189

hipPointerAttribute_t::device

int device

Definition hip_runtime_api.h:195

hipPointerAttribute_t::memoryType

enum hipMemoryType memoryType

Definition hip_runtime_api.h:192

hipPointerAttribute_t::hostPointer

void * hostPointer

Definition hip_runtime_api.h:197

hipPointerAttribute_t::type

enum hipMemoryType type

Definition hip_runtime_api.h:193

hipPointerAttribute_t::isManaged

int isManaged

Definition hip_runtime_api.h:198

hipPointerAttribute_t::devicePointer

void * devicePointer

Definition hip_runtime_api.h:196

hipPointerAttribute_t::allocationFlags

unsigned allocationFlags

Definition hip_runtime_api.h:199

hipResourceDesc

Definition driver_types.h:263

hipResourceViewDesc

Definition driver_types.h:319

hipTextureDesc

Definition texture_types.h:118

hipUUID

Definition hip_runtime_api.h:85

textureReference

Definition texture_types.h:97

surface_types.h

Defines surface types for HIP runtime.

hipSurfaceObject_t

struct __hip_surface * hipSurfaceObject_t

Definition surface_types.h:41

texture_types.h

hipTextureObject_t

struct __hip_texture * hipTextureObject_t

Definition texture_types.h:72

hipTextureAddressMode

hipTextureAddressMode

Definition texture_types.h:77

hipTextureFilterMode

hipTextureFilterMode

Definition texture_types.h:87

hipKernelNodeAttrValue

Definition hip_runtime_api.h:1185

hipKernelNodeAttrValue::cooperative

int cooperative

Definition hip_runtime_api.h:1187

hipKernelNodeAttrValue::accessPolicyWindow

hipAccessPolicyWindow accessPolicyWindow

Definition hip_runtime_api.h:1186