/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hip/checkouts/docs-5.1.3/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 - 2021 Advanced Micro Devices, Inc. All rights reserved.

3

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

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

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

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

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

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

10

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

12all copies or substantial portions of the Software.

13

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

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

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

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

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

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

20THE SOFTWARE.

21*/

22

30#ifndef HIP_INCLUDE_HIP_HIP_RUNTIME_API_H

31#define HIP_INCLUDE_HIP_HIP_RUNTIME_API_H

32

33

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

35#include <hip/hip_version.h>

36#include <hip/hip_common.h>

37

38enum {

39 HIP_SUCCESS = 0,

40 HIP_ERROR_INVALID_VALUE,

41 HIP_ERROR_NOT_INITIALIZED,

42 HIP_ERROR_LAUNCH_OUT_OF_RESOURCES

43};

44

45typedef struct {

46 // 32-bit Atomics

47 unsigned hasGlobalInt32Atomics : 1;

48 unsigned hasGlobalFloatAtomicExch : 1;

49 unsigned hasSharedInt32Atomics : 1;

50 unsigned hasSharedFloatAtomicExch : 1;

51 unsigned hasFloatAtomicAdd : 1;

52

53 // 64-bit Atomics

54 unsigned hasGlobalInt64Atomics : 1;

55 unsigned hasSharedInt64Atomics : 1;

56

57 // Doubles

58 unsigned hasDoubles : 1;

59

60 // Warp cross-lane operations

61 unsigned hasWarpVote : 1;

62 unsigned hasWarpBallot : 1;

63 unsigned hasWarpShuffle : 1;

64 unsigned hasFunnelShift : 1;

65

66 // Sync

67 unsigned hasThreadFenceSystem : 1;

68 unsigned hasSyncThreadsExt : 1;

69

70 // Misc

71 unsigned hasSurfaceFuncs : 1;

72 unsigned has3dGrid : 1;

73 unsigned hasDynamicParallelism : 1;

74} hipDeviceArch_t;

75

76

77//---

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

79

84typedef struct hipDeviceProp_t {

85 char name[256];

86 size_t totalGlobalMem;

87 size_t sharedMemPerBlock;

88 int regsPerBlock;

89 int warpSize;

90 int maxThreadsPerBlock;

91 int maxThreadsDim[3];

92 int maxGridSize[3];

93 int clockRate;

94 int memoryClockRate;

95 int memoryBusWidth;

96 size_t totalConstMem;

97 int major;

100 int minor;

103 int multiProcessorCount;

104 int l2CacheSize;

105 int maxThreadsPerMultiProcessor;

106 int computeMode;

107 int clockInstructionRate;

109 hipDeviceArch_t arch;

110 int concurrentKernels;

111 int pciDomainID;

112 int pciBusID;

113 int pciDeviceID;

114 size_t maxSharedMemoryPerMultiProcessor;

115 int isMultiGpuBoard;

116 int canMapHostMemory;

117 int gcnArch;

118 char gcnArchName[256];

119 int integrated;

120 int cooperativeLaunch;

121 int cooperativeMultiDeviceLaunch;

122 int maxTexture1DLinear;

123 int maxTexture1D;

124 int maxTexture2D[2];

125 int maxTexture3D[3];

126 unsigned int* hdpMemFlushCntl;

127 unsigned int* hdpRegFlushCntl;

128 size_t memPitch;

129 size_t textureAlignment;

130 size_t texturePitchAlignment;

131 int kernelExecTimeoutEnabled;

132 int ECCEnabled;

133 int tccDriver;

134 int cooperativeMultiDeviceUnmatchedFunc;

136 int cooperativeMultiDeviceUnmatchedGridDim;

138 int cooperativeMultiDeviceUnmatchedBlockDim;

140 int cooperativeMultiDeviceUnmatchedSharedMem;

142 int isLargeBar;

143 int asicRevision;

144 int managedMemory;

145 int directManagedMemAccessFromHost;

146 int concurrentManagedAccess;

147 int pageableMemoryAccess;

149 int pageableMemoryAccessUsesHostPageTables;

150} hipDeviceProp_t;

151

152

156typedef enum hipMemoryType {

157 hipMemoryTypeHost,

158 hipMemoryTypeDevice,

160 hipMemoryTypeArray,

162 hipMemoryTypeUnified

163} hipMemoryType;

164

165

169typedef struct hipPointerAttribute_t {

170 enum hipMemoryType memoryType;

171 int device;

172 void* devicePointer;

173 void* hostPointer;

174 int isManaged;

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

176 /* peers? */

177} hipPointerAttribute_t;

178

179

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

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

188// we can make that yield a warning

189#if __cplusplus >= 201703L

190#define __HIP_NODISCARD [[nodiscard]]

191#else

192#define __HIP_NODISCARD

193#endif

194

195/*

196 * @brief hipError_t

197 * @enum

198 * @ingroup Enumerations

199 */

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

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

202

203typedef enum __HIP_NODISCARD hipError_t {

204 hipSuccess = 0,

205 hipErrorInvalidValue = 1,

207 hipErrorOutOfMemory = 2,

208 // Deprecated

209 hipErrorMemoryAllocation = 2,

210 hipErrorNotInitialized = 3,

211 // Deprecated

212 hipErrorInitializationError = 3,

213 hipErrorDeinitialized = 4,

214 hipErrorProfilerDisabled = 5,

215 hipErrorProfilerNotInitialized = 6,

216 hipErrorProfilerAlreadyStarted = 7,

217 hipErrorProfilerAlreadyStopped = 8,

218 hipErrorInvalidConfiguration = 9,

219 hipErrorInvalidPitchValue = 12,

220 hipErrorInvalidSymbol = 13,

221 hipErrorInvalidDevicePointer = 17,

222 hipErrorInvalidMemcpyDirection = 21,

223 hipErrorInsufficientDriver = 35,

224 hipErrorMissingConfiguration = 52,

225 hipErrorPriorLaunchFailure = 53,

226 hipErrorInvalidDeviceFunction = 98,

227 hipErrorNoDevice = 100,

228 hipErrorInvalidDevice = 101,

229 hipErrorInvalidImage = 200,

230 hipErrorInvalidContext = 201,

231 hipErrorContextAlreadyCurrent = 202,

232 hipErrorMapFailed = 205,

233 // Deprecated

234 hipErrorMapBufferObjectFailed = 205,

235 hipErrorUnmapFailed = 206,

236 hipErrorArrayIsMapped = 207,

237 hipErrorAlreadyMapped = 208,

238 hipErrorNoBinaryForGpu = 209,

239 hipErrorAlreadyAcquired = 210,

240 hipErrorNotMapped = 211,

241 hipErrorNotMappedAsArray = 212,

242 hipErrorNotMappedAsPointer = 213,

243 hipErrorECCNotCorrectable = 214,

244 hipErrorUnsupportedLimit = 215,

245 hipErrorContextAlreadyInUse = 216,

246 hipErrorPeerAccessUnsupported = 217,

247 hipErrorInvalidKernelFile = 218,

248 hipErrorInvalidGraphicsContext = 219,

249 hipErrorInvalidSource = 300,

250 hipErrorFileNotFound = 301,

251 hipErrorSharedObjectSymbolNotFound = 302,

252 hipErrorSharedObjectInitFailed = 303,

253 hipErrorOperatingSystem = 304,

254 hipErrorInvalidHandle = 400,

255 // Deprecated

256 hipErrorInvalidResourceHandle = 400,

257 hipErrorIllegalState = 401,

258 hipErrorNotFound = 500,

259 hipErrorNotReady = 600,

263 hipErrorIllegalAddress = 700,

264 hipErrorLaunchOutOfResources = 701,

265 hipErrorLaunchTimeOut = 702,

266 hipErrorPeerAccessAlreadyEnabled =

267 704,

268 hipErrorPeerAccessNotEnabled =

269 705,

270 hipErrorSetOnActiveProcess = 708,

271 hipErrorContextIsDestroyed = 709,

272 hipErrorAssert = 710,

273 hipErrorHostMemoryAlreadyRegistered =

274 712,

275 hipErrorHostMemoryNotRegistered =

276 713,

277 hipErrorLaunchFailure =

278 719,

279 hipErrorCooperativeLaunchTooLarge =

280 720,

283 hipErrorNotSupported = 801,

284 hipErrorStreamCaptureUnsupported = 900,

286 hipErrorStreamCaptureInvalidated = 901,

288 hipErrorStreamCaptureMerge = 902,

290 hipErrorStreamCaptureUnmatched = 903,

291 hipErrorStreamCaptureUnjoined = 904,

293 hipErrorStreamCaptureIsolation = 905,

297 hipErrorStreamCaptureImplicit = 906,

300 hipErrorCapturedEvent = 907,

302 hipErrorStreamCaptureWrongThread = 908,

306 hipErrorGraphExecUpdateFailure = 910,

310 hipErrorUnknown = 999, //< Unknown error.

311 // HSA Runtime Error Codes start here.

312 hipErrorRuntimeMemory = 1052,

314 hipErrorRuntimeOther = 1053,

316 hipErrorTbd

317} hipError_t;

318

319#undef __HIP_NODISCARD

320

321/*

322 * @brief hipDeviceAttribute_t

323 * @enum

324 * @ingroup Enumerations

325 */

326typedef enum hipDeviceAttribute_t {

327 hipDeviceAttributeCudaCompatibleBegin = 0,

328

329 hipDeviceAttributeEccEnabled = hipDeviceAttributeCudaCompatibleBegin,

330 hipDeviceAttributeAccessPolicyMaxWindowSize,

331 hipDeviceAttributeAsyncEngineCount,

332 hipDeviceAttributeCanMapHostMemory,

333 hipDeviceAttributeCanUseHostPointerForRegisteredMem,

335 hipDeviceAttributeClockRate,

336 hipDeviceAttributeComputeMode,

337 hipDeviceAttributeComputePreemptionSupported,

338 hipDeviceAttributeConcurrentKernels,

339 hipDeviceAttributeConcurrentManagedAccess,

340 hipDeviceAttributeCooperativeLaunch,

341 hipDeviceAttributeCooperativeMultiDeviceLaunch,

342 hipDeviceAttributeDeviceOverlap,

344 hipDeviceAttributeDirectManagedMemAccessFromHost,

346 hipDeviceAttributeGlobalL1CacheSupported,

347 hipDeviceAttributeHostNativeAtomicSupported,

348 hipDeviceAttributeIntegrated,

349 hipDeviceAttributeIsMultiGpuBoard,

350 hipDeviceAttributeKernelExecTimeout,

351 hipDeviceAttributeL2CacheSize,

352 hipDeviceAttributeLocalL1CacheSupported,

353 hipDeviceAttributeLuid,

354 hipDeviceAttributeLuidDeviceNodeMask,

355 hipDeviceAttributeComputeCapabilityMajor,

356 hipDeviceAttributeManagedMemory,

357 hipDeviceAttributeMaxBlocksPerMultiProcessor,

358 hipDeviceAttributeMaxBlockDimX,

359 hipDeviceAttributeMaxBlockDimY,

360 hipDeviceAttributeMaxBlockDimZ,

361 hipDeviceAttributeMaxGridDimX,

362 hipDeviceAttributeMaxGridDimY,

363 hipDeviceAttributeMaxGridDimZ,

364 hipDeviceAttributeMaxSurface1D,

365 hipDeviceAttributeMaxSurface1DLayered,

366 hipDeviceAttributeMaxSurface2D,

367 hipDeviceAttributeMaxSurface2DLayered,

368 hipDeviceAttributeMaxSurface3D,

369 hipDeviceAttributeMaxSurfaceCubemap,

370 hipDeviceAttributeMaxSurfaceCubemapLayered,

371 hipDeviceAttributeMaxTexture1DWidth,

372 hipDeviceAttributeMaxTexture1DLayered,

373 hipDeviceAttributeMaxTexture1DLinear,

375 hipDeviceAttributeMaxTexture1DMipmap,

376 hipDeviceAttributeMaxTexture2DWidth,

377 hipDeviceAttributeMaxTexture2DHeight,

378 hipDeviceAttributeMaxTexture2DGather,

379 hipDeviceAttributeMaxTexture2DLayered,

380 hipDeviceAttributeMaxTexture2DLinear,

381 hipDeviceAttributeMaxTexture2DMipmap,

382 hipDeviceAttributeMaxTexture3DWidth,

383 hipDeviceAttributeMaxTexture3DHeight,

384 hipDeviceAttributeMaxTexture3DDepth,

385 hipDeviceAttributeMaxTexture3DAlt,

386 hipDeviceAttributeMaxTextureCubemap,

387 hipDeviceAttributeMaxTextureCubemapLayered,

388 hipDeviceAttributeMaxThreadsDim,

389 hipDeviceAttributeMaxThreadsPerBlock,

390 hipDeviceAttributeMaxThreadsPerMultiProcessor,

391 hipDeviceAttributeMaxPitch,

392 hipDeviceAttributeMemoryBusWidth,

393 hipDeviceAttributeMemoryClockRate,

394 hipDeviceAttributeComputeCapabilityMinor,

395 hipDeviceAttributeMultiGpuBoardGroupID,

396 hipDeviceAttributeMultiprocessorCount,

397 hipDeviceAttributeName,

398 hipDeviceAttributePageableMemoryAccess,

400 hipDeviceAttributePageableMemoryAccessUsesHostPageTables,

401 hipDeviceAttributePciBusId,

402 hipDeviceAttributePciDeviceId,

403 hipDeviceAttributePciDomainID,

404 hipDeviceAttributePersistingL2CacheMaxSize,

405 hipDeviceAttributeMaxRegistersPerBlock,

407 hipDeviceAttributeMaxRegistersPerMultiprocessor,

408 hipDeviceAttributeReservedSharedMemPerBlock,

409 hipDeviceAttributeMaxSharedMemoryPerBlock,

410 hipDeviceAttributeSharedMemPerBlockOptin,

411 hipDeviceAttributeSharedMemPerMultiprocessor,

412 hipDeviceAttributeSingleToDoublePrecisionPerfRatio,

413 hipDeviceAttributeStreamPrioritiesSupported,

414 hipDeviceAttributeSurfaceAlignment,

415 hipDeviceAttributeTccDriver,

416 hipDeviceAttributeTextureAlignment,

417 hipDeviceAttributeTexturePitchAlignment,

418 hipDeviceAttributeTotalConstantMemory,

419 hipDeviceAttributeTotalGlobalMem,

420 hipDeviceAttributeUnifiedAddressing,

421 hipDeviceAttributeUuid,

422 hipDeviceAttributeWarpSize,

423

424 hipDeviceAttributeCudaCompatibleEnd = 9999,

425 hipDeviceAttributeAmdSpecificBegin = 10000,

426

427 hipDeviceAttributeClockInstructionRate = hipDeviceAttributeAmdSpecificBegin,

428 hipDeviceAttributeArch,

429 hipDeviceAttributeMaxSharedMemoryPerMultiprocessor,

430 hipDeviceAttributeGcnArch,

431 hipDeviceAttributeGcnArchName,

432 hipDeviceAttributeHdpMemFlushCntl,

433 hipDeviceAttributeHdpRegFlushCntl,

434 hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc,

436 hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim,

438 hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim,

440 hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem,

442 hipDeviceAttributeIsLargeBar,

443 hipDeviceAttributeAsicRevision,

444 hipDeviceAttributeCanUseStreamWaitValue,

446 hipDeviceAttributeImageSupport,

447 hipDeviceAttributePhysicalMultiProcessorCount,

449 hipDeviceAttributeAmdSpecificEnd = 19999,

450 hipDeviceAttributeVendorSpecificBegin = 20000,

451 // Extended attributes for vendors

452} hipDeviceAttribute_t;

453

454enum hipComputeMode {

455 hipComputeModeDefault = 0,

456 hipComputeModeExclusive = 1,

457 hipComputeModeProhibited = 2,

458 hipComputeModeExclusiveProcess = 3

459};

460

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

466

467#include <stdint.h>

468#include <stddef.h>

469#ifndef GENERIC_GRID_LAUNCH

470#define GENERIC_GRID_LAUNCH 1

471#endif

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

473#include <hip/driver_types.h>

474#include <hip/texture_types.h>

475#include <hip/surface_types.h>

476#if defined(_MSC_VER)

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

478#else // !defined(_MSC_VER)

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

480#endif // !defined(_MSC_VER)

481#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"

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

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

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

485#ifdef __cplusplus

486 #define __dparm(x) \

487 = x

488#else

489 #define __dparm(x)

490#endif

491#ifdef __GNUC__

492#pragma GCC visibility push (default)

493#endif

494#ifdef __cplusplus

495namespace hip_impl {

496hipError_t hip_init();

497} // namespace hip_impl

498#endif

499// Structure definitions:

500#ifdef __cplusplus

