rocprofiler-sdk/hip/api_args.h Source File

ROCprofiler-SDK developer API 1.0.0 ROCm Profiling API and tools

• rocprofiler-sdk
• hip

api_args.h

1// MIT License

2//

3// Copyright (c) 2023-2025 Advanced Micro Devices, Inc. All rights reserved.

4//

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

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

7// in the Software without restriction, including without limitation the rights

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

9// copies of the Software, and to permit persons to whom the Software is

10// furnished to do so, subject to the following conditions:

11//

12// The above copyright notice and this permission notice shall be included in

13// all copies or substantial portions of the Software.

14//

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

16// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

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

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

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

20// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

21// THE SOFTWARE.

22

23#pragma once

24

25#include <rocprofiler-sdk/defines.h>

26#include <rocprofiler-sdk/fwd.h>

27

28#include <hip/hip_runtime.h>

29#include <hip/hip_runtime_api.h>

30#include <hip/hip_version.h>

31// must be included after

32#include <hip/hip_deprecated.h>

33

34#include <hip/amd_detail/amd_hip_gl_interop.h>

35#include <hip/amd_detail/hip_api_trace.hpp>

36

37#include <stdint.h>

38

39ROCPROFILER_EXTERN_C_INIT

40

41// Empty struct has a size of 0 in C but size of 1 in C++.

42// This struct is added to the union members which represent

43// functions with no arguments to ensure ABI compatibility

44typedef struct rocprofiler_hip_api_no_args

45{

46 char empty;

47} rocprofiler_hip_api_no_args;

48

49typedef union rocprofiler_hip_api_retval_t

50{

51#ifdef __cplusplus

52 rocprofiler_hip_api_retval_t() = default;

53 ~rocprofiler_hip_api_retval_t() = default;

54#endif

55

56 uint64_t uint64_t_retval;

57 int int_retval;

58 const char* const_charp_retval;

59 hipError_t hipError_t_retval;

60 hipChannelFormatDesc hipChannelFormatDesc_retval;

61 void** voidpp_retval;

62} rocprofiler_hip_api_retval_t;

63

64// NOTE: dim3 value arguments replaced with rocprofiler_dim3_t because dim3 has a non-trivial

65// destructor

66typedef union rocprofiler_hip_api_args_t

