rocprofiler-sdk/hsa/api_args.h Source File

ROCprofiler-SDK developer API 1.0.0 ROCm Profiling API and tools

• rocprofiler-sdk
• hsa

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/ext_version.h>

27#include <rocprofiler-sdk/hsa/api_trace_version.h>

28

29#include <hsa/hsa.h>

30#include <hsa/hsa_ext_amd.h>

31#include <hsa/hsa_ext_finalize.h>

32#include <hsa/hsa_ext_image.h>

33

34ROCPROFILER_EXTERN_C_INIT

35

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

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

38// functions with no arguments to ensure ABI compatibility

39typedef struct rocprofiler_hsa_api_no_args

40{

41 char empty;

42} rocprofiler_hsa_api_no_args;

43

44typedef union rocprofiler_hsa_api_retval_t

45{

46 uint64_t uint64_t_retval;

47 uint32_t uint32_t_retval;

48 hsa_signal_value_t hsa_signal_value_t_retval;

49 hsa_status_t hsa_status_t_retval;

50} rocprofiler_hsa_api_retval_t;

51

52// the following hsa_* typedefs are only in hsa/hsa_api_trace.h but we cannot include that file here

53// because it is not C-compatible

54typedef hsa_status_t (*hsa_ext_program_iterate_modules_cb_t)(hsa_ext_program_t program,

55 hsa_ext_module_t module,

56 void* data);

57

58typedef void (*hsa_amd_queue_intercept_packet_writer)(const void* pkts, uint64_t pkt_count);

59

60typedef void (*hsa_amd_queue_intercept_handler)(const void* pkts,

61 uint64_t pkt_count,

62 uint64_t user_pkt_index,

63 void* data,

64 hsa_amd_queue_intercept_packet_writer writer);

65

66typedef void (*hsa_amd_runtime_queue_notifier)(const hsa_queue_t* queue,

67 hsa_agent_t agent,

68 void* data);

69

70typedef union rocprofiler_hsa_api_args_t