501extern "C" {

502#endif

503//---

504// API-visible structures

505typedef struct ihipCtx_t* hipCtx_t;

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

507typedef int hipDevice_t;

508typedef enum hipDeviceP2PAttr {

509 hipDevP2PAttrPerformanceRank = 0,

510 hipDevP2PAttrAccessSupported,

511 hipDevP2PAttrNativeAtomicSupported,

512 hipDevP2PAttrHipArrayAccessSupported

513} hipDeviceP2PAttr;

514typedef struct ihipStream_t* hipStream_t;

515#define hipIpcMemLazyEnablePeerAccess 0

516#define HIP_IPC_HANDLE_SIZE 64

517typedef struct hipIpcMemHandle_st {

518 char reserved[HIP_IPC_HANDLE_SIZE];

519} hipIpcMemHandle_t;

520typedef struct hipIpcEventHandle_st {

521 char reserved[HIP_IPC_HANDLE_SIZE];

522} hipIpcEventHandle_t;

523typedef struct ihipModule_t* hipModule_t;

524typedef struct ihipModuleSymbol_t* hipFunction_t;

525typedef struct hipFuncAttributes {

526 int binaryVersion;

527 int cacheModeCA;

528 size_t constSizeBytes;

529 size_t localSizeBytes;

530 int maxDynamicSharedSizeBytes;

531 int maxThreadsPerBlock;

532 int numRegs;

533 int preferredShmemCarveout;

534 int ptxVersion;

535 size_t sharedSizeBytes;

536} hipFuncAttributes;

537typedef struct ihipEvent_t* hipEvent_t;

538enum hipLimit_t {

539 hipLimitPrintfFifoSize = 0x01,

540 hipLimitMallocHeapSize = 0x02,

541};

546//Flags that can be used with hipStreamCreateWithFlags.

548#define hipStreamDefault 0x00

549

551#define hipStreamNonBlocking 0x01

552

553//Flags that can be used with hipEventCreateWithFlags.

555#define hipEventDefault 0x0

556

558#define hipEventBlockingSync 0x1

559

561#define hipEventDisableTiming 0x2

562

564#define hipEventInterprocess 0x4

565

568#define hipEventReleaseToDevice 0x40000000

569

572#define hipEventReleaseToSystem 0x80000000

573

574//Flags that can be used with hipHostMalloc.

576#define hipHostMallocDefault 0x0

577

579#define hipHostMallocPortable 0x1

580

583#define hipHostMallocMapped 0x2

584

588#define hipHostMallocWriteCombined 0x4

589

591#define hipHostMallocNumaUser 0x20000000

592

594#define hipHostMallocCoherent 0x40000000

595

597#define hipHostMallocNonCoherent 0x80000000

598

600#define hipMemAttachGlobal 0x01

601

603#define hipMemAttachHost 0x02

604

606#define hipMemAttachSingle 0x04

607

608#define hipDeviceMallocDefault 0x0

609

611#define hipDeviceMallocFinegrained 0x1

612

614#define hipMallocSignalMemory 0x2

615

616//Flags that can be used with hipHostRegister.

618#define hipHostRegisterDefault 0x0

619

621#define hipHostRegisterPortable 0x1

622

625#define hipHostRegisterMapped 0x2

626

628#define hipHostRegisterIoMemory 0x4

629

631#define hipExtHostRegisterCoarseGrained 0x8

632

634#define hipDeviceScheduleAuto 0x0

635

638#define hipDeviceScheduleSpin 0x1

639

642#define hipDeviceScheduleYield 0x2

643#define hipDeviceScheduleBlockingSync 0x4

644#define hipDeviceScheduleMask 0x7

645#define hipDeviceMapHost 0x8

646#define hipDeviceLmemResizeToMax 0x16

648#define hipArrayDefault 0x00

649#define hipArrayLayered 0x01

650#define hipArraySurfaceLoadStore 0x02

651#define hipArrayCubemap 0x04

652#define hipArrayTextureGather 0x08

653#define hipOccupancyDefault 0x00

654#define hipCooperativeLaunchMultiDeviceNoPreSync 0x01

655#define hipCooperativeLaunchMultiDeviceNoPostSync 0x02

656#define hipCpuDeviceId ((int)-1)

657#define hipInvalidDeviceId ((int)-2)

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

660#define hipExtAnyOrderLaunch 0x01

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

662#define hipStreamWaitValueGte 0x0

663#define hipStreamWaitValueEq 0x1

664#define hipStreamWaitValueAnd 0x2

665#define hipStreamWaitValueNor 0x3

666// Stream per thread

668#define hipStreamPerThread ((hipStream_t)2)

669/*

670 * @brief HIP Memory Advise values

671 * @enum

672 * @ingroup Enumerations

673 */

674typedef enum hipMemoryAdvise {

675 hipMemAdviseSetReadMostly = 1,

677 hipMemAdviseUnsetReadMostly = 2,

678 hipMemAdviseSetPreferredLocation = 3,

680 hipMemAdviseUnsetPreferredLocation = 4,

681 hipMemAdviseSetAccessedBy = 5,

683 hipMemAdviseUnsetAccessedBy = 6,

685 hipMemAdviseSetCoarseGrain = 100,

690 hipMemAdviseUnsetCoarseGrain = 101

691} hipMemoryAdvise;

692/*

693 * @brief HIP Coherency Mode

694 * @enum

695 * @ingroup Enumerations

696 */

697typedef enum hipMemRangeCoherencyMode {

698 hipMemRangeCoherencyModeFineGrain = 0,

700 hipMemRangeCoherencyModeCoarseGrain = 1,

702 hipMemRangeCoherencyModeIndeterminate = 2

705} hipMemRangeCoherencyMode;

706/*

707 * @brief HIP range attributes

708 * @enum

709 * @ingroup Enumerations

710 */

711typedef enum hipMemRangeAttribute {

712 hipMemRangeAttributeReadMostly = 1,

714 hipMemRangeAttributePreferredLocation = 2,

715 hipMemRangeAttributeAccessedBy = 3,

717 hipMemRangeAttributeLastPrefetchLocation = 4,

719 hipMemRangeAttributeCoherencyMode = 100,

721} hipMemRangeAttribute;

722/*

723 * @brief hipJitOption

724 * @enum

725 * @ingroup Enumerations

726 */

727typedef enum hipJitOption {

728 hipJitOptionMaxRegisters = 0,

729 hipJitOptionThreadsPerBlock,

730 hipJitOptionWallTime,

731 hipJitOptionInfoLogBuffer,

732 hipJitOptionInfoLogBufferSizeBytes,

733 hipJitOptionErrorLogBuffer,

734 hipJitOptionErrorLogBufferSizeBytes,

735 hipJitOptionOptimizationLevel,

736 hipJitOptionTargetFromContext,

737 hipJitOptionTarget,

738 hipJitOptionFallbackStrategy,

739 hipJitOptionGenerateDebugInfo,

740 hipJitOptionLogVerbose,

741 hipJitOptionGenerateLineInfo,

742 hipJitOptionCacheMode,

743 hipJitOptionSm3xOpt,

744 hipJitOptionFastCompile,

745 hipJitOptionNumOptions

746} hipJitOption;

750typedef enum hipFuncAttribute {

751 hipFuncAttributeMaxDynamicSharedMemorySize = 8,

752 hipFuncAttributePreferredSharedMemoryCarveout = 9,

753 hipFuncAttributeMax

754} hipFuncAttribute;

758typedef enum hipFuncCache_t {

759 hipFuncCachePreferNone,

760 hipFuncCachePreferShared,

761 hipFuncCachePreferL1,

762 hipFuncCachePreferEqual,

763} hipFuncCache_t;

767typedef enum hipSharedMemConfig {

768 hipSharedMemBankSizeDefault,

769 hipSharedMemBankSizeFourByte,

771 hipSharedMemBankSizeEightByte

773} hipSharedMemConfig;

778typedef struct dim3 {

779 uint32_t x;

780 uint32_t y;

781 uint32_t z;

782#ifdef __cplusplus

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

784#endif

785} dim3;

786typedef struct hipLaunchParams_t {

787 void* func;

788 dim3 gridDim;

789 dim3 blockDim;

790 void **args;

791 size_t sharedMem;

792 hipStream_t stream;

793} hipLaunchParams;

794typedef enum hipExternalMemoryHandleType_enum {

795 hipExternalMemoryHandleTypeOpaqueFd = 1,

796 hipExternalMemoryHandleTypeOpaqueWin32 = 2,

797 hipExternalMemoryHandleTypeOpaqueWin32Kmt = 3,

798 hipExternalMemoryHandleTypeD3D12Heap = 4,

799 hipExternalMemoryHandleTypeD3D12Resource = 5,

800 hipExternalMemoryHandleTypeD3D11Resource = 6,

801 hipExternalMemoryHandleTypeD3D11ResourceKmt = 7,

802} hipExternalMemoryHandleType;

803typedef struct hipExternalMemoryHandleDesc_st {

804 hipExternalMemoryHandleType type;

805 union {

806 int fd;

807 struct {

808 void *handle;

809 const void *name;

810 } win32;

811 } handle;

812 unsigned long long size;

813 unsigned int flags;

814} hipExternalMemoryHandleDesc;

815typedef struct hipExternalMemoryBufferDesc_st {

816 unsigned long long offset;

817 unsigned long long size;

818 unsigned int flags;

819} hipExternalMemoryBufferDesc;

820typedef void* hipExternalMemory_t;

821typedef enum hipExternalSemaphoreHandleType_enum {

822 hipExternalSemaphoreHandleTypeOpaqueFd = 1,

823 hipExternalSemaphoreHandleTypeOpaqueWin32 = 2,

824 hipExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3,

825 hipExternalSemaphoreHandleTypeD3D12Fence = 4

826} hipExternalSemaphoreHandleType;

827typedef struct hipExternalSemaphoreHandleDesc_st {

828 hipExternalSemaphoreHandleType type;

829 union {

830 int fd;

831 struct {

832 void* handle;

833 const void* name;

834 } win32;

835 } handle;

836 unsigned int flags;

837} hipExternalSemaphoreHandleDesc;

838typedef void* hipExternalSemaphore_t;

839typedef struct hipExternalSemaphoreSignalParams_st {

840 struct {

841 struct {

842 unsigned long long value;

843 } fence;

844 struct {

845 unsigned long long key;

846 } keyedMutex;

847 unsigned int reserved[12];

848 } params;

849 unsigned int flags;

850 unsigned int reserved[16];

851} hipExternalSemaphoreSignalParams;

855typedef struct hipExternalSemaphoreWaitParams_st {

856 struct {

857 struct {

858 unsigned long long value;

859 } fence;

860 struct {

861 unsigned long long key;

862 unsigned int timeoutMs;

863 } keyedMutex;

864 unsigned int reserved[10];

865 } params;

866 unsigned int flags;

867 unsigned int reserved[16];

868} hipExternalSemaphoreWaitParams;

869

870#if __HIP_HAS_GET_PCH

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

877#endif

878

879/*

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

881 * @enum

882 * @ingroup Enumerations

883 */

884typedef enum hipGLDeviceList {

885 hipGLDeviceListAll = 1,

886 hipGLDeviceListCurrentFrame = 2,

888 hipGLDeviceListNextFrame = 3

890} hipGLDeviceList;

891

892/*

893 * @brief HIP Access falgs for Interop resources.

894 * @enum

895 * @ingroup Enumerations

896 */

897typedef enum hipGraphicsRegisterFlags {

898 hipGraphicsRegisterFlagsNone = 0,

899 hipGraphicsRegisterFlagsReadOnly = 1,

900 hipGraphicsRegisterFlagsWriteDiscard =

901 2,

902 hipGraphicsRegisterFlagsSurfaceLoadStore = 4,

903 hipGraphicsRegisterFlagsTextureGather =

904 8

905} hipGraphicsRegisterFlags;

906

907typedef struct _hipGraphicsResource hipGraphicsResource;

908

909typedef hipGraphicsResource* hipGraphicsResource_t;

910

911// Doxygen end group GlobalDefs

913//-------------------------------------------------------------------------------------------------

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

915// out-of-scope.

916// typedef class ihipStream_t * hipStream_t;

917/*

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

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

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

921// typedef struct hipEvent_t {

922// struct ihipEvent_t *_handle;

923//} hipEvent_t;

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

943hipError_t hipInit(unsigned int flags);

959hipError_t hipDriverGetVersion(int* driverVersion);

974hipError_t hipRuntimeGetVersion(int* runtimeVersion);

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

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

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

1010hipError_t hipDeviceGetP2PAttribute(int* value, hipDeviceP2PAttr attr,

1011 int srcDevice, int dstDevice);

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

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

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

1037// doxygen end initialization

1056hipError_t hipDeviceSynchronize(void);

1068hipError_t hipDeviceReset(void);

1100hipError_t hipSetDevice(int deviceId);

1114hipError_t hipGetDevice(int* deviceId);

1127hipError_t hipGetDeviceCount(int* count);

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

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

1162hipError_t hipDeviceSetCacheConfig(hipFuncCache_t cacheConfig);

1173hipError_t hipDeviceGetCacheConfig(hipFuncCache_t* cacheConfig);

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

1196hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig* pConfig);

1204hipError_t hipGetDeviceFlags(unsigned int* flags);

1216hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config);

1241hipError_t hipSetDeviceFlags(unsigned flags);

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

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

1264// TODO: implement IPC apis

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

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

1346hipError_t hipIpcCloseMemHandle(void* devPtr);

1347

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

1363

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

1380

1381// end doxygen Device

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

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

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

1430//doxygen end execution

1452hipError_t hipGetLastError(void);

1463hipError_t hipPeekAtLastError(void);

1472const char* hipGetErrorName(hipError_t hip_error);

1483const char* hipGetErrorString(hipError_t hipError);

1484// end doxygen Error

1514hipError_t hipStreamCreate(hipStream_t* stream);

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

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

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

1582hipError_t hipStreamDestroy(hipStream_t stream);

1598hipError_t hipStreamQuery(hipStream_t stream);

1618hipError_t hipStreamSynchronize(hipStream_t stream);

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

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

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

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

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

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

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

1720 unsigned int flags);

1721// end doxygen Stream

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

1765 uint32_t mask __dparm(0xFFFFFFFF));

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

1799 uint64_t mask __dparm(0xFFFFFFFFFFFFFFFF));

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

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

1840// end doxygen Stream Memory Operations

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

1885hipError_t hipEventCreate(hipEvent_t* event);

1913#ifdef __cplusplus

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

1915#else

1916hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream);

1917#endif

1934hipError_t hipEventDestroy(hipEvent_t event);

1952hipError_t hipEventSynchronize(hipEvent_t event);

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

2004hipError_t hipEventQuery(hipEvent_t event);

2005// end doxygen Events

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

2047hipError_t hipPointerGetAttribute(void* data, hipPointer_attribute attribute,

2048 hipDeviceptr_t ptr);

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

2066 void** data, hipDeviceptr_t ptr);

2077hipError_t hipImportExternalSemaphore(hipExternalSemaphore_t* extSem_out,

2078 const hipExternalSemaphoreHandleDesc* semHandleDesc);

2091hipError_t hipSignalExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

2092 const hipExternalSemaphoreSignalParams* paramsArray,

2093 unsigned int numExtSems, hipStream_t stream);

2106hipError_t hipWaitExternalSemaphoresAsync(const hipExternalSemaphore_t* extSemArray,

2107 const hipExternalSemaphoreWaitParams* paramsArray,

2108 unsigned int numExtSems, hipStream_t stream);

2118hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem);

2119

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

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

2152hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem);

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

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

2194DEPRECATED("use hipHostMalloc instead")

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

2208DEPRECATED("use hipHostMalloc instead")

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

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

2243hipError_t hipMallocManaged(void** dev_ptr,

2244 size_t size,

2245 unsigned int flags __dparm(hipMemAttachGlobal));

2256hipError_t hipMemPrefetchAsync(const void* dev_ptr,

2257 size_t count,

2258 int device,

2259 hipStream_t stream __dparm(0));

2270hipError_t hipMemAdvise(const void* dev_ptr,

2271 size_t count,

2272 hipMemoryAdvise advice,

2273 int device);

2286hipError_t hipMemRangeGetAttribute(void* data,

2287 size_t data_size,

2288 hipMemRangeAttribute attribute,

2289 const void* dev_ptr,

2290 size_t count);

2305hipError_t hipMemRangeGetAttributes(void** data,

2306 size_t* data_sizes,

2307 hipMemRangeAttribute* attributes,

2308 size_t num_attributes,

2309 const void* dev_ptr,

2310 size_t count);

2323hipError_t hipStreamAttachMemAsync(hipStream_t stream,

2324 void* dev_ptr,

2325 size_t length __dparm(0),

2326 unsigned int flags __dparm(hipMemAttachSingle));

2327// end doxygen Managed Memory

2344DEPRECATED("use hipHostMalloc instead")

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

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

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

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

2413hipError_t hipHostUnregister(void* hostPtr);

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

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

2468hipError_t hipFree(void* ptr);

2478DEPRECATED("use hipHostFree instead")

2479hipError_t hipFreeHost(void* ptr);

2493hipError_t hipHostFree(void* ptr);

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

2524// TODO: Add description

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

2526 hipMemcpyKind kind, hipStream_t stream);

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

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

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

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

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

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

2635 hipStream_t stream);

2636

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

2652 hipModule_t hmod, const char* name);

2653

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

2664

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

2675

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

2695 size_t sizeBytes, size_t offset __dparm(0),

2696 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice));

2697

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

2712 size_t sizeBytes, size_t offset,

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

2714

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

2728 size_t sizeBytes, size_t offset __dparm(0),

2729 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost));

2730

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

2745 size_t sizeBytes, size_t offset,

2746 hipMemcpyKind kind,

2747 hipStream_t stream __dparm(0));

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

2777 hipStream_t stream __dparm(0));

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

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

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

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

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

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

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

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

2882 hipStream_t stream __dparm(0));

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

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

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

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

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

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

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

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

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

2951hipError_t hipArrayDestroy(hipArray* array);

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

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

2962hipError_t hipFreeArray(hipArray* array);

2970hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray);

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

2983 struct hipExtent extent, unsigned int flags);

2995hipError_t hipMallocMipmappedArray(

2996 hipMipmappedArray_t *mipmappedArray,

2997 const struct hipChannelFormatDesc* desc,

2998 struct hipExtent extent,

2999 unsigned int numLevels,

3000 unsigned int flags __dparm(0));

3010hipError_t hipGetMipmappedArrayLevel(

3011 hipArray_t *levelArray,

3012 hipMipmappedArray_const_t mipmappedArray,

3013 unsigned int level);

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

3031 size_t height, hipMemcpyKind kind);

3041hipError_t hipMemcpyParam2D(const hip_Memcpy2D* pCopy);

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

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

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

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

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

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

3110 size_t spitch, size_t width, size_t height, hipMemcpyKind kind,

3111 hipStream_t stream __dparm(0));

3127DEPRECATED(DEPRECATED_MSG)

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

3129 size_t count, hipMemcpyKind kind);

3145DEPRECATED(DEPRECATED_MSG)

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

3147 size_t count, hipMemcpyKind kind);

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

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

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

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

3223hipError_t hipMemcpy3D(const struct hipMemcpy3DParms* p);

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

3246hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D* pCopy);

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

3259// doxygen end Memory

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

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

3316hipError_t hipDeviceDisablePeerAccess(int peerDeviceId);

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

3330#ifndef USE_PEER_NON_UNIFIED

3331#define USE_PEER_NON_UNIFIED 1

3332#endif

3333#if USE_PEER_NON_UNIFIED == 1

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

3346 size_t sizeBytes);

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

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

3361#endif

3362// doxygen end PeerToPeer

3392DEPRECATED(DEPRECATED_MSG)

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

3404DEPRECATED(DEPRECATED_MSG)

3405hipError_t hipCtxDestroy(hipCtx_t ctx);

3416DEPRECATED(DEPRECATED_MSG)

3417hipError_t hipCtxPopCurrent(hipCtx_t* ctx);

3428DEPRECATED(DEPRECATED_MSG)

3429hipError_t hipCtxPushCurrent(hipCtx_t ctx);

3440DEPRECATED(DEPRECATED_MSG)

3441hipError_t hipCtxSetCurrent(hipCtx_t ctx);

3452DEPRECATED(DEPRECATED_MSG)

3453hipError_t hipCtxGetCurrent(hipCtx_t* ctx);

3464DEPRECATED(DEPRECATED_MSG)

3465hipError_t hipCtxGetDevice(hipDevice_t* device);

3483DEPRECATED(DEPRECATED_MSG)

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

3498DEPRECATED(DEPRECATED_MSG)

3499hipError_t hipCtxGetCacheConfig(hipFuncCache_t* cacheConfig);

3513DEPRECATED(DEPRECATED_MSG)

3514hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig);

3528DEPRECATED(DEPRECATED_MSG)

3529hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config);

3543DEPRECATED(DEPRECATED_MSG)

3544hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig* pConfig);

3556DEPRECATED(DEPRECATED_MSG)

3557hipError_t hipCtxSynchronize(void);

3568DEPRECATED(DEPRECATED_MSG)

3569hipError_t hipCtxGetFlags(unsigned int* flags);

3589DEPRECATED(DEPRECATED_MSG)

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

3607DEPRECATED(DEPRECATED_MSG)

3608hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx);

3609// doxygen end Context deprecated

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

3638hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev);

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

3661hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev);

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

3674// doxygen end Context Management

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

3706hipError_t hipModuleUnload(hipModule_t module);

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

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

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

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

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

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

3770 hipJitOption* options, void** optionValues);

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

3800 unsigned int gridDimZ, unsigned int blockDimX,

3801 unsigned int blockDimY, unsigned int blockDimZ,

3802 unsigned int sharedMemBytes, hipStream_t stream,

3803 void** kernelParams, void** extra);

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

3823 void** kernelParams, unsigned int sharedMemBytes,

3824 hipStream_t stream);

3835hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

3836 int numDevices, unsigned int flags);

3848hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

3849 int numDevices, unsigned int flags);

3850// doxygen end Module

3875//TODO - Match CUoccupancyB2DSize

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

3877 hipFunction_t f, size_t dynSharedMemPerBlk,

3878 int blockSizeLimit);

3894//TODO - Match CUoccupancyB2DSize

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

3896 hipFunction_t f, size_t dynSharedMemPerBlk,

3897 int blockSizeLimit, unsigned int flags);

3906hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessor(

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

3917hipError_t hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

3927hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(

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

3938hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

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

3955 const void* f, size_t dynSharedMemPerBlk,

3956 int blockSizeLimit);

3957// doxygen end Occupancy

3971// TODO - expand descriptions:

3977DEPRECATED("use roctracer/rocTX instead")

3978hipError_t hipProfilerStart();

3984DEPRECATED("use roctracer/rocTX instead")

3985hipError_t hipProfilerStop();

3986// doxygen end profiler

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

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

4033hipError_t hipLaunchByPtr(const void* func);

4050hipError_t __hipPushCallConfiguration(dim3 gridDim,

4051 dim3 blockDim,

4052 size_t sharedMem __dparm(0),

4053 hipStream_t stream __dparm(0));

4073hipError_t __hipPopCallConfiguration(dim3 *gridDim,

4074 dim3 *blockDim,

4075 size_t *sharedMem,

4076 hipStream_t *stream);

4092hipError_t hipLaunchKernel(const void* function_address,

4093 dim3 numBlocks,

4094 dim3 dimBlocks,

4095 void** args,

4096 size_t sharedMemBytes __dparm(0),

4097 hipStream_t stream __dparm(0));

4105hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D* pCopy);

4106//TODO: Move this to hip_ext.h

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

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

4129 hipEvent_t startEvent, hipEvent_t stopEvent, int flags);

4130// doxygen end Clang launch

4152hipError_t hipBindTextureToMipmappedArray(

4153 const textureReference* tex,

4154 hipMipmappedArray_const_t mipmappedArray,

4155 const hipChannelFormatDesc* desc);

4156

4166 hipError_t hipGetTextureReference(

4167 const textureReference** texref,

4168 const void* symbol);

4169

4181hipError_t hipCreateTextureObject(

4182 hipTextureObject_t* pTexObject,

4183 const hipResourceDesc* pResDesc,

4184 const hipTextureDesc* pTexDesc,

4185 const struct hipResourceViewDesc* pResViewDesc);

4186

4195hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject);

4196

4206hipError_t hipGetChannelDesc(

4207 hipChannelFormatDesc* desc,

4208 hipArray_const_t array);

4209

4219hipError_t hipGetTextureObjectResourceDesc(

4220 hipResourceDesc* pResDesc,

4221 hipTextureObject_t textureObject);

4222

4232hipError_t hipGetTextureObjectResourceViewDesc(

4233 struct hipResourceViewDesc* pResViewDesc,

4234 hipTextureObject_t textureObject);

4235

4245hipError_t hipGetTextureObjectTextureDesc(

4246 hipTextureDesc* pTexDesc,

4247 hipTextureObject_t textureObject);

4248

4252hipError_t hipTexRefSetAddressMode(

4253 textureReference* texRef,

4254 int dim,

4255 enum hipTextureAddressMode am);

4256hipError_t hipTexRefSetArray(

4257 textureReference* tex,

4258 hipArray_const_t array,

4259 unsigned int flags);

4260hipError_t hipTexRefSetFilterMode(

4261 textureReference* texRef,

4262 enum hipTextureFilterMode fm);

4263hipError_t hipTexRefSetFlags(

4264 textureReference* texRef,

4265 unsigned int Flags);

4266hipError_t hipTexRefSetFormat(

4267 textureReference* texRef,

4268 hipArray_Format fmt,

4269 int NumPackedComponents);

4270hipError_t hipTexObjectCreate(

4271 hipTextureObject_t* pTexObject,

4272 const HIP_RESOURCE_DESC* pResDesc,

4273 const HIP_TEXTURE_DESC* pTexDesc,

4274 const HIP_RESOURCE_VIEW_DESC* pResViewDesc);

4275hipError_t hipTexObjectDestroy(

4276 hipTextureObject_t texObject);

4277hipError_t hipTexObjectGetResourceDesc(

4278 HIP_RESOURCE_DESC* pResDesc,

4279 hipTextureObject_t texObject);

4280hipError_t hipTexObjectGetResourceViewDesc(

4281 HIP_RESOURCE_VIEW_DESC* pResViewDesc,

4282 hipTextureObject_t texObject);

4283hipError_t hipTexObjectGetTextureDesc(

4284 HIP_TEXTURE_DESC* pTexDesc,

4285 hipTextureObject_t texObject);

4286

4294DEPRECATED(DEPRECATED_MSG)

4295hipError_t hipBindTexture(

4296 size_t* offset,

4297 const textureReference* tex,

4298 const void* devPtr,

4299 const hipChannelFormatDesc* desc,

4300 size_t size __dparm(UINT_MAX));

4301DEPRECATED(DEPRECATED_MSG)

4302hipError_t hipBindTexture2D(

4303 size_t* offset,

4304 const textureReference* tex,

4305 const void* devPtr,

4306 const hipChannelFormatDesc* desc,

4307 size_t width,

4308 size_t height,

4309 size_t pitch);

4310DEPRECATED(DEPRECATED_MSG)

4311hipError_t hipBindTextureToArray(

4312 const textureReference* tex,

4313 hipArray_const_t array,

4314 const hipChannelFormatDesc* desc);

4315DEPRECATED(DEPRECATED_MSG)

4316hipError_t hipGetTextureAlignmentOffset(

4317 size_t* offset,

4318 const textureReference* texref);

4319DEPRECATED(DEPRECATED_MSG)

4320hipError_t hipUnbindTexture(const textureReference* tex);

4321DEPRECATED(DEPRECATED_MSG)

4322hipError_t hipTexRefGetAddress(

4323 hipDeviceptr_t* dev_ptr,

4324 const textureReference* texRef);

4325DEPRECATED(DEPRECATED_MSG)

4326hipError_t hipTexRefGetAddressMode(

4327 enum hipTextureAddressMode* pam,

4328 const textureReference* texRef,

4329 int dim);

4330DEPRECATED(DEPRECATED_MSG)

4331hipError_t hipTexRefGetFilterMode(

4332 enum hipTextureFilterMode* pfm,

4333 const textureReference* texRef);

4334DEPRECATED(DEPRECATED_MSG)

4335hipError_t hipTexRefGetFlags(

4336 unsigned int* pFlags,

4337 const textureReference* texRef);

4338DEPRECATED(DEPRECATED_MSG)

4339hipError_t hipTexRefGetFormat(

4340 hipArray_Format* pFormat,

4341 int* pNumChannels,

4342 const textureReference* texRef);

4343DEPRECATED(DEPRECATED_MSG)

4344hipError_t hipTexRefGetMaxAnisotropy(

4345 int* pmaxAnsio,

4346 const textureReference* texRef);

4347DEPRECATED(DEPRECATED_MSG)

4348hipError_t hipTexRefGetMipmapFilterMode(

4349 enum hipTextureFilterMode* pfm,

4350 const textureReference* texRef);

4351DEPRECATED(DEPRECATED_MSG)

4352hipError_t hipTexRefGetMipmapLevelBias(

4353 float* pbias,

4354 const textureReference* texRef);

4355DEPRECATED(DEPRECATED_MSG)

4356hipError_t hipTexRefGetMipmapLevelClamp(

4357 float* pminMipmapLevelClamp,

4358 float* pmaxMipmapLevelClamp,

4359 const textureReference* texRef);

4360DEPRECATED(DEPRECATED_MSG)

4361hipError_t hipTexRefGetMipMappedArray(

4362 hipMipmappedArray_t* pArray,

4363 const textureReference* texRef);

4364DEPRECATED(DEPRECATED_MSG)

4365hipError_t hipTexRefSetAddress(

4366 size_t* ByteOffset,

4367 textureReference* texRef,

4368 hipDeviceptr_t dptr,

4369 size_t bytes);

4370DEPRECATED(DEPRECATED_MSG)

4371hipError_t hipTexRefSetAddress2D(

4372 textureReference* texRef,

4373 const HIP_ARRAY_DESCRIPTOR* desc,

4374 hipDeviceptr_t dptr,

4375 size_t Pitch);

4376DEPRECATED(DEPRECATED_MSG)

4377hipError_t hipTexRefSetMaxAnisotropy(

4378 textureReference* texRef,

4379 unsigned int maxAniso);

4380// doxygen end deprecated texture management

4386// The following are not supported.

4394DEPRECATED(DEPRECATED_MSG)

4395hipError_t hipTexRefSetBorderColor(

4396 textureReference* texRef,

4397 float* pBorderColor);

4398hipError_t hipTexRefSetMipmapFilterMode(

4399 textureReference* texRef,

4400 enum hipTextureFilterMode fm);

4401hipError_t hipTexRefSetMipmapLevelBias(

4402 textureReference* texRef,

4403 float bias);

4404hipError_t hipTexRefSetMipmapLevelClamp(

4405 textureReference* texRef,

4406 float minMipMapLevelClamp,

4407 float maxMipMapLevelClamp);

4408hipError_t hipTexRefSetMipmappedArray(

4409 textureReference* texRef,

4410 struct hipMipmappedArray* mipmappedArray,

4411 unsigned int Flags);

4412hipError_t hipMipmappedArrayCreate(

4413 hipMipmappedArray_t* pHandle,

4414 HIP_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc,

4415 unsigned int numMipmapLevels);

4416hipError_t hipMipmappedArrayDestroy(

4417 hipMipmappedArray_t hMipmappedArray);

4418hipError_t hipMipmappedArrayGetLevel(

4419 hipArray_t* pLevelArray,

4420 hipMipmappedArray_t hMipMappedArray,

4421 unsigned int level);

4422// doxygen end unsuppported texture management

4427// doxygen end Texture management

4439// This group is for HIPrtc

4440

4441// doxygen end Runtime

4452hipError_t hipRegisterApiCallback(uint32_t id, void* fun, void* arg);

4453hipError_t hipRemoveApiCallback(uint32_t id);

4454hipError_t hipRegisterActivityCallback(uint32_t id, void* fun, void* arg);

4455hipError_t hipRemoveActivityCallback(uint32_t id);

4456const char* hipApiName(uint32_t id);

4457const char* hipKernelNameRef(const hipFunction_t f);

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

4459int hipGetStreamDeviceId(hipStream_t stream);

4460

4461// doxygen end Callback

4476typedef struct ihipGraph* hipGraph_t;

4480typedef struct hipGraphNode* hipGraphNode_t;

4484typedef struct hipGraphExec* hipGraphExec_t;

4485

4491typedef enum hipGraphNodeType {

4492 hipGraphNodeTypeKernel = 1,

4493 hipGraphNodeTypeMemcpy = 2,

4494 hipGraphNodeTypeMemset = 3,

4495 hipGraphNodeTypeHost = 4,

4496 hipGraphNodeTypeGraph = 5,

4497 hipGraphNodeTypeEmpty = 6,

4498 hipGraphNodeTypeWaitEvent = 7,

4499 hipGraphNodeTypeEventRecord = 8,

4500 hipGraphNodeTypeMemcpy1D = 9,

4501 hipGraphNodeTypeMemcpyFromSymbol = 10,

4502 hipGraphNodeTypeMemcpyToSymbol = 11,

4503 hipGraphNodeTypeCount

4504} hipGraphNodeType;

4505

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

4507typedef struct hipHostNodeParams {

4508 hipHostFn_t fn;

4509 void* userData;

4510} hipHostNodeParams;

4511typedef struct hipKernelNodeParams {

4512 dim3 blockDim;

4513 void** extra;

4514 void* func;

4515 dim3 gridDim;

4516 void** kernelParams;

4517 unsigned int sharedMemBytes;

4518} hipKernelNodeParams;

4519typedef struct hipMemsetParams {

4520 void* dst;

4521 unsigned int elementSize;

4522 size_t height;

4523 size_t pitch;

4524 unsigned int value;

4525 size_t width;

4526} hipMemsetParams;

4527

4533typedef enum hipGraphExecUpdateResult {

4534 hipGraphExecUpdateSuccess = 0x0,

4535 hipGraphExecUpdateError = 0x1,

4537 hipGraphExecUpdateErrorTopologyChanged = 0x2,

4538 hipGraphExecUpdateErrorNodeTypeChanged = 0x3,

4539 hipGraphExecUpdateErrorFunctionChanged =

4540 0x4,

4541 hipGraphExecUpdateErrorParametersChanged =

4542 0x5,

4543 hipGraphExecUpdateErrorNotSupported =

4544 0x6,

4545 hipGraphExecUpdateErrorUnsupportedFunctionChange = 0x7

4546} hipGraphExecUpdateResult;

4547

4548typedef enum hipStreamCaptureMode {

4549 hipStreamCaptureModeGlobal = 0,

4550 hipStreamCaptureModeThreadLocal,

4551 hipStreamCaptureModeRelaxed

4552} hipStreamCaptureMode;

4553typedef enum hipStreamCaptureStatus {

4554 hipStreamCaptureStatusNone = 0,

4555 hipStreamCaptureStatusActive,

4556 hipStreamCaptureStatusInvalidated

4558} hipStreamCaptureStatus;

4559

4560typedef enum hipStreamUpdateCaptureDependenciesFlags {

4561 hipStreamAddCaptureDependencies = 0,

4562 hipStreamSetCaptureDependencies,

4563} hipStreamUpdateCaptureDependenciesFlags;

4564

4578hipError_t hipStreamBeginCapture(hipStream_t stream, hipStreamCaptureMode mode);

4579

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

4593

4607hipError_t hipStreamGetCaptureInfo(hipStream_t stream, hipStreamCaptureStatus* pCaptureStatus,

4608 unsigned long long* pId);

4609

4626hipError_t hipStreamGetCaptureInfo_v2(hipStream_t stream, hipStreamCaptureStatus* captureStatus_out,

4627 unsigned long long* id_out __dparm(0),

4628 hipGraph_t* graph_out __dparm(0),

4629 const hipGraphNode_t** dependencies_out __dparm(0),

4630 size_t* numDependencies_out __dparm(0));

4631

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

4645

4658hipError_t hipStreamUpdateCaptureDependencies(hipStream_t stream, hipGraphNode_t* dependencies,

4659 size_t numDependencies,

4660 unsigned int flags __dparm(0));

4661

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

4675

4687hipError_t hipGraphDestroy(hipGraph_t graph);

4688

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

4703 const hipGraphNode_t* to, size_t numDependencies);

4704

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

4719 const hipGraphNode_t* to, size_t numDependencies);

4720

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

4739 size_t* numEdges);

4740

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

4758

4775hipError_t hipGraphGetRootNodes(hipGraph_t graph, hipGraphNode_t* pRootNodes,

4776 size_t* pNumRootNodes);

4777

4794hipError_t hipGraphNodeGetDependencies(hipGraphNode_t node, hipGraphNode_t* pDependencies,

4795 size_t* pNumDependencies);

4796

4814hipError_t hipGraphNodeGetDependentNodes(hipGraphNode_t node, hipGraphNode_t* pDependentNodes,

4815 size_t* pNumDependentNodes);

4816

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

4829

4840hipError_t hipGraphDestroyNode(hipGraphNode_t node);

4841

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

4854

4867hipError_t hipGraphNodeFindInClone(hipGraphNode_t* pNode, hipGraphNode_t originalNode,

4868 hipGraph_t clonedGraph);

4869

4886hipError_t hipGraphInstantiate(hipGraphExec_t* pGraphExec, hipGraph_t graph,

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

4888

4901hipError_t hipGraphInstantiateWithFlags(hipGraphExec_t* pGraphExec, hipGraph_t graph,

4902 unsigned long long flags);

4903

4914hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream);

4915

4926hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec);

4927

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

4942hipError_t hipGraphExecUpdate(hipGraphExec_t hGraphExec, hipGraph_t hGraph,

4943 hipGraphNode_t* hErrorNode_out,

4944 hipGraphExecUpdateResult* updateResult_out);

4945

4958hipError_t hipGraphAddKernelNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

4959 const hipGraphNode_t* pDependencies, size_t numDependencies,

4960 const hipKernelNodeParams* pNodeParams);

4961

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

4972

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

4983

4994hipError_t hipGraphExecKernelNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

4995 const hipKernelNodeParams* pNodeParams);

4996

5009hipError_t hipGraphAddMemcpyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

5010 const hipGraphNode_t* pDependencies, size_t numDependencies,

5011 const hipMemcpy3DParms* pCopyParams);

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

5022

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

5033

5044hipError_t hipGraphExecMemcpyNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

5045 hipMemcpy3DParms* pNodeParams);

5046

5062hipError_t hipGraphAddMemcpyNode1D(hipGraphNode_t* pGraphNode, hipGraph_t graph,

5063 const hipGraphNode_t* pDependencies, size_t numDependencies,

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

5065

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

5079 size_t count, hipMemcpyKind kind);

5080

5095hipError_t hipGraphExecMemcpyNodeSetParams1D(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

5097 hipMemcpyKind kind);

5098

5115hipError_t hipGraphAddMemcpyNodeFromSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

5116 const hipGraphNode_t* pDependencies,

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

5118 size_t count, size_t offset, hipMemcpyKind kind);

5119

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

5134 size_t count, size_t offset, hipMemcpyKind kind);

5135

5151hipError_t hipGraphExecMemcpyNodeSetParamsFromSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

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

5153 size_t offset, hipMemcpyKind kind);

5154

5171hipError_t hipGraphAddMemcpyNodeToSymbol(hipGraphNode_t* pGraphNode, hipGraph_t graph,

5172 const hipGraphNode_t* pDependencies,

5173 size_t numDependencies, const void* symbol,

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

5175 hipMemcpyKind kind);

5176

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

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

5192 hipMemcpyKind kind);

5193

5194

5209hipError_t hipGraphExecMemcpyNodeSetParamsToSymbol(hipGraphExec_t hGraphExec, hipGraphNode_t node,

5210 const void* symbol, const void* src,

5211 size_t count, size_t offset, hipMemcpyKind kind);

5212

5225hipError_t hipGraphAddMemsetNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

5226 const hipGraphNode_t* pDependencies, size_t numDependencies,

5227 const hipMemsetParams* pMemsetParams);

5228

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

5239

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

5250

5261hipError_t hipGraphExecMemsetNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

5262 const hipMemsetParams* pNodeParams);

5263

5276hipError_t hipGraphAddHostNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

5277 const hipGraphNode_t* pDependencies, size_t numDependencies,

5278 const hipHostNodeParams* pNodeParams);

5279

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

5290

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

5301

5312hipError_t hipGraphExecHostNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

5313 const hipHostNodeParams* pNodeParams);

5314

5327hipError_t hipGraphAddChildGraphNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

5328 const hipGraphNode_t* pDependencies, size_t numDependencies,

5329 hipGraph_t childGraph);

5330

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

5341

5352hipError_t hipGraphExecChildGraphNodeSetParams(hipGraphExec_t hGraphExec, hipGraphNode_t node,

5353 hipGraph_t childGraph);

5354

5366hipError_t hipGraphAddEmptyNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

5367 const hipGraphNode_t* pDependencies, size_t numDependencies);

5368

5369

5382hipError_t hipGraphAddEventRecordNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

5383 const hipGraphNode_t* pDependencies, size_t numDependencies,

5384 hipEvent_t event);

5385

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

5396

5406hipError_t hipGraphEventRecordNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

5407

5418hipError_t hipGraphExecEventRecordNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

5419 hipEvent_t event);

5420

5433hipError_t hipGraphAddEventWaitNode(hipGraphNode_t* pGraphNode, hipGraph_t graph,

5434 const hipGraphNode_t* pDependencies, size_t numDependencies,

5435 hipEvent_t event);

5436

5437

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

5448

5458hipError_t hipGraphEventWaitNodeSetEvent(hipGraphNode_t node, hipEvent_t event);

5459

5470hipError_t hipGraphExecEventWaitNodeSetEvent(hipGraphExec_t hGraphExec, hipGraphNode_t hNode,

5471 hipEvent_t event);

5472

5473// doxygen end graph API

5486typedef unsigned int GLuint;

5487typedef unsigned int GLenum;

5488

5489// Queries devices associated with GL Context.

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

5491 unsigned int hipDeviceCount, hipGLDeviceList deviceList);

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

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

5494 unsigned int flags);

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

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

5497 GLenum target, unsigned int flags);

5498// Maps a graphics resource for hip access.

5499hipError_t hipGraphicsMapResources(int count, hipGraphicsResource_t* resources,

5500 hipStream_t stream __dparm(0) );

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

5502hipError_t hipGraphicsSubResourceGetMappedArray(hipArray_t* array, hipGraphicsResource_t resource,

5503 unsigned int arrayIndex, unsigned int mipLevel);

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

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

5506 hipGraphicsResource_t resource);

5507// Unmaps a graphics resource for hip access.

5508hipError_t hipGraphicsUnmapResources(int count, hipGraphicsResource_t* resources,

5509 hipStream_t stream __dparm(0));

5510// Unregisters a graphics resource.

5511hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource);

5512// doxygen end GL Interop

5518#ifdef __cplusplus

5519} /* extern "c" */

5520#endif

5521#ifdef __cplusplus

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

5523template <typename T>

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

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

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

5527}