67{

68#ifdef __cplusplus

69 rocprofiler_hip_api_args_t() = default;

70 ~rocprofiler_hip_api_args_t() = default;

71#endif

72

73 // compiler

74 struct

75 {

76 dim3* gridDim;

77 dim3* blockDim;

78 size_t* sharedMem;

79 hipStream_t* stream;

80 } __hipPopCallConfiguration;

81 struct

82 {

83 rocprofiler_dim3_t gridDim;

84 rocprofiler_dim3_t blockDim;

85 size_t sharedMem;

86 hipStream_t stream;

87 } __hipPushCallConfiguration;

88 struct

89 {

90 const void* data;

91 } __hipRegisterFatBinary;

92 struct

93 {

94 void** modules;

95 const void* hostFunction;

96 char* deviceFunction;

97 const char* deviceName;

98 unsigned int threadLimit;

99 uint3* tid;

100 uint3* bid;

101 dim3* blockDim;

102 dim3* gridDim;

103 int* wSize;

104 } __hipRegisterFunction;

105 struct

106 {

107 void* hipModule;

108 void** pointer;

109 void* init_value;

110 const char* name;

111 size_t size;

112 unsigned align;

113 } __hipRegisterManagedVar;

114 struct

115 {

116 void** modules;

117 void* var;

118 char* hostVar;

119 char* deviceVar;

120 int type;

121 int ext;

122 } __hipRegisterSurface;

123 struct

124 {

125 void** modules;

126 void* var;

127 char* hostVar;

128 char* deviceVar;

129 int type;

130 int norm;

131 int ext;

132 } __hipRegisterTexture;

133 struct

134 {

135 void** modules;

136 void* var;

137 char* hostVar;

138 char* deviceVar;

139 int ext;

140 size_t size;

141 int constant;

142 int global;

143 } __hipRegisterVar;

144 struct

145 {

146 void** modules;

147 } __hipUnregisterFatBinary;

148 // runtime

149 struct

150 {

151 uint32_t id;

152 } hipApiName;

153 struct

154 {

155 hipArray_t* array;

156 const HIP_ARRAY3D_DESCRIPTOR* pAllocateArray;

157 } hipArray3DCreate;

158 struct

159 {

160 HIP_ARRAY3D_DESCRIPTOR* pArrayDescriptor;

161 hipArray_t array;

162 } hipArray3DGetDescriptor;

163 struct

164 {

165 hipArray_t* pHandle;

166 const HIP_ARRAY_DESCRIPTOR* pAllocateArray;

167 } hipArrayCreate;

168 struct

169 {

170 hipArray_t array;

171 } hipArrayDestroy;

172 struct

173 {

174 HIP_ARRAY_DESCRIPTOR* pArrayDescriptor;

175 hipArray_t array;

176 } hipArrayGetDescriptor;

177 struct

178 {

179 hipChannelFormatDesc* desc;

180 hipExtent* extent;

181 unsigned int* flags;

182 hipArray_t array;

183 } hipArrayGetInfo;

184 struct

185 {

186 size_t* offset;

187 const textureReference* tex;

188 const void* devPtr;

189 const hipChannelFormatDesc* desc;

190 size_t size;

191 } hipBindTexture;

192 struct

193 {

194 size_t* offset;

195 const textureReference* tex;

196 const void* devPtr;

197 const hipChannelFormatDesc* desc;

198 size_t width;

199 size_t height;

200 size_t pitch;

201 } hipBindTexture2D;

202 struct

203 {

204 const textureReference* tex;

205 hipArray_const_t array;

206 const hipChannelFormatDesc* desc;

207 } hipBindTextureToArray;

208 struct

209 {

210 const textureReference* tex;

211 hipMipmappedArray_const_t mipmappedArray;

212 const hipChannelFormatDesc* desc;

213 } hipBindTextureToMipmappedArray;

214 struct

215 {

216 int* device;

217 const hipDeviceProp_tR0600* prop;

218 } hipChooseDevice;

219 struct

220 {

221 int* device;

222 const hipDeviceProp_tR0000* prop;

223 } hipChooseDeviceR0000;

224 struct

225 {

226 rocprofiler_dim3_t gridDim;

227 rocprofiler_dim3_t blockDim;

228 size_t sharedMem;

229 hipStream_t stream;

230 } hipConfigureCall;

231 struct

232 {

233 hipSurfaceObject_t* pSurfObject;

234 const hipResourceDesc* pResDesc;

235 } hipCreateSurfaceObject;

236 struct

237 {

238 hipTextureObject_t* pTexObject;

239 const hipResourceDesc* pResDesc;

240 const hipTextureDesc* pTexDesc;

241 const struct hipResourceViewDesc* pResViewDesc;

242 } hipCreateTextureObject;

243 struct

244 {

245 hipCtx_t* ctx;

246 unsigned int flags;

247 hipDevice_t device;

248 } hipCtxCreate;

249 struct

250 {

251 hipCtx_t ctx;

252 } hipCtxDestroy;

253 struct

254 {

255 hipCtx_t peerCtx;

256 } hipCtxDisablePeerAccess;

257 struct

258 {

259 hipCtx_t peerCtx;

260 unsigned int flags;

261 } hipCtxEnablePeerAccess;

262 struct

263 {

264 // In HIP v7.0, apiVersion was changed from int* to unsigned int* to match CUDA signature.

265 // If rocprofiler-sdk is compiled with HIP >= 7.0 and HIP is < 7.0 at runtime, there is

266 // expectation that this will NOT cause issues: apiVersion should never be negative and

267 // should never be >= INT_MAX

268 hipCtx_t ctx;

269#if ROCPROFILER_SDK_COMPUTE_VERSION(HIP_VERSION_MAJOR, HIP_VERSION_MINOR, 0) >= \

270 ROCPROFILER_SDK_COMPUTE_VERSION(7, 0, 0)

271 unsigned int* apiVersion;

272#else

273 int* apiVersion; // HIP version < 7.0

274#endif

275 } hipCtxGetApiVersion;

276 struct

277 {

278 hipFuncCache_t* cacheConfig;

279 } hipCtxGetCacheConfig;

280 struct

281 {

282 hipCtx_t* ctx;

283 } hipCtxGetCurrent;

284 struct

285 {

286 hipDevice_t* device;

287 } hipCtxGetDevice;

288 struct

289 {

290 unsigned int* flags;

291 } hipCtxGetFlags;

292 struct

293 {

294 hipSharedMemConfig* pConfig;

295 } hipCtxGetSharedMemConfig;

296 struct

297 {

298 hipCtx_t* ctx;

299 } hipCtxPopCurrent;

300 struct

301 {

302 hipCtx_t ctx;

303 } hipCtxPushCurrent;

304 struct

305 {

306 hipFuncCache_t cacheConfig;

307 } hipCtxSetCacheConfig;

308 struct

309 {

310 hipCtx_t ctx;

311 } hipCtxSetCurrent;

312 struct

313 {

314 hipSharedMemConfig config;

315 } hipCtxSetSharedMemConfig;

316 struct

317 {

318 // Empty struct has a size of 0 in C but size of 1 in C++.

319 // Add the rocprofiler_hip_api_no_args struct to fix this

320 rocprofiler_hip_api_no_args no_args;

321 } hipCtxSynchronize;

322 struct

323 {

324 hipExternalMemory_t extMem;

325 } hipDestroyExternalMemory;

326 struct

327 {

328 hipExternalSemaphore_t extSem;

329 } hipDestroyExternalSemaphore;

330 struct

331 {

332 hipSurfaceObject_t surfaceObject;

333 } hipDestroySurfaceObject;

334 struct

335 {

336 hipTextureObject_t textureObject;

337 } hipDestroyTextureObject;

338 struct

339 {

340 int* canAccessPeer;

341 int deviceId;

342 int peerDeviceId;

343 } hipDeviceCanAccessPeer;

344 struct

345 {

346 int* major;

347 int* minor;

348 hipDevice_t device;

349 } hipDeviceComputeCapability;

350 struct

351 {

352 int peerDeviceId;

353 } hipDeviceDisablePeerAccess;

354 struct

355 {

356 int peerDeviceId;

357 unsigned int flags;

358 } hipDeviceEnablePeerAccess;

359 struct

360 {

361 hipDevice_t* device;

362 int ordinal;

363 } hipDeviceGet;

364 struct

365 {

366 int* pi;

367 hipDeviceAttribute_t attr;

368 int deviceId;

369 } hipDeviceGetAttribute;

370 struct

371 {

372 int* device;

373 const char* pciBusId;

374 } hipDeviceGetByPCIBusId;

375 struct

376 {

377 hipFuncCache_t* cacheConfig;

378 } hipDeviceGetCacheConfig;

379 struct

380 {

381 hipMemPool_t* mem_pool;

382 int device;

383 } hipDeviceGetDefaultMemPool;

384 struct

385 {

386 int device;

387 hipGraphMemAttributeType attr;

388 void* value;

389 } hipDeviceGetGraphMemAttribute;

390 struct

391 {

392 size_t* pValue;

393 enum hipLimit_t limit;

394 } hipDeviceGetLimit;

395 struct

396 {

397 hipMemPool_t* mem_pool;

398 int device;

399 } hipDeviceGetMemPool;

400 struct

401 {

402 void* name; // changed to void* (real: char*) to avoid stringify on stack-allocated output

403 // parameter

404 int len;

405 hipDevice_t device;

406 } hipDeviceGetName;

407 struct

408 {

409 int* value;

410 hipDeviceP2PAttr attr;

411 int srcDevice;

412 int dstDevice;

413 } hipDeviceGetP2PAttribute;

414 struct

415 {

416 void* pciBusId; // changed to void* (real: char*) to avoid stringify on stack-allocated

417 // output parameter

418 int len;

419 int device;

420 } hipDeviceGetPCIBusId;

421 struct

422 {

423 hipSharedMemConfig* pConfig;

424 } hipDeviceGetSharedMemConfig;

425 struct

426 {

427 int* leastPriority;

428 int* greatestPriority;

429 } hipDeviceGetStreamPriorityRange;

430 struct

431 {

432 hipUUID* uuid;

433 hipDevice_t device;

434 } hipDeviceGetUuid;

435 struct

436 {

437 int device;

438 } hipDeviceGraphMemTrim;

439 struct

440 {

441 hipDevice_t dev;

442 unsigned int* flags;

443 int* active;

444 } hipDevicePrimaryCtxGetState;

445 struct

446 {

447 hipDevice_t dev;

448 } hipDevicePrimaryCtxRelease;

449 struct

450 {

451 hipDevice_t dev;

452 } hipDevicePrimaryCtxReset;

453 struct

454 {

455 hipCtx_t* pctx;

456 hipDevice_t dev;

457 } hipDevicePrimaryCtxRetain;

458 struct

459 {

460 hipDevice_t dev;

461 unsigned int flags;

462 } hipDevicePrimaryCtxSetFlags;

463 struct

464 {

465 // Empty struct has a size of 0 in C but size of 1 in C++.

466 // Add the rocprofiler_hip_api_no_args struct to fix this

467 rocprofiler_hip_api_no_args no_args;

468 } hipDeviceReset;

469 struct

470 {

471 hipFuncCache_t cacheConfig;

472 } hipDeviceSetCacheConfig;

473 struct

474 {

475 int device;

476 hipGraphMemAttributeType attr;

477 void* value;

478 } hipDeviceSetGraphMemAttribute;

479 struct

480 {

481 enum hipLimit_t limit;

482 size_t value;

483 } hipDeviceSetLimit;

484 struct

485 {

486 int device;

487 hipMemPool_t mem_pool;

488 } hipDeviceSetMemPool;

489 struct

490 {

491 hipSharedMemConfig config;

492 } hipDeviceSetSharedMemConfig;

493 struct

494 {

495 // Empty struct has a size of 0 in C but size of 1 in C++.

496 // Add the rocprofiler_hip_api_no_args struct to fix this

497 rocprofiler_hip_api_no_args no_args;

498 } hipDeviceSynchronize;

499 struct

500 {

501 size_t* bytes;

502 hipDevice_t device;

503 } hipDeviceTotalMem;

504 struct

505 {

506 int* driverVersion;

507 } hipDriverGetVersion;

508 struct

509 {

510 hipError_t hipError;

511 const char** errorString;

512 } hipDrvGetErrorName;

513 struct

514 {

515 hipError_t hipError;

516 const char** errorString;

517 } hipDrvGetErrorString;

518 struct

519 {

520 hipGraphNode_t* phGraphNode;

521 hipGraph_t hGraph;

522 const hipGraphNode_t* dependencies;

523 size_t numDependencies;

524 const HIP_MEMCPY3D* copyParams;

525 hipCtx_t ctx;

526 } hipDrvGraphAddMemcpyNode;

527 struct

528 {

529 const hip_Memcpy2D* pCopy;

530 } hipDrvMemcpy2DUnaligned;

531 struct

532 {

533 const HIP_MEMCPY3D* pCopy;

534 } hipDrvMemcpy3D;

535 struct

536 {

537 const HIP_MEMCPY3D* pCopy;

538 hipStream_t stream;

539 } hipDrvMemcpy3DAsync;

540 struct

541 {

542 unsigned int numAttributes;

543 hipPointer_attribute* attributes;

544 void** data;

545 hipDeviceptr_t ptr;

546 } hipDrvPointerGetAttributes;

547 struct

548 {

549 hipEvent_t* event;

550 } hipEventCreate;

551 struct

552 {

553 hipEvent_t* event;

554 unsigned flags;

555 } hipEventCreateWithFlags;

556 struct

557 {

558 hipEvent_t event;

559 } hipEventDestroy;

560 struct

561 {

562 float* ms;

563 hipEvent_t start;

564 hipEvent_t stop;

565 } hipEventElapsedTime;

566 struct

567 {

568 hipEvent_t event;

569 } hipEventQuery;

570 struct

571 {

572 hipEvent_t event;

573 hipStream_t stream;

574 } hipEventRecord;

575 struct

576 {

577 hipEvent_t event;

578 } hipEventSynchronize;

579 struct

580 {

581 int device1;

582 int device2;

583 uint32_t* linktype;

584 uint32_t* hopcount;

585 } hipExtGetLinkTypeAndHopCount;

586 struct

587 {

588 const void* function_address;

589 rocprofiler_dim3_t numBlocks;

590 rocprofiler_dim3_t dimBlocks;

591 void** args;

592 size_t sharedMemBytes;

593 hipStream_t stream;

594 hipEvent_t startEvent;

595 hipEvent_t stopEvent;

596 int flags;

597 } hipExtLaunchKernel;

598 struct

599 {

600 hipLaunchParams* launchParamsList;

601 int numDevices;

602 unsigned int flags;

603 } hipExtLaunchMultiKernelMultiDevice;

604 struct

605 {

606 void** ptr;

607 size_t sizeBytes;

608 unsigned int flags;

609 } hipExtMallocWithFlags;

610 struct

611 {

612 hipStream_t* stream;

613 uint32_t cuMaskSize;

614 const uint32_t* cuMask;

615 } hipExtStreamCreateWithCUMask;

616 struct

617 {

618 hipStream_t stream;

619 uint32_t cuMaskSize;

620 uint32_t* cuMask;

621 } hipExtStreamGetCUMask;

622 struct

623 {

624 void** devPtr;

625 hipExternalMemory_t extMem;

626 const hipExternalMemoryBufferDesc* bufferDesc;

627 } hipExternalMemoryGetMappedBuffer;

628 struct

629 {

630 void* ptr;

631 } hipFree;

632 struct

633 {

634 hipArray_t array;

635 } hipFreeArray;

636 struct

637 {

638 void* dev_ptr;

639 hipStream_t stream;

640 } hipFreeAsync;

641 struct

642 {

643 void* ptr;

644 } hipFreeHost;

645 struct

646 {

647 hipMipmappedArray_t mipmappedArray;

648 } hipFreeMipmappedArray;

649 struct

650 {

651 int* value;

652 hipFunction_attribute attrib;

653 hipFunction_t hfunc;

654 } hipFuncGetAttribute;

655 struct

656 {

657 struct hipFuncAttributes* attr;

658 const void* func;

659 } hipFuncGetAttributes;

660 struct

661 {

662 const void* func;

663 hipFuncAttribute attr;

664 int value;

665 } hipFuncSetAttribute;

666 struct

667 {

668 const void* func;

669 hipFuncCache_t config;

670 } hipFuncSetCacheConfig;

671 struct

672 {

673 const void* func;

674 hipSharedMemConfig config;

675 } hipFuncSetSharedMemConfig;

676 struct

677 {

678 unsigned int* pHipDeviceCount;

679 int* pHipDevices;

680 unsigned int hipDeviceCount;

681 hipGLDeviceList deviceList;

682 } hipGLGetDevices;

683 struct

684 {

685 hipChannelFormatDesc* desc;

686 hipArray_const_t array;

687 } hipGetChannelDesc;

688 struct

689 {

690 int* deviceId;

691 } hipGetDevice;

692 struct

693 {

694 int* count;

695 } hipGetDeviceCount;

696 struct

697 {

698 unsigned int* flags;

699 } hipGetDeviceFlags;

700 struct

701 {

702 hipDeviceProp_tR0600* prop;

703 int deviceId;

704 } hipGetDevicePropertiesR0600;

705 struct

706 {

707 hipDeviceProp_tR0000* prop;

708 int deviceId;

709 } hipGetDevicePropertiesR0000;

710 struct

711 {

712 hipError_t hip_error;

713 } hipGetErrorName;

714 struct

715 {

716 hipError_t hipError;

717 } hipGetErrorString;

718 struct

719 {

720 // Empty struct has a size of 0 in C but size of 1 in C++.

721 // Add the rocprofiler_hip_api_no_args struct to fix this

722 rocprofiler_hip_api_no_args no_args;

723 } hipGetLastError;

724 struct

725 {

726 hipArray_t* levelArray;

727 hipMipmappedArray_const_t mipmappedArray;

728 unsigned int level;

729 } hipGetMipmappedArrayLevel;

730 struct

731 {

732 void** devPtr;

733 const void* symbol;

734 } hipGetSymbolAddress;

735 struct

736 {

737 size_t* size;

738 const void* symbol;

739 } hipGetSymbolSize;

740 struct

741 {

742 size_t* offset;

743 const textureReference* texref;

744 } hipGetTextureAlignmentOffset;

745 struct

746 {

747 hipResourceDesc* pResDesc;

748 hipTextureObject_t textureObject;

749 } hipGetTextureObjectResourceDesc;

750 struct

751 {

752 struct hipResourceViewDesc* pResViewDesc;

753 hipTextureObject_t textureObject;

754 } hipGetTextureObjectResourceViewDesc;

755 struct

756 {

757 hipTextureDesc* pTexDesc;

758 hipTextureObject_t textureObject;

759 } hipGetTextureObjectTextureDesc;

760 struct

761 {

762 const textureReference** texref;

763 const void* symbol;

764 } hipGetTextureReference;

765 struct

766 {

767 hipGraphNode_t* pGraphNode;

768 hipGraph_t graph;

769 const hipGraphNode_t* pDependencies;

770 size_t numDependencies;

771 hipGraph_t childGraph;

772 } hipGraphAddChildGraphNode;

773 struct

774 {

775 hipGraph_t graph;

776 const hipGraphNode_t* from;

777 const hipGraphNode_t* to;

778 size_t numDependencies;

779 } hipGraphAddDependencies;

780 struct

781 {

782 hipGraphNode_t* pGraphNode;

783 hipGraph_t graph;

784 const hipGraphNode_t* pDependencies;

785 size_t numDependencies;

786 } hipGraphAddEmptyNode;

787 struct

788 {

789 hipGraphNode_t* pGraphNode;

790 hipGraph_t graph;

791 const hipGraphNode_t* pDependencies;

792 size_t numDependencies;

793 hipEvent_t event;

794 } hipGraphAddEventRecordNode;

795 struct

796 {

797 hipGraphNode_t* pGraphNode;

798 hipGraph_t graph;

799 const hipGraphNode_t* pDependencies;

800 size_t numDependencies;

801 hipEvent_t event;

802 } hipGraphAddEventWaitNode;

803 struct

804 {

805 hipGraphNode_t* pGraphNode;

806 hipGraph_t graph;

807 const hipGraphNode_t* pDependencies;

808 size_t numDependencies;

809 const hipHostNodeParams* pNodeParams;

810 } hipGraphAddHostNode;

811 struct

812 {

813 hipGraphNode_t* pGraphNode;

814 hipGraph_t graph;

815 const hipGraphNode_t* pDependencies;

816 size_t numDependencies;

817 const hipKernelNodeParams* pNodeParams;

818 } hipGraphAddKernelNode;

819 struct

820 {

821 hipGraphNode_t* pGraphNode;

822 hipGraph_t graph;

823 const hipGraphNode_t* pDependencies;

824 size_t numDependencies;

825 hipMemAllocNodeParams* pNodeParams;

826 } hipGraphAddMemAllocNode;

827 struct

828 {

829 hipGraphNode_t* pGraphNode;

830 hipGraph_t graph;

831 const hipGraphNode_t* pDependencies;

832 size_t numDependencies;

833 void* dev_ptr;

834 } hipGraphAddMemFreeNode;

835 struct

836 {

837 hipGraphNode_t* pGraphNode;

838 hipGraph_t graph;

839 const hipGraphNode_t* pDependencies;

840 size_t numDependencies;

841 const hipMemcpy3DParms* pCopyParams;

842 } hipGraphAddMemcpyNode;

843 struct

844 {

845 hipGraphNode_t* pGraphNode;

846 hipGraph_t graph;

847 const hipGraphNode_t* pDependencies;

848 size_t numDependencies;

849 void* dst;

850 const void* src;

851 size_t count;

852 hipMemcpyKind kind;

853 } hipGraphAddMemcpyNode1D;

854 struct

855 {

856 hipGraphNode_t* pGraphNode;

857 hipGraph_t graph;

858 const hipGraphNode_t* pDependencies;

859 size_t numDependencies;

860 void* dst;

861 const void* symbol;

862 size_t count;

863 size_t offset;

864 hipMemcpyKind kind;

865 } hipGraphAddMemcpyNodeFromSymbol;

866 struct

867 {

868 hipGraphNode_t* pGraphNode;

869 hipGraph_t graph;

870 const hipGraphNode_t* pDependencies;

871 size_t numDependencies;

872 const void* symbol;

873 const void* src;

874 size_t count;

875 size_t offset;

876 hipMemcpyKind kind;

877 } hipGraphAddMemcpyNodeToSymbol;

878 struct

879 {

880 hipGraphNode_t* pGraphNode;

881 hipGraph_t graph;

882 const hipGraphNode_t* pDependencies;

883 size_t numDependencies;

884 const hipMemsetParams* pMemsetParams;

885 } hipGraphAddMemsetNode;

886 struct

887 {

888 hipGraphNode_t node;

889 hipGraph_t* pGraph;

890 } hipGraphChildGraphNodeGetGraph;

891 struct

892 {

893 hipGraph_t* pGraphClone;

894 hipGraph_t originalGraph;

895 } hipGraphClone;

896 struct

897 {

898 hipGraph_t* pGraph;

899 unsigned int flags;

900 } hipGraphCreate;

901 struct

902 {

903 hipGraph_t graph;

904 const char* path;

905 unsigned int flags;

906 } hipGraphDebugDotPrint;

907 struct

908 {

909 hipGraph_t graph;

910 } hipGraphDestroy;

911 struct

912 {

913 hipGraphNode_t node;

914 } hipGraphDestroyNode;

915 struct

916 {

917 hipGraphNode_t node;

918 hipEvent_t* event_out;

919 } hipGraphEventRecordNodeGetEvent;

920 struct

921 {

922 hipGraphNode_t node;

923 hipEvent_t event;

924 } hipGraphEventRecordNodeSetEvent;

925 struct

926 {

927 hipGraphNode_t node;

928 hipEvent_t* event_out;

929 } hipGraphEventWaitNodeGetEvent;

930 struct

931 {

932 hipGraphNode_t node;

933 hipEvent_t event;

934 } hipGraphEventWaitNodeSetEvent;

935 struct

936 {

937 hipGraphExec_t hGraphExec;

938 hipGraphNode_t node;

939 hipGraph_t childGraph;

940 } hipGraphExecChildGraphNodeSetParams;

941 struct

942 {

943 hipGraphExec_t graphExec;

944 } hipGraphExecDestroy;

945 struct

946 {

947 hipGraphExec_t hGraphExec;

948 hipGraphNode_t hNode;

949 hipEvent_t event;

950 } hipGraphExecEventRecordNodeSetEvent;

951 struct

952 {

953 hipGraphExec_t hGraphExec;

954 hipGraphNode_t hNode;

955 hipEvent_t event;

956 } hipGraphExecEventWaitNodeSetEvent;

957 struct

958 {

959 hipGraphExec_t hGraphExec;

960 hipGraphNode_t node;

961 const hipHostNodeParams* pNodeParams;

962 } hipGraphExecHostNodeSetParams;

963 struct

964 {

965 hipGraphExec_t hGraphExec;

966 hipGraphNode_t node;

967 const hipKernelNodeParams* pNodeParams;

968 } hipGraphExecKernelNodeSetParams;

969 struct

970 {

971 hipGraphExec_t hGraphExec;

972 hipGraphNode_t node;

973 hipMemcpy3DParms* pNodeParams;

974 } hipGraphExecMemcpyNodeSetParams;

975 struct

976 {

977 hipGraphExec_t hGraphExec;

978 hipGraphNode_t node;

979 void* dst;

980 const void* src;

981 size_t count;

982 hipMemcpyKind kind;

983 } hipGraphExecMemcpyNodeSetParams1D;

984 struct

985 {

986 hipGraphExec_t hGraphExec;

987 hipGraphNode_t node;

988 void* dst;

989 const void* symbol;

990 size_t count;

991 size_t offset;

992 hipMemcpyKind kind;

993 } hipGraphExecMemcpyNodeSetParamsFromSymbol;

994 struct

995 {

996 hipGraphExec_t hGraphExec;

997 hipGraphNode_t node;

998 const void* symbol;

999 const void* src;

1000 size_t count;

1001 size_t offset;

1002 hipMemcpyKind kind;

1003 } hipGraphExecMemcpyNodeSetParamsToSymbol;

1004 struct

1005 {

1006 hipGraphExec_t hGraphExec;

1007 hipGraphNode_t node;

1008 const hipMemsetParams* pNodeParams;

1009 } hipGraphExecMemsetNodeSetParams;

1010 struct

1011 {

1012 hipGraphExec_t hGraphExec;

1013 hipGraph_t hGraph;

1014 hipGraphNode_t* hErrorNode_out;

1015 hipGraphExecUpdateResult* updateResult_out;

1016 } hipGraphExecUpdate;

1017 struct

1018 {

1019 hipGraph_t graph;

1020 hipGraphNode_t* from;

1021 hipGraphNode_t* to;

1022 size_t* numEdges;

1023 } hipGraphGetEdges;

1024 struct

1025 {

1026 hipGraph_t graph;

1027 hipGraphNode_t* nodes;

1028 size_t* numNodes;

1029 } hipGraphGetNodes;

1030 struct

1031 {

1032 hipGraph_t graph;

1033 hipGraphNode_t* pRootNodes;

1034 size_t* pNumRootNodes;

1035 } hipGraphGetRootNodes;

1036 struct

1037 {

1038 hipGraphNode_t node;

1039 hipHostNodeParams* pNodeParams;

1040 } hipGraphHostNodeGetParams;

1041 struct

1042 {

1043 hipGraphNode_t node;

1044 const hipHostNodeParams* pNodeParams;

1045 } hipGraphHostNodeSetParams;

1046 struct

1047 {

1048 hipGraphExec_t* pGraphExec;

1049 hipGraph_t graph;

1050 hipGraphNode_t* pErrorNode;

1051 void* pLogBuffer; // changed to void* (real: char*) to avoid stringify on stack-allocated

1052 // output parameter

1053 size_t bufferSize;

1054 } hipGraphInstantiate;

1055 struct

1056 {

1057 hipGraphExec_t* pGraphExec;

1058 hipGraph_t graph;

1059 unsigned long long flags;

1060 } hipGraphInstantiateWithFlags;

1061 struct

1062 {

1063 hipGraphNode_t hSrc;

1064 hipGraphNode_t hDst;

1065 } hipGraphKernelNodeCopyAttributes;

1066 struct

1067 {

1068 hipGraphNode_t hNode;

1069 hipKernelNodeAttrID attr;

1070 hipKernelNodeAttrValue* value;

1071 } hipGraphKernelNodeGetAttribute;

1072 struct

1073 {

1074 hipGraphNode_t node;

1075 hipKernelNodeParams* pNodeParams;

1076 } hipGraphKernelNodeGetParams;

1077 struct

1078 {

1079 hipGraphNode_t hNode;

1080 hipKernelNodeAttrID attr;

1081 const hipKernelNodeAttrValue* value;

1082 } hipGraphKernelNodeSetAttribute;

1083 struct

1084 {

1085 hipGraphNode_t node;

1086 const hipKernelNodeParams* pNodeParams;

1087 } hipGraphKernelNodeSetParams;

1088 struct

1089 {

1090 hipGraphExec_t graphExec;

1091 hipStream_t stream;

1092 } hipGraphLaunch;

1093 struct

1094 {

1095 hipGraphNode_t node;

1096 hipMemAllocNodeParams* pNodeParams;

1097 } hipGraphMemAllocNodeGetParams;

1098 struct

1099 {

1100 hipGraphNode_t node;

1101 void* dev_ptr;

1102 } hipGraphMemFreeNodeGetParams;

1103 struct

1104 {

1105 hipGraphNode_t node;

1106 hipMemcpy3DParms* pNodeParams;

1107 } hipGraphMemcpyNodeGetParams;

1108 struct

1109 {

1110 hipGraphNode_t node;

1111 const hipMemcpy3DParms* pNodeParams;

1112 } hipGraphMemcpyNodeSetParams;

1113 struct

1114 {

1115 hipGraphNode_t node;

1116 void* dst;

1117 const void* src;

1118 size_t count;

1119 hipMemcpyKind kind;

1120 } hipGraphMemcpyNodeSetParams1D;

1121 struct

1122 {

1123 hipGraphNode_t node;

1124 void* dst;

1125 const void* symbol;

1126 size_t count;

1127 size_t offset;

1128 hipMemcpyKind kind;

1129 } hipGraphMemcpyNodeSetParamsFromSymbol;

1130 struct

1131 {

1132 hipGraphNode_t node;

1133 const void* symbol;

1134 const void* src;

1135 size_t count;

1136 size_t offset;

1137 hipMemcpyKind kind;

1138 } hipGraphMemcpyNodeSetParamsToSymbol;

1139 struct

1140 {

1141 hipGraphNode_t node;

1142 hipMemsetParams* pNodeParams;

1143 } hipGraphMemsetNodeGetParams;

1144 struct

1145 {

1146 hipGraphNode_t node;

1147 const hipMemsetParams* pNodeParams;

1148 } hipGraphMemsetNodeSetParams;

1149 struct

1150 {

1151 hipGraphNode_t* pNode;

1152 hipGraphNode_t originalNode;

1153 hipGraph_t clonedGraph;

1154 } hipGraphNodeFindInClone;

1155 struct

1156 {

1157 hipGraphNode_t node;

1158 hipGraphNode_t* pDependencies;

1159 size_t* pNumDependencies;

1160 } hipGraphNodeGetDependencies;

1161 struct

1162 {

1163 hipGraphNode_t node;

1164 hipGraphNode_t* pDependentNodes;

1165 size_t* pNumDependentNodes;

1166 } hipGraphNodeGetDependentNodes;

1167 struct

1168 {

1169 hipGraphExec_t hGraphExec;

1170 hipGraphNode_t hNode;

1171 unsigned int* isEnabled;

1172 } hipGraphNodeGetEnabled;

1173 struct

1174 {

1175 hipGraphNode_t node;

1176 hipGraphNodeType* pType;

1177 } hipGraphNodeGetType;

1178 struct

1179 {

1180 hipGraphExec_t hGraphExec;

1181 hipGraphNode_t hNode;

1182 unsigned int isEnabled;

1183 } hipGraphNodeSetEnabled;

1184 struct

1185 {

1186 hipGraph_t graph;

1187 hipUserObject_t object;

1188 unsigned int count;

1189 } hipGraphReleaseUserObject;

1190 struct

1191 {

1192 hipGraph_t graph;

1193 const hipGraphNode_t* from;

1194 const hipGraphNode_t* to;

1195 size_t numDependencies;

1196 } hipGraphRemoveDependencies;

1197 struct

1198 {

1199 hipGraph_t graph;

1200 hipUserObject_t object;

1201 unsigned int count;

1202 unsigned int flags;

1203 } hipGraphRetainUserObject;

1204 struct

1205 {

1206 hipGraphExec_t graphExec;

1207 hipStream_t stream;

1208 } hipGraphUpload;

1209 struct

1210 {

1211 hipGraphicsResource** resource;

1212 GLuint buffer;

1213 unsigned int flags;

1214 } hipGraphicsGLRegisterBuffer;

1215 struct

1216 {

1217 hipGraphicsResource** resource;

1218 GLuint image;

1219 GLenum target;

1220 unsigned int flags;

1221 } hipGraphicsGLRegisterImage;

1222 struct

1223 {

1224 int count;

1225 hipGraphicsResource_t* resources;

1226 hipStream_t stream;

1227 } hipGraphicsMapResources;

1228 struct

1229 {

1230 void** devPtr;

1231 size_t* size;

1232 hipGraphicsResource_t resource;

1233 } hipGraphicsResourceGetMappedPointer;

1234 struct

1235 {

1236 hipArray_t* array;

1237 hipGraphicsResource_t resource;

1238 unsigned int arrayIndex;

1239 unsigned int mipLevel;

1240 } hipGraphicsSubResourceGetMappedArray;

1241 struct

1242 {

1243 int count;

1244 hipGraphicsResource_t* resources;

1245 hipStream_t stream;

1246 } hipGraphicsUnmapResources;

1247 struct

1248 {

1249 hipGraphicsResource_t resource;

1250 } hipGraphicsUnregisterResource;

1251 struct

1252 {

1253 void** ptr;

1254 size_t size;

1255 unsigned int flags;

1256 } hipHostAlloc;

1257 struct

1258 {

1259 void* ptr;

1260 } hipHostFree;

1261 struct

1262 {

1263 void** devPtr;

1264 void* hstPtr;

1265 unsigned int flags;

1266 } hipHostGetDevicePointer;

1267 struct

1268 {

1269 unsigned int* flagsPtr;

1270 void* hostPtr;

1271 } hipHostGetFlags;

1272 struct

1273 {

1274 void** ptr;

1275 size_t size;

1276 unsigned int flags;

1277 } hipHostMalloc;

1278 struct

1279 {

1280 void* hostPtr;

1281 size_t sizeBytes;

1282 unsigned int flags;

1283 } hipHostRegister;

1284 struct

1285 {

1286 void* hostPtr;

1287 } hipHostUnregister;

1288 struct

1289 {

1290 hipExternalMemory_t* extMem_out;

1291 const hipExternalMemoryHandleDesc* memHandleDesc;

1292 } hipImportExternalMemory;

1293 struct

1294 {

1295 hipExternalSemaphore_t* extSem_out;

1296 const hipExternalSemaphoreHandleDesc* semHandleDesc;

1297 } hipImportExternalSemaphore;

1298 struct

1299 {

1300 unsigned int flags;

1301 } hipInit;

1302 struct

1303 {

1304 void* devPtr;

1305 } hipIpcCloseMemHandle;

1306 struct

1307 {

1308 hipIpcEventHandle_t* handle;

1309 hipEvent_t event;

1310 } hipIpcGetEventHandle;

1311 struct

1312 {

1313 hipIpcMemHandle_t* handle;

1314 void* devPtr;

1315 } hipIpcGetMemHandle;

1316 struct

1317 {

1318 hipEvent_t* event;

1319 hipIpcEventHandle_t handle;

1320 } hipIpcOpenEventHandle;

1321 struct

1322 {

1323 void** devPtr;

1324 hipIpcMemHandle_t handle;

1325 unsigned int flags;

1326 } hipIpcOpenMemHandle;

1327 struct

1328 {

1329 hipFunction_t func;

1330 } hipKernelNameRef;

1331 struct

1332 {

1333 const void* hostFunction;

1334 hipStream_t stream;

1335 } hipKernelNameRefByPtr;

1336 struct

1337 {

1338 const void* func;

1339 } hipLaunchByPtr;

1340 struct

1341 {

1342 const void* func;

1343 rocprofiler_dim3_t gridDim;

1344 rocprofiler_dim3_t blockDimX;

1345 void** kernelParams;

1346 unsigned int sharedMemBytes;

1347 hipStream_t stream;

1348 } hipLaunchCooperativeKernel;

1349 struct

1350 {

1351 hipLaunchParams* launchParamsList;

1352 int numDevices;

1353 unsigned int flags;

1354 } hipLaunchCooperativeKernelMultiDevice;

1355 struct

1356 {

1357 hipStream_t stream;

1358 hipHostFn_t fn;

1359 void* userData;

1360 } hipLaunchHostFunc;

1361 struct

1362 {

1363 const void* function_address;

1364 rocprofiler_dim3_t numBlocks;

1365 rocprofiler_dim3_t dimBlocks;

1366 void** args;

1367 size_t sharedMemBytes;

1368 hipStream_t stream;

1369 } hipLaunchKernel;

1370 struct

1371 {

1372 void** ptr;

1373 size_t size;

1374 } hipMalloc;

1375 struct

1376 {

1377 hipPitchedPtr* pitchedDevPtr;

1378 hipExtent extent;

1379 } hipMalloc3D;

1380 struct

1381 {

1382 hipArray_t* array;

1383 const struct hipChannelFormatDesc* desc;

1384 struct hipExtent extent;

1385 unsigned int flags;

1386 } hipMalloc3DArray;

1387 struct

1388 {

1389 hipArray_t* array;

1390 const hipChannelFormatDesc* desc;

1391 size_t width;

1392 size_t height;

1393 unsigned int flags;

1394 } hipMallocArray;

1395 struct

1396 {

1397 void** dev_ptr;

1398 size_t size;

1399 hipStream_t stream;

1400 } hipMallocAsync;

1401 struct

1402 {

1403 void** dev_ptr;

1404 size_t size;

1405 hipMemPool_t mem_pool;

1406 hipStream_t stream;

1407 } hipMallocFromPoolAsync;

1408 struct

1409 {

1410 void** ptr;

1411 size_t size;

1412 } hipMallocHost;

1413 struct

1414 {

1415 void** dev_ptr;

1416 size_t size;

1417 unsigned int flags;

1418 } hipMallocManaged;

1419 struct

1420 {

1421 hipMipmappedArray_t* mipmappedArray;

1422 const struct hipChannelFormatDesc* desc;

1423 struct hipExtent extent;

1424 unsigned int numLevels;

1425 unsigned int flags;

1426 } hipMallocMipmappedArray;

1427 struct

1428 {

1429 void** ptr;

1430 size_t* pitch;

1431 size_t width;

1432 size_t height;

1433 } hipMallocPitch;

1434 struct

1435 {

1436 void* devPtr;

1437 size_t size;

1438 } hipMemAddressFree;

1439 struct

1440 {

1441 void** ptr;

1442 size_t size;

1443 size_t alignment;

1444 void* addr;

1445 unsigned long long flags;

1446 } hipMemAddressReserve;

1447 struct

1448 {

1449 const void* dev_ptr;

1450 size_t count;

1451 hipMemoryAdvise advice;

1452 int device;

1453 } hipMemAdvise;

1454 struct

1455 {

1456 void** ptr;

1457 size_t size;

1458 } hipMemAllocHost;

1459 struct

1460 {

1461 hipDeviceptr_t* dptr;

1462 size_t* pitch;

1463 size_t widthInBytes;

1464 size_t height;

1465 unsigned int elementSizeBytes;

1466 } hipMemAllocPitch;

1467 struct

1468 {

1469 hipMemGenericAllocationHandle_t* handle;

1470 size_t size;

1471 const hipMemAllocationProp* prop;

1472 unsigned long long flags;

1473 } hipMemCreate;

1474 struct

1475 {

1476 void* shareableHandle;

1477 hipMemGenericAllocationHandle_t handle;

1478 hipMemAllocationHandleType handleType;

1479 unsigned long long flags;

1480 } hipMemExportToShareableHandle;

1481 struct

1482 {

1483 unsigned long long* flags;

1484 const hipMemLocation* location;

1485 void* ptr;

1486 } hipMemGetAccess;

1487 struct

1488 {

1489 hipDeviceptr_t* pbase;

1490 size_t* psize;

1491 hipDeviceptr_t dptr;

1492 } hipMemGetAddressRange;

1493 struct

1494 {

1495 size_t* granularity;

1496 const hipMemAllocationProp* prop;

1497 hipMemAllocationGranularity_flags option;

1498 } hipMemGetAllocationGranularity;

1499 struct

1500 {

1501 hipMemAllocationProp* prop;

1502 hipMemGenericAllocationHandle_t handle;

1503 } hipMemGetAllocationPropertiesFromHandle;

1504 struct

1505 {

1506 size_t* free;

1507 size_t* total;

1508 } hipMemGetInfo;

1509 struct

1510 {

1511 hipMemGenericAllocationHandle_t* handle;

1512 void* osHandle;

1513 hipMemAllocationHandleType shHandleType;

1514 } hipMemImportFromShareableHandle;

1515 struct

1516 {

1517 void* ptr;

1518 size_t size;

1519 size_t offset;

1520 hipMemGenericAllocationHandle_t handle;

1521 unsigned long long flags;

1522 } hipMemMap;

1523 struct

1524 {

1525 hipArrayMapInfo* mapInfoList;

1526 unsigned int count;

1527 hipStream_t stream;

1528 } hipMemMapArrayAsync;

1529 struct

1530 {

1531 hipMemPool_t* mem_pool;

1532 const hipMemPoolProps* pool_props;

1533 } hipMemPoolCreate;

1534 struct

1535 {

1536 hipMemPool_t mem_pool;

1537 } hipMemPoolDestroy;

1538 struct

1539 {

1540 hipMemPoolPtrExportData* export_data;

1541 void* dev_ptr;

1542 } hipMemPoolExportPointer;

1543 struct

1544 {

1545 void* shared_handle;

1546 hipMemPool_t mem_pool;

1547 hipMemAllocationHandleType handle_type;

1548 unsigned int flags;

1549 } hipMemPoolExportToShareableHandle;

1550 struct

1551 {

1552 hipMemAccessFlags* flags;

1553 hipMemPool_t mem_pool;

1554 hipMemLocation* location;

1555 } hipMemPoolGetAccess;

1556 struct

1557 {

1558 hipMemPool_t mem_pool;

1559 hipMemPoolAttr attr;

1560 void* value;

1561 } hipMemPoolGetAttribute;

1562 struct

1563 {

1564 hipMemPool_t* mem_pool;

1565 void* shared_handle;

1566 hipMemAllocationHandleType handle_type;

1567 unsigned int flags;

1568 } hipMemPoolImportFromShareableHandle;

1569 struct

1570 {

1571 void** dev_ptr;

1572 hipMemPool_t mem_pool;

1573 hipMemPoolPtrExportData* export_data;

1574 } hipMemPoolImportPointer;

1575 struct

1576 {

1577 hipMemPool_t mem_pool;

1578 const hipMemAccessDesc* desc_list;

1579 size_t count;

1580 } hipMemPoolSetAccess;

1581 struct

1582 {

1583 hipMemPool_t mem_pool;

1584 hipMemPoolAttr attr;

1585 void* value;

1586 } hipMemPoolSetAttribute;

1587 struct

1588 {

1589 hipMemPool_t mem_pool;

1590 size_t min_bytes_to_hold;

1591 } hipMemPoolTrimTo;

1592 struct

1593 {

1594 const void* dev_ptr;

1595 size_t count;

1596 int device;

1597 hipStream_t stream;

1598 } hipMemPrefetchAsync;

1599 struct

1600 {

1601 void* ptr;

1602 size_t* size;

1603 } hipMemPtrGetInfo;

1604 struct

1605 {

1606 void* data;

1607 size_t data_size;

1608 hipMemRangeAttribute attribute;

1609 const void* dev_ptr;

1610 size_t count;

1611 } hipMemRangeGetAttribute;

1612 struct

1613 {

1614 void** data;

1615 size_t* data_sizes;

1616 hipMemRangeAttribute* attributes;

1617 size_t num_attributes;

1618 const void* dev_ptr;

1619 size_t count;

1620 } hipMemRangeGetAttributes;

1621 struct

1622 {

1623 hipMemGenericAllocationHandle_t handle;

1624 } hipMemRelease;

1625 struct

1626 {

1627 hipMemGenericAllocationHandle_t* handle;

1628 void* addr;

1629 } hipMemRetainAllocationHandle;

1630 struct

1631 {

1632 void* ptr;

1633 size_t size;

1634 const hipMemAccessDesc* desc;

1635 size_t count;

1636 } hipMemSetAccess;

1637 struct

1638 {

1639 void* ptr;

1640 size_t size;

1641 } hipMemUnmap;

1642 struct

1643 {

1644 void* dst;

1645 const void* src;

1646 size_t sizeBytes;

1647 hipMemcpyKind kind;

1648 } hipMemcpy;

1649 struct

1650 {

1651 void* dst;

1652 size_t dpitch;

1653 const void* src;

1654 size_t spitch;

1655 size_t width;

1656 size_t height;

1657 hipMemcpyKind kind;

1658 } hipMemcpy2D;

1659 struct

1660 {

1661 void* dst;

1662 size_t dpitch;

1663 const void* src;

1664 size_t spitch;

1665 size_t width;

1666 size_t height;

1667 hipMemcpyKind kind;

1668 hipStream_t stream;

1669 } hipMemcpy2DAsync;

1670 struct

1671 {

1672 void* dst;

1673 size_t dpitch;

1674 hipArray_const_t src;

1675 size_t wOffset;

1676 size_t hOffset;

1677 size_t width;

1678 size_t height;

1679 hipMemcpyKind kind;

1680 } hipMemcpy2DFromArray;

1681 struct

1682 {

1683 void* dst;

1684 size_t dpitch;

1685 hipArray_const_t src;

1686 size_t wOffset;

1687 size_t hOffset;

1688 size_t width;

1689 size_t height;

1690 hipMemcpyKind kind;

1691 hipStream_t stream;

1692 } hipMemcpy2DFromArrayAsync;

1693 struct

1694 {

1695 hipArray_t dst;

1696 size_t wOffset;

1697 size_t hOffset;

1698 const void* src;

1699 size_t spitch;

1700 size_t width;

1701 size_t height;

1702 hipMemcpyKind kind;

1703 } hipMemcpy2DToArray;

1704 struct

1705 {

1706 hipArray_t dst;

1707 size_t wOffset;

1708 size_t hOffset;

1709 const void* src;

1710 size_t spitch;

1711 size_t width;

1712 size_t height;

1713 hipMemcpyKind kind;

1714 hipStream_t stream;

1715 } hipMemcpy2DToArrayAsync;

1716 struct

1717 {

1718 const struct hipMemcpy3DParms* p;

1719 } hipMemcpy3D;

1720 struct

1721 {

1722 const struct hipMemcpy3DParms* p;

1723 hipStream_t stream;

1724 } hipMemcpy3DAsync;

1725 struct

1726 {

1727 void* dst;

1728 const void* src;

1729 size_t sizeBytes;

1730 hipMemcpyKind kind;

1731 hipStream_t stream;

1732 } hipMemcpyAsync;

1733 struct

1734 {

1735 void* dst;

1736 hipArray_t srcArray;

1737 size_t srcOffset;

1738 size_t count;

1739 } hipMemcpyAtoH;

1740 struct

1741 {

1742 hipDeviceptr_t dst;

1743 hipDeviceptr_t src;

1744 size_t sizeBytes;

1745 } hipMemcpyDtoD;

1746 struct

1747 {

1748 hipDeviceptr_t dst;

1749 hipDeviceptr_t src;

1750 size_t sizeBytes;

1751 hipStream_t stream;

1752 } hipMemcpyDtoDAsync;

1753 struct

1754 {

1755 void* dst;

1756 hipDeviceptr_t src;

1757 size_t sizeBytes;

1758 } hipMemcpyDtoH;

1759 struct

1760 {

1761 void* dst;

1762 hipDeviceptr_t src;

1763 size_t sizeBytes;

1764 hipStream_t stream;

1765 } hipMemcpyDtoHAsync;

1766 struct

1767 {

1768 void* dst;

1769 hipArray_const_t srcArray;

1770 size_t wOffset;

1771 size_t hOffset;

1772 size_t count;

1773 hipMemcpyKind kind;

1774 } hipMemcpyFromArray;

1775 struct

1776 {

1777 void* dst;

1778 const void* symbol;

1779 size_t sizeBytes;

1780 size_t offset;

1781 hipMemcpyKind kind;

1782 } hipMemcpyFromSymbol;

1783 struct

1784 {

1785 void* dst;

1786 const void* symbol;

1787 size_t sizeBytes;

1788 size_t offset;

1789 hipMemcpyKind kind;

1790 hipStream_t stream;

1791 } hipMemcpyFromSymbolAsync;

1792 struct

1793 {

1794 hipArray_t dstArray;

1795 size_t dstOffset;

1796 const void* srcHost;

1797 size_t count;

1798 } hipMemcpyHtoA;

1799 struct

1800 {

1801 hipDeviceptr_t dst;

1802 const void* src;

1803 size_t sizeBytes;

1804 } hipMemcpyHtoD;

1805 struct

1806 {

1807 hipDeviceptr_t dst;

1808 const void* src;

1809 size_t sizeBytes;

1810 hipStream_t stream;

1811 } hipMemcpyHtoDAsync;

1812 struct

1813 {

1814 const hip_Memcpy2D* pCopy;

1815 } hipMemcpyParam2D;

1816 struct

1817 {

1818 const hip_Memcpy2D* pCopy;

1819 hipStream_t stream;

1820 } hipMemcpyParam2DAsync;

1821 struct

1822 {

1823 void* dst;

1824 int dstDeviceId;

1825 const void* src;

1826 int srcDeviceId;

1827 size_t sizeBytes;

1828 } hipMemcpyPeer;

1829 struct

1830 {

1831 void* dst;

1832 int dstDeviceId;

1833 const void* src;

1834 int srcDevice;

1835 size_t sizeBytes;

1836 hipStream_t stream;

1837 } hipMemcpyPeerAsync;

1838 struct

1839 {

1840 hipArray_t dst;

1841 size_t wOffset;

1842 size_t hOffset;

1843 const void* src;

1844 size_t count;

1845 hipMemcpyKind kind;

1846 } hipMemcpyToArray;

1847 struct

1848 {

1849 const void* symbol;

1850 const void* src;

1851 size_t sizeBytes;

1852 size_t offset;

1853 hipMemcpyKind kind;

1854 } hipMemcpyToSymbol;

1855 struct

1856 {

1857 const void* symbol;

1858 const void* src;

1859 size_t sizeBytes;

1860 size_t offset;

1861 hipMemcpyKind kind;

1862 hipStream_t stream;

1863 } hipMemcpyToSymbolAsync;

1864 struct

1865 {

1866 void* dst;

1867 const void* src;

1868 size_t sizeBytes;

1869 hipMemcpyKind kind;

1870 hipStream_t stream;

1871 } hipMemcpyWithStream;

1872 struct

1873 {

1874 void* dst;

1875 int value;

1876 size_t sizeBytes;

1877 } hipMemset;

1878 struct

1879 {

1880 void* dst;

1881 size_t pitch;

1882 int value;

1883 size_t width;

1884 size_t height;

1885 } hipMemset2D;

1886 struct

1887 {

1888 void* dst;

1889 size_t pitch;

1890 int value;

1891 size_t width;

1892 size_t height;

1893 hipStream_t stream;

1894 } hipMemset2DAsync;

1895 struct

1896 {

1897 hipPitchedPtr pitchedDevPtr;

1898 int value;

1899 hipExtent extent;

1900 } hipMemset3D;

1901 struct

1902 {

1903 hipPitchedPtr pitchedDevPtr;

1904 int value;

1905 hipExtent extent;

1906 hipStream_t stream;

1907 } hipMemset3DAsync;

1908 struct

1909 {

1910 void* dst;

1911 int value;

1912 size_t sizeBytes;

1913 hipStream_t stream;

1914 } hipMemsetAsync;

1915 struct

1916 {

1917 hipDeviceptr_t dest;

1918 unsigned short value;

1919 size_t count;

1920 } hipMemsetD16;

1921 struct

1922 {

1923 hipDeviceptr_t dest;

1924 unsigned short value;

1925 size_t count;

1926 hipStream_t stream;

1927 } hipMemsetD16Async;

1928 struct

1929 {

1930 hipDeviceptr_t dest;

1931 int value;

1932 size_t count;

1933 } hipMemsetD32;

1934 struct

1935 {

1936 hipDeviceptr_t dst;

1937 int value;

1938 size_t count;

1939 hipStream_t stream;

1940 } hipMemsetD32Async;

1941 struct

1942 {

1943 hipDeviceptr_t dest;

1944 unsigned char value;

1945 size_t count;

1946 } hipMemsetD8;

1947 struct

1948 {

1949 hipDeviceptr_t dest;

1950 unsigned char value;

1951 size_t count;

1952 hipStream_t stream;

1953 } hipMemsetD8Async;

1954 struct

1955 {

1956 hipMipmappedArray_t* pHandle;

1957 HIP_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc;

1958 unsigned int numMipmapLevels;

1959 } hipMipmappedArrayCreate;

1960 struct

1961 {

1962 hipMipmappedArray_t hMipmappedArray;

1963 } hipMipmappedArrayDestroy;

1964 struct

1965 {

1966 hipArray_t* pLevelArray;

1967 hipMipmappedArray_t hMipMappedArray;

1968 unsigned int level;

1969 } hipMipmappedArrayGetLevel;

1970 struct

1971 {

1972 hipFunction_t* function;

1973 hipModule_t module;

1974 const char* kname;

1975 } hipModuleGetFunction;

1976 struct

1977 {

1978 hipDeviceptr_t* dptr;

1979 size_t* bytes;

1980 hipModule_t hmod;

1981 const char* name;

1982 } hipModuleGetGlobal;

1983 struct

1984 {

1985 textureReference** texRef;

1986 hipModule_t hmod;

1987 const char* name;

1988 } hipModuleGetTexRef;

1989 struct

1990 {

1991 hipFunction_t func;

1992 unsigned int gridDimX;

1993 unsigned int gridDimY;

1994 unsigned int gridDimZ;

1995 unsigned int blockDimX;

1996 unsigned int blockDimY;

1997 unsigned int blockDimZ;

1998 unsigned int sharedMemBytes;

1999 hipStream_t stream;

2000 void** kernelParams;

2001 } hipModuleLaunchCooperativeKernel;

2002 struct

2003 {

2004 hipFunctionLaunchParams* launchParamsList;

2005 unsigned int numDevices;

2006 unsigned int flags;

2007 } hipModuleLaunchCooperativeKernelMultiDevice;

2008 struct

2009 {

2010 hipFunction_t func;

2011 unsigned int gridDimX;

2012 unsigned int gridDimY;

2013 unsigned int gridDimZ;

2014 unsigned int blockDimX;

2015 unsigned int blockDimY;

2016 unsigned int blockDimZ;

2017 unsigned int sharedMemBytes;

2018 hipStream_t stream;

2019 void** kernelParams;

2020 void** extra;

2021 } hipModuleLaunchKernel;

2022 struct

2023 {

2024 hipModule_t* module;

2025 const char* fname;

2026 } hipModuleLoad;

2027 struct

2028 {

2029 hipModule_t* module;

2030 const void* image;

2031 } hipModuleLoadData;

2032 struct

2033 {

2034 hipModule_t* module;

2035 const void* image;

2036 unsigned int numOptions;

2037 hipJitOption* options;

2038 void** optionValues;

2039 } hipModuleLoadDataEx;

2040 struct

2041 {

2042 int* numBlocks;

2043 hipFunction_t func;

2044 int blockSize;

2045 size_t dynSharedMemPerBlk;

2046 } hipModuleOccupancyMaxActiveBlocksPerMultiprocessor;

2047 struct

2048 {

2049 int* numBlocks;

2050 hipFunction_t func;

2051 int blockSize;

2052 size_t dynSharedMemPerBlk;

2053 unsigned int flags;

2054 } hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags;

2055 struct

2056 {

2057 int* gridSize;

2058 int* blockSize;

2059 hipFunction_t func;

2060 size_t dynSharedMemPerBlk;

2061 int blockSizeLimit;

2062 } hipModuleOccupancyMaxPotentialBlockSize;

2063 struct

2064 {

2065 int* gridSize;

2066 int* blockSize;

2067 hipFunction_t func;

2068 size_t dynSharedMemPerBlk;

2069 int blockSizeLimit;

2070 unsigned int flags;

2071 } hipModuleOccupancyMaxPotentialBlockSizeWithFlags;

2072 struct

2073 {

2074 hipModule_t module;

2075 } hipModuleUnload;

2076 struct

2077 {

2078 int* numBlocks;

2079 const void* func;

2080 int blockSize;

2081 size_t dynSharedMemPerBlk;

2082 } hipOccupancyMaxActiveBlocksPerMultiprocessor;

2083 struct

2084 {

2085 int* numBlocks;

2086 const void* func;

2087 int blockSize;

2088 size_t dynSharedMemPerBlk;

2089 unsigned int flags;

2090 } hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags;

2091 struct

2092 {

2093 int* gridSize;

2094 int* blockSize;

2095 const void* func;

2096 size_t dynSharedMemPerBlk;

2097 int blockSizeLimit;

2098 } hipOccupancyMaxPotentialBlockSize;

2099 struct

2100 {

2101 // Empty struct has a size of 0 in C but size of 1 in C++.

2102 // Add the rocprofiler_hip_api_no_args struct to fix this

2103 rocprofiler_hip_api_no_args no_args;

2104 } hipPeekAtLastError;

2105 struct

2106 {

2107 void* data;

2108 hipPointer_attribute attribute;

2109 hipDeviceptr_t ptr;

2110 } hipPointerGetAttribute;

2111 struct

2112 {

2113 hipPointerAttribute_t* attributes;

2114 const void* ptr;

2115 } hipPointerGetAttributes;

2116 struct

2117 {

2118 const void* value;

2119 hipPointer_attribute attribute;

2120 hipDeviceptr_t ptr;

2121 } hipPointerSetAttribute;

2122 struct

2123 {

2124 // Empty struct has a size of 0 in C but size of 1 in C++.

2125 // Add the rocprofiler_hip_api_no_args struct to fix this

2126 rocprofiler_hip_api_no_args no_args;

2127 } hipProfilerStart;

2128 struct

2129 {

2130 // Empty struct has a size of 0 in C but size of 1 in C++.

2131 // Add the rocprofiler_hip_api_no_args struct to fix this

2132 rocprofiler_hip_api_no_args no_args;

2133 } hipProfilerStop;

2134 struct

2135 {

2136 int* runtimeVersion;

2137 } hipRuntimeGetVersion;

2138 struct

2139 {

2140 int deviceId;

2141 } hipSetDevice;

2142 struct

2143 {

2144 unsigned flags;

2145 } hipSetDeviceFlags;

2146 struct

2147 {

2148 const void* arg;

2149 size_t size;

2150 size_t offset;

2151 } hipSetupArgument;

2152 struct

2153 {

2154 const hipExternalSemaphore_t* extSemArray;

2155 const hipExternalSemaphoreSignalParams* paramsArray;

2156 unsigned int numExtSems;

2157 hipStream_t stream;

2158 } hipSignalExternalSemaphoresAsync;

2159 struct

2160 {

2161 hipStream_t stream;

2162 hipStreamCallback_t callback;

2163 void* userData;

2164 unsigned int flags;

2165 } hipStreamAddCallback;

2166 struct

2167 {

2168 hipStream_t stream;

2169 void* dev_ptr;

2170 size_t length;

2171 unsigned int flags;

2172 } hipStreamAttachMemAsync;

2173 struct

2174 {

2175 hipStream_t stream;

2176 hipStreamCaptureMode mode;

2177 } hipStreamBeginCapture;

2178 struct

2179 {

2180 hipStream_t* stream;

2181 } hipStreamCreate;

2182 struct

2183 {

2184 hipStream_t* stream;

2185 unsigned int flags;

2186 } hipStreamCreateWithFlags;

2187 struct

2188 {

2189 hipStream_t* stream;

2190 unsigned int flags;

2191 int priority;

2192 } hipStreamCreateWithPriority;

2193 struct

2194 {

2195 hipStream_t stream;

2196 } hipStreamDestroy;

2197 struct

2198 {

2199 hipStream_t stream;

2200 hipGraph_t* pGraph;

2201 } hipStreamEndCapture;

2202 struct

2203 {

2204 hipStream_t stream;

2205 hipStreamCaptureStatus* pCaptureStatus;

2206 unsigned long long* pId;

2207 } hipStreamGetCaptureInfo;

2208 struct

2209 {

2210 hipStream_t stream;

2211 hipStreamCaptureStatus* captureStatus_out;

2212 unsigned long long* id_out;

2213 hipGraph_t* graph_out;

2214 const hipGraphNode_t** dependencies_out;

2215 size_t* numDependencies_out;

2216 } hipStreamGetCaptureInfo_v2;

2217 struct

2218 {

2219 hipStream_t stream;

2220 hipDevice_t* device;

2221 } hipStreamGetDevice;

2222 struct

2223 {

2224 hipStream_t stream;

2225 unsigned int* flags;

2226 } hipStreamGetFlags;

2227 struct

2228 {

2229 hipStream_t stream;

2230 int* priority;

2231 } hipStreamGetPriority;

2232 struct

2233 {

2234 hipStream_t stream;

2235 hipStreamCaptureStatus* pCaptureStatus;

2236 } hipStreamIsCapturing;

2237 struct

2238 {

2239 hipStream_t stream;

2240 } hipStreamQuery;

2241 struct

2242 {

2243 hipStream_t stream;

2244 } hipStreamSynchronize;

2245 struct

2246 {

2247 hipStream_t stream;

2248 hipGraphNode_t* dependencies;

2249 size_t numDependencies;

2250 unsigned int flags;

2251 } hipStreamUpdateCaptureDependencies;

2252 struct

2253 {

2254 hipStream_t stream;

2255 hipEvent_t event;

2256 unsigned int flags;

2257 } hipStreamWaitEvent;

2258 struct

2259 {

2260 hipStream_t stream;

2261 void* ptr;

2262 uint32_t value;

2263 unsigned int flags;

2264 uint32_t mask;

2265 } hipStreamWaitValue32;

2266 struct

2267 {

2268 hipStream_t stream;

2269 void* ptr;

2270 uint64_t value;

2271 unsigned int flags;

2272 uint64_t mask;

2273 } hipStreamWaitValue64;

2274 struct

2275 {

2276 hipStream_t stream;

2277 void* ptr;

2278 uint32_t value;

2279 unsigned int flags;

2280 } hipStreamWriteValue32;

2281 struct

2282 {

2283 hipStream_t stream;

2284 void* ptr;

2285 uint64_t value;

2286 unsigned int flags;

2287 } hipStreamWriteValue64;

2288 struct

2289 {

2290 hipTextureObject_t* pTexObject;

2291 const HIP_RESOURCE_DESC* pResDesc;

2292 const HIP_TEXTURE_DESC* pTexDesc;

2293 const HIP_RESOURCE_VIEW_DESC* pResViewDesc;

2294 } hipTexObjectCreate;

2295 struct

2296 {

2297 hipTextureObject_t texObject;

2298 } hipTexObjectDestroy;

2299 struct

2300 {

2301 HIP_RESOURCE_DESC* pResDesc;

2302 hipTextureObject_t texObject;

2303 } hipTexObjectGetResourceDesc;

2304 struct

2305 {

2306 HIP_RESOURCE_VIEW_DESC* pResViewDesc;

2307 hipTextureObject_t texObject;

2308 } hipTexObjectGetResourceViewDesc;

2309 struct

2310 {

2311 HIP_TEXTURE_DESC* pTexDesc;

2312 hipTextureObject_t texObject;

2313 } hipTexObjectGetTextureDesc;

2314 struct

2315 {

2316 hipDeviceptr_t* dev_ptr;

2317 const textureReference* texRef;

2318 } hipTexRefGetAddress;

2319 struct

2320 {

2321 enum hipTextureAddressMode* pam;

2322 const textureReference* texRef;

2323 int dim;

2324 } hipTexRefGetAddressMode;

2325 struct

2326 {

2327 enum hipTextureFilterMode* pfm;

2328 const textureReference* texRef;

2329 } hipTexRefGetFilterMode;

2330 struct

2331 {

2332 unsigned int* pFlags;

2333 const textureReference* texRef;

2334 } hipTexRefGetFlags;

2335 struct

2336 {

2337 hipArray_Format* pFormat;

2338 int* pNumChannels;

2339 const textureReference* texRef;

2340 } hipTexRefGetFormat;

2341 struct

2342 {

2343 int* pmaxAnsio;

2344 const textureReference* texRef;

2345 } hipTexRefGetMaxAnisotropy;

2346 struct

2347 {

2348 hipMipmappedArray_t* pArray;

2349 const textureReference* texRef;

2350 } hipTexRefGetMipMappedArray;

2351 struct

2352 {

2353 enum hipTextureFilterMode* pfm;

2354 const textureReference* texRef;

2355 } hipTexRefGetMipmapFilterMode;

2356 struct

2357 {

2358 float* pbias;

2359 const textureReference* texRef;

2360 } hipTexRefGetMipmapLevelBias;

2361 struct

2362 {

2363 float* pminMipmapLevelClamp;

2364 float* pmaxMipmapLevelClamp;

2365 const textureReference* texRef;

2366 } hipTexRefGetMipmapLevelClamp;

2367 struct

2368 {

2369 size_t* ByteOffset;

2370 textureReference* texRef;

2371 hipDeviceptr_t dptr;

2372 size_t bytes;

2373 } hipTexRefSetAddress;

2374 struct

2375 {

2376 textureReference* texRef;

2377 const HIP_ARRAY_DESCRIPTOR* desc;

2378 hipDeviceptr_t dptr;

2379 size_t Pitch;

2380 } hipTexRefSetAddress2D;

2381 struct

2382 {

2383 textureReference* texRef;

2384 int dim;

2385 enum hipTextureAddressMode am;

2386 } hipTexRefSetAddressMode;

2387 struct

2388 {

2389 textureReference* tex;

2390 hipArray_const_t array;

2391 unsigned int flags;

2392 } hipTexRefSetArray;

2393 struct

2394 {

2395 textureReference* texRef;

2396 float* pBorderColor;

2397 } hipTexRefSetBorderColor;

2398 struct

2399 {

2400 textureReference* texRef;

2401 enum hipTextureFilterMode fm;

2402 } hipTexRefSetFilterMode;

2403 struct

2404 {

2405 textureReference* texRef;

2406 unsigned int Flags;

2407 } hipTexRefSetFlags;

2408 struct

2409 {

2410 textureReference* texRef;

2411 hipArray_Format fmt;

2412 int NumPackedComponents;

2413 } hipTexRefSetFormat;

2414 struct

2415 {

2416 textureReference* texRef;

2417 unsigned int maxAniso;

2418 } hipTexRefSetMaxAnisotropy;

2419 struct

2420 {

2421 textureReference* texRef;

2422 enum hipTextureFilterMode fm;

2423 } hipTexRefSetMipmapFilterMode;

2424 struct

2425 {

2426 textureReference* texRef;

2427 float bias;

2428 } hipTexRefSetMipmapLevelBias;

2429 struct

2430 {

2431 textureReference* texRef;

2432 float minMipMapLevelClamp;

2433 float maxMipMapLevelClamp;

2434 } hipTexRefSetMipmapLevelClamp;

2435 struct

2436 {

2437 textureReference* texRef;

2438 struct hipMipmappedArray* mipmappedArray;

2439 unsigned int Flags;

2440 } hipTexRefSetMipmappedArray;

2441 struct

2442 {

2443 hipStreamCaptureMode* mode;

2444 } hipThreadExchangeStreamCaptureMode;

2445 struct

2446 {

2447 const textureReference* tex;

2448 } hipUnbindTexture;

2449 struct

2450 {

2451 hipUserObject_t* object_out;

2452 void* ptr;

2453 hipHostFn_t destroy;

2454 unsigned int initialRefcount;

2455 unsigned int flags;

2456 } hipUserObjectCreate;

2457 struct

2458 {

2459 hipUserObject_t object;

2460 unsigned int count;

2461 } hipUserObjectRelease;

2462 struct

2463 {

2464 hipUserObject_t object;

2465 unsigned int count;

2466 } hipUserObjectRetain;

2467 struct

2468 {

2469 const hipExternalSemaphore_t* extSemArray;

2470 const hipExternalSemaphoreWaitParams* paramsArray;

2471 unsigned int numExtSems;

2472 hipStream_t stream;

2473 } hipWaitExternalSemaphoresAsync;

2474 struct

2475 {

2476 int x;

2477 int y;

2478 int z;

2479 int w;

2480 hipChannelFormatKind f;

2481 } hipCreateChannelDesc;

2482 struct

2483 {

2484 hipFunction_t func;

2485 uint32_t globalWorkSizeX;

2486 uint32_t globalWorkSizeY;

2487 uint32_t globalWorkSizeZ;

2488 uint32_t localWorkSizeX;

2489 uint32_t localWorkSizeY;

2490 uint32_t localWorkSizeZ;

2491 size_t sharedMemBytes;

2492 hipStream_t stream;

2493 void** kernelParams;

2494 void** extra;

2495 hipEvent_t startEvent;

2496 hipEvent_t stopEvent;

2497 uint32_t flags;

2498 } hipExtModuleLaunchKernel;

2499 struct

2500 {

2501 hipFunction_t func;

2502 uint32_t globalWorkSizeX;

2503 uint32_t globalWorkSizeY;

2504 uint32_t globalWorkSizeZ;

2505 uint32_t localWorkSizeX;

2506 uint32_t localWorkSizeY;

2507 uint32_t localWorkSizeZ;

2508 size_t sharedMemBytes;

2509 hipStream_t stream;

2510 void** kernelParams;

2511 void** extra;

2512 hipEvent_t startEvent;

2513 hipEvent_t stopEvent;

2514 } hipHccModuleLaunchKernel;

2515 struct

2516 {

2517 void* dst;

2518 const void* src;

2519 size_t sizeBytes;

2520 hipMemcpyKind kind;

2521 } hipMemcpy_spt;

2522 struct

2523 {

2524 const void* symbol;

2525 const void* src;

2526 size_t sizeBytes;

2527 size_t offset;

2528 hipMemcpyKind kind;

2529 } hipMemcpyToSymbol_spt;

2530 struct

2531 {

2532 void* dst;

2533 const void* symbol;

2534 size_t sizeBytes;

2535 size_t offset;

2536 hipMemcpyKind kind;

2537 } hipMemcpyFromSymbol_spt;

2538 struct

2539 {

2540 void* dst;

2541 size_t dpitch;

2542 const void* src;

2543 size_t spitch;

2544 size_t width;

2545 size_t height;

2546 hipMemcpyKind kind;

2547 } hipMemcpy2D_spt;

2548 struct

2549 {

2550 void* dst;

2551 size_t dpitch;

2552 hipArray_const_t src;

2553 size_t wOffset;

2554 size_t hOffset;

2555 size_t width;

2556 size_t height;

2557 hipMemcpyKind kind;

2558 } hipMemcpy2DFromArray_spt;

2559 struct

2560 {

2561 const struct hipMemcpy3DParms* p;

2562 } hipMemcpy3D_spt;

2563 struct

2564 {

2565 void* dst;

2566 int value;

2567 size_t sizeBytes;

2568 } hipMemset_spt;

2569 struct

2570 {

2571 void* dst;

2572 int value;

2573 size_t sizeBytes;

2574 hipStream_t stream;

2575 } hipMemsetAsync_spt;

2576 struct

2577 {

2578 void* dst;

2579 size_t pitch;

2580 int value;

2581 size_t width;

2582 size_t height;

2583 } hipMemset2D_spt;

2584 struct

2585 {

2586 void* dst;

2587 size_t pitch;

2588 int value;

2589 size_t width;

2590 size_t height;

2591 hipStream_t stream;

2592 } hipMemset2DAsync_spt;

2593 struct

2594 {

2595 hipPitchedPtr pitchedDevPtr;

2596 int value;

2597 hipExtent extent;

2598 hipStream_t stream;

2599 } hipMemset3DAsync_spt;

2600 struct

2601 {

2602 hipPitchedPtr pitchedDevPtr;

2603 int value;

2604 hipExtent extent;

2605 } hipMemset3D_spt;

2606 struct

2607 {

2608 void* dst;

2609 const void* src;

2610 size_t sizeBytes;

2611 hipMemcpyKind kind;

2612 hipStream_t stream;

2613 } hipMemcpyAsync_spt;

2614 struct

2615 {

2616 const hipMemcpy3DParms* p;

2617 hipStream_t stream;

2618 } hipMemcpy3DAsync_spt;

2619 struct

2620 {

2621 void* dst;

2622 size_t dpitch;

2623 const void* src;

2624 size_t spitch;

2625 size_t width;

2626 size_t height;

2627 hipMemcpyKind kind;

2628 hipStream_t stream;

2629 } hipMemcpy2DAsync_spt;

2630 struct

2631 {

2632 void* dst;

2633 const void* symbol;

2634 size_t sizeBytes;

2635 size_t offset;

2636 hipMemcpyKind kind;

2637 hipStream_t stream;

2638 } hipMemcpyFromSymbolAsync_spt;

2639 struct

2640 {

2641 const void* symbol;

2642 const void* src;

2643 size_t sizeBytes;

2644 size_t offset;

2645 hipMemcpyKind kind;

2646 hipStream_t stream;

2647 } hipMemcpyToSymbolAsync_spt;

2648 struct

2649 {

2650 void* dst;

2651 hipArray_const_t src;

2652 size_t wOffsetSrc;

2653 size_t hOffset;

2654 size_t count;

2655 hipMemcpyKind kind;

2656 } hipMemcpyFromArray_spt;

2657 struct

2658 {

2659 hipArray_t dst;

2660 size_t wOffset;

2661 size_t hOffset;

2662 const void* src;

2663 size_t spitch;

2664 size_t width;

2665 size_t height;

2666 hipMemcpyKind kind;

2667 } hipMemcpy2DToArray_spt;

2668 struct

2669 {

2670 void* dst;

2671 size_t dpitch;

2672 hipArray_const_t src;

2673 size_t wOffsetSrc;

2674 size_t hOffsetSrc;

2675 size_t width;

2676 size_t height;

2677 hipMemcpyKind kind;

2678 hipStream_t stream;

2679 } hipMemcpy2DFromArrayAsync_spt;

2680 struct

2681 {

2682 hipArray_t dst;

2683 size_t wOffset;

2684 size_t hOffset;

2685 const void* src;

2686 size_t spitch;

2687 size_t width;

2688 size_t height;

2689 hipMemcpyKind kind;

2690 hipStream_t stream;

2691 } hipMemcpy2DToArrayAsync_spt;

2692 struct

2693 {

2694 hipStream_t stream;

2695 } hipStreamQuery_spt;

2696 struct

2697 {

2698 hipStream_t stream;

2699 } hipStreamSynchronize_spt;

2700 struct

2701 {

2702 hipStream_t stream;

2703 int* priority;

2704 } hipStreamGetPriority_spt;

2705 struct

2706 {

2707 hipStream_t stream;

2708 hipEvent_t event;

2709 unsigned int flags;

2710 } hipStreamWaitEvent_spt;

2711 struct

2712 {

2713 hipStream_t stream;

2714 unsigned int* flags;

2715 } hipStreamGetFlags_spt;

2716 struct

2717 {

2718 hipStream_t stream;

2719 hipStreamCallback_t callback;

2720 void* userData;

2721 unsigned int flags;

2722 } hipStreamAddCallback_spt;

2723 struct

2724 {

2725 hipEvent_t event;

2726 hipStream_t stream;

2727 } hipEventRecord_spt;

2728 struct

2729 {

2730 const void* func;

2731 rocprofiler_dim3_t gridDim;

2732 rocprofiler_dim3_t blockDim;

2733 void** kernelParams;

2734 uint32_t sharedMemBytes;

2735 hipStream_t stream;

2736 } hipLaunchCooperativeKernel_spt;

2737 struct

2738 {

2739 const void* function_address;

2740 rocprofiler_dim3_t numBlocks;

2741 rocprofiler_dim3_t dimBlocks;

2742 void** args;

2743 size_t sharedMemBytes;

2744 hipStream_t stream;

2745 } hipLaunchKernel_spt;

2746 struct

2747 {

2748 hipGraphExec_t graphExec;

2749 hipStream_t stream;

2750 } hipGraphLaunch_spt;

2751 struct

2752 {

2753 hipStream_t stream;

2754 hipStreamCaptureMode mode;

2755 } hipStreamBeginCapture_spt;

2756 struct

2757 {

2758 hipStream_t stream;

2759 hipGraph_t* pGraph;

2760 } hipStreamEndCapture_spt;

2761 struct

2762 {

2763 hipStream_t stream;

2764 hipStreamCaptureStatus* pCaptureStatus;

2765 } hipStreamIsCapturing_spt;

2766 struct

2767 {

2768 hipStream_t stream;

2769 hipStreamCaptureStatus* pCaptureStatus;

2770 unsigned long long* pId;

2771 } hipStreamGetCaptureInfo_spt;

2772 struct

2773 {

2774 hipStream_t stream;

2775 hipStreamCaptureStatus* captureStatus_out;

2776 unsigned long long* id_out;

2777 hipGraph_t* graph_out;

2778 const hipGraphNode_t** dependencies_out;

2779 size_t* numDependencies_out;

2780 } hipStreamGetCaptureInfo_v2_spt;

2781 struct

2782 {

2783 hipStream_t stream;

2784 hipHostFn_t fn;

2785 void* userData;

2786 } hipLaunchHostFunc_spt;

2787 struct

2788 {

2789 hipStream_t stream;

2790 } hipGetStreamDeviceId;

2791 struct

2792 {

2793 hipGraphNode_t* phGraphNode;

2794 hipGraph_t hGraph;

2795 const hipGraphNode_t* dependencies;

2796 size_t numDependencies;

2797#if HIP_RUNTIME_API_TABLE_STEP_VERSION < 13

2798 const HIP_MEMSET_NODE_PARAMS* memsetParams;

2799#endif

2800#if HIP_RUNTIME_API_TABLE_STEP_VERSION >= 13

2801 const hipMemsetParams* memsetParams;

2802#endif

2803 hipCtx_t ctx;

2804 } hipDrvGraphAddMemsetNode;

2805 struct

2806 {

2807 hipGraphNode_t* pGraphNode;

2808 hipGraph_t graph;

2809 const hipGraphNode_t* pDependencies;

2810 size_t numDependencies;

2811 const hipExternalSemaphoreWaitNodeParams* nodeParams;

2812 } hipGraphAddExternalSemaphoresWaitNode;

2813 struct

2814 {

2815 hipGraphNode_t* pGraphNode;

2816 hipGraph_t graph;

2817 const hipGraphNode_t* pDependencies;

2818 size_t numDependencies;

2819 const hipExternalSemaphoreSignalNodeParams* nodeParams;

2820 } hipGraphAddExternalSemaphoresSignalNode;

2821 struct

2822 {

2823 hipGraphNode_t hNode;

2824 const hipExternalSemaphoreSignalNodeParams* nodeParams;

2825 } hipGraphExternalSemaphoresSignalNodeSetParams;

2826 struct

2827 {

2828 hipGraphNode_t hNode;

2829 const hipExternalSemaphoreWaitNodeParams* nodeParams;

2830 } hipGraphExternalSemaphoresWaitNodeSetParams;

2831 struct

2832 {

2833 hipGraphNode_t hNode;

2834 hipExternalSemaphoreSignalNodeParams* params_out;

2835 } hipGraphExternalSemaphoresSignalNodeGetParams;

2836 struct

2837 {

2838 hipGraphNode_t hNode;

2839 hipExternalSemaphoreWaitNodeParams* params_out;

2840 } hipGraphExternalSemaphoresWaitNodeGetParams;

2841 struct

2842 {

2843 hipGraphExec_t hGraphExec;

2844 hipGraphNode_t hNode;

2845 const hipExternalSemaphoreSignalNodeParams* nodeParams;

2846 } hipGraphExecExternalSemaphoresSignalNodeSetParams;

2847 struct

2848 {

2849 hipGraphExec_t hGraphExec;

2850 hipGraphNode_t hNode;

2851 const hipExternalSemaphoreWaitNodeParams* nodeParams;

2852 } hipGraphExecExternalSemaphoresWaitNodeSetParams;

2853 struct

2854 {

2855 hipGraphNode_t* pGraphNode;

2856 hipGraph_t graph;

2857 const hipGraphNode_t* pDependencies;

2858 size_t numDependencies;

2859 hipGraphNodeParams* nodeParams;

2860 } hipGraphAddNode;

2861 struct

2862 {

2863 hipGraphExec_t* pGraphExec;

2864 hipGraph_t graph;

2865 hipGraphInstantiateParams* instantiateParams;

2866 } hipGraphInstantiateWithParams;

2867 struct

2868 {

2869 // Empty struct has a size of 0 in C but size of 1 in C++.

2870 // Add the rocprofiler_hip_api_no_args struct to fix this

2871 rocprofiler_hip_api_no_args no_args;

2872 } hipExtGetLastError;

2873 struct

2874 {

2875 float* pBorderColor;

2876 const textureReference* texRef;

2877 } hipTexRefGetBorderColor;

2878 struct

2879 {

2880 hipArray_t* pArray;

2881 const textureReference* texRef;

2882 } hipTexRefGetArray;

2883#if HIP_RUNTIME_API_TABLE_STEP_VERSION >= 1

2884 struct

2885 {

2886 const char* symbol;

2887 void** pfn;

2888 int hipVersion;

2889 uint64_t flags;

2890 hipDriverProcAddressQueryResult* symbolStatus;

2891 } hipGetProcAddress;

2892#endif

2893#if HIP_RUNTIME_API_TABLE_STEP_VERSION >= 2

2894 struct

2895 {

2896 hipStream_t stream;

2897 hipGraph_t graph;

2898 const hipGraphNode_t* dependencies;

2899 const hipGraphEdgeData* dependencyData;

2900 size_t numDependencies;

2901 hipStreamCaptureMode mode;

2902 } hipStreamBeginCaptureToGraph;

2903#endif

2904#if HIP_RUNTIME_API_TABLE_STEP_VERSION >= 3

2905 struct

2906 {

2907 hipFunction_t* functionPtr;

2908 const void* symbolPtr;

2909 } hipGetFuncBySymbol;

2910 struct

2911 {

2912 int* device_arr;

2913 int len;

2914 } hipSetValidDevices;

2915 struct

2916 {

2917 hipDeviceptr_t dstDevice;

2918 hipArray_t srcArray;

2919 size_t srcOffset;

2920 size_t ByteCount;

2921 } hipMemcpyAtoD;

2922 struct

2923 {

2924 hipArray_t dstArray;

2925 size_t dstOffset;

2926 hipDeviceptr_t srcDevice;

2927 size_t ByteCount;

2928 } hipMemcpyDtoA;

2929 struct

2930 {

2931 hipArray_t dstArray;

2932 size_t dstOffset;

2933 hipArray_t srcArray;

2934 size_t srcOffset;

2935 size_t ByteCount;

2936 } hipMemcpyAtoA;

2937 struct

2938 {

2939 void* dstHost;

2940 hipArray_t srcArray;

2941 size_t srcOffset;

2942 size_t ByteCount;

2943 hipStream_t stream;

2944 } hipMemcpyAtoHAsync;

2945 struct

2946 {

2947 hipArray_t dstArray;

2948 size_t dstOffset;

2949 const void* srcHost;

2950 size_t ByteCount;

2951 hipStream_t stream;

2952 } hipMemcpyHtoAAsync;

2953 struct

2954 {

2955 hipArray_t dst;

2956 size_t wOffsetDst;

2957 size_t hOffsetDst;

2958 hipArray_const_t src;

2959 size_t wOffsetSrc;

2960 size_t hOffsetSrc;

2961 size_t width;

2962 size_t height;

2963 hipMemcpyKind kind;

2964 } hipMemcpy2DArrayToArray;

2965#endif

2966#if HIP_RUNTIME_API_TABLE_STEP_VERSION >= 4

2967 struct

2968 {

2969 hipGraphNode_t* phGraphNode;

2970 hipGraph_t hGraph;

2971 const hipGraphNode_t* dependencies;

2972 size_t numDependencies;

2973 hipDeviceptr_t dptr;

2974 } hipDrvGraphAddMemFreeNode;

2975 struct

2976 {

2977 hipGraphExec_t hGraphExec;

2978 hipGraphNode_t hNode;

2979 const HIP_MEMCPY3D* copyParams;

2980 hipCtx_t ctx;

2981 } hipDrvGraphExecMemcpyNodeSetParams;

2982 struct

2983 {

2984 hipGraphExec_t hGraphExec;

2985 hipGraphNode_t hNode;

2986# if HIP_RUNTIME_API_TABLE_STEP_VERSION < 13

2987 const HIP_MEMSET_NODE_PARAMS* memsetParams;

2988# endif

2989# if HIP_RUNTIME_API_TABLE_STEP_VERSION >= 13

2990 const hipMemsetParams* memsetParams;

2991# endif

2992 hipCtx_t ctx;

2993 } hipDrvGraphExecMemsetNodeSetParams;

2994 struct

2995 {

2996 hipGraphExec_t graphExec;

2997 unsigned long long* flags;

2998 } hipGraphExecGetFlags;

2999 struct

3000 {

3001 hipGraphNode_t node;

3002 hipGraphNodeParams* nodeParams;

3003 } hipGraphNodeSetParams;

3004 struct

3005 {

3006 hipGraphExec_t graphExec;

3007 hipGraphNode_t node;

3008 hipGraphNodeParams* nodeParams;

3009 } hipGraphExecNodeSetParams;

3010 struct

3011 {

3012 hipMipmappedArray_t* mipmap;

3013 hipExternalMemory_t extMem;

3014 const hipExternalMemoryMipmappedArrayDesc* mipmapDesc;

3015 } hipExternalMemoryGetMappedMipmappedArray;

3016 struct

3017 {

3018 hipGraphNode_t hNode;

3019 HIP_MEMCPY3D* nodeParams;

3020 } hipDrvGraphMemcpyNodeGetParams;

3021 struct

3022 {

3023 hipGraphNode_t hNode;

3024 const HIP_MEMCPY3D* nodeParams;

3025 } hipDrvGraphMemcpyNodeSetParams;

3026#endif

3027#if HIP_RUNTIME_API_TABLE_STEP_VERSION >= 5

3028 struct

3029 {

3030 void** ptr;

3031 size_t size;

3032 unsigned int flags;

3033 } hipExtHostAlloc;

3034#endif

3035#if HIP_RUNTIME_API_TABLE_STEP_VERSION >= 6

3036 struct

3037 {

3038 size_t* maxWidthInElements;

3039 const hipChannelFormatDesc* fmtDesc;

3040 int device;

3041 } hipDeviceGetTexture1DLinearMaxWidth;

3042#endif

3043#if HIP_RUNTIME_API_TABLE_STEP_VERSION >= 7

3044 struct

3045 {

3046 hipStream_t stream;

3047 unsigned int count;

3048 hipStreamBatchMemOpParams* paramArray;

3049 unsigned int flags;

3050 } hipStreamBatchMemOp;

3051#endif

3052#if HIP_RUNTIME_API_TABLE_STEP_VERSION >= 8

3053 struct

3054 {

3055 hipGraphNode_t* phGraphNode;

3056 hipGraph_t hGraph;

3057 const hipGraphNode_t* dependencies;

3058 size_t numDependencies;

3059 const hipBatchMemOpNodeParams* nodeParams;

3060 } hipGraphAddBatchMemOpNode;

3061 struct

3062 {

3063 hipGraphNode_t hNode;

3064 hipBatchMemOpNodeParams* nodeParams_out;

3065 } hipGraphBatchMemOpNodeGetParams;

3066 struct

3067 {

3068 hipGraphNode_t hNode;

3069 hipBatchMemOpNodeParams* nodeParams;

3070 } hipGraphBatchMemOpNodeSetParams;

3071 struct

3072 {

3073 hipGraphExec_t hGraphExec;

3074 hipGraphNode_t hNode;

3075 const hipBatchMemOpNodeParams* nodeParams;

3076 } hipGraphExecBatchMemOpNodeSetParams;

3077#endif

3078#if HIP_RUNTIME_API_TABLE_STEP_VERSION >= 9

3079 struct

3080 {

3081 hipLinkState_t state;

3082 hipJitInputType type;

3083 void* data;

3084 size_t size;

3085 const char* name;

3086 unsigned int numOptions;

3087 hipJitOption* options;

3088 void** optionValues;

3089 } hipLinkAddData;

3090 struct

3091 {

3092 hipLinkState_t state;

3093 hipJitInputType type;

3094 const char* path;

3095 unsigned int numOptions;

3096 hipJitOption* options;

3097 void** optionValues;

3098 } hipLinkAddFile;

3099 struct

3100 {

3101 hipLinkState_t state;

3102 void** hipBinOut;

3103 size_t* sizeOut;

3104 } hipLinkComplete;

3105 struct

3106 {

3107 unsigned int numOptions;

3108 hipJitOption* options;

3109 void** optionValues;

3110 hipLinkState_t* stateOut;

3111 } hipLinkCreate;

3112 struct

3113 {

3114 hipLinkState_t state;

3115 } hipLinkDestroy;

3116#endif

3117#if HIP_RUNTIME_API_TABLE_STEP_VERSION >= 10

3118 struct

3119 {

3120 hipEvent_t event;

3121 hipStream_t stream;

3122 unsigned int flags;

3123 } hipEventRecordWithFlags;

3124#endif

3125#if HIP_RUNTIME_API_TABLE_STEP_VERSION >= 11

3126 struct

3127 {

3128 const hipLaunchConfig_t* config;

3129 const void* fPtr;

3130 void** args;

3131 } hipLaunchKernelExC;

3132 struct

3133 {

3134 const HIP_LAUNCH_CONFIG* config;

3135 hipFunction_t f;

3136 void** params;

3137 void** extra;

3138 } hipDrvLaunchKernelEx;

3139#endif

3140#if HIP_RUNTIME_API_TABLE_STEP_VERSION >= 12

3141 struct

3142 {

3143 void* handle;

3144 hipDeviceptr_t dptr;

3145 size_t size;

3146 hipMemRangeHandleType handleType;

3147 unsigned long long flags;

3148 } hipMemGetHandleForAddressRange;

3149#endif

3150#if HIP_RUNTIME_API_TABLE_STEP_VERSION >= 14

3151 struct

3152 {

3153 unsigned int* count;

3154 hipModule_t mod;

3155 } hipModuleGetFunctionCount;

3156 struct

3157 {

3158 hipDeviceptr_t dst;

3159 size_t dstPitch;

3160 unsigned char value;

3161 size_t width;

3162 size_t height;

3163 } hipMemsetD2D8;

3164 struct

3165 {

3166 hipDeviceptr_t dst;

3167 size_t dstPitch;

3168 unsigned char value;

3169 size_t width;

3170 size_t height;

3171 hipStream_t stream;

3172 } hipMemsetD2D8Async;

3173 struct

3174 {

3175 hipDeviceptr_t dst;

3176 size_t dstPitch;

3177 unsigned short value;

3178 size_t width;

3179 size_t height;

3180 } hipMemsetD2D16;

3181 struct

3182 {

3183 hipDeviceptr_t dst;

3184 size_t dstPitch;

3185 unsigned short value;

3186 size_t width;

3187 size_t height;

3188 hipStream_t stream;

3189 } hipMemsetD2D16Async;

3190 struct

3191 {

3192 hipDeviceptr_t dst;

3193 size_t dstPitch;

3194 unsigned int value;

3195 size_t width;

3196 size_t height;

3197 } hipMemsetD2D32;

3198 struct

3199 {

3200 hipDeviceptr_t dst;

3201 size_t dstPitch;

3202 unsigned int value;

3203 size_t width;

3204 size_t height;

3205 hipStream_t stream;

3206 } hipMemsetD2D32Async;

3207 struct

3208 {

3209 hipStream_t stream;

3210 hipLaunchAttributeID attr;

3211 const hipLaunchAttributeValue* value_out;

3212 } hipStreamGetAttribute;

3213 struct

3214 {

3215 hipStream_t stream;

3216 hipLaunchAttributeID attr;

3217 const hipLaunchAttributeValue* value;

3218 } hipStreamSetAttribute;

3219 struct

3220 {

3221 hipModule_t* module;

3222 const void* fatbin;

3223 } hipModuleLoadFatBinary;

3224 struct

3225 {

3226 void** dsts;

3227 void** srcs;

3228 size_t* sizes;

3229 size_t count;

3230 hipMemcpyAttributes* attrs;

3231 size_t* attrsIdxs;

3232 size_t numAttrs;

3233 size_t* failIdx;

3234 hipStream_t stream;

3235 } hipMemcpyBatchAsync;

3236 struct

3237 {

3238 size_t numOps;

3239 hipMemcpy3DBatchOp* opList;

3240 size_t* failIdx;

3241 unsigned long long flags;

3242 hipStream_t stream;

3243 } hipMemcpy3DBatchAsync;

3244 struct

3245 {

3246 hipMemcpy3DPeerParms* p;

3247 } hipMemcpy3DPeer;

3248 struct

3249 {

3250 hipMemcpy3DPeerParms* p;

3251 hipStream_t stream;

3252 } hipMemcpy3DPeerAsync;

3253 struct

3254 {

3255 const char* symbol;

3256 void** funcPtr;

3257 unsigned long long flags;

3258 hipDriverEntryPointQueryResult* driverStatus;

3259 } hipGetDriverEntryPoint;

3260 struct

3261 {

3262 const char* symbol;

3263 void** funcPtr;

3264 unsigned long long flags;

3265 hipDriverEntryPointQueryResult* driverStatus;

3266 } hipGetDriverEntryPoint_spt;

3267 struct

3268 {

3269 const void* dev_ptr;

3270 size_t count;

3271 hipMemLocation location;

3272 unsigned int flags;

3273 hipStream_t stream;

3274 } hipMemPrefetchAsync_v2;

3275 struct

3276 {

3277 const void* dev_ptr;

3278 size_t count;

3279 hipMemoryAdvise advice;

3280 hipMemLocation location;

3281 } hipMemAdvise_v2;

3282 struct

3283 {

3284 hipStream_t stream;

3285 unsigned long long* streamId;

3286 } hipStreamGetId;

3287#endif

3288#if HIP_RUNTIME_API_TABLE_STEP_VERSION >= 15

3289 struct

3290 {

3291 hipLibrary_t* library;

3292 const void* code;

3293 hipJitOption* jitOptions;

3294 void** jitOptionsValues;

3295 unsigned int numJitOptions;

3296 hipLibraryOption* libraryOptions;

3297 void** libraryOptionValues;

3298 unsigned int numLibraryOptions;

3299 } hipLibraryLoadData;

3300 struct

3301 {

3302 hipLibrary_t* library;

3303 const char* fileName;

3304 hipJitOption* jitOptions;

3305 void** jitOptionsValues;

3306 unsigned int numJitOptions;

3307 hipLibraryOption* libraryOptions;

3308 void** libraryOptionValues;

3309 unsigned int numLibraryOptions;

3310 } hipLibraryLoadFromFile;

3311 struct

3312 {

3313 hipLibrary_t library;

3314 } hipLibraryUnload;

3315 struct

3316 {

3317 hipKernel_t* pKernel;

3318 hipLibrary_t library;

3319 const char* name;

3320 } hipLibraryGetKernel;

3321 struct

3322 {

3323 unsigned int* count;

3324 hipLibrary_t library;

3325 } hipLibraryGetKernelCount;

3326#endif

3327} rocprofiler_hip_api_args_t;

3328

3329ROCPROFILER_EXTERN_C_FINI

rocprofiler_dim3_t

Multi-dimensional struct of data used to describe GPU workgroup and grid sizes.

Definition fwd.h:702

---

Generated by  1.9.8