71{

72 // block: CoreApi API

73 struct

74 {

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

76 // Add the rocprofiler_hsa_api_no_args struct to fix this

77 rocprofiler_hsa_api_no_args no_args;

78 } hsa_init;

79 struct

80 {

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

82 // Add the rocprofiler_hsa_api_no_args struct to fix this

83 rocprofiler_hsa_api_no_args no_args;

84 } hsa_shut_down;

85 struct

86 {

87 hsa_system_info_t attribute;

88 void* value;

89 } hsa_system_get_info;

90 struct

91 {

92 uint16_t extension;

93 uint16_t version_major;

94 uint16_t version_minor;

95 bool* result;

96 } hsa_system_extension_supported;

97 struct

98 {

99 uint16_t extension;

100 uint16_t version_major;

101 uint16_t version_minor;

102 void* table;

103 } hsa_system_get_extension_table;

104 struct

105 {

106 hsa_status_t (*callback)(hsa_agent_t agent, void* data);

107 void* data;

108 } hsa_iterate_agents;

109 struct

110 {

111 hsa_agent_t agent;

112 hsa_agent_info_t attribute;

113 void* value;

114 } hsa_agent_get_info;

115 struct

116 {

117 hsa_agent_t agent;

118 uint32_t size;

119 hsa_queue_type32_t type;

120 void (*callback)(hsa_status_t status, hsa_queue_t* source, void* data);

121 void* data;

122 uint32_t private_segment_size;

123 uint32_t group_segment_size;

124 hsa_queue_t** queue;

125 } hsa_queue_create;

126 struct

127 {

128 hsa_region_t region;

129 uint32_t size;

130 hsa_queue_type32_t type;

131 uint32_t features;

132 hsa_signal_t doorbell_signal;

133 hsa_queue_t** queue;

134 } hsa_soft_queue_create;

135 struct

136 {

137 hsa_queue_t* queue;

138 } hsa_queue_destroy;

139 struct

140 {

141 hsa_queue_t* queue;

142 } hsa_queue_inactivate;

143 struct

144 {

145 const hsa_queue_t* queue;

146 } hsa_queue_load_read_index_scacquire;

147 struct

148 {

149 const hsa_queue_t* queue;

150 } hsa_queue_load_read_index_relaxed;

151 struct

152 {

153 const hsa_queue_t* queue;

154 } hsa_queue_load_write_index_scacquire;

155 struct

156 {

157 const hsa_queue_t* queue;

158 } hsa_queue_load_write_index_relaxed;

159 struct

160 {

161 const hsa_queue_t* queue;

162 uint64_t value;

163 } hsa_queue_store_write_index_relaxed;

164 struct

165 {

166 const hsa_queue_t* queue;

167 uint64_t value;

168 } hsa_queue_store_write_index_screlease;

169 struct

170 {

171 const hsa_queue_t* queue;

172 uint64_t expected;

173 uint64_t value;

174 } hsa_queue_cas_write_index_scacq_screl;

175 struct

176 {

177 const hsa_queue_t* queue;

178 uint64_t expected;

179 uint64_t value;

180 } hsa_queue_cas_write_index_scacquire;

181 struct

182 {

183 const hsa_queue_t* queue;

184 uint64_t expected;

185 uint64_t value;

186 } hsa_queue_cas_write_index_relaxed;

187 struct

188 {

189 const hsa_queue_t* queue;

190 uint64_t expected;

191 uint64_t value;

192 } hsa_queue_cas_write_index_screlease;

193 struct

194 {

195 const hsa_queue_t* queue;

196 uint64_t value;

197 } hsa_queue_add_write_index_scacq_screl;

198 struct

199 {

200 const hsa_queue_t* queue;

201 uint64_t value;

202 } hsa_queue_add_write_index_scacquire;

203 struct

204 {

205 const hsa_queue_t* queue;

206 uint64_t value;

207 } hsa_queue_add_write_index_relaxed;

208 struct

209 {

210 const hsa_queue_t* queue;

211 uint64_t value;

212 } hsa_queue_add_write_index_screlease;

213 struct

214 {

215 const hsa_queue_t* queue;

216 uint64_t value;

217 } hsa_queue_store_read_index_relaxed;

218 struct

219 {

220 const hsa_queue_t* queue;

221 uint64_t value;

222 } hsa_queue_store_read_index_screlease;

223 struct

224 {

225 hsa_agent_t agent;

226 hsa_status_t (*callback)(hsa_region_t region, void* data);

227 void* data;

228 } hsa_agent_iterate_regions;

229 struct

230 {

231 hsa_region_t region;

232 hsa_region_info_t attribute;

233 void* value;

234 } hsa_region_get_info;

235 struct

236 {

237 hsa_agent_t agent;

238 hsa_profile_t profile;

239 uint16_t* mask;

240 } hsa_agent_get_exception_policies;

241 struct

242 {

243 uint16_t extension;

244 hsa_agent_t agent;

245 uint16_t version_major;

246 uint16_t version_minor;

247 bool* result;

248 } hsa_agent_extension_supported;

249 struct

250 {

251 void* ptr;

252 size_t size;

253 } hsa_memory_register;

254 struct

255 {

256 void* ptr;

257 size_t size;

258 } hsa_memory_deregister;

259 struct

260 {

261 hsa_region_t region;

262 size_t size;

263 void** ptr;

264 } hsa_memory_allocate;

265 struct

266 {

267 void* ptr;

268 } hsa_memory_free;

269 struct

270 {

271 void* dst;

272 const void* src;

273 size_t size;

274 } hsa_memory_copy;

275 struct

276 {

277 void* ptr;

278 hsa_agent_t agent;

279 hsa_access_permission_t access;

280 } hsa_memory_assign_agent;

281 struct

282 {

283 hsa_signal_value_t initial_value;

284 uint32_t num_consumers;

285 const hsa_agent_t* consumers;

286 hsa_signal_t* signal;

287 } hsa_signal_create;

288 struct

289 {

290 hsa_signal_t signal;

291 } hsa_signal_destroy;

292 struct

293 {

294 hsa_signal_t signal;

295 } hsa_signal_load_relaxed;

296 struct

297 {

298 hsa_signal_t signal;

299 } hsa_signal_load_scacquire;

300 struct

301 {

302 hsa_signal_t signal;

303 hsa_signal_value_t value;

304 } hsa_signal_store_relaxed;

305 struct

306 {

307 hsa_signal_t signal;

308 hsa_signal_value_t value;

309 } hsa_signal_store_screlease;

310 struct

311 {

312 hsa_signal_t signal;

313 hsa_signal_condition_t condition;

314 hsa_signal_value_t compare_value;

315 uint64_t timeout_hint;

316 hsa_wait_state_t wait_state_hint;

317 } hsa_signal_wait_relaxed;

318 struct

319 {

320 hsa_signal_t signal;

321 hsa_signal_condition_t condition;

322 hsa_signal_value_t compare_value;

323 uint64_t timeout_hint;

324 hsa_wait_state_t wait_state_hint;

325 } hsa_signal_wait_scacquire;

326 struct

327 {

328 hsa_signal_t signal;

329 hsa_signal_value_t value;

330 } hsa_signal_and_relaxed;

331 struct

332 {

333 hsa_signal_t signal;

334 hsa_signal_value_t value;

335 } hsa_signal_and_scacquire;

336 struct

337 {

338 hsa_signal_t signal;

339 hsa_signal_value_t value;

340 } hsa_signal_and_screlease;

341 struct

342 {

343 hsa_signal_t signal;

344 hsa_signal_value_t value;

345 } hsa_signal_and_scacq_screl;

346 struct

347 {

348 hsa_signal_t signal;

349 hsa_signal_value_t value;

350 } hsa_signal_or_relaxed;

351 struct

352 {

353 hsa_signal_t signal;

354 hsa_signal_value_t value;

355 } hsa_signal_or_scacquire;

356 struct

357 {

358 hsa_signal_t signal;

359 hsa_signal_value_t value;

360 } hsa_signal_or_screlease;

361 struct

362 {

363 hsa_signal_t signal;

364 hsa_signal_value_t value;

365 } hsa_signal_or_scacq_screl;

366 struct

367 {

368 hsa_signal_t signal;

369 hsa_signal_value_t value;

370 } hsa_signal_xor_relaxed;

371 struct

372 {

373 hsa_signal_t signal;

374 hsa_signal_value_t value;

375 } hsa_signal_xor_scacquire;

376 struct

377 {

378 hsa_signal_t signal;

379 hsa_signal_value_t value;

380 } hsa_signal_xor_screlease;

381 struct

382 {

383 hsa_signal_t signal;

384 hsa_signal_value_t value;

385 } hsa_signal_xor_scacq_screl;

386 struct

387 {

388 hsa_signal_t signal;

389 hsa_signal_value_t value;

390 } hsa_signal_exchange_relaxed;

391 struct

392 {

393 hsa_signal_t signal;

394 hsa_signal_value_t value;

395 } hsa_signal_exchange_scacquire;

396 struct

397 {

398 hsa_signal_t signal;

399 hsa_signal_value_t value;

400 } hsa_signal_exchange_screlease;

401 struct

402 {

403 hsa_signal_t signal;

404 hsa_signal_value_t value;

405 } hsa_signal_exchange_scacq_screl;

406 struct

407 {

408 hsa_signal_t signal;

409 hsa_signal_value_t value;

410 } hsa_signal_add_relaxed;

411 struct

412 {

413 hsa_signal_t signal;

414 hsa_signal_value_t value;

415 } hsa_signal_add_scacquire;

416 struct

417 {

418 hsa_signal_t signal;

419 hsa_signal_value_t value;

420 } hsa_signal_add_screlease;

421 struct

422 {

423 hsa_signal_t signal;

424 hsa_signal_value_t value;

425 } hsa_signal_add_scacq_screl;

426 struct

427 {

428 hsa_signal_t signal;

429 hsa_signal_value_t value;

430 } hsa_signal_subtract_relaxed;

431 struct

432 {

433 hsa_signal_t signal;

434 hsa_signal_value_t value;

435 } hsa_signal_subtract_scacquire;

436 struct

437 {

438 hsa_signal_t signal;

439 hsa_signal_value_t value;

440 } hsa_signal_subtract_screlease;

441 struct

442 {

443 hsa_signal_t signal;

444 hsa_signal_value_t value;

445 } hsa_signal_subtract_scacq_screl;

446 struct

447 {

448 hsa_signal_t signal;

449 hsa_signal_value_t expected;

450 hsa_signal_value_t value;

451 } hsa_signal_cas_relaxed;

452 struct

453 {

454 hsa_signal_t signal;

455 hsa_signal_value_t expected;

456 hsa_signal_value_t value;

457 } hsa_signal_cas_scacquire;

458 struct

459 {

460 hsa_signal_t signal;

461 hsa_signal_value_t expected;

462 hsa_signal_value_t value;

463 } hsa_signal_cas_screlease;

464 struct

465 {

466 hsa_signal_t signal;

467 hsa_signal_value_t expected;

468 hsa_signal_value_t value;

469 } hsa_signal_cas_scacq_screl;

470 struct

471 {

472 const char* name;

473 hsa_isa_t* isa;

474 } hsa_isa_from_name;

475 struct

476 {

477 hsa_isa_t isa;

478 hsa_isa_info_t attribute;

479 uint32_t index;

480 void* value;

481 } hsa_isa_get_info;

482 struct

483 {

484 hsa_isa_t code_object_isa;

485 hsa_isa_t agent_isa;

486 bool* result;

487 } hsa_isa_compatible;

488 struct

489 {

490 hsa_code_object_t code_object;

491 hsa_status_t (*alloc_callback)(size_t size, hsa_callback_data_t data, void** address);

492 hsa_callback_data_t callback_data;

493 const char* options;

494 void** serialized_code_object;

495 size_t* serialized_code_object_size;

496 } hsa_code_object_serialize;

497 struct

498 {

499 void* serialized_code_object;

500 size_t serialized_code_object_size;

501 const char* options;

502 hsa_code_object_t* code_object;

503 } hsa_code_object_deserialize;

504 struct

505 {

506 hsa_code_object_t code_object;

507 } hsa_code_object_destroy;

508 struct

509 {

510 hsa_code_object_t code_object;

511 hsa_code_object_info_t attribute;

512 void* value;

513 } hsa_code_object_get_info;

514 struct

515 {

516 hsa_code_object_t code_object;

517 const char* symbol_name;

518 hsa_code_symbol_t* symbol;

519 } hsa_code_object_get_symbol;

520 struct

521 {

522 hsa_code_symbol_t code_symbol;

523 hsa_code_symbol_info_t attribute;

524 void* value;

525 } hsa_code_symbol_get_info;

526 struct

527 {

528 hsa_code_object_t code_object;

529 hsa_status_t (*callback)(hsa_code_object_t code_object,

530 hsa_code_symbol_t symbol,

531 void* data);

532 void* data;

533 } hsa_code_object_iterate_symbols;

534 struct

535 {

536 hsa_profile_t profile;

537 hsa_executable_state_t executable_state;

538 const char* options;

539 hsa_executable_t* executable;

540 } hsa_executable_create;

541 struct

542 {

543 hsa_executable_t executable;

544 } hsa_executable_destroy;

545 struct

546 {

547 hsa_executable_t executable;

548 hsa_agent_t agent;

549 hsa_code_object_t code_object;

550 const char* options;

551 } hsa_executable_load_code_object;

552 struct

553 {

554 hsa_executable_t executable;

555 const char* options;

556 } hsa_executable_freeze;

557 struct

558 {

559 hsa_executable_t executable;

560 hsa_executable_info_t attribute;

561 void* value;

562 } hsa_executable_get_info;

563 struct

564 {

565 hsa_executable_t executable;

566 const char* variable_name;

567 void* address;

568 } hsa_executable_global_variable_define;

569 struct

570 {

571 hsa_executable_t executable;

572 hsa_agent_t agent;

573 const char* variable_name;

574 void* address;

575 } hsa_executable_agent_global_variable_define;

576 struct

577 {

578 hsa_executable_t executable;

579 hsa_agent_t agent;

580 const char* variable_name;

581 void* address;

582 } hsa_executable_readonly_variable_define;

583 struct

584 {

585 hsa_executable_t executable;

586 uint32_t* result;

587 } hsa_executable_validate;

588 struct

589 {

590 hsa_executable_t executable;

591 const char* module_name;

592 const char* symbol_name;

593 hsa_agent_t agent;

594 int32_t call_convention;

595 hsa_executable_symbol_t* symbol;

596 } hsa_executable_get_symbol;

597 struct

598 {

599 hsa_executable_symbol_t executable_symbol;

600 hsa_executable_symbol_info_t attribute;

601 void* value;

602 } hsa_executable_symbol_get_info;

603 struct

604 {

605 hsa_executable_t executable;

606 hsa_status_t (*callback)(hsa_executable_t exec, hsa_executable_symbol_t symbol, void* data);

607 void* data;

608 } hsa_executable_iterate_symbols;

609 struct

610 {

611 hsa_status_t status;

612 const char** status_string;

613 } hsa_status_string;

614 struct

615 {

616 uint16_t extension;

617 const char** name;

618 } hsa_extension_get_name;

619 struct

620 {

621 uint16_t extension;

622 uint16_t version_major;

623 uint16_t* version_minor;

624 bool* result;

625 } hsa_system_major_extension_supported;

626 struct

627 {

628 uint16_t extension;

629 uint16_t version_major;

630 size_t table_length;

631 void* table;

632 } hsa_system_get_major_extension_table;

633 struct

634 {

635 uint16_t extension;

636 hsa_agent_t agent;

637 uint16_t version_major;

638 uint16_t* version_minor;

639 bool* result;

640 } hsa_agent_major_extension_supported;

641 struct

642 {

643 hsa_cache_t cache;

644 hsa_cache_info_t attribute;

645 void* value;

646 } hsa_cache_get_info;

647 struct

648 {

649 hsa_agent_t agent;

650 hsa_status_t (*callback)(hsa_cache_t cache, void* data);

651 void* data;

652 } hsa_agent_iterate_caches;

653 struct

654 {

655 hsa_signal_t signal;

656 hsa_signal_value_t value;

657 } hsa_signal_silent_store_relaxed;

658 struct

659 {

660 hsa_signal_t signal;

661 hsa_signal_value_t value;

662 } hsa_signal_silent_store_screlease;

663 struct

664 {

665 uint32_t num_signals;

666 const hsa_signal_t* signals;

667 uint32_t num_consumers;

668 const hsa_agent_t* consumers;

669 hsa_signal_group_t* signal_group;

670 } hsa_signal_group_create;

671 struct

672 {

673 hsa_signal_group_t signal_group;

674 } hsa_signal_group_destroy;

675 struct

676 {

677 hsa_signal_group_t signal_group;

678 const hsa_signal_condition_t* conditions;

679 const hsa_signal_value_t* compare_values;

680 hsa_wait_state_t wait_state_hint;

681 hsa_signal_t* signal;

682 hsa_signal_value_t* value;

683 } hsa_signal_group_wait_any_scacquire;

684 struct

685 {

686 hsa_signal_group_t signal_group;

687 const hsa_signal_condition_t* conditions;

688 const hsa_signal_value_t* compare_values;

689 hsa_wait_state_t wait_state_hint;

690 hsa_signal_t* signal;

691 hsa_signal_value_t* value;

692 } hsa_signal_group_wait_any_relaxed;

693 struct

694 {

695 hsa_agent_t agent;

696 hsa_status_t (*callback)(hsa_isa_t isa, void* data);

697 void* data;

698 } hsa_agent_iterate_isas;

699 struct

700 {

701 hsa_isa_t isa;

702 hsa_isa_info_t attribute;

703 void* value;

704 } hsa_isa_get_info_alt;

705 struct

706 {

707 hsa_isa_t isa;

708 hsa_profile_t profile;

709 uint16_t* mask;

710 } hsa_isa_get_exception_policies;

711 struct

712 {

713 hsa_isa_t isa;

714 hsa_fp_type_t fp_type;

715 hsa_flush_mode_t flush_mode;

716 hsa_round_method_t* round_method;

717 } hsa_isa_get_round_method;

718 struct

719 {

720 hsa_wavefront_t wavefront;

721 hsa_wavefront_info_t attribute;

722 void* value;

723 } hsa_wavefront_get_info;

724 struct

725 {

726 hsa_isa_t isa;

727 hsa_status_t (*callback)(hsa_wavefront_t wavefront, void* data);

728 void* data;

729 } hsa_isa_iterate_wavefronts;

730 struct

731 {

732 hsa_code_object_t code_object;

733 const char* module_name;

734 const char* symbol_name;

735 hsa_code_symbol_t* symbol;

736 } hsa_code_object_get_symbol_from_name;

737 struct

738 {

739 hsa_file_t file;

740 hsa_code_object_reader_t* code_object_reader;

741 } hsa_code_object_reader_create_from_file;

742 struct

743 {

744 const void* code_object;

745 size_t size;

746 hsa_code_object_reader_t* code_object_reader;

747 } hsa_code_object_reader_create_from_memory;

748 struct

749 {

750 hsa_code_object_reader_t code_object_reader;

751 } hsa_code_object_reader_destroy;

752 struct

753 {

754 hsa_profile_t profile;

755 hsa_default_float_rounding_mode_t default_float_rounding_mode;

756 const char* options;

757 hsa_executable_t* executable;

758 } hsa_executable_create_alt;

759 struct

760 {

761 hsa_executable_t executable;

762 hsa_code_object_reader_t code_object_reader;

763 const char* options;

764 hsa_loaded_code_object_t* loaded_code_object;

765 } hsa_executable_load_program_code_object;

766 struct

767 {

768 hsa_executable_t executable;

769 hsa_agent_t agent;

770 hsa_code_object_reader_t code_object_reader;

771 const char* options;

772 hsa_loaded_code_object_t* loaded_code_object;

773 } hsa_executable_load_agent_code_object;

774 struct

775 {

776 hsa_executable_t executable;

777 const char* options;

778 uint32_t* result;

779 } hsa_executable_validate_alt;

780 struct

781 {

782 hsa_executable_t executable;

783 const char* symbol_name;

784 const hsa_agent_t* agent;

785 hsa_executable_symbol_t* symbol;

786 } hsa_executable_get_symbol_by_name;

787 struct

788 {

789 hsa_executable_t executable;

790 hsa_agent_t agent;

791 hsa_status_t (*callback)(hsa_executable_t exec,

792 hsa_agent_t agent,

793 hsa_executable_symbol_t symbol,

794 void* data);

795 void* data;

796 } hsa_executable_iterate_agent_symbols;

797 struct

798 {

799 hsa_executable_t executable;

800 hsa_status_t (*callback)(hsa_executable_t exec, hsa_executable_symbol_t symbol, void* data);

801 void* data;

802 } hsa_executable_iterate_program_symbols;

803

804 // block: AmdExt API

805 struct

806 {

807 hsa_agent_t agent;

808 hsa_amd_coherency_type_t* type;

809 } hsa_amd_coherency_get_type;

810 struct

811 {

812 hsa_agent_t agent;

813 hsa_amd_coherency_type_t type;

814 } hsa_amd_coherency_set_type;

815 struct

816 {

817 hsa_queue_t* queue;

818 int enable;

819 } hsa_amd_profiling_set_profiler_enabled;

820 struct

821 {

822 bool enable;

823 } hsa_amd_profiling_async_copy_enable;

824 struct

825 {

826 hsa_agent_t agent;

827 hsa_signal_t signal;

828 hsa_amd_profiling_dispatch_time_t* time;

829 } hsa_amd_profiling_get_dispatch_time;

830 struct

831 {

832 hsa_signal_t signal;

833 hsa_amd_profiling_async_copy_time_t* time;

834 } hsa_amd_profiling_get_async_copy_time;

835 struct

836 {

837 hsa_agent_t agent;

838 uint64_t agent_tick;

839 uint64_t* system_tick;

840 } hsa_amd_profiling_convert_tick_to_system_domain;

841 struct

842 {

843 hsa_signal_t signal;

844 hsa_signal_condition_t cond;

845 hsa_signal_value_t value;

846 hsa_amd_signal_handler handler;

847 void* arg;

848 } hsa_amd_signal_async_handler;

849 struct

850 {

851 void (*callback)(void* arg);

852 void* arg;

853 } hsa_amd_async_function;

854 struct

855 {

856 uint32_t signal_count;

857 hsa_signal_t* signals;

858 hsa_signal_condition_t* conds;

859 hsa_signal_value_t* values;

860 uint64_t timeout_hint;

861 hsa_wait_state_t wait_hint;

862 hsa_signal_value_t* satisfying_value;

863 } hsa_amd_signal_wait_any;

864 struct

865 {

866 const hsa_queue_t* queue;

867 uint32_t num_cu_mask_count;

868 const uint32_t* cu_mask;

869 } hsa_amd_queue_cu_set_mask;

870 struct

871 {

872 hsa_amd_memory_pool_t memory_pool;

873 hsa_amd_memory_pool_info_t attribute;

874 void* value;

875 } hsa_amd_memory_pool_get_info;

876 struct

877 {

878 hsa_agent_t agent;

879 hsa_status_t (*callback)(hsa_amd_memory_pool_t memory_pool, void* data);

880 void* data;

881 } hsa_amd_agent_iterate_memory_pools;

882 struct

883 {

884 hsa_amd_memory_pool_t memory_pool;

885 size_t size;

886 uint32_t flags;

887 void** ptr;

888 } hsa_amd_memory_pool_allocate;

889 struct

890 {

891 void* ptr;

892 } hsa_amd_memory_pool_free;

893 struct

894 {

895 void* dst;

896 hsa_agent_t dst_agent;

897 const void* src;

898 hsa_agent_t src_agent;

899 size_t size;

900 uint32_t num_dep_signals;

901 const hsa_signal_t* dep_signals;

902 hsa_signal_t completion_signal;

903 } hsa_amd_memory_async_copy;

904 struct

905 {

906 void* dst;

907 hsa_agent_t dst_agent;

908 const void* src;

909 hsa_agent_t src_agent;

910 size_t size;

911 uint32_t num_dep_signals;

912 const hsa_signal_t* dep_signals;

913 hsa_signal_t completion_signal;

914 hsa_amd_sdma_engine_id_t engine_id;

915 bool force_copy_on_sdma;

916 } hsa_amd_memory_async_copy_on_engine;

917 struct

918 {

919 hsa_agent_t dst_agent;

920 hsa_agent_t src_agent;

921 uint32_t* engine_ids_mask;

922 } hsa_amd_memory_copy_engine_status;

923 struct

924 {

925 hsa_agent_t agent;

926 hsa_amd_memory_pool_t memory_pool;

927 hsa_amd_agent_memory_pool_info_t attribute;

928 void* value;

929 } hsa_amd_agent_memory_pool_get_info;

930 struct

931 {

932 uint32_t num_agents;

933 const hsa_agent_t* agents;

934 const uint32_t* flags;

935 const void* ptr;

936 } hsa_amd_agents_allow_access;

937 struct

938 {

939 hsa_amd_memory_pool_t src_memory_pool;

940 hsa_amd_memory_pool_t dst_memory_pool;

941 bool* result;

942 } hsa_amd_memory_pool_can_migrate;

943 struct

944 {

945 const void* ptr;

946 hsa_amd_memory_pool_t memory_pool;

947 uint32_t flags;

948 } hsa_amd_memory_migrate;

949 struct

950 {

951 void* host_ptr;

952 size_t size;

953 hsa_agent_t* agents;

954 int num_agent;

955 void** agent_ptr;

956 } hsa_amd_memory_lock;

957 struct

958 {

959 void* host_ptr;

960 } hsa_amd_memory_unlock;

961 struct

962 {

963 void* ptr;

964 uint32_t value;

965 size_t count;

966 } hsa_amd_memory_fill;

967 struct

968 {

969 uint32_t num_agents;

970 hsa_agent_t* agents;

971 int interop_handle;

972 uint32_t flags;

973 size_t* size;

974 void** ptr;

975 size_t* metadata_size;

976 const void** metadata;

977 } hsa_amd_interop_map_buffer;

978 struct

979 {

980 void* ptr;

981 } hsa_amd_interop_unmap_buffer;

982 struct

983 {

984 hsa_agent_t agent;

985 const hsa_ext_image_descriptor_t* image_descriptor;

986 const hsa_amd_image_descriptor_t* image_layout;

987 const void* image_data;

988 hsa_access_permission_t access_permission;

989 hsa_ext_image_t* image;

990 } hsa_amd_image_create;

991 struct

992 {

993 const void* ptr;

994 hsa_amd_pointer_info_t* info;

995 void* (*alloc)(size_t);

996 uint32_t* num_agents_accessible;

997 hsa_agent_t** accessible;

998 } hsa_amd_pointer_info;

999 struct

1000 {

1001 const void* ptr;

1002 void* userdata;

1003 } hsa_amd_pointer_info_set_userdata;

1004 struct

1005 {

1006 void* ptr;

1007 size_t len;

1008 hsa_amd_ipc_memory_t* handle;

1009 } hsa_amd_ipc_memory_create;

1010 struct

1011 {

1012 const hsa_amd_ipc_memory_t* handle;

1013 size_t len;

1014 uint32_t num_agents;

1015 const hsa_agent_t* mapping_agents;

1016 void** mapped_ptr;

1017 } hsa_amd_ipc_memory_attach;

1018 struct

1019 {

1020 void* mapped_ptr;

1021 } hsa_amd_ipc_memory_detach;

1022 struct

1023 {

1024 hsa_signal_value_t initial_value;

1025 uint32_t num_consumers;

1026 const hsa_agent_t* consumers;

1027 uint64_t attributes;

1028 hsa_signal_t* signal;

1029 } hsa_amd_signal_create;

1030 struct

1031 {

1032 hsa_signal_t signal;

1033 hsa_amd_ipc_signal_t* handle;

1034 } hsa_amd_ipc_signal_create;

1035 struct

1036 {

1037 const hsa_amd_ipc_signal_t* handle;

1038 hsa_signal_t* signal;

1039 } hsa_amd_ipc_signal_attach;

1040 struct

1041 {

1042 hsa_amd_system_event_callback_t callback;

1043 void* data;

1044 } hsa_amd_register_system_event_handler;

1045 struct

1046 {

1047 hsa_agent_t agent_handle;

1048 uint32_t size;

1049 hsa_queue_type32_t type;

1050 void (*callback)(hsa_status_t status, hsa_queue_t* source, void* data);

1051 void* data;

1052 uint32_t private_segment_size;

1053 uint32_t group_segment_size;

1054 hsa_queue_t** queue;

1055 } hsa_amd_queue_intercept_create;

1056 struct

1057 {

1058 hsa_queue_t* queue;

1059 hsa_amd_queue_intercept_handler callback;

1060 void* user_data;

1061 } hsa_amd_queue_intercept_register;

1062 struct

1063 {

1064 hsa_queue_t* queue;

1065 hsa_amd_queue_priority_t priority;

1066 } hsa_amd_queue_set_priority;

1067 struct

1068 {

1069 const hsa_pitched_ptr_t* dst;

1070 const hsa_dim3_t* dst_offset;

1071 const hsa_pitched_ptr_t* src;

1072 const hsa_dim3_t* src_offset;

1073 const hsa_dim3_t* range;

1074 hsa_agent_t copy_agent;

1075 hsa_amd_copy_direction_t dir;

1076 uint32_t num_dep_signals;

1077 const hsa_signal_t* dep_signals;

1078 hsa_signal_t completion_signal;

1079 } hsa_amd_memory_async_copy_rect;

1080 struct

1081 {

1082 hsa_amd_runtime_queue_notifier callback;

1083 void* user_data;

1084 } hsa_amd_runtime_queue_create_register;

1085 struct

1086 {

1087 void* host_ptr;

1088 size_t size;

1089 hsa_agent_t* agents;

1090 int num_agent;

1091 hsa_amd_memory_pool_t pool;

1092 uint32_t flags;

1093 void** agent_ptr;

1094 } hsa_amd_memory_lock_to_pool;

1095 struct

1096 {

1097 void* ptr;

1098 hsa_amd_deallocation_callback_t callback;

1099 void* user_data;

1100 } hsa_amd_register_deallocation_callback;

1101 struct

1102 {

1103 void* ptr;

1104 hsa_amd_deallocation_callback_t callback;

1105 } hsa_amd_deregister_deallocation_callback;

1106 struct

1107 {

1108 hsa_signal_t signal;

1109 volatile hsa_signal_value_t** value_ptr;

1110 } hsa_amd_signal_value_pointer;

1111 struct

1112 {

1113 void* ptr;

1114 size_t size;

1115 hsa_amd_svm_attribute_pair_t* attribute_list;

1116 size_t attribute_count;

1117 } hsa_amd_svm_attributes_set;

1118 struct

1119 {

1120 void* ptr;

1121 size_t size;

1122 hsa_amd_svm_attribute_pair_t* attribute_list;

1123 size_t attribute_count;

1124 } hsa_amd_svm_attributes_get;

1125 struct

1126 {

1127 void* ptr;

1128 size_t size;

1129 hsa_agent_t agent;

1130 uint32_t num_dep_signals;

1131 const hsa_signal_t* dep_signals;

1132 hsa_signal_t completion_signal;

1133 } hsa_amd_svm_prefetch_async;

1134 struct

1135 {

1136 hsa_agent_t preferred_agent;

1137 } hsa_amd_spm_acquire;

1138 struct

1139 {

1140 hsa_agent_t preferred_agent;

1141 } hsa_amd_spm_release;

1142 struct

1143 {

1144 hsa_agent_t preferred_agent;

1145 size_t size_in_bytes;

1146 uint32_t* timeout;

1147 uint32_t* size_copied;

1148 void* dest;

1149 bool* is_data_loss;

1150 } hsa_amd_spm_set_dest_buffer;

1151 struct

1152 {

1153 const hsa_queue_t* queue;

1154 uint32_t num_cu_mask_count;

1155 uint32_t* cu_mask;

1156 } hsa_amd_queue_cu_get_mask;

1157 struct

1158 {

1159 const void* ptr;

1160 size_t size;

1161 int* dmabuf;

1162 uint64_t* offset;

1163 } hsa_amd_portable_export_dmabuf;

1164 struct

1165 {

1166 int dmabuf;

1167 } hsa_amd_portable_close_dmabuf;

1168

1169 // block: ImageExt API

1170 struct

1171 {

1172 hsa_agent_t agent;

1173 hsa_ext_image_geometry_t geometry;

1174 const hsa_ext_image_format_t* image_format;

1175 uint32_t* capability_mask;

1176 } hsa_ext_image_get_capability;

1177 struct

1178 {

1179 hsa_agent_t agent;

1180 const hsa_ext_image_descriptor_t* image_descriptor;

1181 hsa_access_permission_t access_permission;

1182 hsa_ext_image_data_info_t* image_data_info;

1183 } hsa_ext_image_data_get_info;

1184 struct

1185 {

1186 hsa_agent_t agent;

1187 const hsa_ext_image_descriptor_t* image_descriptor;

1188 const void* image_data;

1189 hsa_access_permission_t access_permission;

1190 hsa_ext_image_t* image;

1191 } hsa_ext_image_create;

1192 struct

1193 {

1194 hsa_agent_t agent;

1195 const void* src_memory;

1196 size_t src_row_pitch;

1197 size_t src_slice_pitch;

1198 hsa_ext_image_t dst_image;

1199 const hsa_ext_image_region_t* image_region;

1200 } hsa_ext_image_import;

1201 struct

1202 {

1203 hsa_agent_t agent;

1204 hsa_ext_image_t src_image;

1205 void* dst_memory;

1206 size_t dst_row_pitch;

1207 size_t dst_slice_pitch;

1208 const hsa_ext_image_region_t* image_region;

1209 } hsa_ext_image_export;

1210 struct

1211 {

1212 hsa_agent_t agent;

1213 hsa_ext_image_t src_image;

1214 const hsa_dim3_t* src_offset;

1215 hsa_ext_image_t dst_image;

1216 const hsa_dim3_t* dst_offset;

1217 const hsa_dim3_t* range;

1218 } hsa_ext_image_copy;

1219 struct

1220 {

1221 hsa_agent_t agent;

1222 hsa_ext_image_t image;

1223 const void* data;

1224 const hsa_ext_image_region_t* image_region;

1225 } hsa_ext_image_clear;

1226 struct

1227 {

1228 hsa_agent_t agent;

1229 hsa_ext_image_t image;

1230 } hsa_ext_image_destroy;

1231 struct

1232 {

1233 hsa_agent_t agent;

1234 const hsa_ext_sampler_descriptor_t* sampler_descriptor;

1235 hsa_ext_sampler_t* sampler;

1236 } hsa_ext_sampler_create;

1237 struct

1238 {

1239 hsa_agent_t agent;

1240 hsa_ext_sampler_t sampler;

1241 } hsa_ext_sampler_destroy;

1242 struct

1243 {

1244 hsa_agent_t agent;

1245 hsa_ext_image_geometry_t geometry;

1246 const hsa_ext_image_format_t* image_format;

1247 hsa_ext_image_data_layout_t image_data_layout;

1248 uint32_t* capability_mask;

1249 } hsa_ext_image_get_capability_with_layout;

1250 struct

1251 {

1252 hsa_agent_t agent;

1253 const hsa_ext_image_descriptor_t* image_descriptor;

1254 hsa_access_permission_t access_permission;

1255 hsa_ext_image_data_layout_t image_data_layout;

1256 size_t image_data_row_pitch;

1257 size_t image_data_slice_pitch;

1258 hsa_ext_image_data_info_t* image_data_info;

1259 } hsa_ext_image_data_get_info_with_layout;

1260 struct

1261 {

1262 hsa_agent_t agent;

1263 const hsa_ext_image_descriptor_t* image_descriptor;

1264 const void* image_data;

1265 hsa_access_permission_t access_permission;

1266 hsa_ext_image_data_layout_t image_data_layout;

1267 size_t image_data_row_pitch;

1268 size_t image_data_slice_pitch;

1269 hsa_ext_image_t* image;

1270 } hsa_ext_image_create_with_layout;

1271 // finalize ext

1272 struct

1273 {

1274 hsa_machine_model_t machine_model;

1275 hsa_profile_t profile;

1276 hsa_default_float_rounding_mode_t default_float_rounding_mode;

1277 const char* options;

1278 hsa_ext_program_t* program;

1279 } hsa_ext_program_create;

1280 struct

1281 {

1282 hsa_ext_program_t program;

1283 } hsa_ext_program_destroy;

1284 struct

1285 {

1286 hsa_ext_program_t program;

1287 hsa_ext_module_t module;

1288 } hsa_ext_program_add_module;

1289 struct

1290 {

1291 hsa_ext_program_t program;

1292 hsa_ext_program_iterate_modules_cb_t callback;

1293 void* data;

1294 } hsa_ext_program_iterate_modules;

1295 struct

1296 {

1297 hsa_ext_program_t program;

1298 hsa_ext_program_info_t attribute;

1299 void* value;

1300 } hsa_ext_program_get_info;

1301 struct

1302 {

1303 hsa_ext_program_t program;

1304 hsa_isa_t isa;

1305 int32_t call_convention;

1306 hsa_ext_control_directives_t control_directives;

1307 const char* options;

1308 hsa_code_object_type_t code_object_type;

1309 hsa_code_object_t* code_object;

1310 } hsa_ext_program_finalize;

1311 //

1312#if HSA_AMD_EXT_API_TABLE_MAJOR_VERSION >= 0x02

1313 struct

1314 {

1315 void** ptr;

1316 size_t size;

1317 uint64_t address;

1318 uint64_t flags;

1319 } hsa_amd_vmem_address_reserve;

1320 struct

1321 {

1322 void* ptr;

1323 size_t size;

1324 } hsa_amd_vmem_address_free;

1325 struct

1326 {

1327 hsa_amd_memory_pool_t pool;

1328 size_t size;

1329 hsa_amd_memory_type_t type;

1330 uint64_t flags;

1331 hsa_amd_vmem_alloc_handle_t* memory_handle;

1332 } hsa_amd_vmem_handle_create;

1333 struct

1334 {

1335 hsa_amd_vmem_alloc_handle_t memory_handle;

1336 } hsa_amd_vmem_handle_release;

1337 struct

1338 {

1339 void* va;

1340 size_t size;

1341 size_t in_offset;

1342 hsa_amd_vmem_alloc_handle_t memory_handle;

1343 uint64_t flags;

1344 } hsa_amd_vmem_map;

1345 struct

1346 {

1347 void* va;

1348 size_t size;

1349 } hsa_amd_vmem_unmap;

1350 struct

1351 {

1352 void* va;

1353 size_t size;

1354 const hsa_amd_memory_access_desc_t* desc;

1355 size_t desc_cnt;

1356 } hsa_amd_vmem_set_access;

1357 struct

1358 {

1359 void* va;

1360 hsa_access_permission_t* perms;

1361 hsa_agent_t agent_handle;

1362 } hsa_amd_vmem_get_access;

1363 struct

1364 {

1365 int* dmabuf_fd;

1366 hsa_amd_vmem_alloc_handle_t handle;

1367 uint64_t flags;

1368 } hsa_amd_vmem_export_shareable_handle;

1369 struct

1370 {

1371 int dmabuf_fd;

1372 hsa_amd_vmem_alloc_handle_t* handle;

1373 } hsa_amd_vmem_import_shareable_handle;

1374 struct

1375 {

1376 hsa_amd_vmem_alloc_handle_t* handle;

1377 void* addr;

1378 } hsa_amd_vmem_retain_alloc_handle;

1379 struct

1380 {

1381 hsa_amd_vmem_alloc_handle_t alloc_handle;

1382 hsa_amd_memory_pool_t* pool;

1383 hsa_amd_memory_type_t* type;

1384 } hsa_amd_vmem_get_alloc_properties_from_handle;

1385# if HSA_AMD_EXT_API_TABLE_STEP_VERSION >= 0x01

1386 struct

1387 {

1388 hsa_agent_t agent;

1389 size_t threshold;

1390 } hsa_amd_agent_set_async_scratch_limit;

1391# endif

1392# if HSA_AMD_EXT_API_TABLE_STEP_VERSION >= 0x02

1393 struct

1394 {

1395 hsa_queue_t* queue;

1396 hsa_queue_info_attribute_t attribute;

1397 void* value;

1398 } hsa_amd_queue_get_info;

1399# endif

1400# if HSA_AMD_EXT_API_TABLE_STEP_VERSION >= 0x03

1401 struct

1402 {

1403 void** ptr;

1404 size_t size;

1405 uint64_t address;

1406 uint64_t alignment;

1407 uint64_t flags;

1408 } hsa_amd_vmem_address_reserve_align;

1409# endif

1410# if HSA_AMD_EXT_API_TABLE_STEP_VERSION >= 0x04

1411 struct

1412 {

1413 uint8_t* flags;

1414 void* file;

1415 } hsa_amd_enable_logging;

1416# endif

1417# if HSA_AMD_EXT_API_TABLE_STEP_VERSION >= 0x05

1418 struct

1419 {

1420 uint32_t signal_count;

1421 hsa_signal_t* signals;

1422 hsa_signal_condition_t* conds;

1423 hsa_signal_value_t* values;

1424 uint64_t timeout_hint;

1425 hsa_wait_state_t wait_hint;

1426 hsa_signal_value_t* satisfying_values;

1427 } hsa_amd_signal_wait_all;

1428# endif

1429# if HSA_AMD_EXT_API_TABLE_STEP_VERSION >= 0x06

1430 struct

1431 {

1432 hsa_agent_t dst_agent;

1433 hsa_agent_t src_agent;

1434 uint32_t* recommended_ids_mask;

1435 } hsa_amd_memory_get_preferred_copy_engine;

1436# endif

1437# if HSA_AMD_EXT_API_TABLE_STEP_VERSION >= 0x07

1438 struct

1439 {

1440 const void* ptr;

1441 size_t size;

1442 int* dmabuf;

1443 uint64_t* offset;

1444 uint64_t flags;

1445 } hsa_amd_portable_export_dmabuf_v2;

1446# endif

1447# if HSA_AMD_EXT_API_TABLE_STEP_VERSION >= 0x08

1448 struct

1449 {

1450 hsa_amd_ais_file_handle_t handle;

1451 void* devicePtr;

1452 uint64_t size;

1453 int64_t file_offset;

1454 uint64_t* size_copied;

1455 int32_t* status;

1456 } hsa_amd_ais_file_write;

1457 struct

1458 {

1459 hsa_amd_ais_file_handle_t handle;

1460 void* devicePtr;

1461 uint64_t size;

1462 int64_t file_offset;

1463 uint64_t* size_copied;

1464 int32_t* status;

1465 } hsa_amd_ais_file_read;

1466# endif

1467#endif

1468} rocprofiler_hsa_api_args_t;

1469

1470ROCPROFILER_EXTERN_C_FINI

ext_version.h

Defines versions for external dependencies.

---

Generated by  1.9.8