5528template <typename T>

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

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

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

5532}

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

5534template <typename T>

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

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

5537}

5538template <typename T>

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

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

5541}

5542template <typename T>

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

5544 size_t offset __dparm(0),

5545 hipMemcpyKind kind __dparm(hipMemcpyHostToDevice)) {

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

5547}

5548template <typename T>

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

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

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

5552}

5553template <typename T>

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

5555 size_t sizeBytes, size_t offset __dparm(0),

5556 hipMemcpyKind kind __dparm(hipMemcpyDeviceToHost)) {

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

5558}

5559template <typename T>

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

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

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

5563}

5564template <class T>

5565inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessor(

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

5567 return hipOccupancyMaxActiveBlocksPerMultiprocessor(

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

5569}

5570template <class T>

5571inline hipError_t hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

5573 return hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(

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

5575}

5576template <typename F>

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

5578 F kernel, size_t dynSharedMemPerBlk, uint32_t blockSizeLimit) {

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

5580}

5581template <class T>

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

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

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

5585 blockDim, kernelParams, sharedMemBytes, stream);

5586}

5587template <class T>

5588inline hipError_t hipLaunchCooperativeKernelMultiDevice(hipLaunchParams* launchParamsList,

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

5590 return hipLaunchCooperativeKernelMultiDevice(launchParamsList, numDevices, flags);

5591}

