// MIT License // // Copyright (c) 2023-2025 Advanced Micro Devices, Inc. All rights reserved. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal // in the Software without restriction, including without limitation the rights // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell // copies of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in // all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. #pragma once #include #include #include #include #include #include #include ROCPROFILER_EXTERN_C_INIT // Empty struct has a size of 0 in C but size of 1 in C++. // This struct is added to the union members which represent // functions with no arguments to ensure ABI compatibility typedef struct rocprofiler_hsa_api_no_args { char empty; } rocprofiler_hsa_api_no_args; typedef union rocprofiler_hsa_api_retval_t { uint64_t uint64_t_retval; uint32_t uint32_t_retval; hsa_signal_value_t hsa_signal_value_t_retval; hsa_status_t hsa_status_t_retval; } rocprofiler_hsa_api_retval_t; // the following hsa_* typedefs are only in hsa/hsa_api_trace.h but we cannot include that file here // because it is not C-compatible typedef hsa_status_t (*hsa_ext_program_iterate_modules_cb_t)(hsa_ext_program_t program, hsa_ext_module_t module, void* data); typedef void (*hsa_amd_queue_intercept_packet_writer)(const void* pkts, uint64_t pkt_count); typedef void (*hsa_amd_queue_intercept_handler)(const void* pkts, uint64_t pkt_count, uint64_t user_pkt_index, void* data, hsa_amd_queue_intercept_packet_writer writer); typedef void (*hsa_amd_runtime_queue_notifier)(const hsa_queue_t* queue, hsa_agent_t agent, void* data); typedef union rocprofiler_hsa_api_args_t { // block: CoreApi API struct { // Empty struct has a size of 0 in C but size of 1 in C++. // Add the rocprofiler_hsa_api_no_args struct to fix this rocprofiler_hsa_api_no_args no_args; } hsa_init; struct { // Empty struct has a size of 0 in C but size of 1 in C++. // Add the rocprofiler_hsa_api_no_args struct to fix this rocprofiler_hsa_api_no_args no_args; } hsa_shut_down; struct { hsa_system_info_t attribute; void* value; } hsa_system_get_info; struct { uint16_t extension; uint16_t version_major; uint16_t version_minor; bool* result; } hsa_system_extension_supported; struct { uint16_t extension; uint16_t version_major; uint16_t version_minor; void* table; } hsa_system_get_extension_table; struct { hsa_status_t (*callback)(hsa_agent_t agent, void* data); void* data; } hsa_iterate_agents; struct { hsa_agent_t agent; hsa_agent_info_t attribute; void* value; } hsa_agent_get_info; struct { hsa_agent_t agent; uint32_t size; hsa_queue_type32_t type; void (*callback)(hsa_status_t status, hsa_queue_t* source, void* data); void* data; uint32_t private_segment_size; uint32_t group_segment_size; hsa_queue_t** queue; } hsa_queue_create; struct { hsa_region_t region; uint32_t size; hsa_queue_type32_t type; uint32_t features; hsa_signal_t doorbell_signal; hsa_queue_t** queue; } hsa_soft_queue_create; struct { hsa_queue_t* queue; } hsa_queue_destroy; struct { hsa_queue_t* queue; } hsa_queue_inactivate; struct { const hsa_queue_t* queue; } hsa_queue_load_read_index_scacquire; struct { const hsa_queue_t* queue; } hsa_queue_load_read_index_relaxed; struct { const hsa_queue_t* queue; } hsa_queue_load_write_index_scacquire; struct { const hsa_queue_t* queue; } hsa_queue_load_write_index_relaxed; struct { const hsa_queue_t* queue; uint64_t value; } hsa_queue_store_write_index_relaxed; struct { const hsa_queue_t* queue; uint64_t value; } hsa_queue_store_write_index_screlease; struct { const hsa_queue_t* queue; uint64_t expected; uint64_t value; } hsa_queue_cas_write_index_scacq_screl; struct { const hsa_queue_t* queue; uint64_t expected; uint64_t value; } hsa_queue_cas_write_index_scacquire; struct { const hsa_queue_t* queue; uint64_t expected; uint64_t value; } hsa_queue_cas_write_index_relaxed; struct { const hsa_queue_t* queue; uint64_t expected; uint64_t value; } hsa_queue_cas_write_index_screlease; struct { const hsa_queue_t* queue; uint64_t value; } hsa_queue_add_write_index_scacq_screl; struct { const hsa_queue_t* queue; uint64_t value; } hsa_queue_add_write_index_scacquire; struct { const hsa_queue_t* queue; uint64_t value; } hsa_queue_add_write_index_relaxed; struct { const hsa_queue_t* queue; uint64_t value; } hsa_queue_add_write_index_screlease; struct { const hsa_queue_t* queue; uint64_t value; } hsa_queue_store_read_index_relaxed; struct { const hsa_queue_t* queue; uint64_t value; } hsa_queue_store_read_index_screlease; struct { hsa_agent_t agent; hsa_status_t (*callback)(hsa_region_t region, void* data); void* data; } hsa_agent_iterate_regions; struct { hsa_region_t region; hsa_region_info_t attribute; void* value; } hsa_region_get_info; struct { hsa_agent_t agent; hsa_profile_t profile; uint16_t* mask; } hsa_agent_get_exception_policies; struct { uint16_t extension; hsa_agent_t agent; uint16_t version_major; uint16_t version_minor; bool* result; } hsa_agent_extension_supported; struct { void* ptr; size_t size; } hsa_memory_register; struct { void* ptr; size_t size; } hsa_memory_deregister; struct { hsa_region_t region; size_t size; void** ptr; } hsa_memory_allocate; struct { void* ptr; } hsa_memory_free; struct { void* dst; const void* src; size_t size; } hsa_memory_copy; struct { void* ptr; hsa_agent_t agent; hsa_access_permission_t access; } hsa_memory_assign_agent; struct { hsa_signal_value_t initial_value; uint32_t num_consumers; const hsa_agent_t* consumers; hsa_signal_t* signal; } hsa_signal_create; struct { hsa_signal_t signal; } hsa_signal_destroy; struct { hsa_signal_t signal; } hsa_signal_load_relaxed; struct { hsa_signal_t signal; } hsa_signal_load_scacquire; struct { hsa_signal_t signal; hsa_signal_value_t value; } hsa_signal_store_relaxed; struct { hsa_signal_t signal; hsa_signal_value_t value; } hsa_signal_store_screlease; struct { hsa_signal_t signal; hsa_signal_condition_t condition; hsa_signal_value_t compare_value; uint64_t timeout_hint; hsa_wait_state_t wait_state_hint; } hsa_signal_wait_relaxed; struct { hsa_signal_t signal; hsa_signal_condition_t condition; hsa_signal_value_t compare_value; uint64_t timeout_hint; hsa_wait_state_t wait_state_hint; } hsa_signal_wait_scacquire; struct { hsa_signal_t signal; hsa_signal_value_t value; } hsa_signal_and_relaxed; struct { hsa_signal_t signal; hsa_signal_value_t value; } hsa_signal_and_scacquire; struct { hsa_signal_t signal; hsa_signal_value_t value; } hsa_signal_and_screlease; struct { hsa_signal_t signal; hsa_signal_value_t value; } hsa_signal_and_scacq_screl; struct { hsa_signal_t signal; hsa_signal_value_t value; } hsa_signal_or_relaxed; struct { hsa_signal_t signal; hsa_signal_value_t value; } hsa_signal_or_scacquire; struct { hsa_signal_t signal; hsa_signal_value_t value; } hsa_signal_or_screlease; struct { hsa_signal_t signal; hsa_signal_value_t value; } hsa_signal_or_scacq_screl; struct { hsa_signal_t signal; hsa_signal_value_t value; } hsa_signal_xor_relaxed; struct { hsa_signal_t signal; hsa_signal_value_t value; } hsa_signal_xor_scacquire; struct { hsa_signal_t signal; hsa_signal_value_t value; } hsa_signal_xor_screlease; struct { hsa_signal_t signal; hsa_signal_value_t value; } hsa_signal_xor_scacq_screl; struct { hsa_signal_t signal; hsa_signal_value_t value; } hsa_signal_exchange_relaxed; struct { hsa_signal_t signal; hsa_signal_value_t value; } hsa_signal_exchange_scacquire; struct { hsa_signal_t signal; hsa_signal_value_t value; } hsa_signal_exchange_screlease; struct { hsa_signal_t signal; hsa_signal_value_t value; } hsa_signal_exchange_scacq_screl; struct { hsa_signal_t signal; hsa_signal_value_t value; } hsa_signal_add_relaxed; struct { hsa_signal_t signal; hsa_signal_value_t value; } hsa_signal_add_scacquire; struct { hsa_signal_t signal; hsa_signal_value_t value; } hsa_signal_add_screlease; struct { hsa_signal_t signal; hsa_signal_value_t value; } hsa_signal_add_scacq_screl; struct { hsa_signal_t signal; hsa_signal_value_t value; } hsa_signal_subtract_relaxed; struct { hsa_signal_t signal; hsa_signal_value_t value; } hsa_signal_subtract_scacquire; struct { hsa_signal_t signal; hsa_signal_value_t value; } hsa_signal_subtract_screlease; struct { hsa_signal_t signal; hsa_signal_value_t value; } hsa_signal_subtract_scacq_screl; struct { hsa_signal_t signal; hsa_signal_value_t expected; hsa_signal_value_t value; } hsa_signal_cas_relaxed; struct { hsa_signal_t signal; hsa_signal_value_t expected; hsa_signal_value_t value; } hsa_signal_cas_scacquire; struct { hsa_signal_t signal; hsa_signal_value_t expected; hsa_signal_value_t value; } hsa_signal_cas_screlease; struct { hsa_signal_t signal; hsa_signal_value_t expected; hsa_signal_value_t value; } hsa_signal_cas_scacq_screl; struct { const char* name; hsa_isa_t* isa; } hsa_isa_from_name; struct { hsa_isa_t isa; hsa_isa_info_t attribute; uint32_t index; void* value; } hsa_isa_get_info; struct { hsa_isa_t code_object_isa; hsa_isa_t agent_isa; bool* result; } hsa_isa_compatible; struct { hsa_code_object_t code_object; hsa_status_t (*alloc_callback)(size_t size, hsa_callback_data_t data, void** address); hsa_callback_data_t callback_data; const char* options; void** serialized_code_object; size_t* serialized_code_object_size; } hsa_code_object_serialize; struct { void* serialized_code_object; size_t serialized_code_object_size; const char* options; hsa_code_object_t* code_object; } hsa_code_object_deserialize; struct { hsa_code_object_t code_object; } hsa_code_object_destroy; struct { hsa_code_object_t code_object; hsa_code_object_info_t attribute; void* value; } hsa_code_object_get_info; struct { hsa_code_object_t code_object; const char* symbol_name; hsa_code_symbol_t* symbol; } hsa_code_object_get_symbol; struct { hsa_code_symbol_t code_symbol; hsa_code_symbol_info_t attribute; void* value; } hsa_code_symbol_get_info; struct { hsa_code_object_t code_object; hsa_status_t (*callback)(hsa_code_object_t code_object, hsa_code_symbol_t symbol, void* data); void* data; } hsa_code_object_iterate_symbols; struct { hsa_profile_t profile; hsa_executable_state_t executable_state; const char* options; hsa_executable_t* executable; } hsa_executable_create; struct { hsa_executable_t executable; } hsa_executable_destroy; struct { hsa_executable_t executable; hsa_agent_t agent; hsa_code_object_t code_object; const char* options; } hsa_executable_load_code_object; struct { hsa_executable_t executable; const char* options; } hsa_executable_freeze; struct { hsa_executable_t executable; hsa_executable_info_t attribute; void* value; } hsa_executable_get_info; struct { hsa_executable_t executable; const char* variable_name; void* address; } hsa_executable_global_variable_define; struct { hsa_executable_t executable; hsa_agent_t agent; const char* variable_name; void* address; } hsa_executable_agent_global_variable_define; struct { hsa_executable_t executable; hsa_agent_t agent; const char* variable_name; void* address; } hsa_executable_readonly_variable_define; struct { hsa_executable_t executable; uint32_t* result; } hsa_executable_validate; struct { hsa_executable_t executable; const char* module_name; const char* symbol_name; hsa_agent_t agent; int32_t call_convention; hsa_executable_symbol_t* symbol; } hsa_executable_get_symbol; struct { hsa_executable_symbol_t executable_symbol; hsa_executable_symbol_info_t attribute; void* value; } hsa_executable_symbol_get_info; struct { hsa_executable_t executable; hsa_status_t (*callback)(hsa_executable_t exec, hsa_executable_symbol_t symbol, void* data); void* data; } hsa_executable_iterate_symbols; struct { hsa_status_t status; const char** status_string; } hsa_status_string; struct { uint16_t extension; const char** name; } hsa_extension_get_name; struct { uint16_t extension; uint16_t version_major; uint16_t* version_minor; bool* result; } hsa_system_major_extension_supported; struct { uint16_t extension; uint16_t version_major; size_t table_length; void* table; } hsa_system_get_major_extension_table; struct { uint16_t extension; hsa_agent_t agent; uint16_t version_major; uint16_t* version_minor; bool* result; } hsa_agent_major_extension_supported; struct { hsa_cache_t cache; hsa_cache_info_t attribute; void* value; } hsa_cache_get_info; struct { hsa_agent_t agent; hsa_status_t (*callback)(hsa_cache_t cache, void* data); void* data; } hsa_agent_iterate_caches; struct { hsa_signal_t signal; hsa_signal_value_t value; } hsa_signal_silent_store_relaxed; struct { hsa_signal_t signal; hsa_signal_value_t value; } hsa_signal_silent_store_screlease; struct { uint32_t num_signals; const hsa_signal_t* signals; uint32_t num_consumers; const hsa_agent_t* consumers; hsa_signal_group_t* signal_group; } hsa_signal_group_create; struct { hsa_signal_group_t signal_group; } hsa_signal_group_destroy; struct { hsa_signal_group_t signal_group; const hsa_signal_condition_t* conditions; const hsa_signal_value_t* compare_values; hsa_wait_state_t wait_state_hint; hsa_signal_t* signal; hsa_signal_value_t* value; } hsa_signal_group_wait_any_scacquire; struct { hsa_signal_group_t signal_group; const hsa_signal_condition_t* conditions; const hsa_signal_value_t* compare_values; hsa_wait_state_t wait_state_hint; hsa_signal_t* signal; hsa_signal_value_t* value; } hsa_signal_group_wait_any_relaxed; struct { hsa_agent_t agent; hsa_status_t (*callback)(hsa_isa_t isa, void* data); void* data; } hsa_agent_iterate_isas; struct { hsa_isa_t isa; hsa_isa_info_t attribute; void* value; } hsa_isa_get_info_alt; struct { hsa_isa_t isa; hsa_profile_t profile; uint16_t* mask; } hsa_isa_get_exception_policies; struct { hsa_isa_t isa; hsa_fp_type_t fp_type; hsa_flush_mode_t flush_mode; hsa_round_method_t* round_method; } hsa_isa_get_round_method; struct { hsa_wavefront_t wavefront; hsa_wavefront_info_t attribute; void* value; } hsa_wavefront_get_info; struct { hsa_isa_t isa; hsa_status_t (*callback)(hsa_wavefront_t wavefront, void* data); void* data; } hsa_isa_iterate_wavefronts; struct { hsa_code_object_t code_object; const char* module_name; const char* symbol_name; hsa_code_symbol_t* symbol; } hsa_code_object_get_symbol_from_name; struct { hsa_file_t file; hsa_code_object_reader_t* code_object_reader; } hsa_code_object_reader_create_from_file; struct { const void* code_object; size_t size; hsa_code_object_reader_t* code_object_reader; } hsa_code_object_reader_create_from_memory; struct { hsa_code_object_reader_t code_object_reader; } hsa_code_object_reader_destroy; struct { hsa_profile_t profile; hsa_default_float_rounding_mode_t default_float_rounding_mode; const char* options; hsa_executable_t* executable; } hsa_executable_create_alt; struct { hsa_executable_t executable; hsa_code_object_reader_t code_object_reader; const char* options; hsa_loaded_code_object_t* loaded_code_object; } hsa_executable_load_program_code_object; struct { hsa_executable_t executable; hsa_agent_t agent; hsa_code_object_reader_t code_object_reader; const char* options; hsa_loaded_code_object_t* loaded_code_object; } hsa_executable_load_agent_code_object; struct { hsa_executable_t executable; const char* options; uint32_t* result; } hsa_executable_validate_alt; struct { hsa_executable_t executable; const char* symbol_name; const hsa_agent_t* agent; hsa_executable_symbol_t* symbol; } hsa_executable_get_symbol_by_name; struct { hsa_executable_t executable; hsa_agent_t agent; hsa_status_t (*callback)(hsa_executable_t exec, hsa_agent_t agent, hsa_executable_symbol_t symbol, void* data); void* data; } hsa_executable_iterate_agent_symbols; struct { hsa_executable_t executable; hsa_status_t (*callback)(hsa_executable_t exec, hsa_executable_symbol_t symbol, void* data); void* data; } hsa_executable_iterate_program_symbols; // block: AmdExt API struct { hsa_agent_t agent; hsa_amd_coherency_type_t* type; } hsa_amd_coherency_get_type; struct { hsa_agent_t agent; hsa_amd_coherency_type_t type; } hsa_amd_coherency_set_type; struct { hsa_queue_t* queue; int enable; } hsa_amd_profiling_set_profiler_enabled; struct { bool enable; } hsa_amd_profiling_async_copy_enable; struct { hsa_agent_t agent; hsa_signal_t signal; hsa_amd_profiling_dispatch_time_t* time; } hsa_amd_profiling_get_dispatch_time; struct { hsa_signal_t signal; hsa_amd_profiling_async_copy_time_t* time; } hsa_amd_profiling_get_async_copy_time; struct { hsa_agent_t agent; uint64_t agent_tick; uint64_t* system_tick; } hsa_amd_profiling_convert_tick_to_system_domain; struct { hsa_signal_t signal; hsa_signal_condition_t cond; hsa_signal_value_t value; hsa_amd_signal_handler handler; void* arg; } hsa_amd_signal_async_handler; struct { void (*callback)(void* arg); void* arg; } hsa_amd_async_function; struct { uint32_t signal_count; hsa_signal_t* signals; hsa_signal_condition_t* conds; hsa_signal_value_t* values; uint64_t timeout_hint; hsa_wait_state_t wait_hint; hsa_signal_value_t* satisfying_value; } hsa_amd_signal_wait_any; struct { const hsa_queue_t* queue; uint32_t num_cu_mask_count; const uint32_t* cu_mask; } hsa_amd_queue_cu_set_mask; struct { hsa_amd_memory_pool_t memory_pool; hsa_amd_memory_pool_info_t attribute; void* value; } hsa_amd_memory_pool_get_info; struct { hsa_agent_t agent; hsa_status_t (*callback)(hsa_amd_memory_pool_t memory_pool, void* data); void* data; } hsa_amd_agent_iterate_memory_pools; struct { hsa_amd_memory_pool_t memory_pool; size_t size; uint32_t flags; void** ptr; } hsa_amd_memory_pool_allocate; struct { void* ptr; } hsa_amd_memory_pool_free; struct { void* dst; hsa_agent_t dst_agent; const void* src; hsa_agent_t src_agent; size_t size; uint32_t num_dep_signals; const hsa_signal_t* dep_signals; hsa_signal_t completion_signal; } hsa_amd_memory_async_copy; struct { void* dst; hsa_agent_t dst_agent; const void* src; hsa_agent_t src_agent; size_t size; uint32_t num_dep_signals; const hsa_signal_t* dep_signals; hsa_signal_t completion_signal; hsa_amd_sdma_engine_id_t engine_id; bool force_copy_on_sdma; } hsa_amd_memory_async_copy_on_engine; struct { hsa_agent_t dst_agent; hsa_agent_t src_agent; uint32_t* engine_ids_mask; } hsa_amd_memory_copy_engine_status; struct { hsa_agent_t agent; hsa_amd_memory_pool_t memory_pool; hsa_amd_agent_memory_pool_info_t attribute; void* value; } hsa_amd_agent_memory_pool_get_info; struct { uint32_t num_agents; const hsa_agent_t* agents; const uint32_t* flags; const void* ptr; } hsa_amd_agents_allow_access; struct { hsa_amd_memory_pool_t src_memory_pool; hsa_amd_memory_pool_t dst_memory_pool; bool* result; } hsa_amd_memory_pool_can_migrate; struct { const void* ptr; hsa_amd_memory_pool_t memory_pool; uint32_t flags; } hsa_amd_memory_migrate; struct { void* host_ptr; size_t size; hsa_agent_t* agents; int num_agent; void** agent_ptr; } hsa_amd_memory_lock; struct { void* host_ptr; } hsa_amd_memory_unlock; struct { void* ptr; uint32_t value; size_t count; } hsa_amd_memory_fill; struct { uint32_t num_agents; hsa_agent_t* agents; int interop_handle; uint32_t flags; size_t* size; void** ptr; size_t* metadata_size; const void** metadata; } hsa_amd_interop_map_buffer; struct { void* ptr; } hsa_amd_interop_unmap_buffer; struct { hsa_agent_t agent; const hsa_ext_image_descriptor_t* image_descriptor; const hsa_amd_image_descriptor_t* image_layout; const void* image_data; hsa_access_permission_t access_permission; hsa_ext_image_t* image; } hsa_amd_image_create; struct { const void* ptr; hsa_amd_pointer_info_t* info; void* (*alloc)(size_t); uint32_t* num_agents_accessible; hsa_agent_t** accessible; } hsa_amd_pointer_info; struct { const void* ptr; void* userdata; } hsa_amd_pointer_info_set_userdata; struct { void* ptr; size_t len; hsa_amd_ipc_memory_t* handle; } hsa_amd_ipc_memory_create; struct { const hsa_amd_ipc_memory_t* handle; size_t len; uint32_t num_agents; const hsa_agent_t* mapping_agents; void** mapped_ptr; } hsa_amd_ipc_memory_attach; struct { void* mapped_ptr; } hsa_amd_ipc_memory_detach; struct { hsa_signal_value_t initial_value; uint32_t num_consumers; const hsa_agent_t* consumers; uint64_t attributes; hsa_signal_t* signal; } hsa_amd_signal_create; struct { hsa_signal_t signal; hsa_amd_ipc_signal_t* handle; } hsa_amd_ipc_signal_create; struct { const hsa_amd_ipc_signal_t* handle; hsa_signal_t* signal; } hsa_amd_ipc_signal_attach; struct { hsa_amd_system_event_callback_t callback; void* data; } hsa_amd_register_system_event_handler; struct { hsa_agent_t agent_handle; uint32_t size; hsa_queue_type32_t type; void (*callback)(hsa_status_t status, hsa_queue_t* source, void* data); void* data; uint32_t private_segment_size; uint32_t group_segment_size; hsa_queue_t** queue; } hsa_amd_queue_intercept_create; struct { hsa_queue_t* queue; hsa_amd_queue_intercept_handler callback; void* user_data; } hsa_amd_queue_intercept_register; struct { hsa_queue_t* queue; hsa_amd_queue_priority_t priority; } hsa_amd_queue_set_priority; struct { const hsa_pitched_ptr_t* dst; const hsa_dim3_t* dst_offset; const hsa_pitched_ptr_t* src; const hsa_dim3_t* src_offset; const hsa_dim3_t* range; hsa_agent_t copy_agent; hsa_amd_copy_direction_t dir; uint32_t num_dep_signals; const hsa_signal_t* dep_signals; hsa_signal_t completion_signal; } hsa_amd_memory_async_copy_rect; struct { hsa_amd_runtime_queue_notifier callback; void* user_data; } hsa_amd_runtime_queue_create_register; struct { void* host_ptr; size_t size; hsa_agent_t* agents; int num_agent; hsa_amd_memory_pool_t pool; uint32_t flags; void** agent_ptr; } hsa_amd_memory_lock_to_pool; struct { void* ptr; hsa_amd_deallocation_callback_t callback; void* user_data; } hsa_amd_register_deallocation_callback; struct { void* ptr; hsa_amd_deallocation_callback_t callback; } hsa_amd_deregister_deallocation_callback; struct { hsa_signal_t signal; volatile hsa_signal_value_t** value_ptr; } hsa_amd_signal_value_pointer; struct { void* ptr; size_t size; hsa_amd_svm_attribute_pair_t* attribute_list; size_t attribute_count; } hsa_amd_svm_attributes_set; struct { void* ptr; size_t size; hsa_amd_svm_attribute_pair_t* attribute_list; size_t attribute_count; } hsa_amd_svm_attributes_get; struct { void* ptr; size_t size; hsa_agent_t agent; uint32_t num_dep_signals; const hsa_signal_t* dep_signals; hsa_signal_t completion_signal; } hsa_amd_svm_prefetch_async; struct { hsa_agent_t preferred_agent; } hsa_amd_spm_acquire; struct { hsa_agent_t preferred_agent; } hsa_amd_spm_release; struct { hsa_agent_t preferred_agent; size_t size_in_bytes; uint32_t* timeout; uint32_t* size_copied; void* dest; bool* is_data_loss; } hsa_amd_spm_set_dest_buffer; struct { const hsa_queue_t* queue; uint32_t num_cu_mask_count; uint32_t* cu_mask; } hsa_amd_queue_cu_get_mask; struct { const void* ptr; size_t size; int* dmabuf; uint64_t* offset; } hsa_amd_portable_export_dmabuf; struct { int dmabuf; } hsa_amd_portable_close_dmabuf; // block: ImageExt API struct { hsa_agent_t agent; hsa_ext_image_geometry_t geometry; const hsa_ext_image_format_t* image_format; uint32_t* capability_mask; } hsa_ext_image_get_capability; struct { hsa_agent_t agent; const hsa_ext_image_descriptor_t* image_descriptor; hsa_access_permission_t access_permission; hsa_ext_image_data_info_t* image_data_info; } hsa_ext_image_data_get_info; struct { hsa_agent_t agent; const hsa_ext_image_descriptor_t* image_descriptor; const void* image_data; hsa_access_permission_t access_permission; hsa_ext_image_t* image; } hsa_ext_image_create; struct { hsa_agent_t agent; const void* src_memory; size_t src_row_pitch; size_t src_slice_pitch; hsa_ext_image_t dst_image; const hsa_ext_image_region_t* image_region; } hsa_ext_image_import; struct { hsa_agent_t agent; hsa_ext_image_t src_image; void* dst_memory; size_t dst_row_pitch; size_t dst_slice_pitch; const hsa_ext_image_region_t* image_region; } hsa_ext_image_export; struct { hsa_agent_t agent; hsa_ext_image_t src_image; const hsa_dim3_t* src_offset; hsa_ext_image_t dst_image; const hsa_dim3_t* dst_offset; const hsa_dim3_t* range; } hsa_ext_image_copy; struct { hsa_agent_t agent; hsa_ext_image_t image; const void* data; const hsa_ext_image_region_t* image_region; } hsa_ext_image_clear; struct { hsa_agent_t agent; hsa_ext_image_t image; } hsa_ext_image_destroy; struct { hsa_agent_t agent; const hsa_ext_sampler_descriptor_t* sampler_descriptor; hsa_ext_sampler_t* sampler; } hsa_ext_sampler_create; struct { hsa_agent_t agent; hsa_ext_sampler_t sampler; } hsa_ext_sampler_destroy; struct { hsa_agent_t agent; hsa_ext_image_geometry_t geometry; const hsa_ext_image_format_t* image_format; hsa_ext_image_data_layout_t image_data_layout; uint32_t* capability_mask; } hsa_ext_image_get_capability_with_layout; struct { hsa_agent_t agent; const hsa_ext_image_descriptor_t* image_descriptor; hsa_access_permission_t access_permission; hsa_ext_image_data_layout_t image_data_layout; size_t image_data_row_pitch; size_t image_data_slice_pitch; hsa_ext_image_data_info_t* image_data_info; } hsa_ext_image_data_get_info_with_layout; struct { hsa_agent_t agent; const hsa_ext_image_descriptor_t* image_descriptor; const void* image_data; hsa_access_permission_t access_permission; hsa_ext_image_data_layout_t image_data_layout; size_t image_data_row_pitch; size_t image_data_slice_pitch; hsa_ext_image_t* image; } hsa_ext_image_create_with_layout; // finalize ext struct { hsa_machine_model_t machine_model; hsa_profile_t profile; hsa_default_float_rounding_mode_t default_float_rounding_mode; const char* options; hsa_ext_program_t* program; } hsa_ext_program_create; struct { hsa_ext_program_t program; } hsa_ext_program_destroy; struct { hsa_ext_program_t program; hsa_ext_module_t module; } hsa_ext_program_add_module; struct { hsa_ext_program_t program; hsa_ext_program_iterate_modules_cb_t callback; void* data; } hsa_ext_program_iterate_modules; struct { hsa_ext_program_t program; hsa_ext_program_info_t attribute; void* value; } hsa_ext_program_get_info; struct { hsa_ext_program_t program; hsa_isa_t isa; int32_t call_convention; hsa_ext_control_directives_t control_directives; const char* options; hsa_code_object_type_t code_object_type; hsa_code_object_t* code_object; } hsa_ext_program_finalize; // #if HSA_AMD_EXT_API_TABLE_MAJOR_VERSION >= 0x02 struct { void** ptr; size_t size; uint64_t address; uint64_t flags; } hsa_amd_vmem_address_reserve; struct { void* ptr; size_t size; } hsa_amd_vmem_address_free; struct { hsa_amd_memory_pool_t pool; size_t size; hsa_amd_memory_type_t type; uint64_t flags; hsa_amd_vmem_alloc_handle_t* memory_handle; } hsa_amd_vmem_handle_create; struct { hsa_amd_vmem_alloc_handle_t memory_handle; } hsa_amd_vmem_handle_release; struct { void* va; size_t size; size_t in_offset; hsa_amd_vmem_alloc_handle_t memory_handle; uint64_t flags; } hsa_amd_vmem_map; struct { void* va; size_t size; } hsa_amd_vmem_unmap; struct { void* va; size_t size; const hsa_amd_memory_access_desc_t* desc; size_t desc_cnt; } hsa_amd_vmem_set_access; struct { void* va; hsa_access_permission_t* perms; hsa_agent_t agent_handle; } hsa_amd_vmem_get_access; struct { int* dmabuf_fd; hsa_amd_vmem_alloc_handle_t handle; uint64_t flags; } hsa_amd_vmem_export_shareable_handle; struct { int dmabuf_fd; hsa_amd_vmem_alloc_handle_t* handle; } hsa_amd_vmem_import_shareable_handle; struct { hsa_amd_vmem_alloc_handle_t* handle; void* addr; } hsa_amd_vmem_retain_alloc_handle; struct { hsa_amd_vmem_alloc_handle_t alloc_handle; hsa_amd_memory_pool_t* pool; hsa_amd_memory_type_t* type; } hsa_amd_vmem_get_alloc_properties_from_handle; # if HSA_AMD_EXT_API_TABLE_STEP_VERSION >= 0x01 struct { hsa_agent_t agent; size_t threshold; } hsa_amd_agent_set_async_scratch_limit; # endif # if HSA_AMD_EXT_API_TABLE_STEP_VERSION >= 0x02 struct { hsa_queue_t* queue; hsa_queue_info_attribute_t attribute; void* value; } hsa_amd_queue_get_info; # endif # if HSA_AMD_EXT_API_TABLE_STEP_VERSION >= 0x03 struct { void** ptr; size_t size; uint64_t address; uint64_t alignment; uint64_t flags; } hsa_amd_vmem_address_reserve_align; # endif # if HSA_AMD_EXT_API_TABLE_STEP_VERSION >= 0x04 struct { uint8_t* flags; void* file; } hsa_amd_enable_logging; # endif # if HSA_AMD_EXT_API_TABLE_STEP_VERSION >= 0x05 struct { uint32_t signal_count; hsa_signal_t* signals; hsa_signal_condition_t* conds; hsa_signal_value_t* values; uint64_t timeout_hint; hsa_wait_state_t wait_hint; hsa_signal_value_t* satisfying_values; } hsa_amd_signal_wait_all; # endif #endif } rocprofiler_hsa_api_args_t; ROCPROFILER_EXTERN_C_FINI