5592template <class T>

5593inline hipError_t hipExtLaunchMultiKernelMultiDevice(hipLaunchParams* launchParamsList,

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

5595 return hipExtLaunchMultiKernelMultiDevice(launchParamsList, numDevices, flags);

5596}

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

5598hipError_t hipDestroySurfaceObject(hipSurfaceObject_t surfaceObject);

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

5600DEPRECATED(DEPRECATED_MSG)

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

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

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

5604}

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

5606DEPRECATED(DEPRECATED_MSG)

5607static inline hipError_t

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

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

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

5611}

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

5613DEPRECATED(DEPRECATED_MSG)

5614static inline hipError_t hipBindTexture2D(

5615 size_t *offset,

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

5617 const void *devPtr,

5618 size_t width,

5619 size_t height,

5620 size_t pitch)

5621{

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

5623}

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

5625DEPRECATED(DEPRECATED_MSG)

5626static inline hipError_t hipBindTexture2D(

5627 size_t *offset,

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

5629 const void *devPtr,

5630 const struct hipChannelFormatDesc &desc,

5631 size_t width,

5632 size_t height,

5633 size_t pitch)

5634{

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

5636}

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

5638DEPRECATED(DEPRECATED_MSG)

5639static inline hipError_t hipBindTextureToArray(

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

5641 hipArray_const_t array)

5642{

5643 struct hipChannelFormatDesc desc;

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

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

5646}

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

5648DEPRECATED(DEPRECATED_MSG)

5649static inline hipError_t hipBindTextureToArray(

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

5651 hipArray_const_t array,

5652 const struct hipChannelFormatDesc &desc)

5653{

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

5655}

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

5657static inline hipError_t hipBindTextureToMipmappedArray(

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

5659 hipMipmappedArray_const_t mipmappedArray)

5660{

5661 struct hipChannelFormatDesc desc;

5662 hipArray_t levelArray;

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

5664 if (err != hipSuccess) {

5665 return err;

5666 }

5667 err = hipGetChannelDesc(&desc, levelArray);

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

5669}

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

5671static inline hipError_t hipBindTextureToMipmappedArray(

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

5673 hipMipmappedArray_const_t mipmappedArray,

5674 const struct hipChannelFormatDesc &desc)

5675{

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

5677}

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

5679DEPRECATED(DEPRECATED_MSG)

5680static inline hipError_t hipUnbindTexture(

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

5682{

5683 return hipUnbindTexture(&tex);

5684}

5685

5686

5687#endif // __cplusplus

5688

5689#ifdef __GNUC__

5690#pragma GCC visibility pop

5691#endif

5692// doxygen end HIP API

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

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

5699#else

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

5701#endif

5702

5703

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

5716template <class T>

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

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

5719}

5720

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

5722// default for the flags.

5723template <class T>

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

5725 unsigned int flags = hipHostMallocDefault) {

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

5727}

5728

5729template <class T>

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

5731 unsigned int flags = hipMemAttachGlobal) {

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

5733}

5734#endif

5735#endif

5736

5737#if USE_PROF_API

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

5739#endif

driver_types.h

hipMemcpyKind

hipMemcpyKind

Definition driver_types.h:344

hipMemcpyDeviceToHost

@ hipMemcpyDeviceToHost

Device-to-Host Copy.

Definition driver_types.h:347

hipMemcpyHostToDevice

@ hipMemcpyHostToDevice

Host-to-Device Copy.

Definition driver_types.h:346

hipPointer_attribute

hipPointer_attribute

Definition driver_types.h:441

hipDeviceptr_t

void * hipDeviceptr_t

Definition driver_types.h:40

hipFunction_attribute

hipFunction_attribute

Definition driver_types.h:427

hipArray_Format

hipArray_Format

Definition driver_types.h:58

hipRegisterApiCallback

hipError_t hipRegisterApiCallback(uint32_t id, void *fun, void *arg)

hipApiName

const char * hipApiName(uint32_t id)

hipRemoveApiCallback

hipError_t hipRemoveApiCallback(uint32_t id)

hipKernelNameRef

const char * hipKernelNameRef(const hipFunction_t f)

hipKernelNameRefByPtr

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

hipRemoveActivityCallback

hipError_t hipRemoveActivityCallback(uint32_t id)

hipGetStreamDeviceId

int hipGetStreamDeviceId(hipStream_t stream)

hipRegisterActivityCallback

hipError_t hipRegisterActivityCallback(uint32_t id, void *fun, void *arg)

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.

hipExtLaunchKernel

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

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

hipConfigureCall

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

Configure a kernel launch.

hipLaunchByPtr

hipError_t hipLaunchByPtr(const void *func)

Launch a kernel.

hipLaunchKernel

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

C compliant kernel launch API.

hipDrvMemcpy2DUnaligned

hipError_t hipDrvMemcpy2DUnaligned(const hip_Memcpy2D *pCopy)

hipCtxGetFlags

hipError_t hipCtxGetFlags(unsigned int *flags)

Return flags used for creating default context.

hipCtxPopCurrent

hipError_t hipCtxPopCurrent(hipCtx_t *ctx)

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

hipCtxGetSharedMemConfig

hipError_t hipCtxGetSharedMemConfig(hipSharedMemConfig *pConfig)

Get Shared memory bank configuration.

hipCtxGetCurrent

hipError_t hipCtxGetCurrent(hipCtx_t *ctx)

Get the handle of the current/ default context.

hipCtxSetCacheConfig

hipError_t hipCtxSetCacheConfig(hipFuncCache_t cacheConfig)

Set L1/Shared cache partition.

hipCtxSetCurrent

hipError_t hipCtxSetCurrent(hipCtx_t ctx)

Set the passed context as current/default.

hipCtxEnablePeerAccess

hipError_t hipCtxEnablePeerAccess(hipCtx_t peerCtx, unsigned int flags)

Enables direct access to memory allocations in a peer context.

hipCtxGetDevice

hipError_t hipCtxGetDevice(hipDevice_t *device)

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

hipCtxDestroy

hipError_t hipCtxDestroy(hipCtx_t ctx)

Destroy a HIP context.

hipCtxPushCurrent

hipError_t hipCtxPushCurrent(hipCtx_t ctx)

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

hipCtxGetCacheConfig

hipError_t hipCtxGetCacheConfig(hipFuncCache_t *cacheConfig)

Set Cache configuration for a specific function.

hipCtxCreate

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

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

hipCtxGetApiVersion

hipError_t hipCtxGetApiVersion(hipCtx_t ctx, int *apiVersion)

Returns the approximate HIP api version.

hipCtxSynchronize

hipError_t hipCtxSynchronize(void)

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

hipCtxSetSharedMemConfig

hipError_t hipCtxSetSharedMemConfig(hipSharedMemConfig config)

Set Shared memory bank configuration.

hipCtxDisablePeerAccess

hipError_t hipCtxDisablePeerAccess(hipCtx_t peerCtx)

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

hipDevicePrimaryCtxSetFlags

hipError_t hipDevicePrimaryCtxSetFlags(hipDevice_t dev, unsigned int flags)

Set flags for the primary context.

hipDevicePrimaryCtxGetState

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

Get the state of the primary context.

hipDevicePrimaryCtxRelease

hipError_t hipDevicePrimaryCtxRelease(hipDevice_t dev)

Release the primary context on the GPU.

hipDevicePrimaryCtxRetain

hipError_t hipDevicePrimaryCtxRetain(hipCtx_t *pctx, hipDevice_t dev)

Retain the primary context on the GPU.

hipDevicePrimaryCtxReset

hipError_t hipDevicePrimaryCtxReset(hipDevice_t dev)

Resets the primary context on the GPU.

hipGetDeviceFlags

hipError_t hipGetDeviceFlags(unsigned int *flags)

Gets the flags set for current device.

hipIpcGetEventHandle

hipError_t hipIpcGetEventHandle(hipIpcEventHandle_t *handle, hipEvent_t event)

Gets an opaque interprocess handle for an event.

hipDeviceGetSharedMemConfig

hipError_t hipDeviceGetSharedMemConfig(hipSharedMemConfig *pConfig)

Returns bank width of shared memory for current 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)

Set Cache configuration for a specific function.

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.

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)

Get Resource limits of current device.

hipDeviceSetSharedMemConfig

hipError_t hipDeviceSetSharedMemConfig(hipSharedMemConfig config)

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

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.

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

hipGetLastError

hipError_t hipGetLastError(void)

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

hipGetErrorName

const char * hipGetErrorName(hipError_t hip_error)

Return name of the specified error code in text form.

hipEventSynchronize

hipError_t hipEventSynchronize(hipEvent_t event)

Wait for an event to complete.

hipEventRecord

hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream)

Record an event in the specified stream.

hipEventQuery

hipError_t hipEventQuery(hipEvent_t event)

Query event status.

hipEventCreate

hipError_t hipEventCreate(hipEvent_t *event)

hipEventDestroy

hipError_t hipEventDestroy(hipEvent_t event)

Destroy the specified event.

hipEventElapsedTime

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

Return the elapsed time between two events.

hipEventCreateWithFlags

hipError_t hipEventCreateWithFlags(hipEvent_t *event, unsigned flags)

Create an event with the specified flags.

hipFuncSetSharedMemConfig

hipError_t hipFuncSetSharedMemConfig(const void *func, hipSharedMemConfig config)

Set shared memory configuation for a specific function.

hipFuncSetAttribute

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

Set attribute for a specific function.

hipFuncSetCacheConfig

hipError_t hipFuncSetCacheConfig(const void *func, hipFuncCache_t config)

Set Cache configuration for a specific function.

hipGLGetDevices

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

hipGraphicsGLRegisterImage

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

hipGraphicsUnregisterResource

hipError_t hipGraphicsUnregisterResource(hipGraphicsResource_t resource)

hipGraphicsGLRegisterBuffer

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

hipGraphicsMapResources

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

GLenum

unsigned int GLenum

Definition hip_runtime_api.h:5487

hipGraphicsSubResourceGetMappedArray

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

GLuint

unsigned int GLuint

Definition hip_runtime_api.h:5486

hipGraphicsUnmapResources

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

hipGraphicsResourceGetMappedPointer

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

hipGraphicsResource_t

hipGraphicsResource * hipGraphicsResource_t

Definition hip_runtime_api.h:909

hipGLDeviceList

hipGLDeviceList

Definition hip_runtime_api.h:884

hipMemRangeAttribute

hipMemRangeAttribute

Definition hip_runtime_api.h:711

hipMemAttachSingle

#define hipMemAttachSingle

Definition hip_runtime_api.h:606

hipMemoryAdvise

hipMemoryAdvise

Definition hip_runtime_api.h:674

hipArrayDefault

#define hipArrayDefault

Definition hip_runtime_api.h:648

hipSharedMemConfig

hipSharedMemConfig

Definition hip_runtime_api.h:767

hipComputeMode

hipComputeMode

Definition hip_runtime_api.h:454

hipExternalMemoryHandleType

hipExternalMemoryHandleType

Definition hip_runtime_api.h:794

hipMemAttachGlobal

#define hipMemAttachGlobal

Definition hip_runtime_api.h:600

hipFuncAttribute

hipFuncAttribute

Definition hip_runtime_api.h:750

hipExternalSemaphoreHandleType

hipExternalSemaphoreHandleType

Definition hip_runtime_api.h:821

hipJitOption

hipJitOption

Definition hip_runtime_api.h:727

hipError_t

enum __HIP_NODISCARD hipError_t hipError_t

Definition hip_runtime_api.h:203

hipOccupancyDefault

#define hipOccupancyDefault

Definition hip_runtime_api.h:653

hipFuncCache_t

hipFuncCache_t

Definition hip_runtime_api.h:758

__HIP_NODISCARD

#define __HIP_NODISCARD

Definition hip_runtime_api.h:192

hipExternalSemaphore_t

void * hipExternalSemaphore_t

Definition hip_runtime_api.h:838

hipGraphicsRegisterFlags

hipGraphicsRegisterFlags

Definition hip_runtime_api.h:897

hipMemRangeCoherencyMode

hipMemRangeCoherencyMode

Definition hip_runtime_api.h:697

hipExternalMemory_t

void * hipExternalMemory_t

Definition hip_runtime_api.h:820

hipDeviceAttribute_t

hipDeviceAttribute_t

Definition hip_runtime_api.h:326

hipHostMallocDefault

#define hipHostMallocDefault

Definition hip_runtime_api.h:576

hipGraphicsResource

struct _hipGraphicsResource hipGraphicsResource

Definition hip_runtime_api.h:907

hipGLDeviceListNextFrame

@ hipGLDeviceListNextFrame

frame.

Definition hip_runtime_api.h:888

hipGLDeviceListAll

@ hipGLDeviceListAll

All hip devices used by current OpenGL context.

Definition hip_runtime_api.h:885

hipGLDeviceListCurrentFrame

@ hipGLDeviceListCurrentFrame

frame

Definition hip_runtime_api.h:886

hipMemRangeAttributeLastPrefetchLocation

@ hipMemRangeAttributeLastPrefetchLocation

prefetched

Definition hip_runtime_api.h:717

hipMemRangeAttributePreferredLocation

@ hipMemRangeAttributePreferredLocation

The preferred location of the range.

Definition hip_runtime_api.h:714

hipMemRangeAttributeAccessedBy

@ hipMemRangeAttributeAccessedBy

Definition hip_runtime_api.h:715

hipMemRangeAttributeReadMostly

@ hipMemRangeAttributeReadMostly

Definition hip_runtime_api.h:712

hipMemRangeAttributeCoherencyMode

@ hipMemRangeAttributeCoherencyMode

Definition hip_runtime_api.h:719

hipMemAdviseUnsetAccessedBy

@ hipMemAdviseUnsetAccessedBy

Definition hip_runtime_api.h:683

hipMemAdviseUnsetCoarseGrain

@ hipMemAdviseUnsetCoarseGrain

Restores cache coherency policy back to fine-grain.

Definition hip_runtime_api.h:690

hipMemAdviseSetCoarseGrain

@ hipMemAdviseSetCoarseGrain

Definition hip_runtime_api.h:685

hipMemAdviseUnsetPreferredLocation

@ hipMemAdviseUnsetPreferredLocation

Clear the preferred location for the data.

Definition hip_runtime_api.h:680

hipMemAdviseSetAccessedBy

@ hipMemAdviseSetAccessedBy

Definition hip_runtime_api.h:681

hipMemAdviseSetPreferredLocation

@ hipMemAdviseSetPreferredLocation

Definition hip_runtime_api.h:678

hipMemAdviseSetReadMostly

@ hipMemAdviseSetReadMostly

Definition hip_runtime_api.h:675

hipMemAdviseUnsetReadMostly

@ hipMemAdviseUnsetReadMostly

Undo the effect of hipMemAdviseSetReadMostly.

Definition hip_runtime_api.h:677

hipSharedMemBankSizeFourByte

@ hipSharedMemBankSizeFourByte

Definition hip_runtime_api.h:769

hipSharedMemBankSizeEightByte

@ hipSharedMemBankSizeEightByte

Definition hip_runtime_api.h:771

hipSharedMemBankSizeDefault

@ hipSharedMemBankSizeDefault

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

Definition hip_runtime_api.h:768

hipComputeModeProhibited

@ hipComputeModeProhibited

Definition hip_runtime_api.h:457

hipComputeModeExclusive

@ hipComputeModeExclusive

Definition hip_runtime_api.h:456

hipComputeModeDefault

@ hipComputeModeDefault

Definition hip_runtime_api.h:455

hipComputeModeExclusiveProcess

@ hipComputeModeExclusiveProcess

Definition hip_runtime_api.h:458

hipExternalMemoryHandleTypeD3D11Resource

@ hipExternalMemoryHandleTypeD3D11Resource

Definition hip_runtime_api.h:800

hipExternalMemoryHandleTypeD3D12Resource

@ hipExternalMemoryHandleTypeD3D12Resource

Definition hip_runtime_api.h:799

hipExternalMemoryHandleTypeOpaqueFd

@ hipExternalMemoryHandleTypeOpaqueFd

Definition hip_runtime_api.h:795

hipExternalMemoryHandleTypeD3D12Heap

@ hipExternalMemoryHandleTypeD3D12Heap

Definition hip_runtime_api.h:798

hipExternalMemoryHandleTypeOpaqueWin32Kmt

@ hipExternalMemoryHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:797

hipExternalMemoryHandleTypeOpaqueWin32

@ hipExternalMemoryHandleTypeOpaqueWin32

Definition hip_runtime_api.h:796

hipExternalMemoryHandleTypeD3D11ResourceKmt

@ hipExternalMemoryHandleTypeD3D11ResourceKmt

Definition hip_runtime_api.h:801

hipFuncAttributePreferredSharedMemoryCarveout

@ hipFuncAttributePreferredSharedMemoryCarveout

Definition hip_runtime_api.h:752

hipFuncAttributeMaxDynamicSharedMemorySize

@ hipFuncAttributeMaxDynamicSharedMemorySize

Definition hip_runtime_api.h:751

hipFuncAttributeMax

@ hipFuncAttributeMax

Definition hip_runtime_api.h:753

hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

@ hipExternalSemaphoreHandleTypeOpaqueWin32Kmt

Definition hip_runtime_api.h:824

hipExternalSemaphoreHandleTypeOpaqueFd

@ hipExternalSemaphoreHandleTypeOpaqueFd

Definition hip_runtime_api.h:822

hipExternalSemaphoreHandleTypeOpaqueWin32

@ hipExternalSemaphoreHandleTypeOpaqueWin32

Definition hip_runtime_api.h:823

hipExternalSemaphoreHandleTypeD3D12Fence

@ hipExternalSemaphoreHandleTypeD3D12Fence

Definition hip_runtime_api.h:825

hipJitOptionCacheMode

@ hipJitOptionCacheMode

Definition hip_runtime_api.h:742

hipJitOptionFastCompile

@ hipJitOptionFastCompile

Definition hip_runtime_api.h:744

hipJitOptionInfoLogBuffer

@ hipJitOptionInfoLogBuffer

Definition hip_runtime_api.h:731

hipJitOptionErrorLogBuffer

@ hipJitOptionErrorLogBuffer

Definition hip_runtime_api.h:733

hipJitOptionTarget

@ hipJitOptionTarget

Definition hip_runtime_api.h:737

hipJitOptionThreadsPerBlock

@ hipJitOptionThreadsPerBlock

Definition hip_runtime_api.h:729

hipJitOptionNumOptions

@ hipJitOptionNumOptions

Definition hip_runtime_api.h:745

hipJitOptionGenerateLineInfo

@ hipJitOptionGenerateLineInfo

Definition hip_runtime_api.h:741

hipJitOptionOptimizationLevel

@ hipJitOptionOptimizationLevel

Definition hip_runtime_api.h:735

hipJitOptionErrorLogBufferSizeBytes

@ hipJitOptionErrorLogBufferSizeBytes

Definition hip_runtime_api.h:734

hipJitOptionWallTime

@ hipJitOptionWallTime

Definition hip_runtime_api.h:730

hipJitOptionInfoLogBufferSizeBytes

@ hipJitOptionInfoLogBufferSizeBytes

Definition hip_runtime_api.h:732

hipJitOptionTargetFromContext

@ hipJitOptionTargetFromContext

Definition hip_runtime_api.h:736

hipJitOptionGenerateDebugInfo

@ hipJitOptionGenerateDebugInfo

Definition hip_runtime_api.h:739

hipJitOptionLogVerbose

@ hipJitOptionLogVerbose

Definition hip_runtime_api.h:740

hipJitOptionMaxRegisters

@ hipJitOptionMaxRegisters

Definition hip_runtime_api.h:728

hipJitOptionSm3xOpt

@ hipJitOptionSm3xOpt

Definition hip_runtime_api.h:743

hipJitOptionFallbackStrategy

@ hipJitOptionFallbackStrategy

Definition hip_runtime_api.h:738

hipFuncCachePreferNone

@ hipFuncCachePreferNone

no preference for shared memory or L1 (default)

Definition hip_runtime_api.h:759

hipFuncCachePreferEqual

@ hipFuncCachePreferEqual

prefer equal size L1 cache and shared memory

Definition hip_runtime_api.h:762

hipFuncCachePreferL1

@ hipFuncCachePreferL1

prefer larger L1 cache and smaller shared memory

Definition hip_runtime_api.h:761

hipFuncCachePreferShared

@ hipFuncCachePreferShared

prefer larger shared memory and smaller L1 cache

Definition hip_runtime_api.h:760

hipGraphicsRegisterFlagsReadOnly

@ hipGraphicsRegisterFlagsReadOnly

HIP will not write to this registered resource.

Definition hip_runtime_api.h:899

hipGraphicsRegisterFlagsTextureGather

@ hipGraphicsRegisterFlagsTextureGather

HIP will perform texture gather operations on this registered resource.

Definition hip_runtime_api.h:903

hipGraphicsRegisterFlagsWriteDiscard

@ hipGraphicsRegisterFlagsWriteDiscard

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

Definition hip_runtime_api.h:900

hipGraphicsRegisterFlagsNone

@ hipGraphicsRegisterFlagsNone

Definition hip_runtime_api.h:898

hipGraphicsRegisterFlagsSurfaceLoadStore

@ hipGraphicsRegisterFlagsSurfaceLoadStore

HIP will bind this resource to a surface.

Definition hip_runtime_api.h:902

hipMemRangeCoherencyModeFineGrain

@ hipMemRangeCoherencyModeFineGrain

Definition hip_runtime_api.h:698

hipMemRangeCoherencyModeIndeterminate

@ hipMemRangeCoherencyModeIndeterminate

Definition hip_runtime_api.h:702

hipMemRangeCoherencyModeCoarseGrain

@ hipMemRangeCoherencyModeCoarseGrain

Definition hip_runtime_api.h:700

hipDeviceAttributeDirectManagedMemAccessFromHost

@ hipDeviceAttributeDirectManagedMemAccessFromHost

Definition hip_runtime_api.h:344

hipDeviceAttributeSurfaceAlignment

@ hipDeviceAttributeSurfaceAlignment

Cuda only. Alignment requirement for surfaces.

Definition hip_runtime_api.h:414

hipDeviceAttributeMaxGridDimX

@ hipDeviceAttributeMaxGridDimX

Max grid size in width.

Definition hip_runtime_api.h:361

hipDeviceAttributeMaxSurfaceCubemapLayered

@ hipDeviceAttributeMaxSurfaceCubemapLayered

Cuda only. Maximum dimension of Cubemap layered surface.

Definition hip_runtime_api.h:370

hipDeviceAttributeMaxSurface3D

@ hipDeviceAttributeMaxSurface3D

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

Definition hip_runtime_api.h:368

hipDeviceAttributeMaxPitch

@ hipDeviceAttributeMaxPitch

Maximum pitch in bytes allowed by memory copies.

Definition hip_runtime_api.h:391

hipDeviceAttributeTccDriver

@ hipDeviceAttributeTccDriver

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

Definition hip_runtime_api.h:415

hipDeviceAttributeHostNativeAtomicSupported

@ hipDeviceAttributeHostNativeAtomicSupported

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

Definition hip_runtime_api.h:347

hipDeviceAttributePageableMemoryAccessUsesHostPageTables

@ hipDeviceAttributePageableMemoryAccessUsesHostPageTables

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

Definition hip_runtime_api.h:400

hipDeviceAttributeMaxBlockDimY

@ hipDeviceAttributeMaxBlockDimY

Max block size in height.

Definition hip_runtime_api.h:359

hipDeviceAttributeMaxSurfaceCubemap

@ hipDeviceAttributeMaxSurfaceCubemap

Cuda only. Maximum dimensions of Cubemap surface.

Definition hip_runtime_api.h:369

hipDeviceAttributeName

@ hipDeviceAttributeName

Device name.

Definition hip_runtime_api.h:397

hipDeviceAttributePageableMemoryAccess

@ hipDeviceAttributePageableMemoryAccess

Definition hip_runtime_api.h:398

hipDeviceAttributeClockRate

@ hipDeviceAttributeClockRate

Peak clock frequency in kilohertz.

Definition hip_runtime_api.h:335

hipDeviceAttributeCudaCompatibleEnd

@ hipDeviceAttributeCudaCompatibleEnd

Definition hip_runtime_api.h:424

hipDeviceAttributeMaxTexture1DMipmap

@ hipDeviceAttributeMaxTexture1DMipmap

Cuda only. Maximum size of 1D mipmapped texture.

Definition hip_runtime_api.h:375

hipDeviceAttributeComputeCapabilityMajor

@ hipDeviceAttributeComputeCapabilityMajor

Major compute capability version number.

Definition hip_runtime_api.h:355

hipDeviceAttributeGlobalL1CacheSupported

@ hipDeviceAttributeGlobalL1CacheSupported

Cuda only. Device supports caching globals in L1.

Definition hip_runtime_api.h:346

hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem

Definition hip_runtime_api.h:440

hipDeviceAttributeAccessPolicyMaxWindowSize

@ hipDeviceAttributeAccessPolicyMaxWindowSize

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

Definition hip_runtime_api.h:330

hipDeviceAttributeMaxTexture3DHeight

@ hipDeviceAttributeMaxTexture3DHeight

Maximum dimension height of 3D texture.

Definition hip_runtime_api.h:383

hipDeviceAttributeComputeCapabilityMinor

@ hipDeviceAttributeComputeCapabilityMinor

Minor compute capability version number.

Definition hip_runtime_api.h:394

hipDeviceAttributeMaxTextureCubemap

@ hipDeviceAttributeMaxTextureCubemap

Cuda only. Maximum dimensions of Cubemap texture.

Definition hip_runtime_api.h:386

hipDeviceAttributeDeviceOverlap

@ hipDeviceAttributeDeviceOverlap

Definition hip_runtime_api.h:342

hipDeviceAttributeMaxTexture2DLinear

@ hipDeviceAttributeMaxTexture2DLinear

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

Definition hip_runtime_api.h:380

hipDeviceAttributeMaxSurface2D

@ hipDeviceAttributeMaxSurface2D

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

Definition hip_runtime_api.h:366

hipDeviceAttributeMaxSurface1DLayered

@ hipDeviceAttributeMaxSurface1DLayered

Cuda only. Maximum dimensions of 1D layered surface.

Definition hip_runtime_api.h:365

hipDeviceAttributeHdpRegFlushCntl

@ hipDeviceAttributeHdpRegFlushCntl

Address of the HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:433

hipDeviceAttributeComputeMode

@ hipDeviceAttributeComputeMode

Compute mode that device is currently in.

Definition hip_runtime_api.h:336

hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc

Definition hip_runtime_api.h:434

hipDeviceAttributeAsicRevision

@ hipDeviceAttributeAsicRevision

Revision of the GPU in this device.

Definition hip_runtime_api.h:443

hipDeviceAttributeCooperativeMultiDeviceLaunch

@ hipDeviceAttributeCooperativeMultiDeviceLaunch

Support cooperative launch on multiple devices.

Definition hip_runtime_api.h:341

hipDeviceAttributeMaxTexture2DHeight

@ hipDeviceAttributeMaxTexture2DHeight

Maximum dimension hight of 2D texture.

Definition hip_runtime_api.h:377

hipDeviceAttributePersistingL2CacheMaxSize

@ hipDeviceAttributePersistingL2CacheMaxSize

Cuda11 only. Maximum l2 persisting lines capacity in bytes.

Definition hip_runtime_api.h:404

hipDeviceAttributeEccEnabled

@ hipDeviceAttributeEccEnabled

Whether ECC support is enabled.

Definition hip_runtime_api.h:329

hipDeviceAttributeCanUseHostPointerForRegisteredMem

@ hipDeviceAttributeCanUseHostPointerForRegisteredMem

Definition hip_runtime_api.h:333

hipDeviceAttributePciBusId

@ hipDeviceAttributePciBusId

PCI Bus ID.

Definition hip_runtime_api.h:401

hipDeviceAttributeL2CacheSize

@ hipDeviceAttributeL2CacheSize

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

Definition hip_runtime_api.h:351

hipDeviceAttributeKernelExecTimeout

@ hipDeviceAttributeKernelExecTimeout

Run time limit for kernels executed on the device.

Definition hip_runtime_api.h:350

hipDeviceAttributeMaxThreadsDim

@ hipDeviceAttributeMaxThreadsDim

Maximum dimension of a block.

Definition hip_runtime_api.h:388

hipDeviceAttributeSingleToDoublePrecisionPerfRatio

@ hipDeviceAttributeSingleToDoublePrecisionPerfRatio

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

Definition hip_runtime_api.h:412

hipDeviceAttributeMaxGridDimY

@ hipDeviceAttributeMaxGridDimY

Max grid size in height.

Definition hip_runtime_api.h:362

hipDeviceAttributeMultiprocessorCount

@ hipDeviceAttributeMultiprocessorCount

Number of multiprocessors on the device.

Definition hip_runtime_api.h:396

hipDeviceAttributeUuid

@ hipDeviceAttributeUuid

Cuda only. Unique ID in 16 byte.

Definition hip_runtime_api.h:421

hipDeviceAttributeAmdSpecificBegin

@ hipDeviceAttributeAmdSpecificBegin

Definition hip_runtime_api.h:425

hipDeviceAttributeMaxRegistersPerMultiprocessor

@ hipDeviceAttributeMaxRegistersPerMultiprocessor

32-bit registers available per block.

Definition hip_runtime_api.h:407

hipDeviceAttributeGcnArchName

@ hipDeviceAttributeGcnArchName

Device gcnArch name in 256 bytes.

Definition hip_runtime_api.h:431

hipDeviceAttributeIsMultiGpuBoard

@ hipDeviceAttributeIsMultiGpuBoard

Multiple GPU devices.

Definition hip_runtime_api.h:349

hipDeviceAttributeSharedMemPerBlockOptin

@ hipDeviceAttributeSharedMemPerBlockOptin

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

Definition hip_runtime_api.h:410

hipDeviceAttributeMaxSurface2DLayered

@ hipDeviceAttributeMaxSurface2DLayered

Cuda only. Maximum dimensions of 2D layered surface.

Definition hip_runtime_api.h:367

hipDeviceAttributeAmdSpecificEnd

@ hipDeviceAttributeAmdSpecificEnd

Definition hip_runtime_api.h:449

hipDeviceAttributeMemoryClockRate

@ hipDeviceAttributeMemoryClockRate

Peak memory clock frequency in kilohertz.

Definition hip_runtime_api.h:393

hipDeviceAttributeGcnArch

@ hipDeviceAttributeGcnArch

Device gcn architecture.

Definition hip_runtime_api.h:430

hipDeviceAttributeMaxGridDimZ

@ hipDeviceAttributeMaxGridDimZ

Max grid size in depth.

Definition hip_runtime_api.h:363

hipDeviceAttributeHdpMemFlushCntl

@ hipDeviceAttributeHdpMemFlushCntl

Address of the HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:432

hipDeviceAttributeCooperativeLaunch

@ hipDeviceAttributeCooperativeLaunch

Support cooperative launch.

Definition hip_runtime_api.h:340

hipDeviceAttributeUnifiedAddressing

@ hipDeviceAttributeUnifiedAddressing

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

Definition hip_runtime_api.h:420

hipDeviceAttributeAsyncEngineCount

@ hipDeviceAttributeAsyncEngineCount

Cuda only. Asynchronous engines number.

Definition hip_runtime_api.h:331

hipDeviceAttributeMultiGpuBoardGroupID

@ hipDeviceAttributeMultiGpuBoardGroupID

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

Definition hip_runtime_api.h:395

hipDeviceAttributeStreamPrioritiesSupported

@ hipDeviceAttributeStreamPrioritiesSupported

Cuda only. Whether to support stream priorities.

Definition hip_runtime_api.h:413

hipDeviceAttributeMaxSharedMemoryPerBlock

@ hipDeviceAttributeMaxSharedMemoryPerBlock

Maximum shared memory available per block in bytes.

Definition hip_runtime_api.h:409

hipDeviceAttributeLocalL1CacheSupported

@ hipDeviceAttributeLocalL1CacheSupported

caching locals in L1 is supported

Definition hip_runtime_api.h:352

hipDeviceAttributeCanUseStreamWaitValue

@ hipDeviceAttributeCanUseStreamWaitValue

Definition hip_runtime_api.h:444

hipDeviceAttributeMaxRegistersPerBlock

@ hipDeviceAttributeMaxRegistersPerBlock

Definition hip_runtime_api.h:405

hipDeviceAttributeMaxThreadsPerBlock

@ hipDeviceAttributeMaxThreadsPerBlock

Maximum number of threads per block.

Definition hip_runtime_api.h:389

hipDeviceAttributeMemoryBusWidth

@ hipDeviceAttributeMemoryBusWidth

Global memory bus width in bits.

Definition hip_runtime_api.h:392

hipDeviceAttributeComputePreemptionSupported

@ hipDeviceAttributeComputePreemptionSupported

Cuda only. Device supports Compute Preemption.

Definition hip_runtime_api.h:337

hipDeviceAttributeMaxSurface1D

@ hipDeviceAttributeMaxSurface1D

Maximum size of 1D surface.

Definition hip_runtime_api.h:364

hipDeviceAttributeMaxTexture3DAlt

@ hipDeviceAttributeMaxTexture3DAlt

Cuda only. Maximum dimensions of alternate 3D texture.

Definition hip_runtime_api.h:385

hipDeviceAttributeMaxTexture1DLinear

@ hipDeviceAttributeMaxTexture1DLinear

Definition hip_runtime_api.h:373

hipDeviceAttributeMaxTexture2DGather

@ hipDeviceAttributeMaxTexture2DGather

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

Definition hip_runtime_api.h:378

hipDeviceAttributePciDeviceId

@ hipDeviceAttributePciDeviceId

PCI Device ID.

Definition hip_runtime_api.h:402

hipDeviceAttributeCanMapHostMemory

@ hipDeviceAttributeCanMapHostMemory

Whether host memory can be mapped into device address space.

Definition hip_runtime_api.h:332

hipDeviceAttributeMaxTexture1DWidth

@ hipDeviceAttributeMaxTexture1DWidth

Maximum size of 1D texture.

Definition hip_runtime_api.h:371

hipDeviceAttributeConcurrentManagedAccess

@ hipDeviceAttributeConcurrentManagedAccess

Device can coherently access managed memory concurrently with the CPU.

Definition hip_runtime_api.h:339

hipDeviceAttributeVendorSpecificBegin

@ hipDeviceAttributeVendorSpecificBegin

Definition hip_runtime_api.h:450

hipDeviceAttributeArch

@ hipDeviceAttributeArch

Device architecture.

Definition hip_runtime_api.h:428

hipDeviceAttributeManagedMemory

@ hipDeviceAttributeManagedMemory

Device supports allocating managed memory on this system.

Definition hip_runtime_api.h:356

hipDeviceAttributeIntegrated

@ hipDeviceAttributeIntegrated

Device is integrated GPU.

Definition hip_runtime_api.h:348

hipDeviceAttributeMaxTexture2DLayered

@ hipDeviceAttributeMaxTexture2DLayered

Cuda only. Maximum dimensions of 2D layered texture.

Definition hip_runtime_api.h:379

hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim

Definition hip_runtime_api.h:436

hipDeviceAttributeMaxTexture3DDepth

@ hipDeviceAttributeMaxTexture3DDepth

Maximum dimension depth of 3D texture.

Definition hip_runtime_api.h:384

hipDeviceAttributeImageSupport

@ hipDeviceAttributeImageSupport

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

Definition hip_runtime_api.h:446

hipDeviceAttributeTotalGlobalMem

@ hipDeviceAttributeTotalGlobalMem

Global memory available on devicice.

Definition hip_runtime_api.h:419

hipDeviceAttributeMaxBlocksPerMultiProcessor

@ hipDeviceAttributeMaxBlocksPerMultiProcessor

Cuda only. Max block size per multiprocessor.

Definition hip_runtime_api.h:357

hipDeviceAttributeIsLargeBar

@ hipDeviceAttributeIsLargeBar

Whether it is LargeBar.

Definition hip_runtime_api.h:442

hipDeviceAttributeMaxTexture2DWidth

@ hipDeviceAttributeMaxTexture2DWidth

Maximum dimension width of 2D texture.

Definition hip_runtime_api.h:376

hipDeviceAttributeMaxBlockDimX

@ hipDeviceAttributeMaxBlockDimX

Max block size in width.

Definition hip_runtime_api.h:358

hipDeviceAttributeMaxTexture3DWidth

@ hipDeviceAttributeMaxTexture3DWidth

Maximum dimension width of 3D texture.

Definition hip_runtime_api.h:382

hipDeviceAttributeTotalConstantMemory

@ hipDeviceAttributeTotalConstantMemory

Constant memory size in bytes.

Definition hip_runtime_api.h:418

hipDeviceAttributeTextureAlignment

@ hipDeviceAttributeTextureAlignment

Alignment requirement for textures.

Definition hip_runtime_api.h:416

hipDeviceAttributeMaxTexture1DLayered

@ hipDeviceAttributeMaxTexture1DLayered

Cuda only. Maximum dimensions of 1D layered texture.

Definition hip_runtime_api.h:372

hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

@ hipDeviceAttributeMaxSharedMemoryPerMultiprocessor

Maximum Shared Memory PerMultiprocessor.

Definition hip_runtime_api.h:429

hipDeviceAttributeReservedSharedMemPerBlock

@ hipDeviceAttributeReservedSharedMemPerBlock

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

Definition hip_runtime_api.h:408

hipDeviceAttributeCudaCompatibleBegin

@ hipDeviceAttributeCudaCompatibleBegin

Definition hip_runtime_api.h:327

hipDeviceAttributeConcurrentKernels

@ hipDeviceAttributeConcurrentKernels

Device can possibly execute multiple kernels concurrently.

Definition hip_runtime_api.h:338

hipDeviceAttributeLuid

@ hipDeviceAttributeLuid

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

Definition hip_runtime_api.h:353

hipDeviceAttributePciDomainID

@ hipDeviceAttributePciDomainID

PCI Domain ID.

Definition hip_runtime_api.h:403

hipDeviceAttributeMaxThreadsPerMultiProcessor

@ hipDeviceAttributeMaxThreadsPerMultiProcessor

Maximum resident threads per multiprocessor.

Definition hip_runtime_api.h:390

hipDeviceAttributeTexturePitchAlignment

@ hipDeviceAttributeTexturePitchAlignment

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

Definition hip_runtime_api.h:417

hipDeviceAttributePhysicalMultiProcessorCount

@ hipDeviceAttributePhysicalMultiProcessorCount

Definition hip_runtime_api.h:447

hipDeviceAttributeSharedMemPerMultiprocessor

@ hipDeviceAttributeSharedMemPerMultiprocessor

Cuda only. Shared memory available per multiprocessor.

Definition hip_runtime_api.h:411

hipDeviceAttributeLuidDeviceNodeMask

@ hipDeviceAttributeLuidDeviceNodeMask

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

Definition hip_runtime_api.h:354

hipDeviceAttributeMaxTextureCubemapLayered

@ hipDeviceAttributeMaxTextureCubemapLayered

Cuda only. Maximum dimensions of Cubemap layered texture.

Definition hip_runtime_api.h:387

hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

@ hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim

Definition hip_runtime_api.h:438

hipDeviceAttributeClockInstructionRate

@ hipDeviceAttributeClockInstructionRate

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

Definition hip_runtime_api.h:427

hipDeviceAttributeMaxTexture2DMipmap

@ hipDeviceAttributeMaxTexture2DMipmap

Cuda only. Maximum dimensions of 2D mipmapped texture.

Definition hip_runtime_api.h:381

hipDeviceAttributeMaxBlockDimZ

@ hipDeviceAttributeMaxBlockDimZ

Max block size in depth.

Definition hip_runtime_api.h:360

hipDeviceAttributeWarpSize

@ hipDeviceAttributeWarpSize

Warp size in threads.

Definition hip_runtime_api.h:422

hipGraphKernelNodeSetParams

hipError_t hipGraphKernelNodeSetParams(hipGraphNode_t node, const hipKernelNodeParams *pNodeParams)

Sets a kernel node's parameters.

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.

hipGraphMemcpyNodeSetParams

hipError_t hipGraphMemcpyNodeSetParams(hipGraphNode_t node, const hipMemcpy3DParms *pNodeParams)

Sets a memcpy node's parameters.

hipGraphExecUpdate

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

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

hipGraphNodeFindInClone

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

Finds a cloned version of a node.

hipGraphAddEventWaitNode

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

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

hipGraphMemcpyNodeSetParamsToSymbol

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

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

hipStreamIsCapturing

hipError_t hipStreamIsCapturing(hipStream_t stream, hipStreamCaptureStatus *pCaptureStatus)

Get stream's capture state.

hipGraphAddChildGraphNode

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

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

hipGraphDestroyNode

hipError_t hipGraphDestroyNode(hipGraphNode_t node)

Remove a node from the graph.

hipGraphMemcpyNodeSetParamsFromSymbol

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

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

hipGraphRemoveDependencies

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

Removes dependency edges from a graph.

hipStreamCaptureMode

hipStreamCaptureMode

Definition hip_runtime_api.h:4548

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.

hipGraphNodeType

hipGraphNodeType

Definition hip_runtime_api.h:4491

hipGraphExecDestroy

hipError_t hipGraphExecDestroy(hipGraphExec_t graphExec)

Destroys an executable graph.

hipGraphExecHostNodeSetParams

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

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

hipGraphExecChildGraphNodeSetParams

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

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

hipStreamGetCaptureInfo

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

Get capture status of a stream.

hipGraphAddDependencies

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

Adds dependency edges to a graph.

hipGraphExecKernelNodeSetParams

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

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

hipGraphNodeGetDependentNodes

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

Returns a node's dependent nodes.

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.

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.

hipHostFn_t

void(* hipHostFn_t)(void *userData)

Definition hip_runtime_api.h:4506

hipGraphKernelNodeGetParams

hipError_t hipGraphKernelNodeGetParams(hipGraphNode_t node, hipKernelNodeParams *pNodeParams)

Gets kernel node's parameters.

hipGraphAddMemcpyNodeFromSymbol

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

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

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.

hipStreamUpdateCaptureDependenciesFlags

hipStreamUpdateCaptureDependenciesFlags

Definition hip_runtime_api.h:4560

hipGraph_t

struct ihipGraph * hipGraph_t

Definition hip_runtime_api.h:4476

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.

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.

hipGraphExecEventRecordNodeSetEvent

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

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

hipGraphMemsetNodeGetParams

hipError_t hipGraphMemsetNodeGetParams(hipGraphNode_t node, hipMemsetParams *pNodeParams)

Gets a memset node's parameters.

hipGraphChildGraphNodeGetGraph

hipError_t hipGraphChildGraphNodeGetGraph(hipGraphNode_t node, hipGraph_t *pGraph)

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

hipGraphLaunch

hipError_t hipGraphLaunch(hipGraphExec_t graphExec, hipStream_t stream)

launches an executable graph in a stream

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.

hipGraphExec_t

struct hipGraphExec * hipGraphExec_t

Definition hip_runtime_api.h:4484

hipGraphExecUpdateResult

hipGraphExecUpdateResult

Definition hip_runtime_api.h:4533

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.

hipStreamCaptureStatus

hipStreamCaptureStatus

Definition hip_runtime_api.h:4553

hipGraphEventWaitNodeGetEvent

hipError_t hipGraphEventWaitNodeGetEvent(hipGraphNode_t node, hipEvent_t *event_out)

Returns the event associated with an event wait node.

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.

hipGraphNode_t

struct hipGraphNode * hipGraphNode_t

Definition hip_runtime_api.h:4480

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.

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.

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.

hipStreamCaptureModeRelaxed

@ hipStreamCaptureModeRelaxed

Definition hip_runtime_api.h:4551

hipStreamCaptureModeThreadLocal

@ hipStreamCaptureModeThreadLocal

Definition hip_runtime_api.h:4550

hipStreamCaptureModeGlobal

@ hipStreamCaptureModeGlobal

Definition hip_runtime_api.h:4549

hipGraphNodeTypeGraph

@ hipGraphNodeTypeGraph

Node which executes an embedded graph.

Definition hip_runtime_api.h:4496

hipGraphNodeTypeMemset

@ hipGraphNodeTypeMemset

Memset 1D node.

Definition hip_runtime_api.h:4494

hipGraphNodeTypeEventRecord

@ hipGraphNodeTypeEventRecord

External event record node.

Definition hip_runtime_api.h:4499

hipGraphNodeTypeMemcpy

@ hipGraphNodeTypeMemcpy

Memcpy 3D node.

Definition hip_runtime_api.h:4493

hipGraphNodeTypeWaitEvent

@ hipGraphNodeTypeWaitEvent

External event wait node.

Definition hip_runtime_api.h:4498

hipGraphNodeTypeMemcpy1D

@ hipGraphNodeTypeMemcpy1D

Memcpy 1D node.

Definition hip_runtime_api.h:4500

hipGraphNodeTypeCount

@ hipGraphNodeTypeCount

Definition hip_runtime_api.h:4503

hipGraphNodeTypeKernel

@ hipGraphNodeTypeKernel

GPU kernel node.

Definition hip_runtime_api.h:4492

hipGraphNodeTypeHost

@ hipGraphNodeTypeHost

Host (executable) node.

Definition hip_runtime_api.h:4495

hipGraphNodeTypeMemcpyFromSymbol

@ hipGraphNodeTypeMemcpyFromSymbol

MemcpyFromSymbol node.

Definition hip_runtime_api.h:4501

hipGraphNodeTypeMemcpyToSymbol

@ hipGraphNodeTypeMemcpyToSymbol

MemcpyToSymbol node.

Definition hip_runtime_api.h:4502

hipGraphNodeTypeEmpty

@ hipGraphNodeTypeEmpty

Empty (no-op) node.

Definition hip_runtime_api.h:4497

hipStreamAddCaptureDependencies

@ hipStreamAddCaptureDependencies

Add new nodes to the dependency set.

Definition hip_runtime_api.h:4561

hipStreamSetCaptureDependencies

@ hipStreamSetCaptureDependencies

Replace the dependency set with the new nodes.

Definition hip_runtime_api.h:4562

hipGraphExecUpdateErrorNotSupported

@ hipGraphExecUpdateErrorNotSupported

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

Definition hip_runtime_api.h:4543

hipGraphExecUpdateErrorNodeTypeChanged

@ hipGraphExecUpdateErrorNodeTypeChanged

The update failed because a node type changed.

Definition hip_runtime_api.h:4538

hipGraphExecUpdateErrorTopologyChanged

@ hipGraphExecUpdateErrorTopologyChanged

The update failed because the topology changed.

Definition hip_runtime_api.h:4537

hipGraphExecUpdateErrorUnsupportedFunctionChange

@ hipGraphExecUpdateErrorUnsupportedFunctionChange

Definition hip_runtime_api.h:4545

hipGraphExecUpdateError

@ hipGraphExecUpdateError

Definition hip_runtime_api.h:4535

hipGraphExecUpdateErrorFunctionChanged

@ hipGraphExecUpdateErrorFunctionChanged

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

Definition hip_runtime_api.h:4539

hipGraphExecUpdateSuccess

@ hipGraphExecUpdateSuccess

The update succeeded.

Definition hip_runtime_api.h:4534

hipGraphExecUpdateErrorParametersChanged

@ hipGraphExecUpdateErrorParametersChanged

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

Definition hip_runtime_api.h:4541

hipStreamCaptureStatusInvalidated

@ hipStreamCaptureStatusInvalidated

Definition hip_runtime_api.h:4556

hipStreamCaptureStatusNone

@ hipStreamCaptureStatusNone

Stream is not capturing.

Definition hip_runtime_api.h:4554

hipStreamCaptureStatusActive

@ hipStreamCaptureStatusActive

Stream is actively capturing.

Definition hip_runtime_api.h:4555

hipFreeMipmappedArray

hipError_t hipFreeMipmappedArray(hipMipmappedArray_t mipmappedArray)

Frees a mipmapped array on the device.

hipMemcpyToSymbol

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

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

hipDestroyExternalMemory

hipError_t hipDestroyExternalMemory(hipExternalMemory_t extMem)

Destroys an external memory object.

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.

hipImportExternalSemaphore

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

Imports an external semaphore.

hipMemcpyAtoH

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

Copies data between host and device.

hipHostAlloc

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

Allocate device accessible page locked host memory [Deprecated].

hipMemcpy2DToArrayAsync

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

Copies data between host and device.

hipGetMipmappedArrayLevel

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

Gets a mipmap level of a HIP mipmapped array.

hipMemsetD16Async

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

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

hipFreeHost

hipError_t hipFreeHost(void *ptr)

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

hipMemcpyFromSymbol

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

Copies data from the given symbol on the device.

hipHostFree

hipError_t hipHostFree(void *ptr)

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

hipMemcpyToArray

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

Copies data between host and device.

hipMemcpy2DFromArrayAsync

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

Copies data between host and device asynchronously.

hipMemGetInfo

hipError_t hipMemGetInfo(size_t *free, size_t *total)

Query memory info. Return snapshot of free memory, and total allocatable memory on the device.

hipExtMallocWithFlags

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

Allocate memory on the default accelerator.

hipImportExternalMemory

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

Imports an external memory object.

hipMemcpy3D

hipError_t hipMemcpy3D(const struct hipMemcpy3DParms *p)

Copies data between host and device.

hipMemcpy3DAsync

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

Copies data between host and device asynchronously.

hipMemset3D

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

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

hipModuleGetGlobal

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

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

hipMemsetD16

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

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

hipMemcpyFromSymbolAsync

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

Copies data from the given symbol on the device asynchronously.

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.

hipMalloc

hipError_t hipMalloc(void **ptr, size_t size)

Allocate memory on the default accelerator.

hipHostUnregister

hipError_t hipHostUnregister(void *hostPtr)

Un-register host pointer.

hipHostGetFlags

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

Return flags associated with host pointer.

hipMemsetD32

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

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

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.

hipDrvMemcpy3DAsync

hipError_t hipDrvMemcpy3DAsync(const HIP_MEMCPY3D *pCopy, hipStream_t stream)

Copies data between host and device asynchronously.

hipMallocHost

hipError_t hipMallocHost(void **ptr, size_t size)

Allocate pinned host memory [Deprecated].

hipMalloc3DArray

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

Allocate an array on the device.

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.

hipFree

hipError_t hipFree(void *ptr)

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

hipMemcpyToSymbolAsync

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

Copies data to the given symbol on the device asynchronously.

hipPointerGetAttributes

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

Return attributes for the specified pointer.

hipMallocPitch

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

hipMemcpyDtoD

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

Copy data from Device to Device.

hipMemcpy2D

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

Copies data between host and device.

hipMemcpyFromArray

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

Copies data between host and device.

hipHostGetDevicePointer

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

Get Device pointer from Host Pointer allocated through hipHostMalloc.

hipMemcpyParam2DAsync

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

Copies memory for 2D arrays.

hipDestroyExternalSemaphore

hipError_t hipDestroyExternalSemaphore(hipExternalSemaphore_t extSem)

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

hipMemsetD8Async

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

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

hipMemcpy2DFromArray

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

Copies data between host and device.

hipDrvMemcpy3D

hipError_t hipDrvMemcpy3D(const HIP_MEMCPY3D *pCopy)

Copies data between host and device.

hipMemcpyHtoD

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

Copy data from Host to Device.

hipMemcpyParam2D

hipError_t hipMemcpyParam2D(const hip_Memcpy2D *pCopy)

Copies memory for 2D arrays.

hipMemsetAsync

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

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

hipMemset3DAsync

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

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

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.

hipHostMalloc

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

Allocate device accessible page locked host memory.

hipMemcpy2DToArray

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

Copies data between host and device.

hipMemcpyAsync

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

Copy data from src to dst asynchronously.

hipArray3DCreate

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

hipHostRegister

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

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

hipMallocManaged

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

Allocates memory that will be automatically managed by HIP.

hipMemcpy

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

Copy data from src to dst.

hipMemset

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

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

hipMemcpy2DAsync

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

Copies data between host and device.

hipDrvPointerGetAttributes

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

Returns information about the specified pointer.[BETA].

hipMalloc3D

hipError_t hipMalloc3D(hipPitchedPtr *pitchedDevPtr, hipExtent extent)

hipMallocArray

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

Allocate an array on the device.

hipMemcpyDtoDAsync

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

Copy data from Device to Device asynchronously.

hipMemAllocPitch

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

hipMemsetD8

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

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

hipMemcpyDtoHAsync

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

Copy data from Device to Host asynchronously.

hipMemset2DAsync

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

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

hipWaitExternalSemaphoresAsync

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

Waits on a set of external semaphore objects.

hipMallocMipmappedArray

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

Allocate a mipmapped array on the device.

hipMemset2D

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

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

hipFreeArray

hipError_t hipFreeArray(hipArray *array)

Frees an array on the device.

hipMemcpyHtoDAsync

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

Copy data from Host to Device asynchronously.

hipGetSymbolSize

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

Gets the size of the given symbol on the device.

hipMemcpyDtoH

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

Copy data from Device to Host.

hipMemcpyWithStream

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

hipSignalExternalSemaphoresAsync

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

Signals a set of external semaphore objects.

hipGetSymbolAddress

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

Gets device pointer associated with symbol on the device.

hipArrayCreate

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

hipMemAllocHost

hipError_t hipMemAllocHost(void **ptr, size_t size)

Allocate pinned host memory [Deprecated].

hipPointerGetAttribute

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

Returns information about the specified pointer.[BETA].

hipArrayDestroy

hipError_t hipArrayDestroy(hipArray *array)

hipMemcpyHtoA

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

Copies data between host and device.

hipMemPtrGetInfo

hipError_t hipMemPtrGetInfo(void *ptr, size_t *size)

hipMemsetD32Async

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

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

hipExternalMemoryGetMappedBuffer

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

Maps a buffer onto an imported memory object.

hipFuncGetAttributes

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

Find out attributes for a given function.

hipModuleGetTexRef

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

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

hipExtLaunchMultiKernelMultiDevice

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

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

hipModuleLaunchKernel

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

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

hipModuleLoad

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

Loads code object from file into a hipModule_t.

hipModuleLoadDataEx

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

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

hipFuncGetAttribute

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

Find out a specific attribute for a given function.

hipLaunchCooperativeKernelMultiDevice

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

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

hipModuleGetFunction

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

Function with kname will be extracted if present in module.

hipLaunchCooperativeKernel

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

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

hipModuleLoadData

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

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

hipModuleUnload

hipError_t hipModuleUnload(hipModule_t module)

Frees the module.

hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags

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

Returns occupancy for a device function.

hipModuleOccupancyMaxPotentialBlockSize

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

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

hipOccupancyMaxActiveBlocksPerMultiprocessor

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

Returns occupancy for a device function.

hipOccupancyMaxPotentialBlockSize

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

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

hipModuleOccupancyMaxActiveBlocksPerMultiprocessor

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

Returns occupancy for a device function.

hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags

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

Returns occupancy for a device function.

hipModuleOccupancyMaxPotentialBlockSizeWithFlags

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

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

hipDeviceCanAccessPeer

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

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

hipDeviceEnablePeerAccess

hipError_t hipDeviceEnablePeerAccess(int peerDeviceId, unsigned int flags)

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

hipDeviceDisablePeerAccess

hipError_t hipDeviceDisablePeerAccess(int peerDeviceId)

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

hipMemGetAddressRange

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

Get information on memory allocations.

hipProfilerStart

hipError_t hipProfilerStart()

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

hipProfilerStop

hipError_t hipProfilerStop()

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

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

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

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.

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

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.

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

hipStreamCreate

hipError_t hipStreamCreate(hipStream_t *stream)

Create an asynchronous stream.

hipTexRefGetFilterMode

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

hipTexRefGetMipmapLevelClamp

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

hipTexRefGetAddressMode

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

hipTexRefGetFlags

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

hipTexRefSetAddress

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

hipTexRefGetMipmapFilterMode

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

hipGetTextureAlignmentOffset

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

hipBindTexture2D

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

hipTexRefGetMaxAnisotropy

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

hipUnbindTexture

hipError_t hipUnbindTexture(const textureReference *tex)

hipTexRefGetAddress

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

hipTexRefGetMipMappedArray

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

hipTexRefSetMaxAnisotropy

hipError_t hipTexRefSetMaxAnisotropy(textureReference *texRef, unsigned int maxAniso)

hipTexRefGetMipmapLevelBias

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

hipBindTextureToArray

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

hipBindTexture

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

hipTexRefSetAddress2D

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

hipTexRefGetFormat

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

hipBindTextureToMipmappedArray

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

Binds a mipmapped array to a texture.

hipTexRefSetFilterMode

hipError_t hipTexRefSetFilterMode(textureReference *texRef, enum hipTextureFilterMode fm)

hipTexObjectCreate

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

hipGetTextureObjectResourceDesc

hipError_t hipGetTextureObjectResourceDesc(hipResourceDesc *pResDesc, hipTextureObject_t textureObject)

Gets resource descriptor for the texture object.

hipTexRefSetFormat

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

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)

hipCreateTextureObject

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

Creates a texture object.

hipTexRefSetFlags

hipError_t hipTexRefSetFlags(textureReference *texRef, unsigned int Flags)

hipTexRefSetAddressMode

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

hipTexObjectDestroy

hipError_t hipTexObjectDestroy(hipTextureObject_t texObject)

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)

hipTexObjectGetResourceViewDesc

hipError_t hipTexObjectGetResourceViewDesc(HIP_RESOURCE_VIEW_DESC *pResViewDesc, hipTextureObject_t texObject)

hipTexRefSetArray

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

hipDestroyTextureObject

hipError_t hipDestroyTextureObject(hipTextureObject_t textureObject)

Destroys a texture object.

hipGetTextureReference

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

Gets the texture reference related with the symbol.

hipGetTextureObjectTextureDesc

hipError_t hipGetTextureObjectTextureDesc(hipTextureDesc *pTexDesc, hipTextureObject_t textureObject)

Gets texture descriptor for the texture object.

hipTexRefSetMipmappedArray

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

hipMipmappedArrayGetLevel

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

hipMipmappedArrayDestroy

hipError_t hipMipmappedArrayDestroy(hipMipmappedArray_t hMipmappedArray)

hipMipmappedArrayCreate

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

hipTexRefSetMipmapLevelClamp

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

hipTexRefSetBorderColor

hipError_t hipTexRefSetBorderColor(textureReference *texRef, float *pBorderColor)

hipTexRefSetMipmapLevelBias

hipError_t hipTexRefSetMipmapLevelBias(textureReference *texRef, float bias)

hipTexRefSetMipmapFilterMode

hipError_t hipTexRefSetMipmapFilterMode(textureReference *texRef, enum hipTextureFilterMode fm)

hip_common.h

hipLimit_t

hipLimit_t

Definition hip_runtime_api.h:538

hipLimitMallocHeapSize

@ hipLimitMallocHeapSize

Definition hip_runtime_api.h:540

hipLimitPrintfFifoSize

@ hipLimitPrintfFifoSize

Definition hip_runtime_api.h:539

hipErrorIllegalAddress

hipErrorIllegalAddress

Definition hip_runtime_api.h:263

hipErrorMemoryAllocation

hipErrorMemoryAllocation

Memory allocation error.

Definition hip_runtime_api.h:209

hipErrorNotFound

hipErrorNotFound

Definition hip_runtime_api.h:258

hipCtx_t

struct ihipCtx_t * hipCtx_t

Definition hip_runtime_api.h:505

hipErrorProfilerDisabled

hipErrorProfilerDisabled

Definition hip_runtime_api.h:214

__dparm

#define __dparm(x)

Definition hip_runtime_api.h:489

hipStream_t

struct ihipStream_t * hipStream_t

Definition hip_runtime_api.h:514

hipErrorInvalidDevicePointer

hipErrorInvalidDevicePointer

Invalid Device Pointer.

Definition hip_runtime_api.h:221

hipDevice_t

int hipDevice_t

Definition hip_runtime_api.h:507

hipErrorRuntimeMemory

hipErrorRuntimeMemory

Definition hip_runtime_api.h:312

hipErrorInvalidImage

hipErrorInvalidImage

Definition hip_runtime_api.h:229

hipErrorPeerAccessUnsupported

hipErrorPeerAccessUnsupported

Definition hip_runtime_api.h:246

hipErrorArrayIsMapped

hipErrorArrayIsMapped

Definition hip_runtime_api.h:236

hipErrorStreamCaptureIsolation

hipErrorStreamCaptureIsolation

Definition hip_runtime_api.h:293

hipErrorInvalidKernelFile

hipErrorInvalidKernelFile

In CUDA DRV, it is CUDA_ERROR_INVALID_PTX.

Definition hip_runtime_api.h:247

hipErrorNotMapped

hipErrorNotMapped

Definition hip_runtime_api.h:240

hipEvent_t

struct ihipEvent_t * hipEvent_t

Definition hip_runtime_api.h:537

hipErrorGraphExecUpdateFailure

hipErrorGraphExecUpdateFailure

Definition hip_runtime_api.h:306

hipErrorNotInitialized

hipErrorNotInitialized

Definition hip_runtime_api.h:210

hipErrorInvalidResourceHandle

hipErrorInvalidResourceHandle

Resource handle (hipEvent_t or hipStream_t) invalid.

Definition hip_runtime_api.h:256

hipErrorSharedObjectInitFailed

hipErrorSharedObjectInitFailed

Definition hip_runtime_api.h:252

hipErrorInvalidPitchValue

hipErrorInvalidPitchValue

Definition hip_runtime_api.h:219

hipErrorNoBinaryForGpu

hipErrorNoBinaryForGpu

Definition hip_runtime_api.h:238

hipErrorInvalidContext

hipErrorInvalidContext

Produced when input context is invalid.

Definition hip_runtime_api.h:230

hipDeviceP2PAttr

hipDeviceP2PAttr

Definition hip_runtime_api.h:508

hipDevP2PAttrAccessSupported

@ hipDevP2PAttrAccessSupported

Definition hip_runtime_api.h:510

hipDevP2PAttrHipArrayAccessSupported

@ hipDevP2PAttrHipArrayAccessSupported

Definition hip_runtime_api.h:512

hipDevP2PAttrNativeAtomicSupported

@ hipDevP2PAttrNativeAtomicSupported

Definition hip_runtime_api.h:511

hipDevP2PAttrPerformanceRank

@ hipDevP2PAttrPerformanceRank

Definition hip_runtime_api.h:509

hipErrorStreamCaptureUnsupported

hipErrorStreamCaptureUnsupported

Definition hip_runtime_api.h:284

hipErrorPeerAccessNotEnabled

hipErrorPeerAccessNotEnabled

Peer access was never enabled from the current device.

Definition hip_runtime_api.h:268

hipErrorOperatingSystem

hipErrorOperatingSystem

Definition hip_runtime_api.h:253

hipErrorStreamCaptureUnjoined

hipErrorStreamCaptureUnjoined

Definition hip_runtime_api.h:291

hipErrorInitializationError

hipErrorInitializationError

Definition hip_runtime_api.h:212

hipErrorNotMappedAsPointer

hipErrorNotMappedAsPointer

Definition hip_runtime_api.h:242

hipErrorPriorLaunchFailure

hipErrorPriorLaunchFailure

Definition hip_runtime_api.h:225

hipErrorContextIsDestroyed

hipErrorContextIsDestroyed

Definition hip_runtime_api.h:271

hipErrorInvalidValue

hipErrorInvalidValue

Definition hip_runtime_api.h:205

hipErrorLaunchTimeOut

hipErrorLaunchTimeOut

Definition hip_runtime_api.h:265

hipErrorUnmapFailed

hipErrorUnmapFailed

Definition hip_runtime_api.h:235

hipErrorSetOnActiveProcess

hipErrorSetOnActiveProcess

Definition hip_runtime_api.h:270

hipErrorFileNotFound

hipErrorFileNotFound

Definition hip_runtime_api.h:250

hipErrorLaunchFailure

hipErrorLaunchFailure

An exception occurred on the device while executing a kernel.

Definition hip_runtime_api.h:277

hipErrorInvalidDevice

hipErrorInvalidDevice

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

Definition hip_runtime_api.h:228

hipErrorUnsupportedLimit

hipErrorUnsupportedLimit

Definition hip_runtime_api.h:244

hipErrorMapBufferObjectFailed

hipErrorMapBufferObjectFailed

Produced when the IPC memory attach failed from ROCr.

Definition hip_runtime_api.h:234

hipErrorHostMemoryAlreadyRegistered

hipErrorHostMemoryAlreadyRegistered

Produced when trying to lock a page-locked memory.

Definition hip_runtime_api.h:273

hipErrorMissingConfiguration

hipErrorMissingConfiguration

Definition hip_runtime_api.h:224

hipErrorSharedObjectSymbolNotFound

hipErrorSharedObjectSymbolNotFound

Definition hip_runtime_api.h:251

hipErrorECCNotCorrectable

hipErrorECCNotCorrectable

Definition hip_runtime_api.h:243

hipErrorStreamCaptureWrongThread

hipErrorStreamCaptureWrongThread

Definition hip_runtime_api.h:302

hipErrorAssert

hipErrorAssert

Produced when the kernel calls assert.

Definition hip_runtime_api.h:272

DEPRECATED_MSG

#define DEPRECATED_MSG

Definition hip_runtime_api.h:481

hipErrorContextAlreadyInUse

hipErrorContextAlreadyInUse

Definition hip_runtime_api.h:245

hipErrorNotReady

hipErrorNotReady

Definition hip_runtime_api.h:259

hipErrorInvalidSource

hipErrorInvalidSource

Definition hip_runtime_api.h:249

hipErrorLaunchOutOfResources

hipErrorLaunchOutOfResources

Out of resources error.

Definition hip_runtime_api.h:264

hipErrorInvalidDeviceFunction

hipErrorInvalidDeviceFunction

Definition hip_runtime_api.h:226

hipErrorCooperativeLaunchTooLarge

hipErrorCooperativeLaunchTooLarge

Definition hip_runtime_api.h:279

hipErrorAlreadyMapped

hipErrorAlreadyMapped

Definition hip_runtime_api.h:237

hipModule_t

struct ihipModule_t * hipModule_t

Definition hip_runtime_api.h:523

hipErrorProfilerNotInitialized

hipErrorProfilerNotInitialized

Definition hip_runtime_api.h:215

hipErrorProfilerAlreadyStarted

hipErrorProfilerAlreadyStarted

Definition hip_runtime_api.h:216

hipErrorNoDevice

hipErrorNoDevice

Call to hipGetDeviceCount returned 0 devices.

Definition hip_runtime_api.h:227

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

hipErrorStreamCaptureInvalidated

hipErrorStreamCaptureInvalidated

Definition hip_runtime_api.h:286

hipFunction_t

struct ihipModuleSymbol_t * hipFunction_t

Definition hip_runtime_api.h:524

hipErrorProfilerAlreadyStopped

hipErrorProfilerAlreadyStopped

Definition hip_runtime_api.h:217

hipErrorDeinitialized

hipErrorDeinitialized

Definition hip_runtime_api.h:213

hipErrorPeerAccessAlreadyEnabled

hipErrorPeerAccessAlreadyEnabled

Peer access was already enabled from the current device.

Definition hip_runtime_api.h:266

hipErrorNotMappedAsArray

hipErrorNotMappedAsArray

Definition hip_runtime_api.h:241

DEPRECATED

#define DEPRECATED(msg)

Definition hip_runtime_api.h:479

hipErrorNotSupported

hipErrorNotSupported

Produced when the hip API is not supported/implemented.

Definition hip_runtime_api.h:283

hipErrorInvalidConfiguration

hipErrorInvalidConfiguration

Definition hip_runtime_api.h:218

hipErrorStreamCaptureImplicit

hipErrorStreamCaptureImplicit

Definition hip_runtime_api.h:297

hipErrorStreamCaptureMerge

hipErrorStreamCaptureMerge

Definition hip_runtime_api.h:288

hipErrorInvalidGraphicsContext

hipErrorInvalidGraphicsContext

Definition hip_runtime_api.h:248

hipErrorIllegalState

hipErrorIllegalState

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

Definition hip_runtime_api.h:257

hipErrorOutOfMemory

hipErrorOutOfMemory

Definition hip_runtime_api.h:207

hipErrorInvalidSymbol

hipErrorInvalidSymbol

Definition hip_runtime_api.h:220

hipSuccess

hipSuccess

Successful completion.

Definition hip_runtime_api.h:204

hipErrorUnknown

hipErrorUnknown

Definition hip_runtime_api.h:310

hipMemoryType

hipMemoryType

Definition hip_runtime_api.h:156

hipMemoryTypeDevice

@ hipMemoryTypeDevice

Definition hip_runtime_api.h:158

hipMemoryTypeHost

@ hipMemoryTypeHost

Memory is physically located on host.

Definition hip_runtime_api.h:157

hipMemoryTypeArray

@ hipMemoryTypeArray

Definition hip_runtime_api.h:160

hipMemoryTypeUnified

@ hipMemoryTypeUnified

Not used currently.

Definition hip_runtime_api.h:162

hipErrorInvalidHandle

hipErrorInvalidHandle

Definition hip_runtime_api.h:254

hipErrorStreamCaptureUnmatched

hipErrorStreamCaptureUnmatched

The capture was not initiated in this stream.

Definition hip_runtime_api.h:290

hipErrorCapturedEvent

hipErrorCapturedEvent

Definition hip_runtime_api.h:300

hipErrorAlreadyAcquired

hipErrorAlreadyAcquired

Definition hip_runtime_api.h:239

hipErrorInsufficientDriver

hipErrorInsufficientDriver

Definition hip_runtime_api.h:223

hipErrorHostMemoryNotRegistered

hipErrorHostMemoryNotRegistered

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

Definition hip_runtime_api.h:275

HIP_IPC_HANDLE_SIZE

#define HIP_IPC_HANDLE_SIZE

Definition hip_runtime_api.h:516

hipErrorRuntimeOther

hipErrorRuntimeOther

Definition hip_runtime_api.h:314

hipErrorContextAlreadyCurrent

hipErrorContextAlreadyCurrent

Definition hip_runtime_api.h:231

hipErrorInvalidMemcpyDirection

hipErrorInvalidMemcpyDirection

Invalid memory copy direction.

Definition hip_runtime_api.h:222

HIP_ARRAY3D_DESCRIPTOR

Definition driver_types.h:74

HIP_ARRAY_DESCRIPTOR

Definition driver_types.h:68

HIP_MEMCPY3D

Definition driver_types.h:379

HIP_RESOURCE_DESC

Definition driver_types.h:282

HIP_RESOURCE_VIEW_DESC

Definition driver_types.h:328

HIP_TEXTURE_DESC

Definition driver_types.h:165

dim3

Definition hip_runtime_api.h:778

dim3::y

uint32_t y

y

Definition hip_runtime_api.h:780

dim3::z

uint32_t z

z

Definition hip_runtime_api.h:781

dim3::x

uint32_t x

x

Definition hip_runtime_api.h:779

hip_Memcpy2D

Definition driver_types.h:95

hipArray

Definition driver_types.h:82

hipChannelFormatDesc

Definition driver_types.h:47

hipDeviceArch_t

Definition hip_runtime_api.h:45

hipDeviceArch_t::hasSharedInt64Atomics

unsigned hasSharedInt64Atomics

64-bit integer atomics for shared memory.

Definition hip_runtime_api.h:55

hipDeviceArch_t::hasSharedInt32Atomics

unsigned hasSharedInt32Atomics

32-bit integer atomics for shared memory.

Definition hip_runtime_api.h:49

hipDeviceArch_t::hasFloatAtomicAdd

unsigned hasFloatAtomicAdd

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

Definition hip_runtime_api.h:51

hipDeviceArch_t::hasDoubles

unsigned hasDoubles

Double-precision floating point.

Definition hip_runtime_api.h:58

hipDeviceArch_t::hasWarpVote

unsigned hasWarpVote

Warp vote instructions (__any, __all).

Definition hip_runtime_api.h:61

hipDeviceArch_t::hasWarpShuffle

unsigned hasWarpShuffle

Warp shuffle operations. (__shfl_*).

Definition hip_runtime_api.h:63

hipDeviceArch_t::hasGlobalInt32Atomics

unsigned hasGlobalInt32Atomics

32-bit integer atomics for global memory.

Definition hip_runtime_api.h:47

hipDeviceArch_t::hasGlobalFloatAtomicExch

unsigned hasGlobalFloatAtomicExch

32-bit float atomic exch for global memory.

Definition hip_runtime_api.h:48

hipDeviceArch_t::hasDynamicParallelism

unsigned hasDynamicParallelism

Dynamic parallelism.

Definition hip_runtime_api.h:73

hipDeviceArch_t::hasSurfaceFuncs

unsigned hasSurfaceFuncs

Surface functions.

Definition hip_runtime_api.h:71

hipDeviceArch_t::has3dGrid

unsigned has3dGrid

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

Definition hip_runtime_api.h:72

hipDeviceArch_t::hasFunnelShift

unsigned hasFunnelShift

Funnel two words into one with shift&mask caps.

Definition hip_runtime_api.h:64

hipDeviceArch_t::hasThreadFenceSystem

unsigned hasThreadFenceSystem

__threadfence_system.

Definition hip_runtime_api.h:67

hipDeviceArch_t::hasGlobalInt64Atomics

unsigned hasGlobalInt64Atomics

64-bit integer atomics for global memory.

Definition hip_runtime_api.h:54

hipDeviceArch_t::hasSyncThreadsExt

unsigned hasSyncThreadsExt

__syncthreads_count, syncthreads_and, syncthreads_or.

Definition hip_runtime_api.h:68

hipDeviceArch_t::hasWarpBallot

unsigned hasWarpBallot

Warp ballot instructions (__ballot).

Definition hip_runtime_api.h:62

hipDeviceArch_t::hasSharedFloatAtomicExch

unsigned hasSharedFloatAtomicExch

32-bit float atomic exch for shared memory.

Definition hip_runtime_api.h:50

hipDeviceProp_t

Definition hip_runtime_api.h:84

hipDeviceProp_t::ECCEnabled

int ECCEnabled

Device has ECC support enabled.

Definition hip_runtime_api.h:132

hipDeviceProp_t::maxTexture1DLinear

int maxTexture1DLinear

Maximum size for 1D textures bound to linear memory.

Definition hip_runtime_api.h:122

hipDeviceProp_t::pciBusID

int pciBusID

PCI Bus ID.

Definition hip_runtime_api.h:112

hipDeviceProp_t::maxTexture1D

int maxTexture1D

Maximum number of elements in 1D images.

Definition hip_runtime_api.h:123

hipDeviceProp_t::memoryBusWidth

int memoryBusWidth

Global memory bus width in bits.

Definition hip_runtime_api.h:95

hipDeviceProp_t::clockRate

int clockRate

Max clock frequency of the multiProcessors in khz.

Definition hip_runtime_api.h:93

hipDeviceProp_t::maxThreadsPerMultiProcessor

int maxThreadsPerMultiProcessor

Maximum resident threads per multi-processor.

Definition hip_runtime_api.h:105

hipDeviceProp_t::l2CacheSize

int l2CacheSize

L2 cache size.

Definition hip_runtime_api.h:104

hipDeviceProp_t::totalConstMem

size_t totalConstMem

Size of shared memory region (in bytes).

Definition hip_runtime_api.h:96

hipDeviceProp_t::memPitch

size_t memPitch

Maximum pitch in bytes allowed by memory copies.

Definition hip_runtime_api.h:128

hipDeviceProp_t::sharedMemPerBlock

size_t sharedMemPerBlock

Size of shared memory region (in bytes).

Definition hip_runtime_api.h:87

hipDeviceProp_t::cooperativeMultiDeviceLaunch

int cooperativeMultiDeviceLaunch

HIP device supports cooperative launch on multiple devices.

Definition hip_runtime_api.h:121

hipDeviceProp_t::pageableMemoryAccess

int pageableMemoryAccess

Definition hip_runtime_api.h:147

hipDeviceProp_t::name

char name[256]

Device name.

Definition hip_runtime_api.h:85

hipDeviceProp_t::textureAlignment

size_t textureAlignment

Alignment requirement for textures.

Definition hip_runtime_api.h:129

hipDeviceProp_t::memoryClockRate

int memoryClockRate

Max global memory clock frequency in khz.

Definition hip_runtime_api.h:94

hipDeviceProp_t::clockInstructionRate

int clockInstructionRate

Definition hip_runtime_api.h:107

hipDeviceProp_t::regsPerBlock

int regsPerBlock

Registers per block.

Definition hip_runtime_api.h:88

hipDeviceProp_t::maxTexture2D

int maxTexture2D[2]

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

Definition hip_runtime_api.h:124

hipDeviceProp_t::cooperativeLaunch

int cooperativeLaunch

HIP device supports cooperative launch.

Definition hip_runtime_api.h:120

hipDeviceProp_t::maxTexture3D

int maxTexture3D[3]

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

Definition hip_runtime_api.h:125

hipDeviceProp_t::directManagedMemAccessFromHost

int directManagedMemAccessFromHost

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

Definition hip_runtime_api.h:145

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedFunc

int cooperativeMultiDeviceUnmatchedFunc

Definition hip_runtime_api.h:134

hipDeviceProp_t::pageableMemoryAccessUsesHostPageTables

int pageableMemoryAccessUsesHostPageTables

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

Definition hip_runtime_api.h:149

hipDeviceProp_t::hdpRegFlushCntl

unsigned int * hdpRegFlushCntl

Addres of HDP_REG_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:127

hipDeviceProp_t::maxThreadsDim

int maxThreadsDim[3]

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

Definition hip_runtime_api.h:91

hipDeviceProp_t::isMultiGpuBoard

int isMultiGpuBoard

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

Definition hip_runtime_api.h:115

hipDeviceProp_t::pciDomainID

int pciDomainID

PCI Domain ID.

Definition hip_runtime_api.h:111

hipDeviceProp_t::maxSharedMemoryPerMultiProcessor

size_t maxSharedMemoryPerMultiProcessor

Maximum Shared Memory Per Multiprocessor.

Definition hip_runtime_api.h:114

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedGridDim

int cooperativeMultiDeviceUnmatchedGridDim

Definition hip_runtime_api.h:136

hipDeviceProp_t::minor

int minor

Definition hip_runtime_api.h:100

hipDeviceProp_t::gcnArchName

char gcnArchName[256]

AMD GCN Arch Name.

Definition hip_runtime_api.h:118

hipDeviceProp_t::kernelExecTimeoutEnabled

int kernelExecTimeoutEnabled

Run time limit for kernels executed on the device.

Definition hip_runtime_api.h:131

hipDeviceProp_t::hdpMemFlushCntl

unsigned int * hdpMemFlushCntl

Addres of HDP_MEM_COHERENCY_FLUSH_CNTL register.

Definition hip_runtime_api.h:126

hipDeviceProp_t::concurrentManagedAccess

int concurrentManagedAccess

Device can coherently access managed memory concurrently with the CPU.

Definition hip_runtime_api.h:146

hipDeviceProp_t::integrated

int integrated

APU vs dGPU.

Definition hip_runtime_api.h:119

hipDeviceProp_t::canMapHostMemory

int canMapHostMemory

Check whether HIP can map host memory.

Definition hip_runtime_api.h:116

hipDeviceProp_t::asicRevision

int asicRevision

Revision of the GPU in this device.

Definition hip_runtime_api.h:143

hipDeviceProp_t::totalGlobalMem

size_t totalGlobalMem

Size of global memory region (in bytes).

Definition hip_runtime_api.h:86

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedBlockDim

int cooperativeMultiDeviceUnmatchedBlockDim

Definition hip_runtime_api.h:138

hipDeviceProp_t::concurrentKernels

int concurrentKernels

Device can possibly execute multiple kernels concurrently.

Definition hip_runtime_api.h:110

hipDeviceProp_t::isLargeBar

int isLargeBar

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

Definition hip_runtime_api.h:142

hipDeviceProp_t::gcnArch

int gcnArch

DEPRECATED: use gcnArchName instead.

Definition hip_runtime_api.h:117

hipDeviceProp_t::multiProcessorCount

int multiProcessorCount

Number of multi-processors (compute units).

Definition hip_runtime_api.h:103

hipDeviceProp_t::maxGridSize

int maxGridSize[3]

Max grid dimensions (XYZ).

Definition hip_runtime_api.h:92

hipDeviceProp_t::pciDeviceID

int pciDeviceID

PCI Device ID.

Definition hip_runtime_api.h:113

hipDeviceProp_t::computeMode

int computeMode

Compute mode.

Definition hip_runtime_api.h:106

hipDeviceProp_t::major

int major

Definition hip_runtime_api.h:97

hipDeviceProp_t::warpSize

int warpSize

Warp size.

Definition hip_runtime_api.h:89

hipDeviceProp_t::tccDriver

int tccDriver

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

Definition hip_runtime_api.h:133

hipDeviceProp_t::cooperativeMultiDeviceUnmatchedSharedMem

int cooperativeMultiDeviceUnmatchedSharedMem

Definition hip_runtime_api.h:140

hipDeviceProp_t::maxThreadsPerBlock

int maxThreadsPerBlock

Max work items per work group or workgroup max size.

Definition hip_runtime_api.h:90

hipDeviceProp_t::arch

hipDeviceArch_t arch

Architectural feature flags. New for HIP.

Definition hip_runtime_api.h:109

hipDeviceProp_t::managedMemory

int managedMemory

Device supports allocating managed memory on this system.

Definition hip_runtime_api.h:144

hipDeviceProp_t::texturePitchAlignment

size_t texturePitchAlignment

Pitch alignment requirement for texture references bound to pitched memory.

Definition hip_runtime_api.h:130

hipExtent

Definition driver_types.h:358

hipExternalMemoryBufferDesc

Definition hip_runtime_api.h:815

hipExternalMemoryBufferDesc::flags

unsigned int flags

Definition hip_runtime_api.h:818

hipExternalMemoryBufferDesc::offset

unsigned long long offset

Definition hip_runtime_api.h:816

hipExternalMemoryBufferDesc::size

unsigned long long size

Definition hip_runtime_api.h:817

hipExternalMemoryHandleDesc

Definition hip_runtime_api.h:803

hipExternalMemoryHandleDesc::flags

unsigned int flags

Definition hip_runtime_api.h:813

hipExternalMemoryHandleDesc::name

const void * name

Definition hip_runtime_api.h:809

hipExternalMemoryHandleDesc::fd

int fd

Definition hip_runtime_api.h:806

hipExternalMemoryHandleDesc::size

unsigned long long size

Definition hip_runtime_api.h:812

hipExternalMemoryHandleDesc::type

hipExternalMemoryHandleType type

Definition hip_runtime_api.h:804

hipExternalMemoryHandleDesc::handle

void * handle

Definition hip_runtime_api.h:808

hipExternalSemaphoreHandleDesc

Definition hip_runtime_api.h:827

hipExternalSemaphoreHandleDesc::flags

unsigned int flags

Definition hip_runtime_api.h:836

hipExternalSemaphoreHandleDesc::name

const void * name

Definition hip_runtime_api.h:833

hipExternalSemaphoreHandleDesc::type

hipExternalSemaphoreHandleType type

Definition hip_runtime_api.h:828

hipExternalSemaphoreHandleDesc::handle

void * handle

Definition hip_runtime_api.h:832

hipExternalSemaphoreHandleDesc::fd

int fd

Definition hip_runtime_api.h:830

hipExternalSemaphoreSignalParams

Definition hip_runtime_api.h:839

hipExternalSemaphoreSignalParams::value

unsigned long long value

Definition hip_runtime_api.h:842

hipExternalSemaphoreSignalParams::flags

unsigned int flags

Definition hip_runtime_api.h:849

hipExternalSemaphoreSignalParams::key

unsigned long long key

Definition hip_runtime_api.h:845

hipExternalSemaphoreWaitParams

Definition hip_runtime_api.h:855

hipExternalSemaphoreWaitParams::value

unsigned long long value

Definition hip_runtime_api.h:858

hipExternalSemaphoreWaitParams::timeoutMs

unsigned int timeoutMs

Definition hip_runtime_api.h:862

hipExternalSemaphoreWaitParams::key

unsigned long long key

Definition hip_runtime_api.h:861

hipExternalSemaphoreWaitParams::flags

unsigned int flags

Definition hip_runtime_api.h:866

hipFuncAttributes

Definition hip_runtime_api.h:525

hipFuncAttributes::cacheModeCA

int cacheModeCA

Definition hip_runtime_api.h:527

hipFuncAttributes::binaryVersion

int binaryVersion

Definition hip_runtime_api.h:526

hipFuncAttributes::constSizeBytes

size_t constSizeBytes

Definition hip_runtime_api.h:528

hipFuncAttributes::preferredShmemCarveout

int preferredShmemCarveout

Definition hip_runtime_api.h:533

hipFuncAttributes::sharedSizeBytes

size_t sharedSizeBytes

Definition hip_runtime_api.h:535

hipFuncAttributes::maxDynamicSharedSizeBytes

int maxDynamicSharedSizeBytes

Definition hip_runtime_api.h:530

hipFuncAttributes::ptxVersion

int ptxVersion

Definition hip_runtime_api.h:534

hipFuncAttributes::numRegs

int numRegs

Definition hip_runtime_api.h:532

hipFuncAttributes::localSizeBytes

size_t localSizeBytes

Definition hip_runtime_api.h:529

hipFuncAttributes::maxThreadsPerBlock

int maxThreadsPerBlock

Definition hip_runtime_api.h:531

hipHostNodeParams

Definition hip_runtime_api.h:4507

hipHostNodeParams::fn

hipHostFn_t fn

Definition hip_runtime_api.h:4508

hipHostNodeParams::userData

void * userData

Definition hip_runtime_api.h:4509

hipIpcEventHandle_t

Definition hip_runtime_api.h:520

hipIpcMemHandle_t

Definition hip_runtime_api.h:517

hipKernelNodeParams

Definition hip_runtime_api.h:4511

hipKernelNodeParams::gridDim

dim3 gridDim

Definition hip_runtime_api.h:4515

hipKernelNodeParams::sharedMemBytes

unsigned int sharedMemBytes

Definition hip_runtime_api.h:4517

hipKernelNodeParams::blockDim

dim3 blockDim

Definition hip_runtime_api.h:4512

hipKernelNodeParams::kernelParams

void ** kernelParams

Definition hip_runtime_api.h:4516

hipKernelNodeParams::extra

void ** extra

Definition hip_runtime_api.h:4513

hipKernelNodeParams::func

void * func

Definition hip_runtime_api.h:4514

hipLaunchParams

Definition hip_runtime_api.h:786

hipLaunchParams::sharedMem

size_t sharedMem

Shared memory.

Definition hip_runtime_api.h:791

hipLaunchParams::args

void ** args

Arguments.

Definition hip_runtime_api.h:790

hipLaunchParams::blockDim

dim3 blockDim

Block dimentions.

Definition hip_runtime_api.h:789

hipLaunchParams::gridDim

dim3 gridDim

Grid dimentions.

Definition hip_runtime_api.h:788

hipLaunchParams::func

void * func

Device function symbol.

Definition hip_runtime_api.h:787

hipLaunchParams::stream

hipStream_t stream

Stream identifier.

Definition hip_runtime_api.h:792

hipMemcpy3DParms

Definition driver_types.h:369

hipMemsetParams

Definition hip_runtime_api.h:4519

hipMemsetParams::dst

void * dst

Definition hip_runtime_api.h:4520

hipMemsetParams::value

unsigned int value

Definition hip_runtime_api.h:4524

hipMemsetParams::elementSize

unsigned int elementSize

Definition hip_runtime_api.h:4521

hipMemsetParams::width

size_t width

Definition hip_runtime_api.h:4525

hipMemsetParams::pitch

size_t pitch

Definition hip_runtime_api.h:4523

hipMemsetParams::height

size_t height

Definition hip_runtime_api.h:4522

hipMipmappedArray

Definition driver_types.h:117

hipPitchedPtr

Definition driver_types.h:352

hipPointerAttribute_t

Definition hip_runtime_api.h:169

hipPointerAttribute_t::device

int device

Definition hip_runtime_api.h:171

hipPointerAttribute_t::memoryType

enum hipMemoryType memoryType

Definition hip_runtime_api.h:170

hipPointerAttribute_t::hostPointer

void * hostPointer

Definition hip_runtime_api.h:173

hipPointerAttribute_t::isManaged

int isManaged

Definition hip_runtime_api.h:174

hipPointerAttribute_t::devicePointer

void * devicePointer

Definition hip_runtime_api.h:172

hipPointerAttribute_t::allocationFlags

unsigned allocationFlags

Definition hip_runtime_api.h:175

hipResourceDesc

Definition driver_types.h:258

hipResourceViewDesc

Definition driver_types.h:314

hipTextureDesc

Definition texture_types.h:109

textureReference

Definition texture_types.h:88

surface_types.h

Defines surface types for HIP runtime.

hipSurfaceObject_t

struct __hip_surface * hipSurfaceObject_t

Definition surface_types.h:34

texture_types.h

hipTextureObject_t

struct __hip_texture * hipTextureObject_t

Definition texture_types.h:63

hipTextureAddressMode

hipTextureAddressMode

Definition texture_types.h:68

hipTextureFilterMode

hipTextureFilterMode

Definition texture_types.h:78