diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000000..b27d714e28 --- /dev/null +++ b/.gitignore @@ -0,0 +1,9 @@ +.* +!.gitignore +*.o +*.exe +*.swp +*.Po +b +build +test/hsa diff --git a/CMakeLists.txt b/CMakeLists.txt index f34cffe0cb..0b623e463e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -41,7 +41,9 @@ include ( utils ) ## Set build environment include ( env ) ## Set test target -add_custom_target( mytest COMMAND make -C "${CMAKE_CURRENT_SOURCE_DIR}/test/MatrixTranspose" ) +add_custom_target( mytest + COMMAND make -C "${CMAKE_CURRENT_SOURCE_DIR}/test/MatrixTranspose" + COMMAND ${PROJECT_BINARY_DIR}/run.sh) ## Setup the package version. get_version ( "1.0.0" ) @@ -61,7 +63,7 @@ set ( BUILD_VERSION_STRING "${BUILD_VERSION_MAJOR}.${BUILD_VERSION_MINOR}.${BUIL set ( TARGET_NAME "${ROCTRACER_TARGET}" ) set ( ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}" ) set ( LIB_DIR "${ROOT_DIR}/src" ) -#set ( TEST_DIR "${ROOT_DIR}/test" ) +set ( TEST_DIR "${ROOT_DIR}/test" ) ## Build library include ( ${LIB_DIR}/CMakeLists.txt ) @@ -75,6 +77,9 @@ set_property ( TARGET ${TARGET_NAME} PROPERTY SOVERSION "${BUILD_VERSION_MAJOR}" # add_custom_command ( TARGET ${ROCTRACER_TARGET} POST_BUILD COMMAND ${CMAKE_STRIP} *.so ) #endif () +## Build tests +add_subdirectory ( ${TEST_DIR} ${PROJECT_BINARY_DIR}/test ) + ## Install and packaging set ( CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX}/${ROCTRACER_NAME} ) set ( CPACK_PACKAGING_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX} ) diff --git a/inc/ext/hsa_rt_utils.hpp b/inc/ext/hsa_rt_utils.hpp index 346e671077..eaddb27db7 100644 --- a/inc/ext/hsa_rt_utils.hpp +++ b/inc/ext/hsa_rt_utils.hpp @@ -27,6 +27,7 @@ THE SOFTWARE. #include #include +#include #define HSART_CALL(call) \ do { \ @@ -45,10 +46,13 @@ class Timer { public: typedef uint64_t timestamp_t; typedef long double freq_t; + typedef decltype(hsa_system_get_info)* hsa_system_get_info_fn_t; - Timer() { + // Initialization + inline void init(const hsa_system_get_info_fn_t& get_info_fn) { + hsa_system_get_info_fn = get_info_fn; timestamp_t timestamp_hz = 0; - HSART_CALL(hsa_system_get_info(HSA_SYSTEM_INFO_TIMESTAMP_FREQUENCY, ×tamp_hz)); + HSART_CALL(get_info_fn(HSA_SYSTEM_INFO_TIMESTAMP_FREQUENCY, ×tamp_hz)); timestamp_rate_ = (freq_t)1000000000 / (freq_t)timestamp_hz; } @@ -66,8 +70,23 @@ class Timer { HSART_CALL(hsa_system_get_info(HSA_SYSTEM_INFO_TIMESTAMP, ×tamp)); return timestamp_to_ns(timestamp); } + timestamp_t timestamp_fn_ns() const { + timestamp_t timestamp; + HSART_CALL(hsa_system_get_info_fn(HSA_SYSTEM_INFO_TIMESTAMP, ×tamp)); + return timestamp_to_ns(timestamp); + } + + Timer() { + init(hsa_system_get_info); + } + + Timer(hsa_system_get_info_fn_t f) { + init(f); + } private: + // hsa_system_get_info function + hsa_system_get_info_fn_t hsa_system_get_info_fn; // Timestamp rate freq_t timestamp_rate_; }; diff --git a/inc/ext/prof_protocol.h b/inc/ext/prof_protocol.h index c31027e404..8f22d8d685 100644 --- a/inc/ext/prof_protocol.h +++ b/inc/ext/prof_protocol.h @@ -26,9 +26,10 @@ THE SOFTWARE. // Traced API domains typedef enum { ACTIVITY_DOMAIN_ANY = 0, // Any domain - ACTIVITY_DOMAIN_HIP_API = 1, // HIP domain + ACTIVITY_DOMAIN_HSA_API = 1, // HSA domain ACTIVITY_DOMAIN_HCC_OPS = 2, // HCC domain - ACTIVITY_DOMAIN_NUMBER = 3 + ACTIVITY_DOMAIN_HIP_API = 3, // HIP domain + ACTIVITY_DOMAIN_NUMBER = 4 } activity_domain_t; // API calback type diff --git a/inc/hsa_prof_str.h b/inc/hsa_prof_str.h new file mode 100644 index 0000000000..2565008aea --- /dev/null +++ b/inc/hsa_prof_str.h @@ -0,0 +1,4206 @@ +// automatically generated + +/* +Copyright (c) 2018 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. +*/ + +///////////////////////////////////////////////////////////////////////////// +// +// HSA API tracing primitives +// +// 'CoreApiTable', header 'hsa.h', 125 funcs +// 'AmdExtTable', header 'hsa_ext_amd.h', 40 funcs +// 'ImageExtTable', header 'hsa_ext_image.h', 13 funcs +// 'AmdExtTable', header 'hsa_api_trace.h', 40 funcs +// +///////////////////////////////////////////////////////////////////////////// + +#ifndef INC_HSA_PROF_STR_H_ +#define INC_HSA_PROF_STR_H_ + +// section: API ID enumeration + +enum hsa_api_id_t { + // block: CoreApiTable API + HSA_API_ID_hsa_init = 0, + HSA_API_ID_hsa_shut_down = 1, + HSA_API_ID_hsa_system_get_info = 2, + HSA_API_ID_hsa_system_extension_supported = 3, + HSA_API_ID_hsa_system_get_extension_table = 4, + HSA_API_ID_hsa_iterate_agents = 5, + HSA_API_ID_hsa_agent_get_info = 6, + HSA_API_ID_hsa_queue_create = 7, + HSA_API_ID_hsa_soft_queue_create = 8, + HSA_API_ID_hsa_queue_destroy = 9, + HSA_API_ID_hsa_queue_inactivate = 10, + HSA_API_ID_hsa_queue_load_read_index_scacquire = 11, + HSA_API_ID_hsa_queue_load_read_index_relaxed = 12, + HSA_API_ID_hsa_queue_load_write_index_scacquire = 13, + HSA_API_ID_hsa_queue_load_write_index_relaxed = 14, + HSA_API_ID_hsa_queue_store_write_index_relaxed = 15, + HSA_API_ID_hsa_queue_store_write_index_screlease = 16, + HSA_API_ID_hsa_queue_cas_write_index_scacq_screl = 17, + HSA_API_ID_hsa_queue_cas_write_index_scacquire = 18, + HSA_API_ID_hsa_queue_cas_write_index_relaxed = 19, + HSA_API_ID_hsa_queue_cas_write_index_screlease = 20, + HSA_API_ID_hsa_queue_add_write_index_scacq_screl = 21, + HSA_API_ID_hsa_queue_add_write_index_scacquire = 22, + HSA_API_ID_hsa_queue_add_write_index_relaxed = 23, + HSA_API_ID_hsa_queue_add_write_index_screlease = 24, + HSA_API_ID_hsa_queue_store_read_index_relaxed = 25, + HSA_API_ID_hsa_queue_store_read_index_screlease = 26, + HSA_API_ID_hsa_agent_iterate_regions = 27, + HSA_API_ID_hsa_region_get_info = 28, + HSA_API_ID_hsa_agent_get_exception_policies = 29, + HSA_API_ID_hsa_agent_extension_supported = 30, + HSA_API_ID_hsa_memory_register = 31, + HSA_API_ID_hsa_memory_deregister = 32, + HSA_API_ID_hsa_memory_allocate = 33, + HSA_API_ID_hsa_memory_free = 34, + HSA_API_ID_hsa_memory_copy = 35, + HSA_API_ID_hsa_memory_assign_agent = 36, + HSA_API_ID_hsa_signal_create = 37, + HSA_API_ID_hsa_signal_destroy = 38, + HSA_API_ID_hsa_signal_load_relaxed = 39, + HSA_API_ID_hsa_signal_load_scacquire = 40, + HSA_API_ID_hsa_signal_store_relaxed = 41, + HSA_API_ID_hsa_signal_store_screlease = 42, + HSA_API_ID_hsa_signal_wait_relaxed = 43, + HSA_API_ID_hsa_signal_wait_scacquire = 44, + HSA_API_ID_hsa_signal_and_relaxed = 45, + HSA_API_ID_hsa_signal_and_scacquire = 46, + HSA_API_ID_hsa_signal_and_screlease = 47, + HSA_API_ID_hsa_signal_and_scacq_screl = 48, + HSA_API_ID_hsa_signal_or_relaxed = 49, + HSA_API_ID_hsa_signal_or_scacquire = 50, + HSA_API_ID_hsa_signal_or_screlease = 51, + HSA_API_ID_hsa_signal_or_scacq_screl = 52, + HSA_API_ID_hsa_signal_xor_relaxed = 53, + HSA_API_ID_hsa_signal_xor_scacquire = 54, + HSA_API_ID_hsa_signal_xor_screlease = 55, + HSA_API_ID_hsa_signal_xor_scacq_screl = 56, + HSA_API_ID_hsa_signal_exchange_relaxed = 57, + HSA_API_ID_hsa_signal_exchange_scacquire = 58, + HSA_API_ID_hsa_signal_exchange_screlease = 59, + HSA_API_ID_hsa_signal_exchange_scacq_screl = 60, + HSA_API_ID_hsa_signal_add_relaxed = 61, + HSA_API_ID_hsa_signal_add_scacquire = 62, + HSA_API_ID_hsa_signal_add_screlease = 63, + HSA_API_ID_hsa_signal_add_scacq_screl = 64, + HSA_API_ID_hsa_signal_subtract_relaxed = 65, + HSA_API_ID_hsa_signal_subtract_scacquire = 66, + HSA_API_ID_hsa_signal_subtract_screlease = 67, + HSA_API_ID_hsa_signal_subtract_scacq_screl = 68, + HSA_API_ID_hsa_signal_cas_relaxed = 69, + HSA_API_ID_hsa_signal_cas_scacquire = 70, + HSA_API_ID_hsa_signal_cas_screlease = 71, + HSA_API_ID_hsa_signal_cas_scacq_screl = 72, + HSA_API_ID_hsa_isa_from_name = 73, + HSA_API_ID_hsa_isa_get_info = 74, + HSA_API_ID_hsa_isa_compatible = 75, + HSA_API_ID_hsa_code_object_serialize = 76, + HSA_API_ID_hsa_code_object_deserialize = 77, + HSA_API_ID_hsa_code_object_destroy = 78, + HSA_API_ID_hsa_code_object_get_info = 79, + HSA_API_ID_hsa_code_object_get_symbol = 80, + HSA_API_ID_hsa_code_symbol_get_info = 81, + HSA_API_ID_hsa_code_object_iterate_symbols = 82, + HSA_API_ID_hsa_executable_create = 83, + HSA_API_ID_hsa_executable_destroy = 84, + HSA_API_ID_hsa_executable_load_code_object = 85, + HSA_API_ID_hsa_executable_freeze = 86, + HSA_API_ID_hsa_executable_get_info = 87, + HSA_API_ID_hsa_executable_global_variable_define = 88, + HSA_API_ID_hsa_executable_agent_global_variable_define = 89, + HSA_API_ID_hsa_executable_readonly_variable_define = 90, + HSA_API_ID_hsa_executable_validate = 91, + HSA_API_ID_hsa_executable_get_symbol = 92, + HSA_API_ID_hsa_executable_symbol_get_info = 93, + HSA_API_ID_hsa_executable_iterate_symbols = 94, + HSA_API_ID_hsa_status_string = 95, + HSA_API_ID_hsa_extension_get_name = 96, + HSA_API_ID_hsa_system_major_extension_supported = 97, + HSA_API_ID_hsa_system_get_major_extension_table = 98, + HSA_API_ID_hsa_agent_major_extension_supported = 99, + HSA_API_ID_hsa_cache_get_info = 100, + HSA_API_ID_hsa_agent_iterate_caches = 101, + HSA_API_ID_hsa_signal_silent_store_relaxed = 102, + HSA_API_ID_hsa_signal_silent_store_screlease = 103, + HSA_API_ID_hsa_signal_group_create = 104, + HSA_API_ID_hsa_signal_group_destroy = 105, + HSA_API_ID_hsa_signal_group_wait_any_scacquire = 106, + HSA_API_ID_hsa_signal_group_wait_any_relaxed = 107, + HSA_API_ID_hsa_agent_iterate_isas = 108, + HSA_API_ID_hsa_isa_get_info_alt = 109, + HSA_API_ID_hsa_isa_get_exception_policies = 110, + HSA_API_ID_hsa_isa_get_round_method = 111, + HSA_API_ID_hsa_wavefront_get_info = 112, + HSA_API_ID_hsa_isa_iterate_wavefronts = 113, + HSA_API_ID_hsa_code_object_get_symbol_from_name = 114, + HSA_API_ID_hsa_code_object_reader_create_from_file = 115, + HSA_API_ID_hsa_code_object_reader_create_from_memory = 116, + HSA_API_ID_hsa_code_object_reader_destroy = 117, + HSA_API_ID_hsa_executable_create_alt = 118, + HSA_API_ID_hsa_executable_load_program_code_object = 119, + HSA_API_ID_hsa_executable_load_agent_code_object = 120, + HSA_API_ID_hsa_executable_validate_alt = 121, + HSA_API_ID_hsa_executable_get_symbol_by_name = 122, + HSA_API_ID_hsa_executable_iterate_agent_symbols = 123, + HSA_API_ID_hsa_executable_iterate_program_symbols = 124, + + // block: AmdExtTable API + HSA_API_ID_hsa_amd_coherency_get_type = 125, + HSA_API_ID_hsa_amd_coherency_set_type = 126, + HSA_API_ID_hsa_amd_profiling_set_profiler_enabled = 127, + HSA_API_ID_hsa_amd_profiling_async_copy_enable = 128, + HSA_API_ID_hsa_amd_profiling_get_dispatch_time = 129, + HSA_API_ID_hsa_amd_profiling_get_async_copy_time = 130, + HSA_API_ID_hsa_amd_profiling_convert_tick_to_system_domain = 131, + HSA_API_ID_hsa_amd_signal_async_handler = 132, + HSA_API_ID_hsa_amd_async_function = 133, + HSA_API_ID_hsa_amd_signal_wait_any = 134, + HSA_API_ID_hsa_amd_queue_cu_set_mask = 135, + HSA_API_ID_hsa_amd_memory_pool_get_info = 136, + HSA_API_ID_hsa_amd_agent_iterate_memory_pools = 137, + HSA_API_ID_hsa_amd_memory_pool_allocate = 138, + HSA_API_ID_hsa_amd_memory_pool_free = 139, + HSA_API_ID_hsa_amd_memory_async_copy = 140, + HSA_API_ID_hsa_amd_agent_memory_pool_get_info = 141, + HSA_API_ID_hsa_amd_agents_allow_access = 142, + HSA_API_ID_hsa_amd_memory_pool_can_migrate = 143, + HSA_API_ID_hsa_amd_memory_migrate = 144, + HSA_API_ID_hsa_amd_memory_lock = 145, + HSA_API_ID_hsa_amd_memory_unlock = 146, + HSA_API_ID_hsa_amd_memory_fill = 147, + HSA_API_ID_hsa_amd_interop_map_buffer = 148, + HSA_API_ID_hsa_amd_interop_unmap_buffer = 149, + HSA_API_ID_hsa_amd_image_create = 150, + HSA_API_ID_hsa_amd_pointer_info = 151, + HSA_API_ID_hsa_amd_pointer_info_set_userdata = 152, + HSA_API_ID_hsa_amd_ipc_memory_create = 153, + HSA_API_ID_hsa_amd_ipc_memory_attach = 154, + HSA_API_ID_hsa_amd_ipc_memory_detach = 155, + HSA_API_ID_hsa_amd_signal_create = 156, + HSA_API_ID_hsa_amd_ipc_signal_create = 157, + HSA_API_ID_hsa_amd_ipc_signal_attach = 158, + HSA_API_ID_hsa_amd_register_system_event_handler = 159, + HSA_API_ID_hsa_amd_queue_intercept_create = 160, + HSA_API_ID_hsa_amd_queue_intercept_register = 161, + HSA_API_ID_hsa_amd_queue_set_priority = 162, + HSA_API_ID_hsa_amd_memory_async_copy_rect = 163, + HSA_API_ID_hsa_amd_runtime_queue_create_register = 164, + + // block: ImageExtTable API + HSA_API_ID_hsa_ext_image_get_capability = 165, + HSA_API_ID_hsa_ext_image_data_get_info = 166, + HSA_API_ID_hsa_ext_image_create = 167, + HSA_API_ID_hsa_ext_image_import = 168, + HSA_API_ID_hsa_ext_image_export = 169, + HSA_API_ID_hsa_ext_image_copy = 170, + HSA_API_ID_hsa_ext_image_clear = 171, + HSA_API_ID_hsa_ext_image_destroy = 172, + HSA_API_ID_hsa_ext_sampler_create = 173, + HSA_API_ID_hsa_ext_sampler_destroy = 174, + HSA_API_ID_hsa_ext_image_get_capability_with_layout = 175, + HSA_API_ID_hsa_ext_image_data_get_info_with_layout = 176, + HSA_API_ID_hsa_ext_image_create_with_layout = 177, + + HSA_API_ID_NUMBER = 178, + HSA_API_ID_ANY = 179, +}; + +// section: API arg structure + +struct hsa_api_data_t { + uint64_t correlation_id; + uint32_t phase; + union { + // block: CoreApiTable API + struct { + } hsa_init; + struct { + } hsa_shut_down; + struct { + hsa_system_info_t attribute; + void* value; + } hsa_system_get_info; + struct { + uint16_t version_minor; + bool* result; + uint16_t extension; + uint16_t version_major; + } hsa_system_extension_supported; + struct { + void* table; + uint16_t version_minor; + uint16_t extension; + uint16_t version_major; + } hsa_system_get_extension_table; + struct { + hsa_status_t (* callback)(hsa_agent_t agent,void* data); + void* data; + } hsa_iterate_agents; + struct { + hsa_agent_info_t attribute; + void* value; + hsa_agent_t agent; + } hsa_agent_get_info; + struct { + uint32_t private_segment_size; + void* data; + hsa_agent_t agent; + hsa_queue_t** queue; + void (* callback)(hsa_status_t status,hsa_queue_t* source,void* data); + uint32_t group_segment_size; + hsa_queue_type32_t type; + uint32_t size; + } hsa_queue_create; + struct { + uint32_t features; + hsa_region_t region; + hsa_queue_t** queue; + hsa_signal_t doorbell_signal; + hsa_queue_type32_t type; + uint32_t size; + } 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_status_t (* callback)(hsa_region_t region,void* data); + void* data; + hsa_agent_t agent; + } hsa_agent_iterate_regions; + struct { + hsa_region_info_t attribute; + hsa_region_t region; + void* value; + } hsa_region_get_info; + struct { + hsa_profile_t profile; + uint16_t* mask; + hsa_agent_t agent; + } hsa_agent_get_exception_policies; + struct { + bool* result; + uint16_t version_minor; + hsa_agent_t agent; + uint16_t extension; + uint16_t version_major; + } 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; + void** ptr; + size_t size; + } hsa_memory_allocate; + struct { + void* ptr; + } hsa_memory_free; + struct { + const void* src; + void* dst; + size_t size; + } hsa_memory_copy; + struct { + hsa_access_permission_t access; + void* ptr; + hsa_agent_t agent; + } hsa_memory_assign_agent; + struct { + hsa_signal_t* signal; + uint32_t num_consumers; + const hsa_agent_t* consumers; + hsa_signal_value_t initial_value; + } 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; + uint64_t timeout_hint; + hsa_wait_state_t wait_state_hint; + hsa_signal_value_t compare_value; + hsa_signal_condition_t condition; + } hsa_signal_wait_relaxed; + struct { + hsa_signal_t signal; + uint64_t timeout_hint; + hsa_wait_state_t wait_state_hint; + hsa_signal_value_t compare_value; + hsa_signal_condition_t condition; + } 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_value_t expected; + hsa_signal_t signal; + hsa_signal_value_t value; + } hsa_signal_cas_relaxed; + struct { + hsa_signal_value_t expected; + hsa_signal_t signal; + hsa_signal_value_t value; + } hsa_signal_cas_scacquire; + struct { + hsa_signal_value_t expected; + hsa_signal_t signal; + hsa_signal_value_t value; + } hsa_signal_cas_screlease; + struct { + hsa_signal_value_t expected; + hsa_signal_t signal; + hsa_signal_value_t value; + } hsa_signal_cas_scacq_screl; + struct { + hsa_isa_t* isa; + const char* name; + } hsa_isa_from_name; + struct { + hsa_isa_info_t attribute; + hsa_isa_t isa; + void* value; + uint32_t index; + } hsa_isa_get_info; + struct { + hsa_isa_t code_object_isa; + bool* result; + hsa_isa_t agent_isa; + } hsa_isa_compatible; + struct { + hsa_callback_data_t callback_data; + hsa_code_object_t code_object; + void** serialized_code_object; + size_t* serialized_code_object_size; + hsa_status_t (* alloc_callback)(size_t size,hsa_callback_data_t data,void** address); + const char* options; + } hsa_code_object_serialize; + struct { + void* serialized_code_object; + size_t serialized_code_object_size; + hsa_code_object_t* code_object; + const char* options; + } hsa_code_object_deserialize; + struct { + hsa_code_object_t code_object; + } hsa_code_object_destroy; + struct { + hsa_code_object_info_t attribute; + hsa_code_object_t code_object; + void* value; + } hsa_code_object_get_info; + struct { + hsa_code_symbol_t* symbol; + hsa_code_object_t code_object; + const char* symbol_name; + } hsa_code_object_get_symbol; + struct { + hsa_code_symbol_t code_symbol; + void* value; + hsa_code_symbol_info_t attribute; + } hsa_code_symbol_get_info; + struct { + hsa_status_t (* callback)(hsa_code_object_t code_object,hsa_code_symbol_t symbol,void* data); + hsa_code_object_t code_object; + void* data; + } hsa_code_object_iterate_symbols; + struct { + hsa_profile_t profile; + hsa_executable_state_t executable_state; + hsa_executable_t* executable; + const char* options; + } hsa_executable_create; + struct { + hsa_executable_t executable; + } hsa_executable_destroy; + struct { + hsa_executable_t executable; + hsa_code_object_t code_object; + const char* options; + hsa_agent_t agent; + } hsa_executable_load_code_object; + struct { + hsa_executable_t executable; + const char* options; + } hsa_executable_freeze; + struct { + hsa_executable_info_t attribute; + hsa_executable_t executable; + void* value; + } hsa_executable_get_info; + struct { + hsa_executable_t executable; + void* address; + const char* variable_name; + } hsa_executable_global_variable_define; + struct { + hsa_executable_t executable; + void* address; + hsa_agent_t agent; + const char* variable_name; + } hsa_executable_agent_global_variable_define; + struct { + hsa_executable_t executable; + void* address; + hsa_agent_t agent; + const char* variable_name; + } hsa_executable_readonly_variable_define; + struct { + hsa_executable_t executable; + uint32_t* result; + } hsa_executable_validate; + struct { + hsa_executable_t executable; + const char* symbol_name; + hsa_executable_symbol_t* symbol; + hsa_agent_t agent; + int32_t call_convention; + const char* module_name; + } hsa_executable_get_symbol; + struct { + hsa_executable_symbol_info_t attribute; + hsa_executable_symbol_t executable_symbol; + void* value; + } hsa_executable_symbol_get_info; + struct { + hsa_status_t (* callback)(hsa_executable_t exec,hsa_executable_symbol_t symbol,void* data); + hsa_executable_t executable; + void* data; + } hsa_executable_iterate_symbols; + struct { + hsa_status_t status; + const char** status_string; + } hsa_status_string; + struct { + const char** name; + uint16_t extension; + } hsa_extension_get_name; + struct { + uint16_t* version_minor; + bool* result; + uint16_t extension; + uint16_t version_major; + } hsa_system_major_extension_supported; + struct { + void* table; + size_t table_length; + uint16_t extension; + uint16_t version_major; + } hsa_system_get_major_extension_table; + struct { + bool* result; + uint16_t* version_minor; + hsa_agent_t agent; + uint16_t extension; + uint16_t version_major; + } hsa_agent_major_extension_supported; + struct { + hsa_cache_info_t attribute; + hsa_cache_t cache; + void* value; + } hsa_cache_get_info; + struct { + hsa_status_t (* callback)(hsa_cache_t cache,void* data); + void* data; + hsa_agent_t agent; + } 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 { + const hsa_signal_t* signals; + uint32_t num_signals; + hsa_signal_group_t* signal_group; + const hsa_agent_t* consumers; + uint32_t num_consumers; + } hsa_signal_group_create; + struct { + hsa_signal_group_t signal_group; + } hsa_signal_group_destroy; + struct { + hsa_signal_group_t signal_group; + hsa_wait_state_t wait_state_hint; + hsa_signal_t* signal; + const hsa_signal_value_t* compare_values; + hsa_signal_value_t* value; + const hsa_signal_condition_t* conditions; + } hsa_signal_group_wait_any_scacquire; + struct { + hsa_signal_group_t signal_group; + hsa_wait_state_t wait_state_hint; + hsa_signal_t* signal; + const hsa_signal_value_t* compare_values; + hsa_signal_value_t* value; + const hsa_signal_condition_t* conditions; + } hsa_signal_group_wait_any_relaxed; + struct { + hsa_status_t (* callback)(hsa_isa_t isa,void* data); + void* data; + hsa_agent_t agent; + } hsa_agent_iterate_isas; + struct { + hsa_isa_info_t attribute; + hsa_isa_t isa; + void* value; + } hsa_isa_get_info_alt; + struct { + hsa_profile_t profile; + hsa_isa_t isa; + uint16_t* mask; + } hsa_isa_get_exception_policies; + struct { + hsa_isa_t isa; + hsa_round_method_t* round_method; + hsa_flush_mode_t flush_mode; + hsa_fp_type_t fp_type; + } hsa_isa_get_round_method; + struct { + hsa_wavefront_info_t attribute; + hsa_wavefront_t wavefront; + void* value; + } hsa_wavefront_get_info; + struct { + hsa_status_t (* callback)(hsa_wavefront_t wavefront,void* data); + hsa_isa_t isa; + void* data; + } hsa_isa_iterate_wavefronts; + struct { + const char* module_name; + hsa_code_symbol_t* symbol; + hsa_code_object_t code_object; + const char* symbol_name; + } hsa_code_object_get_symbol_from_name; + struct { + hsa_code_object_reader_t* code_object_reader; + hsa_file_t file; + } hsa_code_object_reader_create_from_file; + struct { + hsa_code_object_reader_t* code_object_reader; + const void* code_object; + size_t size; + } 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; + hsa_executable_t* executable; + const char* options; + } hsa_executable_create_alt; + struct { + hsa_code_object_reader_t code_object_reader; + hsa_executable_t executable; + hsa_loaded_code_object_t* loaded_code_object; + const char* options; + } hsa_executable_load_program_code_object; + struct { + hsa_code_object_reader_t code_object_reader; + hsa_executable_t executable; + hsa_loaded_code_object_t* loaded_code_object; + const char* options; + hsa_agent_t agent; + } hsa_executable_load_agent_code_object; + struct { + hsa_executable_t executable; + const char* options; + uint32_t* result; + } hsa_executable_validate_alt; + struct { + hsa_executable_symbol_t* symbol; + hsa_executable_t executable; + const char* symbol_name; + const hsa_agent_t* agent; + } hsa_executable_get_symbol_by_name; + struct { + hsa_status_t (* callback)(hsa_executable_t exec,hsa_agent_t agent,hsa_executable_symbol_t symbol,void* data); + hsa_executable_t executable; + void* data; + hsa_agent_t agent; + } hsa_executable_iterate_agent_symbols; + struct { + hsa_status_t (* callback)(hsa_executable_t exec,hsa_executable_symbol_t symbol,void* data); + hsa_executable_t executable; + void* data; + } hsa_executable_iterate_program_symbols; + + // block: AmdExtTable API + struct { + hsa_amd_coherency_type_t* type; + hsa_agent_t agent; + } hsa_amd_coherency_get_type; + struct { + hsa_amd_coherency_type_t type; + hsa_agent_t agent; + } 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_signal_t signal; + hsa_agent_t agent; + 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 { + uint64_t* system_tick; + hsa_agent_t agent; + uint64_t agent_tick; + } hsa_amd_profiling_convert_tick_to_system_domain; + struct { + hsa_signal_t signal; + hsa_amd_signal_handler handler; + hsa_signal_condition_t cond; + hsa_signal_value_t value; + void* arg; + } hsa_amd_signal_async_handler; + struct { + void (* callback)(void* arg); + void* arg; + } hsa_amd_async_function; + struct { + uint64_t timeout_hint; + uint32_t signal_count; + hsa_signal_condition_t* conds; + hsa_signal_t* signals; + hsa_signal_value_t* values; + hsa_signal_value_t* satisfying_value; + hsa_wait_state_t wait_hint; + } hsa_amd_signal_wait_any; + struct { + const hsa_queue_t* queue; + const uint32_t* cu_mask; + uint32_t num_cu_mask_count; + } hsa_amd_queue_cu_set_mask; + struct { + hsa_amd_memory_pool_info_t attribute; + hsa_amd_memory_pool_t memory_pool; + void* value; + } hsa_amd_memory_pool_get_info; + struct { + hsa_status_t (* callback)(hsa_amd_memory_pool_t memory_pool,void* data); + void* data; + hsa_agent_t agent; + } hsa_amd_agent_iterate_memory_pools; + struct { + void** ptr; + uint32_t flags; + hsa_amd_memory_pool_t memory_pool; + size_t size; + } hsa_amd_memory_pool_allocate; + struct { + void* ptr; + } hsa_amd_memory_pool_free; + struct { + hsa_signal_t completion_signal; + const void* src; + void* dst; + uint32_t num_dep_signals; + hsa_agent_t src_agent; + const hsa_signal_t* dep_signals; + hsa_agent_t dst_agent; + size_t size; + } hsa_amd_memory_async_copy; + struct { + hsa_amd_agent_memory_pool_info_t attribute; + void* value; + hsa_amd_memory_pool_t memory_pool; + hsa_agent_t agent; + } hsa_amd_agent_memory_pool_get_info; + struct { + const uint32_t* flags; + const hsa_agent_t* agents; + const void* ptr; + uint32_t num_agents; + } 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 { + uint32_t flags; + const void* ptr; + hsa_amd_memory_pool_t memory_pool; + } hsa_amd_memory_migrate; + struct { + void* host_ptr; + int num_agent; + hsa_agent_t* agents; + void** agent_ptr; + size_t size; + } hsa_amd_memory_lock; + struct { + void* host_ptr; + } hsa_amd_memory_unlock; + struct { + size_t count; + void* ptr; + uint32_t value; + } hsa_amd_memory_fill; + struct { + uint32_t num_agents; + size_t* metadata_size; + uint32_t flags; + hsa_agent_t* agents; + const void** metadata; + void** ptr; + int interop_handle; + size_t* size; + } hsa_amd_interop_map_buffer; + struct { + void* ptr; + } hsa_amd_interop_unmap_buffer; + struct { + const hsa_ext_image_descriptor_t* image_descriptor; + hsa_ext_image_t* image; + hsa_agent_t agent; + hsa_access_permission_t access_permission; + const void* image_data; + const hsa_amd_image_descriptor_t* image_layout; + } hsa_amd_image_create; + struct { + hsa_amd_pointer_info_t* info; + hsa_agent_t** accessible; + void* (* alloc)(size_t); + void* ptr; + uint32_t* num_agents_accessible; + } hsa_amd_pointer_info; + struct { + void* userdata; + void* ptr; + } hsa_amd_pointer_info_set_userdata; + struct { + hsa_amd_ipc_memory_t* handle; + void* ptr; + size_t len; + } hsa_amd_ipc_memory_create; + struct { + void** mapped_ptr; + const hsa_amd_ipc_memory_t* handle; + const hsa_agent_t* mapping_agents; + size_t len; + uint32_t num_agents; + } hsa_amd_ipc_memory_attach; + struct { + void* mapped_ptr; + } hsa_amd_ipc_memory_detach; + struct { + uint64_t attributes; + hsa_signal_t* signal; + uint32_t num_consumers; + const hsa_agent_t* consumers; + hsa_signal_value_t initial_value; + } hsa_amd_signal_create; + struct { + hsa_signal_t signal; + hsa_amd_ipc_signal_t* handle; + } hsa_amd_ipc_signal_create; + struct { + hsa_signal_t* signal; + const hsa_amd_ipc_signal_t* handle; + } 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 private_segment_size; + void* data; + hsa_queue_t** queue; + void (* callback)(hsa_status_t status,hsa_queue_t* source,void* data); + uint32_t group_segment_size; + hsa_queue_type32_t type; + uint32_t size; + } 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 { + hsa_signal_t completion_signal; + const hsa_pitched_ptr_t* src; + const hsa_dim3_t* src_offset; + const hsa_dim3_t* dst_offset; + const hsa_pitched_ptr_t* dst; + const hsa_signal_t* dep_signals; + uint32_t num_dep_signals; + const hsa_dim3_t* range; + hsa_agent_t copy_agent; + hsa_amd_copy_direction_t dir; + } hsa_amd_memory_async_copy_rect; + struct { + hsa_amd_runtime_queue_notifier callback; + void* user_data; + } hsa_amd_runtime_queue_create_register; + + // block: ImageExtTable API + struct { + hsa_ext_image_geometry_t geometry; + uint32_t* capability_mask; + const hsa_ext_image_format_t* image_format; + hsa_agent_t agent; + } hsa_ext_image_get_capability; + struct { + const hsa_ext_image_descriptor_t* image_descriptor; + hsa_ext_image_data_info_t* image_data_info; + hsa_agent_t agent; + hsa_access_permission_t access_permission; + } hsa_ext_image_data_get_info; + struct { + const void* image_data; + const hsa_ext_image_descriptor_t* image_descriptor; + hsa_ext_image_t* image; + hsa_agent_t agent; + hsa_access_permission_t access_permission; + } hsa_ext_image_create; + struct { + size_t src_row_pitch; + const hsa_ext_image_region_t* image_region; + hsa_agent_t agent; + size_t src_slice_pitch; + const void* src_memory; + hsa_ext_image_t dst_image; + } hsa_ext_image_import; + struct { + size_t dst_slice_pitch; + const hsa_ext_image_region_t* image_region; + hsa_agent_t agent; + size_t dst_row_pitch; + hsa_ext_image_t src_image; + void* dst_memory; + } hsa_ext_image_export; + struct { + const hsa_dim3_t* src_offset; + const hsa_dim3_t* dst_offset; + hsa_agent_t agent; + const hsa_dim3_t* range; + hsa_ext_image_t src_image; + hsa_ext_image_t dst_image; + } hsa_ext_image_copy; + struct { + hsa_ext_image_t image; + const void* data; + const hsa_ext_image_region_t* image_region; + hsa_agent_t agent; + } hsa_ext_image_clear; + struct { + hsa_ext_image_t image; + hsa_agent_t agent; + } hsa_ext_image_destroy; + struct { + const hsa_ext_sampler_descriptor_t* sampler_descriptor; + hsa_agent_t agent; + 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_ext_image_geometry_t geometry; + hsa_ext_image_data_layout_t image_data_layout; + const hsa_ext_image_format_t* image_format; + uint32_t* capability_mask; + hsa_agent_t agent; + } hsa_ext_image_get_capability_with_layout; + struct { + const hsa_ext_image_descriptor_t* image_descriptor; + hsa_ext_image_data_layout_t image_data_layout; + size_t image_data_row_pitch; + hsa_agent_t agent; + hsa_access_permission_t access_permission; + size_t image_data_slice_pitch; + hsa_ext_image_data_info_t* image_data_info; + } hsa_ext_image_data_get_info_with_layout; + struct { + const hsa_ext_image_descriptor_t* image_descriptor; + hsa_ext_image_data_layout_t image_data_layout; + size_t image_data_row_pitch; + hsa_agent_t agent; + size_t image_data_slice_pitch; + hsa_access_permission_t access_permission; + const void* image_data; + hsa_ext_image_t* image; + } hsa_ext_image_create_with_layout; + } args; +}; + +#if PROF_API_IMPL +namespace roctracer { +namespace hsa_support { + +// section: API callback functions + +typedef CbTable cb_table_t; +extern cb_table_t cb_table; + +// block: CoreApiTable API +static hsa_status_t hsa_init_callback() { + hsa_api_data_t api_data{}; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_init, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_init, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_init_fn(); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_init, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_shut_down_callback() { + hsa_api_data_t api_data{}; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_shut_down, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_shut_down, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_shut_down_fn(); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_shut_down, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_system_get_info_callback(hsa_system_info_t attribute, void* value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_system_get_info.attribute = attribute; + api_data.args.hsa_system_get_info.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_system_get_info, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_system_get_info, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_system_get_info_fn(attribute, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_system_get_info, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_system_extension_supported_callback(uint16_t extension, uint16_t version_major, uint16_t version_minor, bool* result) { + hsa_api_data_t api_data{}; + api_data.args.hsa_system_extension_supported.version_minor = version_minor; + api_data.args.hsa_system_extension_supported.result = result; + api_data.args.hsa_system_extension_supported.extension = extension; + api_data.args.hsa_system_extension_supported.version_major = version_major; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_system_extension_supported, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_system_extension_supported, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_system_extension_supported_fn(extension, version_major, version_minor, result); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_system_extension_supported, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_system_get_extension_table_callback(uint16_t extension, uint16_t version_major, uint16_t version_minor, void* table) { + hsa_api_data_t api_data{}; + api_data.args.hsa_system_get_extension_table.table = table; + api_data.args.hsa_system_get_extension_table.version_minor = version_minor; + api_data.args.hsa_system_get_extension_table.extension = extension; + api_data.args.hsa_system_get_extension_table.version_major = version_major; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_system_get_extension_table, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_system_get_extension_table, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_system_get_extension_table_fn(extension, version_major, version_minor, table); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_system_get_extension_table, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_iterate_agents_callback(hsa_status_t (* callback)(hsa_agent_t agent, void* data), void* data) { + hsa_api_data_t api_data{}; + api_data.args.hsa_iterate_agents.callback = callback; + api_data.args.hsa_iterate_agents.data = data; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_iterate_agents, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_iterate_agents, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_iterate_agents_fn(callback, data); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_iterate_agents, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_agent_get_info_callback(hsa_agent_t agent, hsa_agent_info_t attribute, void* value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_agent_get_info.attribute = attribute; + api_data.args.hsa_agent_get_info.value = value; + api_data.args.hsa_agent_get_info.agent = agent; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_agent_get_info, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_agent_get_info, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_agent_get_info_fn(agent, attribute, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_agent_get_info, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_queue_create_callback(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_api_data_t api_data{}; + api_data.args.hsa_queue_create.private_segment_size = private_segment_size; + api_data.args.hsa_queue_create.data = data; + api_data.args.hsa_queue_create.agent = agent; + api_data.args.hsa_queue_create.queue = queue; + api_data.args.hsa_queue_create.callback = callback; + api_data.args.hsa_queue_create.group_segment_size = group_segment_size; + api_data.args.hsa_queue_create.type = type; + api_data.args.hsa_queue_create.size = size; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_queue_create, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_create, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_queue_create_fn(agent, size, type, callback, data, private_segment_size, group_segment_size, queue); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_create, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_soft_queue_create_callback(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_api_data_t api_data{}; + api_data.args.hsa_soft_queue_create.features = features; + api_data.args.hsa_soft_queue_create.region = region; + api_data.args.hsa_soft_queue_create.queue = queue; + api_data.args.hsa_soft_queue_create.doorbell_signal = doorbell_signal; + api_data.args.hsa_soft_queue_create.type = type; + api_data.args.hsa_soft_queue_create.size = size; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_soft_queue_create, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_soft_queue_create, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_soft_queue_create_fn(region, size, type, features, doorbell_signal, queue); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_soft_queue_create, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_queue_destroy_callback(hsa_queue_t* queue) { + hsa_api_data_t api_data{}; + api_data.args.hsa_queue_destroy.queue = queue; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_queue_destroy, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_destroy, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_queue_destroy_fn(queue); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_destroy, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_queue_inactivate_callback(hsa_queue_t* queue) { + hsa_api_data_t api_data{}; + api_data.args.hsa_queue_inactivate.queue = queue; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_queue_inactivate, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_inactivate, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_queue_inactivate_fn(queue); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_inactivate, &api_data, api_callback_arg); + return ret; +} +static uint64_t hsa_queue_load_read_index_scacquire_callback(const hsa_queue_t* queue) { + hsa_api_data_t api_data{}; + api_data.args.hsa_queue_load_read_index_scacquire.queue = queue; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_queue_load_read_index_scacquire, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_load_read_index_scacquire, &api_data, api_callback_arg); + uint64_t ret = CoreApiTable_saved.hsa_queue_load_read_index_scacquire_fn(queue); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_load_read_index_scacquire, &api_data, api_callback_arg); + return ret; +} +static uint64_t hsa_queue_load_read_index_relaxed_callback(const hsa_queue_t* queue) { + hsa_api_data_t api_data{}; + api_data.args.hsa_queue_load_read_index_relaxed.queue = queue; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_queue_load_read_index_relaxed, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_load_read_index_relaxed, &api_data, api_callback_arg); + uint64_t ret = CoreApiTable_saved.hsa_queue_load_read_index_relaxed_fn(queue); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_load_read_index_relaxed, &api_data, api_callback_arg); + return ret; +} +static uint64_t hsa_queue_load_write_index_scacquire_callback(const hsa_queue_t* queue) { + hsa_api_data_t api_data{}; + api_data.args.hsa_queue_load_write_index_scacquire.queue = queue; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_queue_load_write_index_scacquire, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_load_write_index_scacquire, &api_data, api_callback_arg); + uint64_t ret = CoreApiTable_saved.hsa_queue_load_write_index_scacquire_fn(queue); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_load_write_index_scacquire, &api_data, api_callback_arg); + return ret; +} +static uint64_t hsa_queue_load_write_index_relaxed_callback(const hsa_queue_t* queue) { + hsa_api_data_t api_data{}; + api_data.args.hsa_queue_load_write_index_relaxed.queue = queue; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_queue_load_write_index_relaxed, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_load_write_index_relaxed, &api_data, api_callback_arg); + uint64_t ret = CoreApiTable_saved.hsa_queue_load_write_index_relaxed_fn(queue); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_load_write_index_relaxed, &api_data, api_callback_arg); + return ret; +} +static void hsa_queue_store_write_index_relaxed_callback(const hsa_queue_t* queue, uint64_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_queue_store_write_index_relaxed.queue = queue; + api_data.args.hsa_queue_store_write_index_relaxed.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_queue_store_write_index_relaxed, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_store_write_index_relaxed, &api_data, api_callback_arg); + CoreApiTable_saved.hsa_queue_store_write_index_relaxed_fn(queue, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_store_write_index_relaxed, &api_data, api_callback_arg); +} +static void hsa_queue_store_write_index_screlease_callback(const hsa_queue_t* queue, uint64_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_queue_store_write_index_screlease.queue = queue; + api_data.args.hsa_queue_store_write_index_screlease.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_queue_store_write_index_screlease, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_store_write_index_screlease, &api_data, api_callback_arg); + CoreApiTable_saved.hsa_queue_store_write_index_screlease_fn(queue, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_store_write_index_screlease, &api_data, api_callback_arg); +} +static uint64_t hsa_queue_cas_write_index_scacq_screl_callback(const hsa_queue_t* queue, uint64_t expected, uint64_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_queue_cas_write_index_scacq_screl.queue = queue; + api_data.args.hsa_queue_cas_write_index_scacq_screl.expected = expected; + api_data.args.hsa_queue_cas_write_index_scacq_screl.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_queue_cas_write_index_scacq_screl, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_cas_write_index_scacq_screl, &api_data, api_callback_arg); + uint64_t ret = CoreApiTable_saved.hsa_queue_cas_write_index_scacq_screl_fn(queue, expected, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_cas_write_index_scacq_screl, &api_data, api_callback_arg); + return ret; +} +static uint64_t hsa_queue_cas_write_index_scacquire_callback(const hsa_queue_t* queue, uint64_t expected, uint64_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_queue_cas_write_index_scacquire.queue = queue; + api_data.args.hsa_queue_cas_write_index_scacquire.expected = expected; + api_data.args.hsa_queue_cas_write_index_scacquire.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_queue_cas_write_index_scacquire, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_cas_write_index_scacquire, &api_data, api_callback_arg); + uint64_t ret = CoreApiTable_saved.hsa_queue_cas_write_index_scacquire_fn(queue, expected, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_cas_write_index_scacquire, &api_data, api_callback_arg); + return ret; +} +static uint64_t hsa_queue_cas_write_index_relaxed_callback(const hsa_queue_t* queue, uint64_t expected, uint64_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_queue_cas_write_index_relaxed.queue = queue; + api_data.args.hsa_queue_cas_write_index_relaxed.expected = expected; + api_data.args.hsa_queue_cas_write_index_relaxed.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_queue_cas_write_index_relaxed, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_cas_write_index_relaxed, &api_data, api_callback_arg); + uint64_t ret = CoreApiTable_saved.hsa_queue_cas_write_index_relaxed_fn(queue, expected, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_cas_write_index_relaxed, &api_data, api_callback_arg); + return ret; +} +static uint64_t hsa_queue_cas_write_index_screlease_callback(const hsa_queue_t* queue, uint64_t expected, uint64_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_queue_cas_write_index_screlease.queue = queue; + api_data.args.hsa_queue_cas_write_index_screlease.expected = expected; + api_data.args.hsa_queue_cas_write_index_screlease.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_queue_cas_write_index_screlease, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_cas_write_index_screlease, &api_data, api_callback_arg); + uint64_t ret = CoreApiTable_saved.hsa_queue_cas_write_index_screlease_fn(queue, expected, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_cas_write_index_screlease, &api_data, api_callback_arg); + return ret; +} +static uint64_t hsa_queue_add_write_index_scacq_screl_callback(const hsa_queue_t* queue, uint64_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_queue_add_write_index_scacq_screl.queue = queue; + api_data.args.hsa_queue_add_write_index_scacq_screl.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_queue_add_write_index_scacq_screl, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_add_write_index_scacq_screl, &api_data, api_callback_arg); + uint64_t ret = CoreApiTable_saved.hsa_queue_add_write_index_scacq_screl_fn(queue, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_add_write_index_scacq_screl, &api_data, api_callback_arg); + return ret; +} +static uint64_t hsa_queue_add_write_index_scacquire_callback(const hsa_queue_t* queue, uint64_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_queue_add_write_index_scacquire.queue = queue; + api_data.args.hsa_queue_add_write_index_scacquire.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_queue_add_write_index_scacquire, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_add_write_index_scacquire, &api_data, api_callback_arg); + uint64_t ret = CoreApiTable_saved.hsa_queue_add_write_index_scacquire_fn(queue, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_add_write_index_scacquire, &api_data, api_callback_arg); + return ret; +} +static uint64_t hsa_queue_add_write_index_relaxed_callback(const hsa_queue_t* queue, uint64_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_queue_add_write_index_relaxed.queue = queue; + api_data.args.hsa_queue_add_write_index_relaxed.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_queue_add_write_index_relaxed, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_add_write_index_relaxed, &api_data, api_callback_arg); + uint64_t ret = CoreApiTable_saved.hsa_queue_add_write_index_relaxed_fn(queue, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_add_write_index_relaxed, &api_data, api_callback_arg); + return ret; +} +static uint64_t hsa_queue_add_write_index_screlease_callback(const hsa_queue_t* queue, uint64_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_queue_add_write_index_screlease.queue = queue; + api_data.args.hsa_queue_add_write_index_screlease.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_queue_add_write_index_screlease, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_add_write_index_screlease, &api_data, api_callback_arg); + uint64_t ret = CoreApiTable_saved.hsa_queue_add_write_index_screlease_fn(queue, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_add_write_index_screlease, &api_data, api_callback_arg); + return ret; +} +static void hsa_queue_store_read_index_relaxed_callback(const hsa_queue_t* queue, uint64_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_queue_store_read_index_relaxed.queue = queue; + api_data.args.hsa_queue_store_read_index_relaxed.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_queue_store_read_index_relaxed, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_store_read_index_relaxed, &api_data, api_callback_arg); + CoreApiTable_saved.hsa_queue_store_read_index_relaxed_fn(queue, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_store_read_index_relaxed, &api_data, api_callback_arg); +} +static void hsa_queue_store_read_index_screlease_callback(const hsa_queue_t* queue, uint64_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_queue_store_read_index_screlease.queue = queue; + api_data.args.hsa_queue_store_read_index_screlease.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_queue_store_read_index_screlease, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_store_read_index_screlease, &api_data, api_callback_arg); + CoreApiTable_saved.hsa_queue_store_read_index_screlease_fn(queue, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_queue_store_read_index_screlease, &api_data, api_callback_arg); +} +static hsa_status_t hsa_agent_iterate_regions_callback(hsa_agent_t agent, hsa_status_t (* callback)(hsa_region_t region, void* data), void* data) { + hsa_api_data_t api_data{}; + api_data.args.hsa_agent_iterate_regions.callback = callback; + api_data.args.hsa_agent_iterate_regions.data = data; + api_data.args.hsa_agent_iterate_regions.agent = agent; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_agent_iterate_regions, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_agent_iterate_regions, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_agent_iterate_regions_fn(agent, callback, data); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_agent_iterate_regions, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_region_get_info_callback(hsa_region_t region, hsa_region_info_t attribute, void* value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_region_get_info.attribute = attribute; + api_data.args.hsa_region_get_info.region = region; + api_data.args.hsa_region_get_info.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_region_get_info, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_region_get_info, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_region_get_info_fn(region, attribute, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_region_get_info, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_agent_get_exception_policies_callback(hsa_agent_t agent, hsa_profile_t profile, uint16_t* mask) { + hsa_api_data_t api_data{}; + api_data.args.hsa_agent_get_exception_policies.profile = profile; + api_data.args.hsa_agent_get_exception_policies.mask = mask; + api_data.args.hsa_agent_get_exception_policies.agent = agent; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_agent_get_exception_policies, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_agent_get_exception_policies, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_agent_get_exception_policies_fn(agent, profile, mask); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_agent_get_exception_policies, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_agent_extension_supported_callback(uint16_t extension, hsa_agent_t agent, uint16_t version_major, uint16_t version_minor, bool* result) { + hsa_api_data_t api_data{}; + api_data.args.hsa_agent_extension_supported.result = result; + api_data.args.hsa_agent_extension_supported.version_minor = version_minor; + api_data.args.hsa_agent_extension_supported.agent = agent; + api_data.args.hsa_agent_extension_supported.extension = extension; + api_data.args.hsa_agent_extension_supported.version_major = version_major; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_agent_extension_supported, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_agent_extension_supported, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_agent_extension_supported_fn(extension, agent, version_major, version_minor, result); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_agent_extension_supported, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_memory_register_callback(void* ptr, size_t size) { + hsa_api_data_t api_data{}; + api_data.args.hsa_memory_register.ptr = ptr; + api_data.args.hsa_memory_register.size = size; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_memory_register, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_memory_register, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_memory_register_fn(ptr, size); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_memory_register, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_memory_deregister_callback(void* ptr, size_t size) { + hsa_api_data_t api_data{}; + api_data.args.hsa_memory_deregister.ptr = ptr; + api_data.args.hsa_memory_deregister.size = size; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_memory_deregister, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_memory_deregister, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_memory_deregister_fn(ptr, size); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_memory_deregister, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_memory_allocate_callback(hsa_region_t region, size_t size, void** ptr) { + hsa_api_data_t api_data{}; + api_data.args.hsa_memory_allocate.region = region; + api_data.args.hsa_memory_allocate.ptr = ptr; + api_data.args.hsa_memory_allocate.size = size; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_memory_allocate, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_memory_allocate, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_memory_allocate_fn(region, size, ptr); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_memory_allocate, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_memory_free_callback(void* ptr) { + hsa_api_data_t api_data{}; + api_data.args.hsa_memory_free.ptr = ptr; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_memory_free, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_memory_free, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_memory_free_fn(ptr); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_memory_free, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_memory_copy_callback(void* dst, const void* src, size_t size) { + hsa_api_data_t api_data{}; + api_data.args.hsa_memory_copy.src = src; + api_data.args.hsa_memory_copy.dst = dst; + api_data.args.hsa_memory_copy.size = size; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_memory_copy, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_memory_copy, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_memory_copy_fn(dst, src, size); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_memory_copy, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_memory_assign_agent_callback(void* ptr, hsa_agent_t agent, hsa_access_permission_t access) { + hsa_api_data_t api_data{}; + api_data.args.hsa_memory_assign_agent.access = access; + api_data.args.hsa_memory_assign_agent.ptr = ptr; + api_data.args.hsa_memory_assign_agent.agent = agent; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_memory_assign_agent, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_memory_assign_agent, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_memory_assign_agent_fn(ptr, agent, access); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_memory_assign_agent, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_signal_create_callback(hsa_signal_value_t initial_value, uint32_t num_consumers, const hsa_agent_t* consumers, hsa_signal_t* signal) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_create.signal = signal; + api_data.args.hsa_signal_create.num_consumers = num_consumers; + api_data.args.hsa_signal_create.consumers = consumers; + api_data.args.hsa_signal_create.initial_value = initial_value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_create, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_create, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_signal_create_fn(initial_value, num_consumers, consumers, signal); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_create, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_signal_destroy_callback(hsa_signal_t signal) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_destroy.signal = signal; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_destroy, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_destroy, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_signal_destroy_fn(signal); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_destroy, &api_data, api_callback_arg); + return ret; +} +static hsa_signal_value_t hsa_signal_load_relaxed_callback(hsa_signal_t signal) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_load_relaxed.signal = signal; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_load_relaxed, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_load_relaxed, &api_data, api_callback_arg); + hsa_signal_value_t ret = CoreApiTable_saved.hsa_signal_load_relaxed_fn(signal); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_load_relaxed, &api_data, api_callback_arg); + return ret; +} +static hsa_signal_value_t hsa_signal_load_scacquire_callback(hsa_signal_t signal) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_load_scacquire.signal = signal; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_load_scacquire, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_load_scacquire, &api_data, api_callback_arg); + hsa_signal_value_t ret = CoreApiTable_saved.hsa_signal_load_scacquire_fn(signal); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_load_scacquire, &api_data, api_callback_arg); + return ret; +} +static void hsa_signal_store_relaxed_callback(hsa_signal_t signal, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_store_relaxed.signal = signal; + api_data.args.hsa_signal_store_relaxed.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_store_relaxed, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_store_relaxed, &api_data, api_callback_arg); + CoreApiTable_saved.hsa_signal_store_relaxed_fn(signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_store_relaxed, &api_data, api_callback_arg); +} +static void hsa_signal_store_screlease_callback(hsa_signal_t signal, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_store_screlease.signal = signal; + api_data.args.hsa_signal_store_screlease.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_store_screlease, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_store_screlease, &api_data, api_callback_arg); + CoreApiTable_saved.hsa_signal_store_screlease_fn(signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_store_screlease, &api_data, api_callback_arg); +} +static hsa_signal_value_t hsa_signal_wait_relaxed_callback(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_api_data_t api_data{}; + api_data.args.hsa_signal_wait_relaxed.signal = signal; + api_data.args.hsa_signal_wait_relaxed.timeout_hint = timeout_hint; + api_data.args.hsa_signal_wait_relaxed.wait_state_hint = wait_state_hint; + api_data.args.hsa_signal_wait_relaxed.compare_value = compare_value; + api_data.args.hsa_signal_wait_relaxed.condition = condition; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_wait_relaxed, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_wait_relaxed, &api_data, api_callback_arg); + hsa_signal_value_t ret = CoreApiTable_saved.hsa_signal_wait_relaxed_fn(signal, condition, compare_value, timeout_hint, wait_state_hint); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_wait_relaxed, &api_data, api_callback_arg); + return ret; +} +static hsa_signal_value_t hsa_signal_wait_scacquire_callback(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_api_data_t api_data{}; + api_data.args.hsa_signal_wait_scacquire.signal = signal; + api_data.args.hsa_signal_wait_scacquire.timeout_hint = timeout_hint; + api_data.args.hsa_signal_wait_scacquire.wait_state_hint = wait_state_hint; + api_data.args.hsa_signal_wait_scacquire.compare_value = compare_value; + api_data.args.hsa_signal_wait_scacquire.condition = condition; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_wait_scacquire, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_wait_scacquire, &api_data, api_callback_arg); + hsa_signal_value_t ret = CoreApiTable_saved.hsa_signal_wait_scacquire_fn(signal, condition, compare_value, timeout_hint, wait_state_hint); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_wait_scacquire, &api_data, api_callback_arg); + return ret; +} +static void hsa_signal_and_relaxed_callback(hsa_signal_t signal, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_and_relaxed.signal = signal; + api_data.args.hsa_signal_and_relaxed.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_and_relaxed, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_and_relaxed, &api_data, api_callback_arg); + CoreApiTable_saved.hsa_signal_and_relaxed_fn(signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_and_relaxed, &api_data, api_callback_arg); +} +static void hsa_signal_and_scacquire_callback(hsa_signal_t signal, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_and_scacquire.signal = signal; + api_data.args.hsa_signal_and_scacquire.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_and_scacquire, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_and_scacquire, &api_data, api_callback_arg); + CoreApiTable_saved.hsa_signal_and_scacquire_fn(signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_and_scacquire, &api_data, api_callback_arg); +} +static void hsa_signal_and_screlease_callback(hsa_signal_t signal, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_and_screlease.signal = signal; + api_data.args.hsa_signal_and_screlease.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_and_screlease, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_and_screlease, &api_data, api_callback_arg); + CoreApiTable_saved.hsa_signal_and_screlease_fn(signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_and_screlease, &api_data, api_callback_arg); +} +static void hsa_signal_and_scacq_screl_callback(hsa_signal_t signal, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_and_scacq_screl.signal = signal; + api_data.args.hsa_signal_and_scacq_screl.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_and_scacq_screl, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_and_scacq_screl, &api_data, api_callback_arg); + CoreApiTable_saved.hsa_signal_and_scacq_screl_fn(signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_and_scacq_screl, &api_data, api_callback_arg); +} +static void hsa_signal_or_relaxed_callback(hsa_signal_t signal, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_or_relaxed.signal = signal; + api_data.args.hsa_signal_or_relaxed.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_or_relaxed, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_or_relaxed, &api_data, api_callback_arg); + CoreApiTable_saved.hsa_signal_or_relaxed_fn(signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_or_relaxed, &api_data, api_callback_arg); +} +static void hsa_signal_or_scacquire_callback(hsa_signal_t signal, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_or_scacquire.signal = signal; + api_data.args.hsa_signal_or_scacquire.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_or_scacquire, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_or_scacquire, &api_data, api_callback_arg); + CoreApiTable_saved.hsa_signal_or_scacquire_fn(signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_or_scacquire, &api_data, api_callback_arg); +} +static void hsa_signal_or_screlease_callback(hsa_signal_t signal, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_or_screlease.signal = signal; + api_data.args.hsa_signal_or_screlease.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_or_screlease, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_or_screlease, &api_data, api_callback_arg); + CoreApiTable_saved.hsa_signal_or_screlease_fn(signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_or_screlease, &api_data, api_callback_arg); +} +static void hsa_signal_or_scacq_screl_callback(hsa_signal_t signal, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_or_scacq_screl.signal = signal; + api_data.args.hsa_signal_or_scacq_screl.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_or_scacq_screl, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_or_scacq_screl, &api_data, api_callback_arg); + CoreApiTable_saved.hsa_signal_or_scacq_screl_fn(signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_or_scacq_screl, &api_data, api_callback_arg); +} +static void hsa_signal_xor_relaxed_callback(hsa_signal_t signal, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_xor_relaxed.signal = signal; + api_data.args.hsa_signal_xor_relaxed.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_xor_relaxed, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_xor_relaxed, &api_data, api_callback_arg); + CoreApiTable_saved.hsa_signal_xor_relaxed_fn(signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_xor_relaxed, &api_data, api_callback_arg); +} +static void hsa_signal_xor_scacquire_callback(hsa_signal_t signal, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_xor_scacquire.signal = signal; + api_data.args.hsa_signal_xor_scacquire.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_xor_scacquire, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_xor_scacquire, &api_data, api_callback_arg); + CoreApiTable_saved.hsa_signal_xor_scacquire_fn(signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_xor_scacquire, &api_data, api_callback_arg); +} +static void hsa_signal_xor_screlease_callback(hsa_signal_t signal, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_xor_screlease.signal = signal; + api_data.args.hsa_signal_xor_screlease.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_xor_screlease, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_xor_screlease, &api_data, api_callback_arg); + CoreApiTable_saved.hsa_signal_xor_screlease_fn(signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_xor_screlease, &api_data, api_callback_arg); +} +static void hsa_signal_xor_scacq_screl_callback(hsa_signal_t signal, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_xor_scacq_screl.signal = signal; + api_data.args.hsa_signal_xor_scacq_screl.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_xor_scacq_screl, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_xor_scacq_screl, &api_data, api_callback_arg); + CoreApiTable_saved.hsa_signal_xor_scacq_screl_fn(signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_xor_scacq_screl, &api_data, api_callback_arg); +} +static hsa_signal_value_t hsa_signal_exchange_relaxed_callback(hsa_signal_t signal, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_exchange_relaxed.signal = signal; + api_data.args.hsa_signal_exchange_relaxed.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_exchange_relaxed, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_exchange_relaxed, &api_data, api_callback_arg); + hsa_signal_value_t ret = CoreApiTable_saved.hsa_signal_exchange_relaxed_fn(signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_exchange_relaxed, &api_data, api_callback_arg); + return ret; +} +static hsa_signal_value_t hsa_signal_exchange_scacquire_callback(hsa_signal_t signal, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_exchange_scacquire.signal = signal; + api_data.args.hsa_signal_exchange_scacquire.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_exchange_scacquire, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_exchange_scacquire, &api_data, api_callback_arg); + hsa_signal_value_t ret = CoreApiTable_saved.hsa_signal_exchange_scacquire_fn(signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_exchange_scacquire, &api_data, api_callback_arg); + return ret; +} +static hsa_signal_value_t hsa_signal_exchange_screlease_callback(hsa_signal_t signal, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_exchange_screlease.signal = signal; + api_data.args.hsa_signal_exchange_screlease.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_exchange_screlease, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_exchange_screlease, &api_data, api_callback_arg); + hsa_signal_value_t ret = CoreApiTable_saved.hsa_signal_exchange_screlease_fn(signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_exchange_screlease, &api_data, api_callback_arg); + return ret; +} +static hsa_signal_value_t hsa_signal_exchange_scacq_screl_callback(hsa_signal_t signal, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_exchange_scacq_screl.signal = signal; + api_data.args.hsa_signal_exchange_scacq_screl.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_exchange_scacq_screl, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_exchange_scacq_screl, &api_data, api_callback_arg); + hsa_signal_value_t ret = CoreApiTable_saved.hsa_signal_exchange_scacq_screl_fn(signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_exchange_scacq_screl, &api_data, api_callback_arg); + return ret; +} +static void hsa_signal_add_relaxed_callback(hsa_signal_t signal, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_add_relaxed.signal = signal; + api_data.args.hsa_signal_add_relaxed.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_add_relaxed, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_add_relaxed, &api_data, api_callback_arg); + CoreApiTable_saved.hsa_signal_add_relaxed_fn(signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_add_relaxed, &api_data, api_callback_arg); +} +static void hsa_signal_add_scacquire_callback(hsa_signal_t signal, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_add_scacquire.signal = signal; + api_data.args.hsa_signal_add_scacquire.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_add_scacquire, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_add_scacquire, &api_data, api_callback_arg); + CoreApiTable_saved.hsa_signal_add_scacquire_fn(signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_add_scacquire, &api_data, api_callback_arg); +} +static void hsa_signal_add_screlease_callback(hsa_signal_t signal, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_add_screlease.signal = signal; + api_data.args.hsa_signal_add_screlease.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_add_screlease, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_add_screlease, &api_data, api_callback_arg); + CoreApiTable_saved.hsa_signal_add_screlease_fn(signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_add_screlease, &api_data, api_callback_arg); +} +static void hsa_signal_add_scacq_screl_callback(hsa_signal_t signal, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_add_scacq_screl.signal = signal; + api_data.args.hsa_signal_add_scacq_screl.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_add_scacq_screl, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_add_scacq_screl, &api_data, api_callback_arg); + CoreApiTable_saved.hsa_signal_add_scacq_screl_fn(signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_add_scacq_screl, &api_data, api_callback_arg); +} +static void hsa_signal_subtract_relaxed_callback(hsa_signal_t signal, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_subtract_relaxed.signal = signal; + api_data.args.hsa_signal_subtract_relaxed.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_subtract_relaxed, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_subtract_relaxed, &api_data, api_callback_arg); + CoreApiTable_saved.hsa_signal_subtract_relaxed_fn(signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_subtract_relaxed, &api_data, api_callback_arg); +} +static void hsa_signal_subtract_scacquire_callback(hsa_signal_t signal, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_subtract_scacquire.signal = signal; + api_data.args.hsa_signal_subtract_scacquire.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_subtract_scacquire, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_subtract_scacquire, &api_data, api_callback_arg); + CoreApiTable_saved.hsa_signal_subtract_scacquire_fn(signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_subtract_scacquire, &api_data, api_callback_arg); +} +static void hsa_signal_subtract_screlease_callback(hsa_signal_t signal, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_subtract_screlease.signal = signal; + api_data.args.hsa_signal_subtract_screlease.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_subtract_screlease, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_subtract_screlease, &api_data, api_callback_arg); + CoreApiTable_saved.hsa_signal_subtract_screlease_fn(signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_subtract_screlease, &api_data, api_callback_arg); +} +static void hsa_signal_subtract_scacq_screl_callback(hsa_signal_t signal, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_subtract_scacq_screl.signal = signal; + api_data.args.hsa_signal_subtract_scacq_screl.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_subtract_scacq_screl, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_subtract_scacq_screl, &api_data, api_callback_arg); + CoreApiTable_saved.hsa_signal_subtract_scacq_screl_fn(signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_subtract_scacq_screl, &api_data, api_callback_arg); +} +static hsa_signal_value_t hsa_signal_cas_relaxed_callback(hsa_signal_t signal, hsa_signal_value_t expected, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_cas_relaxed.expected = expected; + api_data.args.hsa_signal_cas_relaxed.signal = signal; + api_data.args.hsa_signal_cas_relaxed.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_cas_relaxed, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_cas_relaxed, &api_data, api_callback_arg); + hsa_signal_value_t ret = CoreApiTable_saved.hsa_signal_cas_relaxed_fn(signal, expected, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_cas_relaxed, &api_data, api_callback_arg); + return ret; +} +static hsa_signal_value_t hsa_signal_cas_scacquire_callback(hsa_signal_t signal, hsa_signal_value_t expected, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_cas_scacquire.expected = expected; + api_data.args.hsa_signal_cas_scacquire.signal = signal; + api_data.args.hsa_signal_cas_scacquire.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_cas_scacquire, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_cas_scacquire, &api_data, api_callback_arg); + hsa_signal_value_t ret = CoreApiTable_saved.hsa_signal_cas_scacquire_fn(signal, expected, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_cas_scacquire, &api_data, api_callback_arg); + return ret; +} +static hsa_signal_value_t hsa_signal_cas_screlease_callback(hsa_signal_t signal, hsa_signal_value_t expected, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_cas_screlease.expected = expected; + api_data.args.hsa_signal_cas_screlease.signal = signal; + api_data.args.hsa_signal_cas_screlease.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_cas_screlease, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_cas_screlease, &api_data, api_callback_arg); + hsa_signal_value_t ret = CoreApiTable_saved.hsa_signal_cas_screlease_fn(signal, expected, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_cas_screlease, &api_data, api_callback_arg); + return ret; +} +static hsa_signal_value_t hsa_signal_cas_scacq_screl_callback(hsa_signal_t signal, hsa_signal_value_t expected, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_cas_scacq_screl.expected = expected; + api_data.args.hsa_signal_cas_scacq_screl.signal = signal; + api_data.args.hsa_signal_cas_scacq_screl.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_cas_scacq_screl, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_cas_scacq_screl, &api_data, api_callback_arg); + hsa_signal_value_t ret = CoreApiTable_saved.hsa_signal_cas_scacq_screl_fn(signal, expected, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_cas_scacq_screl, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_isa_from_name_callback(const char* name, hsa_isa_t* isa) { + hsa_api_data_t api_data{}; + api_data.args.hsa_isa_from_name.isa = isa; + api_data.args.hsa_isa_from_name.name = name; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_isa_from_name, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_isa_from_name, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_isa_from_name_fn(name, isa); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_isa_from_name, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_isa_get_info_callback(hsa_isa_t isa, hsa_isa_info_t attribute, uint32_t index, void* value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_isa_get_info.attribute = attribute; + api_data.args.hsa_isa_get_info.isa = isa; + api_data.args.hsa_isa_get_info.value = value; + api_data.args.hsa_isa_get_info.index = index; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_isa_get_info, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_isa_get_info, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_isa_get_info_fn(isa, attribute, index, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_isa_get_info, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_isa_compatible_callback(hsa_isa_t code_object_isa, hsa_isa_t agent_isa, bool* result) { + hsa_api_data_t api_data{}; + api_data.args.hsa_isa_compatible.code_object_isa = code_object_isa; + api_data.args.hsa_isa_compatible.result = result; + api_data.args.hsa_isa_compatible.agent_isa = agent_isa; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_isa_compatible, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_isa_compatible, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_isa_compatible_fn(code_object_isa, agent_isa, result); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_isa_compatible, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_code_object_serialize_callback(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_api_data_t api_data{}; + api_data.args.hsa_code_object_serialize.callback_data = callback_data; + api_data.args.hsa_code_object_serialize.code_object = code_object; + api_data.args.hsa_code_object_serialize.serialized_code_object = serialized_code_object; + api_data.args.hsa_code_object_serialize.serialized_code_object_size = serialized_code_object_size; + api_data.args.hsa_code_object_serialize.alloc_callback = alloc_callback; + api_data.args.hsa_code_object_serialize.options = options; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_code_object_serialize, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_code_object_serialize, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_code_object_serialize_fn(code_object, alloc_callback, callback_data, options, serialized_code_object, serialized_code_object_size); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_code_object_serialize, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_code_object_deserialize_callback(void* serialized_code_object, size_t serialized_code_object_size, const char* options, hsa_code_object_t* code_object) { + hsa_api_data_t api_data{}; + api_data.args.hsa_code_object_deserialize.serialized_code_object = serialized_code_object; + api_data.args.hsa_code_object_deserialize.serialized_code_object_size = serialized_code_object_size; + api_data.args.hsa_code_object_deserialize.code_object = code_object; + api_data.args.hsa_code_object_deserialize.options = options; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_code_object_deserialize, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_code_object_deserialize, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_code_object_deserialize_fn(serialized_code_object, serialized_code_object_size, options, code_object); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_code_object_deserialize, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_code_object_destroy_callback(hsa_code_object_t code_object) { + hsa_api_data_t api_data{}; + api_data.args.hsa_code_object_destroy.code_object = code_object; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_code_object_destroy, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_code_object_destroy, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_code_object_destroy_fn(code_object); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_code_object_destroy, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_code_object_get_info_callback(hsa_code_object_t code_object, hsa_code_object_info_t attribute, void* value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_code_object_get_info.attribute = attribute; + api_data.args.hsa_code_object_get_info.code_object = code_object; + api_data.args.hsa_code_object_get_info.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_code_object_get_info, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_code_object_get_info, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_code_object_get_info_fn(code_object, attribute, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_code_object_get_info, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_code_object_get_symbol_callback(hsa_code_object_t code_object, const char* symbol_name, hsa_code_symbol_t* symbol) { + hsa_api_data_t api_data{}; + api_data.args.hsa_code_object_get_symbol.symbol = symbol; + api_data.args.hsa_code_object_get_symbol.code_object = code_object; + api_data.args.hsa_code_object_get_symbol.symbol_name = symbol_name; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_code_object_get_symbol, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_code_object_get_symbol, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_code_object_get_symbol_fn(code_object, symbol_name, symbol); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_code_object_get_symbol, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_code_symbol_get_info_callback(hsa_code_symbol_t code_symbol, hsa_code_symbol_info_t attribute, void* value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_code_symbol_get_info.code_symbol = code_symbol; + api_data.args.hsa_code_symbol_get_info.value = value; + api_data.args.hsa_code_symbol_get_info.attribute = attribute; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_code_symbol_get_info, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_code_symbol_get_info, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_code_symbol_get_info_fn(code_symbol, attribute, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_code_symbol_get_info, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_code_object_iterate_symbols_callback(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_api_data_t api_data{}; + api_data.args.hsa_code_object_iterate_symbols.callback = callback; + api_data.args.hsa_code_object_iterate_symbols.code_object = code_object; + api_data.args.hsa_code_object_iterate_symbols.data = data; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_code_object_iterate_symbols, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_code_object_iterate_symbols, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_code_object_iterate_symbols_fn(code_object, callback, data); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_code_object_iterate_symbols, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_executable_create_callback(hsa_profile_t profile, hsa_executable_state_t executable_state, const char* options, hsa_executable_t* executable) { + hsa_api_data_t api_data{}; + api_data.args.hsa_executable_create.profile = profile; + api_data.args.hsa_executable_create.executable_state = executable_state; + api_data.args.hsa_executable_create.executable = executable; + api_data.args.hsa_executable_create.options = options; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_executable_create, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_create, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_executable_create_fn(profile, executable_state, options, executable); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_create, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_executable_destroy_callback(hsa_executable_t executable) { + hsa_api_data_t api_data{}; + api_data.args.hsa_executable_destroy.executable = executable; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_executable_destroy, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_destroy, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_executable_destroy_fn(executable); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_destroy, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_executable_load_code_object_callback(hsa_executable_t executable, hsa_agent_t agent, hsa_code_object_t code_object, const char* options) { + hsa_api_data_t api_data{}; + api_data.args.hsa_executable_load_code_object.executable = executable; + api_data.args.hsa_executable_load_code_object.code_object = code_object; + api_data.args.hsa_executable_load_code_object.options = options; + api_data.args.hsa_executable_load_code_object.agent = agent; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_executable_load_code_object, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_load_code_object, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_executable_load_code_object_fn(executable, agent, code_object, options); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_load_code_object, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_executable_freeze_callback(hsa_executable_t executable, const char* options) { + hsa_api_data_t api_data{}; + api_data.args.hsa_executable_freeze.executable = executable; + api_data.args.hsa_executable_freeze.options = options; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_executable_freeze, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_freeze, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_executable_freeze_fn(executable, options); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_freeze, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_executable_get_info_callback(hsa_executable_t executable, hsa_executable_info_t attribute, void* value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_executable_get_info.attribute = attribute; + api_data.args.hsa_executable_get_info.executable = executable; + api_data.args.hsa_executable_get_info.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_executable_get_info, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_get_info, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_executable_get_info_fn(executable, attribute, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_get_info, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_executable_global_variable_define_callback(hsa_executable_t executable, const char* variable_name, void* address) { + hsa_api_data_t api_data{}; + api_data.args.hsa_executable_global_variable_define.executable = executable; + api_data.args.hsa_executable_global_variable_define.address = address; + api_data.args.hsa_executable_global_variable_define.variable_name = variable_name; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_executable_global_variable_define, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_global_variable_define, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_executable_global_variable_define_fn(executable, variable_name, address); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_global_variable_define, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_executable_agent_global_variable_define_callback(hsa_executable_t executable, hsa_agent_t agent, const char* variable_name, void* address) { + hsa_api_data_t api_data{}; + api_data.args.hsa_executable_agent_global_variable_define.executable = executable; + api_data.args.hsa_executable_agent_global_variable_define.address = address; + api_data.args.hsa_executable_agent_global_variable_define.agent = agent; + api_data.args.hsa_executable_agent_global_variable_define.variable_name = variable_name; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_executable_agent_global_variable_define, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_agent_global_variable_define, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_executable_agent_global_variable_define_fn(executable, agent, variable_name, address); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_agent_global_variable_define, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_executable_readonly_variable_define_callback(hsa_executable_t executable, hsa_agent_t agent, const char* variable_name, void* address) { + hsa_api_data_t api_data{}; + api_data.args.hsa_executable_readonly_variable_define.executable = executable; + api_data.args.hsa_executable_readonly_variable_define.address = address; + api_data.args.hsa_executable_readonly_variable_define.agent = agent; + api_data.args.hsa_executable_readonly_variable_define.variable_name = variable_name; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_executable_readonly_variable_define, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_readonly_variable_define, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_executable_readonly_variable_define_fn(executable, agent, variable_name, address); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_readonly_variable_define, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_executable_validate_callback(hsa_executable_t executable, uint32_t* result) { + hsa_api_data_t api_data{}; + api_data.args.hsa_executable_validate.executable = executable; + api_data.args.hsa_executable_validate.result = result; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_executable_validate, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_validate, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_executable_validate_fn(executable, result); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_validate, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_executable_get_symbol_callback(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_api_data_t api_data{}; + api_data.args.hsa_executable_get_symbol.executable = executable; + api_data.args.hsa_executable_get_symbol.symbol_name = symbol_name; + api_data.args.hsa_executable_get_symbol.symbol = symbol; + api_data.args.hsa_executable_get_symbol.agent = agent; + api_data.args.hsa_executable_get_symbol.call_convention = call_convention; + api_data.args.hsa_executable_get_symbol.module_name = module_name; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_executable_get_symbol, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_get_symbol, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_executable_get_symbol_fn(executable, module_name, symbol_name, agent, call_convention, symbol); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_get_symbol, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_executable_symbol_get_info_callback(hsa_executable_symbol_t executable_symbol, hsa_executable_symbol_info_t attribute, void* value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_executable_symbol_get_info.attribute = attribute; + api_data.args.hsa_executable_symbol_get_info.executable_symbol = executable_symbol; + api_data.args.hsa_executable_symbol_get_info.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_executable_symbol_get_info, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_symbol_get_info, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_executable_symbol_get_info_fn(executable_symbol, attribute, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_symbol_get_info, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_executable_iterate_symbols_callback(hsa_executable_t executable, hsa_status_t (* callback)(hsa_executable_t exec, hsa_executable_symbol_t symbol, void* data), void* data) { + hsa_api_data_t api_data{}; + api_data.args.hsa_executable_iterate_symbols.callback = callback; + api_data.args.hsa_executable_iterate_symbols.executable = executable; + api_data.args.hsa_executable_iterate_symbols.data = data; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_executable_iterate_symbols, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_iterate_symbols, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_executable_iterate_symbols_fn(executable, callback, data); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_iterate_symbols, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_status_string_callback(hsa_status_t status, const char** status_string) { + hsa_api_data_t api_data{}; + api_data.args.hsa_status_string.status = status; + api_data.args.hsa_status_string.status_string = status_string; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_status_string, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_status_string, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_status_string_fn(status, status_string); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_status_string, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_extension_get_name_callback(uint16_t extension, const char** name) { + hsa_api_data_t api_data{}; + api_data.args.hsa_extension_get_name.name = name; + api_data.args.hsa_extension_get_name.extension = extension; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_extension_get_name, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_extension_get_name, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_extension_get_name_fn(extension, name); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_extension_get_name, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_system_major_extension_supported_callback(uint16_t extension, uint16_t version_major, uint16_t* version_minor, bool* result) { + hsa_api_data_t api_data{}; + api_data.args.hsa_system_major_extension_supported.version_minor = version_minor; + api_data.args.hsa_system_major_extension_supported.result = result; + api_data.args.hsa_system_major_extension_supported.extension = extension; + api_data.args.hsa_system_major_extension_supported.version_major = version_major; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_system_major_extension_supported, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_system_major_extension_supported, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_system_major_extension_supported_fn(extension, version_major, version_minor, result); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_system_major_extension_supported, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_system_get_major_extension_table_callback(uint16_t extension, uint16_t version_major, size_t table_length, void* table) { + hsa_api_data_t api_data{}; + api_data.args.hsa_system_get_major_extension_table.table = table; + api_data.args.hsa_system_get_major_extension_table.table_length = table_length; + api_data.args.hsa_system_get_major_extension_table.extension = extension; + api_data.args.hsa_system_get_major_extension_table.version_major = version_major; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_system_get_major_extension_table, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_system_get_major_extension_table, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_system_get_major_extension_table_fn(extension, version_major, table_length, table); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_system_get_major_extension_table, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_agent_major_extension_supported_callback(uint16_t extension, hsa_agent_t agent, uint16_t version_major, uint16_t* version_minor, bool* result) { + hsa_api_data_t api_data{}; + api_data.args.hsa_agent_major_extension_supported.result = result; + api_data.args.hsa_agent_major_extension_supported.version_minor = version_minor; + api_data.args.hsa_agent_major_extension_supported.agent = agent; + api_data.args.hsa_agent_major_extension_supported.extension = extension; + api_data.args.hsa_agent_major_extension_supported.version_major = version_major; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_agent_major_extension_supported, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_agent_major_extension_supported, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_agent_major_extension_supported_fn(extension, agent, version_major, version_minor, result); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_agent_major_extension_supported, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_cache_get_info_callback(hsa_cache_t cache, hsa_cache_info_t attribute, void* value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_cache_get_info.attribute = attribute; + api_data.args.hsa_cache_get_info.cache = cache; + api_data.args.hsa_cache_get_info.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_cache_get_info, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_cache_get_info, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_cache_get_info_fn(cache, attribute, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_cache_get_info, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_agent_iterate_caches_callback(hsa_agent_t agent, hsa_status_t (* callback)(hsa_cache_t cache, void* data), void* data) { + hsa_api_data_t api_data{}; + api_data.args.hsa_agent_iterate_caches.callback = callback; + api_data.args.hsa_agent_iterate_caches.data = data; + api_data.args.hsa_agent_iterate_caches.agent = agent; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_agent_iterate_caches, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_agent_iterate_caches, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_agent_iterate_caches_fn(agent, callback, data); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_agent_iterate_caches, &api_data, api_callback_arg); + return ret; +} +static void hsa_signal_silent_store_relaxed_callback(hsa_signal_t signal, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_silent_store_relaxed.signal = signal; + api_data.args.hsa_signal_silent_store_relaxed.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_silent_store_relaxed, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_silent_store_relaxed, &api_data, api_callback_arg); + CoreApiTable_saved.hsa_signal_silent_store_relaxed_fn(signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_silent_store_relaxed, &api_data, api_callback_arg); +} +static void hsa_signal_silent_store_screlease_callback(hsa_signal_t signal, hsa_signal_value_t value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_silent_store_screlease.signal = signal; + api_data.args.hsa_signal_silent_store_screlease.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_silent_store_screlease, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_silent_store_screlease, &api_data, api_callback_arg); + CoreApiTable_saved.hsa_signal_silent_store_screlease_fn(signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_silent_store_screlease, &api_data, api_callback_arg); +} +static hsa_status_t hsa_signal_group_create_callback(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_api_data_t api_data{}; + api_data.args.hsa_signal_group_create.signals = signals; + api_data.args.hsa_signal_group_create.num_signals = num_signals; + api_data.args.hsa_signal_group_create.signal_group = signal_group; + api_data.args.hsa_signal_group_create.consumers = consumers; + api_data.args.hsa_signal_group_create.num_consumers = num_consumers; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_group_create, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_group_create, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_signal_group_create_fn(num_signals, signals, num_consumers, consumers, signal_group); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_group_create, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_signal_group_destroy_callback(hsa_signal_group_t signal_group) { + hsa_api_data_t api_data{}; + api_data.args.hsa_signal_group_destroy.signal_group = signal_group; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_group_destroy, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_group_destroy, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_signal_group_destroy_fn(signal_group); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_group_destroy, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_signal_group_wait_any_scacquire_callback(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_api_data_t api_data{}; + api_data.args.hsa_signal_group_wait_any_scacquire.signal_group = signal_group; + api_data.args.hsa_signal_group_wait_any_scacquire.wait_state_hint = wait_state_hint; + api_data.args.hsa_signal_group_wait_any_scacquire.signal = signal; + api_data.args.hsa_signal_group_wait_any_scacquire.compare_values = compare_values; + api_data.args.hsa_signal_group_wait_any_scacquire.value = value; + api_data.args.hsa_signal_group_wait_any_scacquire.conditions = conditions; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_group_wait_any_scacquire, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_group_wait_any_scacquire, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_signal_group_wait_any_scacquire_fn(signal_group, conditions, compare_values, wait_state_hint, signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_group_wait_any_scacquire, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_signal_group_wait_any_relaxed_callback(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_api_data_t api_data{}; + api_data.args.hsa_signal_group_wait_any_relaxed.signal_group = signal_group; + api_data.args.hsa_signal_group_wait_any_relaxed.wait_state_hint = wait_state_hint; + api_data.args.hsa_signal_group_wait_any_relaxed.signal = signal; + api_data.args.hsa_signal_group_wait_any_relaxed.compare_values = compare_values; + api_data.args.hsa_signal_group_wait_any_relaxed.value = value; + api_data.args.hsa_signal_group_wait_any_relaxed.conditions = conditions; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_signal_group_wait_any_relaxed, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_group_wait_any_relaxed, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_signal_group_wait_any_relaxed_fn(signal_group, conditions, compare_values, wait_state_hint, signal, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_signal_group_wait_any_relaxed, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_agent_iterate_isas_callback(hsa_agent_t agent, hsa_status_t (* callback)(hsa_isa_t isa, void* data), void* data) { + hsa_api_data_t api_data{}; + api_data.args.hsa_agent_iterate_isas.callback = callback; + api_data.args.hsa_agent_iterate_isas.data = data; + api_data.args.hsa_agent_iterate_isas.agent = agent; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_agent_iterate_isas, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_agent_iterate_isas, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_agent_iterate_isas_fn(agent, callback, data); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_agent_iterate_isas, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_isa_get_info_alt_callback(hsa_isa_t isa, hsa_isa_info_t attribute, void* value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_isa_get_info_alt.attribute = attribute; + api_data.args.hsa_isa_get_info_alt.isa = isa; + api_data.args.hsa_isa_get_info_alt.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_isa_get_info_alt, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_isa_get_info_alt, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_isa_get_info_alt_fn(isa, attribute, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_isa_get_info_alt, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_isa_get_exception_policies_callback(hsa_isa_t isa, hsa_profile_t profile, uint16_t* mask) { + hsa_api_data_t api_data{}; + api_data.args.hsa_isa_get_exception_policies.profile = profile; + api_data.args.hsa_isa_get_exception_policies.isa = isa; + api_data.args.hsa_isa_get_exception_policies.mask = mask; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_isa_get_exception_policies, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_isa_get_exception_policies, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_isa_get_exception_policies_fn(isa, profile, mask); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_isa_get_exception_policies, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_isa_get_round_method_callback(hsa_isa_t isa, hsa_fp_type_t fp_type, hsa_flush_mode_t flush_mode, hsa_round_method_t* round_method) { + hsa_api_data_t api_data{}; + api_data.args.hsa_isa_get_round_method.isa = isa; + api_data.args.hsa_isa_get_round_method.round_method = round_method; + api_data.args.hsa_isa_get_round_method.flush_mode = flush_mode; + api_data.args.hsa_isa_get_round_method.fp_type = fp_type; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_isa_get_round_method, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_isa_get_round_method, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_isa_get_round_method_fn(isa, fp_type, flush_mode, round_method); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_isa_get_round_method, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_wavefront_get_info_callback(hsa_wavefront_t wavefront, hsa_wavefront_info_t attribute, void* value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_wavefront_get_info.attribute = attribute; + api_data.args.hsa_wavefront_get_info.wavefront = wavefront; + api_data.args.hsa_wavefront_get_info.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_wavefront_get_info, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_wavefront_get_info, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_wavefront_get_info_fn(wavefront, attribute, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_wavefront_get_info, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_isa_iterate_wavefronts_callback(hsa_isa_t isa, hsa_status_t (* callback)(hsa_wavefront_t wavefront, void* data), void* data) { + hsa_api_data_t api_data{}; + api_data.args.hsa_isa_iterate_wavefronts.callback = callback; + api_data.args.hsa_isa_iterate_wavefronts.isa = isa; + api_data.args.hsa_isa_iterate_wavefronts.data = data; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_isa_iterate_wavefronts, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_isa_iterate_wavefronts, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_isa_iterate_wavefronts_fn(isa, callback, data); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_isa_iterate_wavefronts, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_code_object_get_symbol_from_name_callback(hsa_code_object_t code_object, const char* module_name, const char* symbol_name, hsa_code_symbol_t* symbol) { + hsa_api_data_t api_data{}; + api_data.args.hsa_code_object_get_symbol_from_name.module_name = module_name; + api_data.args.hsa_code_object_get_symbol_from_name.symbol = symbol; + api_data.args.hsa_code_object_get_symbol_from_name.code_object = code_object; + api_data.args.hsa_code_object_get_symbol_from_name.symbol_name = symbol_name; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_code_object_get_symbol_from_name, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_code_object_get_symbol_from_name, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_code_object_get_symbol_from_name_fn(code_object, module_name, symbol_name, symbol); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_code_object_get_symbol_from_name, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_code_object_reader_create_from_file_callback(hsa_file_t file, hsa_code_object_reader_t* code_object_reader) { + hsa_api_data_t api_data{}; + api_data.args.hsa_code_object_reader_create_from_file.code_object_reader = code_object_reader; + api_data.args.hsa_code_object_reader_create_from_file.file = file; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_code_object_reader_create_from_file, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_code_object_reader_create_from_file, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_code_object_reader_create_from_file_fn(file, code_object_reader); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_code_object_reader_create_from_file, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_code_object_reader_create_from_memory_callback(const void* code_object, size_t size, hsa_code_object_reader_t* code_object_reader) { + hsa_api_data_t api_data{}; + api_data.args.hsa_code_object_reader_create_from_memory.code_object_reader = code_object_reader; + api_data.args.hsa_code_object_reader_create_from_memory.code_object = code_object; + api_data.args.hsa_code_object_reader_create_from_memory.size = size; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_code_object_reader_create_from_memory, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_code_object_reader_create_from_memory, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_code_object_reader_create_from_memory_fn(code_object, size, code_object_reader); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_code_object_reader_create_from_memory, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_code_object_reader_destroy_callback(hsa_code_object_reader_t code_object_reader) { + hsa_api_data_t api_data{}; + api_data.args.hsa_code_object_reader_destroy.code_object_reader = code_object_reader; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_code_object_reader_destroy, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_code_object_reader_destroy, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_code_object_reader_destroy_fn(code_object_reader); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_code_object_reader_destroy, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_executable_create_alt_callback(hsa_profile_t profile, hsa_default_float_rounding_mode_t default_float_rounding_mode, const char* options, hsa_executable_t* executable) { + hsa_api_data_t api_data{}; + api_data.args.hsa_executable_create_alt.profile = profile; + api_data.args.hsa_executable_create_alt.default_float_rounding_mode = default_float_rounding_mode; + api_data.args.hsa_executable_create_alt.executable = executable; + api_data.args.hsa_executable_create_alt.options = options; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_executable_create_alt, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_create_alt, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_executable_create_alt_fn(profile, default_float_rounding_mode, options, executable); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_create_alt, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_executable_load_program_code_object_callback(hsa_executable_t executable, hsa_code_object_reader_t code_object_reader, const char* options, hsa_loaded_code_object_t* loaded_code_object) { + hsa_api_data_t api_data{}; + api_data.args.hsa_executable_load_program_code_object.code_object_reader = code_object_reader; + api_data.args.hsa_executable_load_program_code_object.executable = executable; + api_data.args.hsa_executable_load_program_code_object.loaded_code_object = loaded_code_object; + api_data.args.hsa_executable_load_program_code_object.options = options; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_executable_load_program_code_object, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_load_program_code_object, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_executable_load_program_code_object_fn(executable, code_object_reader, options, loaded_code_object); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_load_program_code_object, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_executable_load_agent_code_object_callback(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_api_data_t api_data{}; + api_data.args.hsa_executable_load_agent_code_object.code_object_reader = code_object_reader; + api_data.args.hsa_executable_load_agent_code_object.executable = executable; + api_data.args.hsa_executable_load_agent_code_object.loaded_code_object = loaded_code_object; + api_data.args.hsa_executable_load_agent_code_object.options = options; + api_data.args.hsa_executable_load_agent_code_object.agent = agent; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_executable_load_agent_code_object, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_load_agent_code_object, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_executable_load_agent_code_object_fn(executable, agent, code_object_reader, options, loaded_code_object); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_load_agent_code_object, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_executable_validate_alt_callback(hsa_executable_t executable, const char* options, uint32_t* result) { + hsa_api_data_t api_data{}; + api_data.args.hsa_executable_validate_alt.executable = executable; + api_data.args.hsa_executable_validate_alt.options = options; + api_data.args.hsa_executable_validate_alt.result = result; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_executable_validate_alt, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_validate_alt, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_executable_validate_alt_fn(executable, options, result); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_validate_alt, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_executable_get_symbol_by_name_callback(hsa_executable_t executable, const char* symbol_name, const hsa_agent_t* agent, hsa_executable_symbol_t* symbol) { + hsa_api_data_t api_data{}; + api_data.args.hsa_executable_get_symbol_by_name.symbol = symbol; + api_data.args.hsa_executable_get_symbol_by_name.executable = executable; + api_data.args.hsa_executable_get_symbol_by_name.symbol_name = symbol_name; + api_data.args.hsa_executable_get_symbol_by_name.agent = agent; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_executable_get_symbol_by_name, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_get_symbol_by_name, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_executable_get_symbol_by_name_fn(executable, symbol_name, agent, symbol); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_get_symbol_by_name, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_executable_iterate_agent_symbols_callback(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_api_data_t api_data{}; + api_data.args.hsa_executable_iterate_agent_symbols.callback = callback; + api_data.args.hsa_executable_iterate_agent_symbols.executable = executable; + api_data.args.hsa_executable_iterate_agent_symbols.data = data; + api_data.args.hsa_executable_iterate_agent_symbols.agent = agent; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_executable_iterate_agent_symbols, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_iterate_agent_symbols, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_executable_iterate_agent_symbols_fn(executable, agent, callback, data); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_iterate_agent_symbols, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_executable_iterate_program_symbols_callback(hsa_executable_t executable, hsa_status_t (* callback)(hsa_executable_t exec, hsa_executable_symbol_t symbol, void* data), void* data) { + hsa_api_data_t api_data{}; + api_data.args.hsa_executable_iterate_program_symbols.callback = callback; + api_data.args.hsa_executable_iterate_program_symbols.executable = executable; + api_data.args.hsa_executable_iterate_program_symbols.data = data; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_executable_iterate_program_symbols, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_iterate_program_symbols, &api_data, api_callback_arg); + hsa_status_t ret = CoreApiTable_saved.hsa_executable_iterate_program_symbols_fn(executable, callback, data); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_executable_iterate_program_symbols, &api_data, api_callback_arg); + return ret; +} + +// block: AmdExtTable API +static hsa_status_t hsa_amd_coherency_get_type_callback(hsa_agent_t agent, hsa_amd_coherency_type_t* type) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_coherency_get_type.type = type; + api_data.args.hsa_amd_coherency_get_type.agent = agent; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_coherency_get_type, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_coherency_get_type, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_coherency_get_type_fn(agent, type); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_coherency_get_type, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_coherency_set_type_callback(hsa_agent_t agent, hsa_amd_coherency_type_t type) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_coherency_set_type.type = type; + api_data.args.hsa_amd_coherency_set_type.agent = agent; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_coherency_set_type, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_coherency_set_type, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_coherency_set_type_fn(agent, type); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_coherency_set_type, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_profiling_set_profiler_enabled_callback(hsa_queue_t* queue, int enable) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_profiling_set_profiler_enabled.queue = queue; + api_data.args.hsa_amd_profiling_set_profiler_enabled.enable = enable; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_profiling_set_profiler_enabled, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_profiling_set_profiler_enabled, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_profiling_set_profiler_enabled_fn(queue, enable); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_profiling_set_profiler_enabled, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_profiling_async_copy_enable_callback(bool enable) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_profiling_async_copy_enable.enable = enable; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_profiling_async_copy_enable, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_profiling_async_copy_enable, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_profiling_async_copy_enable_fn(enable); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_profiling_async_copy_enable, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_profiling_get_dispatch_time_callback(hsa_agent_t agent, hsa_signal_t signal, hsa_amd_profiling_dispatch_time_t* time) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_profiling_get_dispatch_time.signal = signal; + api_data.args.hsa_amd_profiling_get_dispatch_time.agent = agent; + api_data.args.hsa_amd_profiling_get_dispatch_time.time = time; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_profiling_get_dispatch_time, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_profiling_get_dispatch_time, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_profiling_get_dispatch_time_fn(agent, signal, time); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_profiling_get_dispatch_time, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_profiling_get_async_copy_time_callback(hsa_signal_t signal, hsa_amd_profiling_async_copy_time_t* time) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_profiling_get_async_copy_time.signal = signal; + api_data.args.hsa_amd_profiling_get_async_copy_time.time = time; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_profiling_get_async_copy_time, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_profiling_get_async_copy_time, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_profiling_get_async_copy_time_fn(signal, time); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_profiling_get_async_copy_time, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_profiling_convert_tick_to_system_domain_callback(hsa_agent_t agent, uint64_t agent_tick, uint64_t* system_tick) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_profiling_convert_tick_to_system_domain.system_tick = system_tick; + api_data.args.hsa_amd_profiling_convert_tick_to_system_domain.agent = agent; + api_data.args.hsa_amd_profiling_convert_tick_to_system_domain.agent_tick = agent_tick; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_profiling_convert_tick_to_system_domain, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_profiling_convert_tick_to_system_domain, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_profiling_convert_tick_to_system_domain_fn(agent, agent_tick, system_tick); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_profiling_convert_tick_to_system_domain, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_signal_async_handler_callback(hsa_signal_t signal, hsa_signal_condition_t cond, hsa_signal_value_t value, hsa_amd_signal_handler handler, void* arg) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_signal_async_handler.signal = signal; + api_data.args.hsa_amd_signal_async_handler.handler = handler; + api_data.args.hsa_amd_signal_async_handler.cond = cond; + api_data.args.hsa_amd_signal_async_handler.value = value; + api_data.args.hsa_amd_signal_async_handler.arg = arg; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_signal_async_handler, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_signal_async_handler, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_signal_async_handler_fn(signal, cond, value, handler, arg); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_signal_async_handler, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_async_function_callback(void (* callback)(void* arg), void* arg) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_async_function.callback = callback; + api_data.args.hsa_amd_async_function.arg = arg; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_async_function, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_async_function, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_async_function_fn(callback, arg); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_async_function, &api_data, api_callback_arg); + return ret; +} +static uint32_t hsa_amd_signal_wait_any_callback(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_api_data_t api_data{}; + api_data.args.hsa_amd_signal_wait_any.timeout_hint = timeout_hint; + api_data.args.hsa_amd_signal_wait_any.signal_count = signal_count; + api_data.args.hsa_amd_signal_wait_any.conds = conds; + api_data.args.hsa_amd_signal_wait_any.signals = signals; + api_data.args.hsa_amd_signal_wait_any.values = values; + api_data.args.hsa_amd_signal_wait_any.satisfying_value = satisfying_value; + api_data.args.hsa_amd_signal_wait_any.wait_hint = wait_hint; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_signal_wait_any, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_signal_wait_any, &api_data, api_callback_arg); + uint32_t ret = AmdExtTable_saved.hsa_amd_signal_wait_any_fn(signal_count, signals, conds, values, timeout_hint, wait_hint, satisfying_value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_signal_wait_any, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_queue_cu_set_mask_callback(const hsa_queue_t* queue, uint32_t num_cu_mask_count, const uint32_t* cu_mask) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_queue_cu_set_mask.queue = queue; + api_data.args.hsa_amd_queue_cu_set_mask.cu_mask = cu_mask; + api_data.args.hsa_amd_queue_cu_set_mask.num_cu_mask_count = num_cu_mask_count; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_queue_cu_set_mask, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_queue_cu_set_mask, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_queue_cu_set_mask_fn(queue, num_cu_mask_count, cu_mask); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_queue_cu_set_mask, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_memory_pool_get_info_callback(hsa_amd_memory_pool_t memory_pool, hsa_amd_memory_pool_info_t attribute, void* value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_memory_pool_get_info.attribute = attribute; + api_data.args.hsa_amd_memory_pool_get_info.memory_pool = memory_pool; + api_data.args.hsa_amd_memory_pool_get_info.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_memory_pool_get_info, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_memory_pool_get_info, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_memory_pool_get_info_fn(memory_pool, attribute, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_memory_pool_get_info, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_agent_iterate_memory_pools_callback(hsa_agent_t agent, hsa_status_t (* callback)(hsa_amd_memory_pool_t memory_pool, void* data), void* data) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_agent_iterate_memory_pools.callback = callback; + api_data.args.hsa_amd_agent_iterate_memory_pools.data = data; + api_data.args.hsa_amd_agent_iterate_memory_pools.agent = agent; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_agent_iterate_memory_pools, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_agent_iterate_memory_pools, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_agent_iterate_memory_pools_fn(agent, callback, data); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_agent_iterate_memory_pools, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_memory_pool_allocate_callback(hsa_amd_memory_pool_t memory_pool, size_t size, uint32_t flags, void** ptr) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_memory_pool_allocate.ptr = ptr; + api_data.args.hsa_amd_memory_pool_allocate.flags = flags; + api_data.args.hsa_amd_memory_pool_allocate.memory_pool = memory_pool; + api_data.args.hsa_amd_memory_pool_allocate.size = size; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_memory_pool_allocate, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_memory_pool_allocate, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_memory_pool_allocate_fn(memory_pool, size, flags, ptr); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_memory_pool_allocate, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_memory_pool_free_callback(void* ptr) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_memory_pool_free.ptr = ptr; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_memory_pool_free, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_memory_pool_free, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_memory_pool_free_fn(ptr); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_memory_pool_free, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_memory_async_copy_callback(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_api_data_t api_data{}; + api_data.args.hsa_amd_memory_async_copy.completion_signal = completion_signal; + api_data.args.hsa_amd_memory_async_copy.src = src; + api_data.args.hsa_amd_memory_async_copy.dst = dst; + api_data.args.hsa_amd_memory_async_copy.num_dep_signals = num_dep_signals; + api_data.args.hsa_amd_memory_async_copy.src_agent = src_agent; + api_data.args.hsa_amd_memory_async_copy.dep_signals = dep_signals; + api_data.args.hsa_amd_memory_async_copy.dst_agent = dst_agent; + api_data.args.hsa_amd_memory_async_copy.size = size; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_memory_async_copy, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_memory_async_copy, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_memory_async_copy_fn(dst, dst_agent, src, src_agent, size, num_dep_signals, dep_signals, completion_signal); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_memory_async_copy, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_agent_memory_pool_get_info_callback(hsa_agent_t agent, hsa_amd_memory_pool_t memory_pool, hsa_amd_agent_memory_pool_info_t attribute, void* value) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_agent_memory_pool_get_info.attribute = attribute; + api_data.args.hsa_amd_agent_memory_pool_get_info.value = value; + api_data.args.hsa_amd_agent_memory_pool_get_info.memory_pool = memory_pool; + api_data.args.hsa_amd_agent_memory_pool_get_info.agent = agent; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_agent_memory_pool_get_info, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_agent_memory_pool_get_info, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_agent_memory_pool_get_info_fn(agent, memory_pool, attribute, value); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_agent_memory_pool_get_info, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_agents_allow_access_callback(uint32_t num_agents, const hsa_agent_t* agents, const uint32_t* flags, const void* ptr) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_agents_allow_access.flags = flags; + api_data.args.hsa_amd_agents_allow_access.agents = agents; + api_data.args.hsa_amd_agents_allow_access.ptr = ptr; + api_data.args.hsa_amd_agents_allow_access.num_agents = num_agents; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_agents_allow_access, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_agents_allow_access, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_agents_allow_access_fn(num_agents, agents, flags, ptr); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_agents_allow_access, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_memory_pool_can_migrate_callback(hsa_amd_memory_pool_t src_memory_pool, hsa_amd_memory_pool_t dst_memory_pool, bool* result) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_memory_pool_can_migrate.src_memory_pool = src_memory_pool; + api_data.args.hsa_amd_memory_pool_can_migrate.dst_memory_pool = dst_memory_pool; + api_data.args.hsa_amd_memory_pool_can_migrate.result = result; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_memory_pool_can_migrate, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_memory_pool_can_migrate, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_memory_pool_can_migrate_fn(src_memory_pool, dst_memory_pool, result); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_memory_pool_can_migrate, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_memory_migrate_callback(const void* ptr, hsa_amd_memory_pool_t memory_pool, uint32_t flags) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_memory_migrate.flags = flags; + api_data.args.hsa_amd_memory_migrate.ptr = ptr; + api_data.args.hsa_amd_memory_migrate.memory_pool = memory_pool; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_memory_migrate, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_memory_migrate, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_memory_migrate_fn(ptr, memory_pool, flags); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_memory_migrate, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_memory_lock_callback(void* host_ptr, size_t size, hsa_agent_t* agents, int num_agent, void** agent_ptr) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_memory_lock.host_ptr = host_ptr; + api_data.args.hsa_amd_memory_lock.num_agent = num_agent; + api_data.args.hsa_amd_memory_lock.agents = agents; + api_data.args.hsa_amd_memory_lock.agent_ptr = agent_ptr; + api_data.args.hsa_amd_memory_lock.size = size; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_memory_lock, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_memory_lock, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_memory_lock_fn(host_ptr, size, agents, num_agent, agent_ptr); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_memory_lock, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_memory_unlock_callback(void* host_ptr) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_memory_unlock.host_ptr = host_ptr; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_memory_unlock, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_memory_unlock, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_memory_unlock_fn(host_ptr); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_memory_unlock, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_memory_fill_callback(void* ptr, uint32_t value, size_t count) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_memory_fill.count = count; + api_data.args.hsa_amd_memory_fill.ptr = ptr; + api_data.args.hsa_amd_memory_fill.value = value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_memory_fill, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_memory_fill, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_memory_fill_fn(ptr, value, count); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_memory_fill, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_interop_map_buffer_callback(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_api_data_t api_data{}; + api_data.args.hsa_amd_interop_map_buffer.num_agents = num_agents; + api_data.args.hsa_amd_interop_map_buffer.metadata_size = metadata_size; + api_data.args.hsa_amd_interop_map_buffer.flags = flags; + api_data.args.hsa_amd_interop_map_buffer.agents = agents; + api_data.args.hsa_amd_interop_map_buffer.metadata = metadata; + api_data.args.hsa_amd_interop_map_buffer.ptr = ptr; + api_data.args.hsa_amd_interop_map_buffer.interop_handle = interop_handle; + api_data.args.hsa_amd_interop_map_buffer.size = size; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_interop_map_buffer, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_interop_map_buffer, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_interop_map_buffer_fn(num_agents, agents, interop_handle, flags, size, ptr, metadata_size, metadata); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_interop_map_buffer, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_interop_unmap_buffer_callback(void* ptr) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_interop_unmap_buffer.ptr = ptr; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_interop_unmap_buffer, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_interop_unmap_buffer, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_interop_unmap_buffer_fn(ptr); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_interop_unmap_buffer, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_image_create_callback(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_api_data_t api_data{}; + api_data.args.hsa_amd_image_create.image_descriptor = image_descriptor; + api_data.args.hsa_amd_image_create.image = image; + api_data.args.hsa_amd_image_create.agent = agent; + api_data.args.hsa_amd_image_create.access_permission = access_permission; + api_data.args.hsa_amd_image_create.image_data = image_data; + api_data.args.hsa_amd_image_create.image_layout = image_layout; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_image_create, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_image_create, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_image_create_fn(agent, image_descriptor, image_layout, image_data, access_permission, image); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_image_create, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_pointer_info_callback(void* ptr, hsa_amd_pointer_info_t* info, void* (* alloc)(size_t), uint32_t* num_agents_accessible, hsa_agent_t** accessible) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_pointer_info.info = info; + api_data.args.hsa_amd_pointer_info.accessible = accessible; + api_data.args.hsa_amd_pointer_info.alloc = alloc; + api_data.args.hsa_amd_pointer_info.ptr = ptr; + api_data.args.hsa_amd_pointer_info.num_agents_accessible = num_agents_accessible; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_pointer_info, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_pointer_info, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_pointer_info_fn(ptr, info, alloc, num_agents_accessible, accessible); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_pointer_info, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_pointer_info_set_userdata_callback(void* ptr, void* userdata) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_pointer_info_set_userdata.userdata = userdata; + api_data.args.hsa_amd_pointer_info_set_userdata.ptr = ptr; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_pointer_info_set_userdata, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_pointer_info_set_userdata, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_pointer_info_set_userdata_fn(ptr, userdata); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_pointer_info_set_userdata, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_ipc_memory_create_callback(void* ptr, size_t len, hsa_amd_ipc_memory_t* handle) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_ipc_memory_create.handle = handle; + api_data.args.hsa_amd_ipc_memory_create.ptr = ptr; + api_data.args.hsa_amd_ipc_memory_create.len = len; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_ipc_memory_create, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_ipc_memory_create, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_ipc_memory_create_fn(ptr, len, handle); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_ipc_memory_create, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_ipc_memory_attach_callback(const hsa_amd_ipc_memory_t* handle, size_t len, uint32_t num_agents, const hsa_agent_t* mapping_agents, void** mapped_ptr) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_ipc_memory_attach.mapped_ptr = mapped_ptr; + api_data.args.hsa_amd_ipc_memory_attach.handle = handle; + api_data.args.hsa_amd_ipc_memory_attach.mapping_agents = mapping_agents; + api_data.args.hsa_amd_ipc_memory_attach.len = len; + api_data.args.hsa_amd_ipc_memory_attach.num_agents = num_agents; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_ipc_memory_attach, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_ipc_memory_attach, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_ipc_memory_attach_fn(handle, len, num_agents, mapping_agents, mapped_ptr); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_ipc_memory_attach, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_ipc_memory_detach_callback(void* mapped_ptr) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_ipc_memory_detach.mapped_ptr = mapped_ptr; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_ipc_memory_detach, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_ipc_memory_detach, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_ipc_memory_detach_fn(mapped_ptr); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_ipc_memory_detach, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_signal_create_callback(hsa_signal_value_t initial_value, uint32_t num_consumers, const hsa_agent_t* consumers, uint64_t attributes, hsa_signal_t* signal) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_signal_create.attributes = attributes; + api_data.args.hsa_amd_signal_create.signal = signal; + api_data.args.hsa_amd_signal_create.num_consumers = num_consumers; + api_data.args.hsa_amd_signal_create.consumers = consumers; + api_data.args.hsa_amd_signal_create.initial_value = initial_value; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_signal_create, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_signal_create, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_signal_create_fn(initial_value, num_consumers, consumers, attributes, signal); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_signal_create, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_ipc_signal_create_callback(hsa_signal_t signal, hsa_amd_ipc_signal_t* handle) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_ipc_signal_create.signal = signal; + api_data.args.hsa_amd_ipc_signal_create.handle = handle; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_ipc_signal_create, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_ipc_signal_create, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_ipc_signal_create_fn(signal, handle); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_ipc_signal_create, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_ipc_signal_attach_callback(const hsa_amd_ipc_signal_t* handle, hsa_signal_t* signal) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_ipc_signal_attach.signal = signal; + api_data.args.hsa_amd_ipc_signal_attach.handle = handle; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_ipc_signal_attach, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_ipc_signal_attach, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_ipc_signal_attach_fn(handle, signal); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_ipc_signal_attach, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_register_system_event_handler_callback(hsa_amd_system_event_callback_t callback, void* data) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_register_system_event_handler.callback = callback; + api_data.args.hsa_amd_register_system_event_handler.data = data; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_register_system_event_handler, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_register_system_event_handler, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_register_system_event_handler_fn(callback, data); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_register_system_event_handler, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_queue_intercept_create_callback(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_api_data_t api_data{}; + api_data.args.hsa_amd_queue_intercept_create.agent_handle = agent_handle; + api_data.args.hsa_amd_queue_intercept_create.private_segment_size = private_segment_size; + api_data.args.hsa_amd_queue_intercept_create.data = data; + api_data.args.hsa_amd_queue_intercept_create.queue = queue; + api_data.args.hsa_amd_queue_intercept_create.callback = callback; + api_data.args.hsa_amd_queue_intercept_create.group_segment_size = group_segment_size; + api_data.args.hsa_amd_queue_intercept_create.type = type; + api_data.args.hsa_amd_queue_intercept_create.size = size; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_queue_intercept_create, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_queue_intercept_create, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_queue_intercept_create_fn(agent_handle, size, type, callback, data, private_segment_size, group_segment_size, queue); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_queue_intercept_create, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_queue_intercept_register_callback(hsa_queue_t* queue, hsa_amd_queue_intercept_handler callback, void* user_data) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_queue_intercept_register.queue = queue; + api_data.args.hsa_amd_queue_intercept_register.callback = callback; + api_data.args.hsa_amd_queue_intercept_register.user_data = user_data; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_queue_intercept_register, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_queue_intercept_register, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_queue_intercept_register_fn(queue, callback, user_data); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_queue_intercept_register, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_queue_set_priority_callback(hsa_queue_t* queue, hsa_amd_queue_priority_t priority) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_queue_set_priority.queue = queue; + api_data.args.hsa_amd_queue_set_priority.priority = priority; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_queue_set_priority, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_queue_set_priority, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_queue_set_priority_fn(queue, priority); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_queue_set_priority, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_memory_async_copy_rect_callback(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_api_data_t api_data{}; + api_data.args.hsa_amd_memory_async_copy_rect.completion_signal = completion_signal; + api_data.args.hsa_amd_memory_async_copy_rect.src = src; + api_data.args.hsa_amd_memory_async_copy_rect.src_offset = src_offset; + api_data.args.hsa_amd_memory_async_copy_rect.dst_offset = dst_offset; + api_data.args.hsa_amd_memory_async_copy_rect.dst = dst; + api_data.args.hsa_amd_memory_async_copy_rect.dep_signals = dep_signals; + api_data.args.hsa_amd_memory_async_copy_rect.num_dep_signals = num_dep_signals; + api_data.args.hsa_amd_memory_async_copy_rect.range = range; + api_data.args.hsa_amd_memory_async_copy_rect.copy_agent = copy_agent; + api_data.args.hsa_amd_memory_async_copy_rect.dir = dir; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_memory_async_copy_rect, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_memory_async_copy_rect, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_memory_async_copy_rect_fn(dst, dst_offset, src, src_offset, range, copy_agent, dir, num_dep_signals, dep_signals, completion_signal); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_memory_async_copy_rect, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_amd_runtime_queue_create_register_callback(hsa_amd_runtime_queue_notifier callback, void* user_data) { + hsa_api_data_t api_data{}; + api_data.args.hsa_amd_runtime_queue_create_register.callback = callback; + api_data.args.hsa_amd_runtime_queue_create_register.user_data = user_data; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_amd_runtime_queue_create_register, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_runtime_queue_create_register, &api_data, api_callback_arg); + hsa_status_t ret = AmdExtTable_saved.hsa_amd_runtime_queue_create_register_fn(callback, user_data); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_amd_runtime_queue_create_register, &api_data, api_callback_arg); + return ret; +} + +// block: ImageExtTable API +static hsa_status_t hsa_ext_image_get_capability_callback(hsa_agent_t agent, hsa_ext_image_geometry_t geometry, const hsa_ext_image_format_t* image_format, uint32_t* capability_mask) { + hsa_api_data_t api_data{}; + api_data.args.hsa_ext_image_get_capability.geometry = geometry; + api_data.args.hsa_ext_image_get_capability.capability_mask = capability_mask; + api_data.args.hsa_ext_image_get_capability.image_format = image_format; + api_data.args.hsa_ext_image_get_capability.agent = agent; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_ext_image_get_capability, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_ext_image_get_capability, &api_data, api_callback_arg); + hsa_status_t ret = ImageExtTable_saved.hsa_ext_image_get_capability_fn(agent, geometry, image_format, capability_mask); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_ext_image_get_capability, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_ext_image_data_get_info_callback(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_api_data_t api_data{}; + api_data.args.hsa_ext_image_data_get_info.image_descriptor = image_descriptor; + api_data.args.hsa_ext_image_data_get_info.image_data_info = image_data_info; + api_data.args.hsa_ext_image_data_get_info.agent = agent; + api_data.args.hsa_ext_image_data_get_info.access_permission = access_permission; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_ext_image_data_get_info, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_ext_image_data_get_info, &api_data, api_callback_arg); + hsa_status_t ret = ImageExtTable_saved.hsa_ext_image_data_get_info_fn(agent, image_descriptor, access_permission, image_data_info); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_ext_image_data_get_info, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_ext_image_create_callback(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_api_data_t api_data{}; + api_data.args.hsa_ext_image_create.image_data = image_data; + api_data.args.hsa_ext_image_create.image_descriptor = image_descriptor; + api_data.args.hsa_ext_image_create.image = image; + api_data.args.hsa_ext_image_create.agent = agent; + api_data.args.hsa_ext_image_create.access_permission = access_permission; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_ext_image_create, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_ext_image_create, &api_data, api_callback_arg); + hsa_status_t ret = ImageExtTable_saved.hsa_ext_image_create_fn(agent, image_descriptor, image_data, access_permission, image); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_ext_image_create, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_ext_image_import_callback(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_api_data_t api_data{}; + api_data.args.hsa_ext_image_import.src_row_pitch = src_row_pitch; + api_data.args.hsa_ext_image_import.image_region = image_region; + api_data.args.hsa_ext_image_import.agent = agent; + api_data.args.hsa_ext_image_import.src_slice_pitch = src_slice_pitch; + api_data.args.hsa_ext_image_import.src_memory = src_memory; + api_data.args.hsa_ext_image_import.dst_image = dst_image; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_ext_image_import, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_ext_image_import, &api_data, api_callback_arg); + hsa_status_t ret = ImageExtTable_saved.hsa_ext_image_import_fn(agent, src_memory, src_row_pitch, src_slice_pitch, dst_image, image_region); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_ext_image_import, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_ext_image_export_callback(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_api_data_t api_data{}; + api_data.args.hsa_ext_image_export.dst_slice_pitch = dst_slice_pitch; + api_data.args.hsa_ext_image_export.image_region = image_region; + api_data.args.hsa_ext_image_export.agent = agent; + api_data.args.hsa_ext_image_export.dst_row_pitch = dst_row_pitch; + api_data.args.hsa_ext_image_export.src_image = src_image; + api_data.args.hsa_ext_image_export.dst_memory = dst_memory; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_ext_image_export, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_ext_image_export, &api_data, api_callback_arg); + hsa_status_t ret = ImageExtTable_saved.hsa_ext_image_export_fn(agent, src_image, dst_memory, dst_row_pitch, dst_slice_pitch, image_region); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_ext_image_export, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_ext_image_copy_callback(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_api_data_t api_data{}; + api_data.args.hsa_ext_image_copy.src_offset = src_offset; + api_data.args.hsa_ext_image_copy.dst_offset = dst_offset; + api_data.args.hsa_ext_image_copy.agent = agent; + api_data.args.hsa_ext_image_copy.range = range; + api_data.args.hsa_ext_image_copy.src_image = src_image; + api_data.args.hsa_ext_image_copy.dst_image = dst_image; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_ext_image_copy, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_ext_image_copy, &api_data, api_callback_arg); + hsa_status_t ret = ImageExtTable_saved.hsa_ext_image_copy_fn(agent, src_image, src_offset, dst_image, dst_offset, range); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_ext_image_copy, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_ext_image_clear_callback(hsa_agent_t agent, hsa_ext_image_t image, const void* data, const hsa_ext_image_region_t* image_region) { + hsa_api_data_t api_data{}; + api_data.args.hsa_ext_image_clear.image = image; + api_data.args.hsa_ext_image_clear.data = data; + api_data.args.hsa_ext_image_clear.image_region = image_region; + api_data.args.hsa_ext_image_clear.agent = agent; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_ext_image_clear, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_ext_image_clear, &api_data, api_callback_arg); + hsa_status_t ret = ImageExtTable_saved.hsa_ext_image_clear_fn(agent, image, data, image_region); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_ext_image_clear, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_ext_image_destroy_callback(hsa_agent_t agent, hsa_ext_image_t image) { + hsa_api_data_t api_data{}; + api_data.args.hsa_ext_image_destroy.image = image; + api_data.args.hsa_ext_image_destroy.agent = agent; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_ext_image_destroy, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_ext_image_destroy, &api_data, api_callback_arg); + hsa_status_t ret = ImageExtTable_saved.hsa_ext_image_destroy_fn(agent, image); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_ext_image_destroy, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_ext_sampler_create_callback(hsa_agent_t agent, const hsa_ext_sampler_descriptor_t* sampler_descriptor, hsa_ext_sampler_t* sampler) { + hsa_api_data_t api_data{}; + api_data.args.hsa_ext_sampler_create.sampler_descriptor = sampler_descriptor; + api_data.args.hsa_ext_sampler_create.agent = agent; + api_data.args.hsa_ext_sampler_create.sampler = sampler; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_ext_sampler_create, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_ext_sampler_create, &api_data, api_callback_arg); + hsa_status_t ret = ImageExtTable_saved.hsa_ext_sampler_create_fn(agent, sampler_descriptor, sampler); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_ext_sampler_create, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_ext_sampler_destroy_callback(hsa_agent_t agent, hsa_ext_sampler_t sampler) { + hsa_api_data_t api_data{}; + api_data.args.hsa_ext_sampler_destroy.agent = agent; + api_data.args.hsa_ext_sampler_destroy.sampler = sampler; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_ext_sampler_destroy, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_ext_sampler_destroy, &api_data, api_callback_arg); + hsa_status_t ret = ImageExtTable_saved.hsa_ext_sampler_destroy_fn(agent, sampler); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_ext_sampler_destroy, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_ext_image_get_capability_with_layout_callback(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_api_data_t api_data{}; + api_data.args.hsa_ext_image_get_capability_with_layout.geometry = geometry; + api_data.args.hsa_ext_image_get_capability_with_layout.image_data_layout = image_data_layout; + api_data.args.hsa_ext_image_get_capability_with_layout.image_format = image_format; + api_data.args.hsa_ext_image_get_capability_with_layout.capability_mask = capability_mask; + api_data.args.hsa_ext_image_get_capability_with_layout.agent = agent; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_ext_image_get_capability_with_layout, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_ext_image_get_capability_with_layout, &api_data, api_callback_arg); + hsa_status_t ret = ImageExtTable_saved.hsa_ext_image_get_capability_with_layout_fn(agent, geometry, image_format, image_data_layout, capability_mask); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_ext_image_get_capability_with_layout, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_ext_image_data_get_info_with_layout_callback(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_api_data_t api_data{}; + api_data.args.hsa_ext_image_data_get_info_with_layout.image_descriptor = image_descriptor; + api_data.args.hsa_ext_image_data_get_info_with_layout.image_data_layout = image_data_layout; + api_data.args.hsa_ext_image_data_get_info_with_layout.image_data_row_pitch = image_data_row_pitch; + api_data.args.hsa_ext_image_data_get_info_with_layout.agent = agent; + api_data.args.hsa_ext_image_data_get_info_with_layout.access_permission = access_permission; + api_data.args.hsa_ext_image_data_get_info_with_layout.image_data_slice_pitch = image_data_slice_pitch; + api_data.args.hsa_ext_image_data_get_info_with_layout.image_data_info = image_data_info; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_ext_image_data_get_info_with_layout, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_ext_image_data_get_info_with_layout, &api_data, api_callback_arg); + hsa_status_t ret = ImageExtTable_saved.hsa_ext_image_data_get_info_with_layout_fn(agent, image_descriptor, access_permission, image_data_layout, image_data_row_pitch, image_data_slice_pitch, image_data_info); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_ext_image_data_get_info_with_layout, &api_data, api_callback_arg); + return ret; +} +static hsa_status_t hsa_ext_image_create_with_layout_callback(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_api_data_t api_data{}; + api_data.args.hsa_ext_image_create_with_layout.image_descriptor = image_descriptor; + api_data.args.hsa_ext_image_create_with_layout.image_data_layout = image_data_layout; + api_data.args.hsa_ext_image_create_with_layout.image_data_row_pitch = image_data_row_pitch; + api_data.args.hsa_ext_image_create_with_layout.agent = agent; + api_data.args.hsa_ext_image_create_with_layout.image_data_slice_pitch = image_data_slice_pitch; + api_data.args.hsa_ext_image_create_with_layout.access_permission = access_permission; + api_data.args.hsa_ext_image_create_with_layout.image_data = image_data; + api_data.args.hsa_ext_image_create_with_layout.image = image; + activity_rtapi_callback_t api_callback_fun = NULL; + void* api_callback_arg = NULL; + cb_table.get(HSA_API_ID_hsa_ext_image_create_with_layout, &api_callback_fun, &api_callback_arg); + api_data.phase = 0; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_ext_image_create_with_layout, &api_data, api_callback_arg); + hsa_status_t ret = ImageExtTable_saved.hsa_ext_image_create_with_layout_fn(agent, image_descriptor, image_data, access_permission, image_data_layout, image_data_row_pitch, image_data_slice_pitch, image); + api_data.phase = 1; + if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_hsa_ext_image_create_with_layout, &api_data, api_callback_arg); + return ret; +} + +// section: API intercepting code + +// block: CoreApiTable API +static void intercept_CoreApiTable(CoreApiTable* table) { + CoreApiTable_saved = *table; + table->hsa_init_fn = hsa_init_callback; + table->hsa_shut_down_fn = hsa_shut_down_callback; + table->hsa_system_get_info_fn = hsa_system_get_info_callback; + table->hsa_system_extension_supported_fn = hsa_system_extension_supported_callback; + table->hsa_system_get_extension_table_fn = hsa_system_get_extension_table_callback; + table->hsa_iterate_agents_fn = hsa_iterate_agents_callback; + table->hsa_agent_get_info_fn = hsa_agent_get_info_callback; + table->hsa_queue_create_fn = hsa_queue_create_callback; + table->hsa_soft_queue_create_fn = hsa_soft_queue_create_callback; + table->hsa_queue_destroy_fn = hsa_queue_destroy_callback; + table->hsa_queue_inactivate_fn = hsa_queue_inactivate_callback; + table->hsa_queue_load_read_index_scacquire_fn = hsa_queue_load_read_index_scacquire_callback; + table->hsa_queue_load_read_index_relaxed_fn = hsa_queue_load_read_index_relaxed_callback; + table->hsa_queue_load_write_index_scacquire_fn = hsa_queue_load_write_index_scacquire_callback; + table->hsa_queue_load_write_index_relaxed_fn = hsa_queue_load_write_index_relaxed_callback; + table->hsa_queue_store_write_index_relaxed_fn = hsa_queue_store_write_index_relaxed_callback; + table->hsa_queue_store_write_index_screlease_fn = hsa_queue_store_write_index_screlease_callback; + table->hsa_queue_cas_write_index_scacq_screl_fn = hsa_queue_cas_write_index_scacq_screl_callback; + table->hsa_queue_cas_write_index_scacquire_fn = hsa_queue_cas_write_index_scacquire_callback; + table->hsa_queue_cas_write_index_relaxed_fn = hsa_queue_cas_write_index_relaxed_callback; + table->hsa_queue_cas_write_index_screlease_fn = hsa_queue_cas_write_index_screlease_callback; + table->hsa_queue_add_write_index_scacq_screl_fn = hsa_queue_add_write_index_scacq_screl_callback; + table->hsa_queue_add_write_index_scacquire_fn = hsa_queue_add_write_index_scacquire_callback; + table->hsa_queue_add_write_index_relaxed_fn = hsa_queue_add_write_index_relaxed_callback; + table->hsa_queue_add_write_index_screlease_fn = hsa_queue_add_write_index_screlease_callback; + table->hsa_queue_store_read_index_relaxed_fn = hsa_queue_store_read_index_relaxed_callback; + table->hsa_queue_store_read_index_screlease_fn = hsa_queue_store_read_index_screlease_callback; + table->hsa_agent_iterate_regions_fn = hsa_agent_iterate_regions_callback; + table->hsa_region_get_info_fn = hsa_region_get_info_callback; + table->hsa_agent_get_exception_policies_fn = hsa_agent_get_exception_policies_callback; + table->hsa_agent_extension_supported_fn = hsa_agent_extension_supported_callback; + table->hsa_memory_register_fn = hsa_memory_register_callback; + table->hsa_memory_deregister_fn = hsa_memory_deregister_callback; + table->hsa_memory_allocate_fn = hsa_memory_allocate_callback; + table->hsa_memory_free_fn = hsa_memory_free_callback; + table->hsa_memory_copy_fn = hsa_memory_copy_callback; + table->hsa_memory_assign_agent_fn = hsa_memory_assign_agent_callback; + table->hsa_signal_create_fn = hsa_signal_create_callback; + table->hsa_signal_destroy_fn = hsa_signal_destroy_callback; + table->hsa_signal_load_relaxed_fn = hsa_signal_load_relaxed_callback; + table->hsa_signal_load_scacquire_fn = hsa_signal_load_scacquire_callback; + table->hsa_signal_store_relaxed_fn = hsa_signal_store_relaxed_callback; + table->hsa_signal_store_screlease_fn = hsa_signal_store_screlease_callback; + table->hsa_signal_wait_relaxed_fn = hsa_signal_wait_relaxed_callback; + table->hsa_signal_wait_scacquire_fn = hsa_signal_wait_scacquire_callback; + table->hsa_signal_and_relaxed_fn = hsa_signal_and_relaxed_callback; + table->hsa_signal_and_scacquire_fn = hsa_signal_and_scacquire_callback; + table->hsa_signal_and_screlease_fn = hsa_signal_and_screlease_callback; + table->hsa_signal_and_scacq_screl_fn = hsa_signal_and_scacq_screl_callback; + table->hsa_signal_or_relaxed_fn = hsa_signal_or_relaxed_callback; + table->hsa_signal_or_scacquire_fn = hsa_signal_or_scacquire_callback; + table->hsa_signal_or_screlease_fn = hsa_signal_or_screlease_callback; + table->hsa_signal_or_scacq_screl_fn = hsa_signal_or_scacq_screl_callback; + table->hsa_signal_xor_relaxed_fn = hsa_signal_xor_relaxed_callback; + table->hsa_signal_xor_scacquire_fn = hsa_signal_xor_scacquire_callback; + table->hsa_signal_xor_screlease_fn = hsa_signal_xor_screlease_callback; + table->hsa_signal_xor_scacq_screl_fn = hsa_signal_xor_scacq_screl_callback; + table->hsa_signal_exchange_relaxed_fn = hsa_signal_exchange_relaxed_callback; + table->hsa_signal_exchange_scacquire_fn = hsa_signal_exchange_scacquire_callback; + table->hsa_signal_exchange_screlease_fn = hsa_signal_exchange_screlease_callback; + table->hsa_signal_exchange_scacq_screl_fn = hsa_signal_exchange_scacq_screl_callback; + table->hsa_signal_add_relaxed_fn = hsa_signal_add_relaxed_callback; + table->hsa_signal_add_scacquire_fn = hsa_signal_add_scacquire_callback; + table->hsa_signal_add_screlease_fn = hsa_signal_add_screlease_callback; + table->hsa_signal_add_scacq_screl_fn = hsa_signal_add_scacq_screl_callback; + table->hsa_signal_subtract_relaxed_fn = hsa_signal_subtract_relaxed_callback; + table->hsa_signal_subtract_scacquire_fn = hsa_signal_subtract_scacquire_callback; + table->hsa_signal_subtract_screlease_fn = hsa_signal_subtract_screlease_callback; + table->hsa_signal_subtract_scacq_screl_fn = hsa_signal_subtract_scacq_screl_callback; + table->hsa_signal_cas_relaxed_fn = hsa_signal_cas_relaxed_callback; + table->hsa_signal_cas_scacquire_fn = hsa_signal_cas_scacquire_callback; + table->hsa_signal_cas_screlease_fn = hsa_signal_cas_screlease_callback; + table->hsa_signal_cas_scacq_screl_fn = hsa_signal_cas_scacq_screl_callback; + table->hsa_isa_from_name_fn = hsa_isa_from_name_callback; + table->hsa_isa_get_info_fn = hsa_isa_get_info_callback; + table->hsa_isa_compatible_fn = hsa_isa_compatible_callback; + table->hsa_code_object_serialize_fn = hsa_code_object_serialize_callback; + table->hsa_code_object_deserialize_fn = hsa_code_object_deserialize_callback; + table->hsa_code_object_destroy_fn = hsa_code_object_destroy_callback; + table->hsa_code_object_get_info_fn = hsa_code_object_get_info_callback; + table->hsa_code_object_get_symbol_fn = hsa_code_object_get_symbol_callback; + table->hsa_code_symbol_get_info_fn = hsa_code_symbol_get_info_callback; + table->hsa_code_object_iterate_symbols_fn = hsa_code_object_iterate_symbols_callback; + table->hsa_executable_create_fn = hsa_executable_create_callback; + table->hsa_executable_destroy_fn = hsa_executable_destroy_callback; + table->hsa_executable_load_code_object_fn = hsa_executable_load_code_object_callback; + table->hsa_executable_freeze_fn = hsa_executable_freeze_callback; + table->hsa_executable_get_info_fn = hsa_executable_get_info_callback; + table->hsa_executable_global_variable_define_fn = hsa_executable_global_variable_define_callback; + table->hsa_executable_agent_global_variable_define_fn = hsa_executable_agent_global_variable_define_callback; + table->hsa_executable_readonly_variable_define_fn = hsa_executable_readonly_variable_define_callback; + table->hsa_executable_validate_fn = hsa_executable_validate_callback; + table->hsa_executable_get_symbol_fn = hsa_executable_get_symbol_callback; + table->hsa_executable_symbol_get_info_fn = hsa_executable_symbol_get_info_callback; + table->hsa_executable_iterate_symbols_fn = hsa_executable_iterate_symbols_callback; + table->hsa_status_string_fn = hsa_status_string_callback; + table->hsa_extension_get_name_fn = hsa_extension_get_name_callback; + table->hsa_system_major_extension_supported_fn = hsa_system_major_extension_supported_callback; + table->hsa_system_get_major_extension_table_fn = hsa_system_get_major_extension_table_callback; + table->hsa_agent_major_extension_supported_fn = hsa_agent_major_extension_supported_callback; + table->hsa_cache_get_info_fn = hsa_cache_get_info_callback; + table->hsa_agent_iterate_caches_fn = hsa_agent_iterate_caches_callback; + table->hsa_signal_silent_store_relaxed_fn = hsa_signal_silent_store_relaxed_callback; + table->hsa_signal_silent_store_screlease_fn = hsa_signal_silent_store_screlease_callback; + table->hsa_signal_group_create_fn = hsa_signal_group_create_callback; + table->hsa_signal_group_destroy_fn = hsa_signal_group_destroy_callback; + table->hsa_signal_group_wait_any_scacquire_fn = hsa_signal_group_wait_any_scacquire_callback; + table->hsa_signal_group_wait_any_relaxed_fn = hsa_signal_group_wait_any_relaxed_callback; + table->hsa_agent_iterate_isas_fn = hsa_agent_iterate_isas_callback; + table->hsa_isa_get_info_alt_fn = hsa_isa_get_info_alt_callback; + table->hsa_isa_get_exception_policies_fn = hsa_isa_get_exception_policies_callback; + table->hsa_isa_get_round_method_fn = hsa_isa_get_round_method_callback; + table->hsa_wavefront_get_info_fn = hsa_wavefront_get_info_callback; + table->hsa_isa_iterate_wavefronts_fn = hsa_isa_iterate_wavefronts_callback; + table->hsa_code_object_get_symbol_from_name_fn = hsa_code_object_get_symbol_from_name_callback; + table->hsa_code_object_reader_create_from_file_fn = hsa_code_object_reader_create_from_file_callback; + table->hsa_code_object_reader_create_from_memory_fn = hsa_code_object_reader_create_from_memory_callback; + table->hsa_code_object_reader_destroy_fn = hsa_code_object_reader_destroy_callback; + table->hsa_executable_create_alt_fn = hsa_executable_create_alt_callback; + table->hsa_executable_load_program_code_object_fn = hsa_executable_load_program_code_object_callback; + table->hsa_executable_load_agent_code_object_fn = hsa_executable_load_agent_code_object_callback; + table->hsa_executable_validate_alt_fn = hsa_executable_validate_alt_callback; + table->hsa_executable_get_symbol_by_name_fn = hsa_executable_get_symbol_by_name_callback; + table->hsa_executable_iterate_agent_symbols_fn = hsa_executable_iterate_agent_symbols_callback; + table->hsa_executable_iterate_program_symbols_fn = hsa_executable_iterate_program_symbols_callback; +}; +static void intercept_AmdExtTable(AmdExtTable* table) { + AmdExtTable_saved = *table; + +// block: AmdExtTable API + table->hsa_amd_coherency_get_type_fn = hsa_amd_coherency_get_type_callback; + table->hsa_amd_coherency_set_type_fn = hsa_amd_coherency_set_type_callback; + table->hsa_amd_profiling_set_profiler_enabled_fn = hsa_amd_profiling_set_profiler_enabled_callback; + table->hsa_amd_profiling_async_copy_enable_fn = hsa_amd_profiling_async_copy_enable_callback; + table->hsa_amd_profiling_get_dispatch_time_fn = hsa_amd_profiling_get_dispatch_time_callback; + table->hsa_amd_profiling_get_async_copy_time_fn = hsa_amd_profiling_get_async_copy_time_callback; + table->hsa_amd_profiling_convert_tick_to_system_domain_fn = hsa_amd_profiling_convert_tick_to_system_domain_callback; + table->hsa_amd_signal_async_handler_fn = hsa_amd_signal_async_handler_callback; + table->hsa_amd_async_function_fn = hsa_amd_async_function_callback; + table->hsa_amd_signal_wait_any_fn = hsa_amd_signal_wait_any_callback; + table->hsa_amd_queue_cu_set_mask_fn = hsa_amd_queue_cu_set_mask_callback; + table->hsa_amd_memory_pool_get_info_fn = hsa_amd_memory_pool_get_info_callback; + table->hsa_amd_agent_iterate_memory_pools_fn = hsa_amd_agent_iterate_memory_pools_callback; + table->hsa_amd_memory_pool_allocate_fn = hsa_amd_memory_pool_allocate_callback; + table->hsa_amd_memory_pool_free_fn = hsa_amd_memory_pool_free_callback; + table->hsa_amd_memory_async_copy_fn = hsa_amd_memory_async_copy_callback; + table->hsa_amd_agent_memory_pool_get_info_fn = hsa_amd_agent_memory_pool_get_info_callback; + table->hsa_amd_agents_allow_access_fn = hsa_amd_agents_allow_access_callback; + table->hsa_amd_memory_pool_can_migrate_fn = hsa_amd_memory_pool_can_migrate_callback; + table->hsa_amd_memory_migrate_fn = hsa_amd_memory_migrate_callback; + table->hsa_amd_memory_lock_fn = hsa_amd_memory_lock_callback; + table->hsa_amd_memory_unlock_fn = hsa_amd_memory_unlock_callback; + table->hsa_amd_memory_fill_fn = hsa_amd_memory_fill_callback; + table->hsa_amd_interop_map_buffer_fn = hsa_amd_interop_map_buffer_callback; + table->hsa_amd_interop_unmap_buffer_fn = hsa_amd_interop_unmap_buffer_callback; + table->hsa_amd_image_create_fn = hsa_amd_image_create_callback; + table->hsa_amd_pointer_info_fn = hsa_amd_pointer_info_callback; + table->hsa_amd_pointer_info_set_userdata_fn = hsa_amd_pointer_info_set_userdata_callback; + table->hsa_amd_ipc_memory_create_fn = hsa_amd_ipc_memory_create_callback; + table->hsa_amd_ipc_memory_attach_fn = hsa_amd_ipc_memory_attach_callback; + table->hsa_amd_ipc_memory_detach_fn = hsa_amd_ipc_memory_detach_callback; + table->hsa_amd_signal_create_fn = hsa_amd_signal_create_callback; + table->hsa_amd_ipc_signal_create_fn = hsa_amd_ipc_signal_create_callback; + table->hsa_amd_ipc_signal_attach_fn = hsa_amd_ipc_signal_attach_callback; + table->hsa_amd_register_system_event_handler_fn = hsa_amd_register_system_event_handler_callback; + table->hsa_amd_queue_intercept_create_fn = hsa_amd_queue_intercept_create_callback; + table->hsa_amd_queue_intercept_register_fn = hsa_amd_queue_intercept_register_callback; + table->hsa_amd_queue_set_priority_fn = hsa_amd_queue_set_priority_callback; + table->hsa_amd_memory_async_copy_rect_fn = hsa_amd_memory_async_copy_rect_callback; + table->hsa_amd_runtime_queue_create_register_fn = hsa_amd_runtime_queue_create_register_callback; +}; +static void intercept_ImageExtTable(ImageExtTable* table) { + ImageExtTable_saved = *table; + +// block: ImageExtTable API + table->hsa_ext_image_get_capability_fn = hsa_ext_image_get_capability_callback; + table->hsa_ext_image_data_get_info_fn = hsa_ext_image_data_get_info_callback; + table->hsa_ext_image_create_fn = hsa_ext_image_create_callback; + table->hsa_ext_image_import_fn = hsa_ext_image_import_callback; + table->hsa_ext_image_export_fn = hsa_ext_image_export_callback; + table->hsa_ext_image_copy_fn = hsa_ext_image_copy_callback; + table->hsa_ext_image_clear_fn = hsa_ext_image_clear_callback; + table->hsa_ext_image_destroy_fn = hsa_ext_image_destroy_callback; + table->hsa_ext_sampler_create_fn = hsa_ext_sampler_create_callback; + table->hsa_ext_sampler_destroy_fn = hsa_ext_sampler_destroy_callback; + table->hsa_ext_image_get_capability_with_layout_fn = hsa_ext_image_get_capability_with_layout_callback; + table->hsa_ext_image_data_get_info_with_layout_fn = hsa_ext_image_data_get_info_with_layout_callback; + table->hsa_ext_image_create_with_layout_fn = hsa_ext_image_create_with_layout_callback; +}; + +// section: API get_name function + +static const char* GetApiName(const uint32_t& id) { + switch (id) { + // block: CoreApiTable API + case HSA_API_ID_hsa_init: return "hsa_init"; + case HSA_API_ID_hsa_shut_down: return "hsa_shut_down"; + case HSA_API_ID_hsa_system_get_info: return "hsa_system_get_info"; + case HSA_API_ID_hsa_system_extension_supported: return "hsa_system_extension_supported"; + case HSA_API_ID_hsa_system_get_extension_table: return "hsa_system_get_extension_table"; + case HSA_API_ID_hsa_iterate_agents: return "hsa_iterate_agents"; + case HSA_API_ID_hsa_agent_get_info: return "hsa_agent_get_info"; + case HSA_API_ID_hsa_queue_create: return "hsa_queue_create"; + case HSA_API_ID_hsa_soft_queue_create: return "hsa_soft_queue_create"; + case HSA_API_ID_hsa_queue_destroy: return "hsa_queue_destroy"; + case HSA_API_ID_hsa_queue_inactivate: return "hsa_queue_inactivate"; + case HSA_API_ID_hsa_queue_load_read_index_scacquire: return "hsa_queue_load_read_index_scacquire"; + case HSA_API_ID_hsa_queue_load_read_index_relaxed: return "hsa_queue_load_read_index_relaxed"; + case HSA_API_ID_hsa_queue_load_write_index_scacquire: return "hsa_queue_load_write_index_scacquire"; + case HSA_API_ID_hsa_queue_load_write_index_relaxed: return "hsa_queue_load_write_index_relaxed"; + case HSA_API_ID_hsa_queue_store_write_index_relaxed: return "hsa_queue_store_write_index_relaxed"; + case HSA_API_ID_hsa_queue_store_write_index_screlease: return "hsa_queue_store_write_index_screlease"; + case HSA_API_ID_hsa_queue_cas_write_index_scacq_screl: return "hsa_queue_cas_write_index_scacq_screl"; + case HSA_API_ID_hsa_queue_cas_write_index_scacquire: return "hsa_queue_cas_write_index_scacquire"; + case HSA_API_ID_hsa_queue_cas_write_index_relaxed: return "hsa_queue_cas_write_index_relaxed"; + case HSA_API_ID_hsa_queue_cas_write_index_screlease: return "hsa_queue_cas_write_index_screlease"; + case HSA_API_ID_hsa_queue_add_write_index_scacq_screl: return "hsa_queue_add_write_index_scacq_screl"; + case HSA_API_ID_hsa_queue_add_write_index_scacquire: return "hsa_queue_add_write_index_scacquire"; + case HSA_API_ID_hsa_queue_add_write_index_relaxed: return "hsa_queue_add_write_index_relaxed"; + case HSA_API_ID_hsa_queue_add_write_index_screlease: return "hsa_queue_add_write_index_screlease"; + case HSA_API_ID_hsa_queue_store_read_index_relaxed: return "hsa_queue_store_read_index_relaxed"; + case HSA_API_ID_hsa_queue_store_read_index_screlease: return "hsa_queue_store_read_index_screlease"; + case HSA_API_ID_hsa_agent_iterate_regions: return "hsa_agent_iterate_regions"; + case HSA_API_ID_hsa_region_get_info: return "hsa_region_get_info"; + case HSA_API_ID_hsa_agent_get_exception_policies: return "hsa_agent_get_exception_policies"; + case HSA_API_ID_hsa_agent_extension_supported: return "hsa_agent_extension_supported"; + case HSA_API_ID_hsa_memory_register: return "hsa_memory_register"; + case HSA_API_ID_hsa_memory_deregister: return "hsa_memory_deregister"; + case HSA_API_ID_hsa_memory_allocate: return "hsa_memory_allocate"; + case HSA_API_ID_hsa_memory_free: return "hsa_memory_free"; + case HSA_API_ID_hsa_memory_copy: return "hsa_memory_copy"; + case HSA_API_ID_hsa_memory_assign_agent: return "hsa_memory_assign_agent"; + case HSA_API_ID_hsa_signal_create: return "hsa_signal_create"; + case HSA_API_ID_hsa_signal_destroy: return "hsa_signal_destroy"; + case HSA_API_ID_hsa_signal_load_relaxed: return "hsa_signal_load_relaxed"; + case HSA_API_ID_hsa_signal_load_scacquire: return "hsa_signal_load_scacquire"; + case HSA_API_ID_hsa_signal_store_relaxed: return "hsa_signal_store_relaxed"; + case HSA_API_ID_hsa_signal_store_screlease: return "hsa_signal_store_screlease"; + case HSA_API_ID_hsa_signal_wait_relaxed: return "hsa_signal_wait_relaxed"; + case HSA_API_ID_hsa_signal_wait_scacquire: return "hsa_signal_wait_scacquire"; + case HSA_API_ID_hsa_signal_and_relaxed: return "hsa_signal_and_relaxed"; + case HSA_API_ID_hsa_signal_and_scacquire: return "hsa_signal_and_scacquire"; + case HSA_API_ID_hsa_signal_and_screlease: return "hsa_signal_and_screlease"; + case HSA_API_ID_hsa_signal_and_scacq_screl: return "hsa_signal_and_scacq_screl"; + case HSA_API_ID_hsa_signal_or_relaxed: return "hsa_signal_or_relaxed"; + case HSA_API_ID_hsa_signal_or_scacquire: return "hsa_signal_or_scacquire"; + case HSA_API_ID_hsa_signal_or_screlease: return "hsa_signal_or_screlease"; + case HSA_API_ID_hsa_signal_or_scacq_screl: return "hsa_signal_or_scacq_screl"; + case HSA_API_ID_hsa_signal_xor_relaxed: return "hsa_signal_xor_relaxed"; + case HSA_API_ID_hsa_signal_xor_scacquire: return "hsa_signal_xor_scacquire"; + case HSA_API_ID_hsa_signal_xor_screlease: return "hsa_signal_xor_screlease"; + case HSA_API_ID_hsa_signal_xor_scacq_screl: return "hsa_signal_xor_scacq_screl"; + case HSA_API_ID_hsa_signal_exchange_relaxed: return "hsa_signal_exchange_relaxed"; + case HSA_API_ID_hsa_signal_exchange_scacquire: return "hsa_signal_exchange_scacquire"; + case HSA_API_ID_hsa_signal_exchange_screlease: return "hsa_signal_exchange_screlease"; + case HSA_API_ID_hsa_signal_exchange_scacq_screl: return "hsa_signal_exchange_scacq_screl"; + case HSA_API_ID_hsa_signal_add_relaxed: return "hsa_signal_add_relaxed"; + case HSA_API_ID_hsa_signal_add_scacquire: return "hsa_signal_add_scacquire"; + case HSA_API_ID_hsa_signal_add_screlease: return "hsa_signal_add_screlease"; + case HSA_API_ID_hsa_signal_add_scacq_screl: return "hsa_signal_add_scacq_screl"; + case HSA_API_ID_hsa_signal_subtract_relaxed: return "hsa_signal_subtract_relaxed"; + case HSA_API_ID_hsa_signal_subtract_scacquire: return "hsa_signal_subtract_scacquire"; + case HSA_API_ID_hsa_signal_subtract_screlease: return "hsa_signal_subtract_screlease"; + case HSA_API_ID_hsa_signal_subtract_scacq_screl: return "hsa_signal_subtract_scacq_screl"; + case HSA_API_ID_hsa_signal_cas_relaxed: return "hsa_signal_cas_relaxed"; + case HSA_API_ID_hsa_signal_cas_scacquire: return "hsa_signal_cas_scacquire"; + case HSA_API_ID_hsa_signal_cas_screlease: return "hsa_signal_cas_screlease"; + case HSA_API_ID_hsa_signal_cas_scacq_screl: return "hsa_signal_cas_scacq_screl"; + case HSA_API_ID_hsa_isa_from_name: return "hsa_isa_from_name"; + case HSA_API_ID_hsa_isa_get_info: return "hsa_isa_get_info"; + case HSA_API_ID_hsa_isa_compatible: return "hsa_isa_compatible"; + case HSA_API_ID_hsa_code_object_serialize: return "hsa_code_object_serialize"; + case HSA_API_ID_hsa_code_object_deserialize: return "hsa_code_object_deserialize"; + case HSA_API_ID_hsa_code_object_destroy: return "hsa_code_object_destroy"; + case HSA_API_ID_hsa_code_object_get_info: return "hsa_code_object_get_info"; + case HSA_API_ID_hsa_code_object_get_symbol: return "hsa_code_object_get_symbol"; + case HSA_API_ID_hsa_code_symbol_get_info: return "hsa_code_symbol_get_info"; + case HSA_API_ID_hsa_code_object_iterate_symbols: return "hsa_code_object_iterate_symbols"; + case HSA_API_ID_hsa_executable_create: return "hsa_executable_create"; + case HSA_API_ID_hsa_executable_destroy: return "hsa_executable_destroy"; + case HSA_API_ID_hsa_executable_load_code_object: return "hsa_executable_load_code_object"; + case HSA_API_ID_hsa_executable_freeze: return "hsa_executable_freeze"; + case HSA_API_ID_hsa_executable_get_info: return "hsa_executable_get_info"; + case HSA_API_ID_hsa_executable_global_variable_define: return "hsa_executable_global_variable_define"; + case HSA_API_ID_hsa_executable_agent_global_variable_define: return "hsa_executable_agent_global_variable_define"; + case HSA_API_ID_hsa_executable_readonly_variable_define: return "hsa_executable_readonly_variable_define"; + case HSA_API_ID_hsa_executable_validate: return "hsa_executable_validate"; + case HSA_API_ID_hsa_executable_get_symbol: return "hsa_executable_get_symbol"; + case HSA_API_ID_hsa_executable_symbol_get_info: return "hsa_executable_symbol_get_info"; + case HSA_API_ID_hsa_executable_iterate_symbols: return "hsa_executable_iterate_symbols"; + case HSA_API_ID_hsa_status_string: return "hsa_status_string"; + case HSA_API_ID_hsa_extension_get_name: return "hsa_extension_get_name"; + case HSA_API_ID_hsa_system_major_extension_supported: return "hsa_system_major_extension_supported"; + case HSA_API_ID_hsa_system_get_major_extension_table: return "hsa_system_get_major_extension_table"; + case HSA_API_ID_hsa_agent_major_extension_supported: return "hsa_agent_major_extension_supported"; + case HSA_API_ID_hsa_cache_get_info: return "hsa_cache_get_info"; + case HSA_API_ID_hsa_agent_iterate_caches: return "hsa_agent_iterate_caches"; + case HSA_API_ID_hsa_signal_silent_store_relaxed: return "hsa_signal_silent_store_relaxed"; + case HSA_API_ID_hsa_signal_silent_store_screlease: return "hsa_signal_silent_store_screlease"; + case HSA_API_ID_hsa_signal_group_create: return "hsa_signal_group_create"; + case HSA_API_ID_hsa_signal_group_destroy: return "hsa_signal_group_destroy"; + case HSA_API_ID_hsa_signal_group_wait_any_scacquire: return "hsa_signal_group_wait_any_scacquire"; + case HSA_API_ID_hsa_signal_group_wait_any_relaxed: return "hsa_signal_group_wait_any_relaxed"; + case HSA_API_ID_hsa_agent_iterate_isas: return "hsa_agent_iterate_isas"; + case HSA_API_ID_hsa_isa_get_info_alt: return "hsa_isa_get_info_alt"; + case HSA_API_ID_hsa_isa_get_exception_policies: return "hsa_isa_get_exception_policies"; + case HSA_API_ID_hsa_isa_get_round_method: return "hsa_isa_get_round_method"; + case HSA_API_ID_hsa_wavefront_get_info: return "hsa_wavefront_get_info"; + case HSA_API_ID_hsa_isa_iterate_wavefronts: return "hsa_isa_iterate_wavefronts"; + case HSA_API_ID_hsa_code_object_get_symbol_from_name: return "hsa_code_object_get_symbol_from_name"; + case HSA_API_ID_hsa_code_object_reader_create_from_file: return "hsa_code_object_reader_create_from_file"; + case HSA_API_ID_hsa_code_object_reader_create_from_memory: return "hsa_code_object_reader_create_from_memory"; + case HSA_API_ID_hsa_code_object_reader_destroy: return "hsa_code_object_reader_destroy"; + case HSA_API_ID_hsa_executable_create_alt: return "hsa_executable_create_alt"; + case HSA_API_ID_hsa_executable_load_program_code_object: return "hsa_executable_load_program_code_object"; + case HSA_API_ID_hsa_executable_load_agent_code_object: return "hsa_executable_load_agent_code_object"; + case HSA_API_ID_hsa_executable_validate_alt: return "hsa_executable_validate_alt"; + case HSA_API_ID_hsa_executable_get_symbol_by_name: return "hsa_executable_get_symbol_by_name"; + case HSA_API_ID_hsa_executable_iterate_agent_symbols: return "hsa_executable_iterate_agent_symbols"; + case HSA_API_ID_hsa_executable_iterate_program_symbols: return "hsa_executable_iterate_program_symbols"; + + // block: AmdExtTable API + case HSA_API_ID_hsa_amd_coherency_get_type: return "hsa_amd_coherency_get_type"; + case HSA_API_ID_hsa_amd_coherency_set_type: return "hsa_amd_coherency_set_type"; + case HSA_API_ID_hsa_amd_profiling_set_profiler_enabled: return "hsa_amd_profiling_set_profiler_enabled"; + case HSA_API_ID_hsa_amd_profiling_async_copy_enable: return "hsa_amd_profiling_async_copy_enable"; + case HSA_API_ID_hsa_amd_profiling_get_dispatch_time: return "hsa_amd_profiling_get_dispatch_time"; + case HSA_API_ID_hsa_amd_profiling_get_async_copy_time: return "hsa_amd_profiling_get_async_copy_time"; + case HSA_API_ID_hsa_amd_profiling_convert_tick_to_system_domain: return "hsa_amd_profiling_convert_tick_to_system_domain"; + case HSA_API_ID_hsa_amd_signal_async_handler: return "hsa_amd_signal_async_handler"; + case HSA_API_ID_hsa_amd_async_function: return "hsa_amd_async_function"; + case HSA_API_ID_hsa_amd_signal_wait_any: return "hsa_amd_signal_wait_any"; + case HSA_API_ID_hsa_amd_queue_cu_set_mask: return "hsa_amd_queue_cu_set_mask"; + case HSA_API_ID_hsa_amd_memory_pool_get_info: return "hsa_amd_memory_pool_get_info"; + case HSA_API_ID_hsa_amd_agent_iterate_memory_pools: return "hsa_amd_agent_iterate_memory_pools"; + case HSA_API_ID_hsa_amd_memory_pool_allocate: return "hsa_amd_memory_pool_allocate"; + case HSA_API_ID_hsa_amd_memory_pool_free: return "hsa_amd_memory_pool_free"; + case HSA_API_ID_hsa_amd_memory_async_copy: return "hsa_amd_memory_async_copy"; + case HSA_API_ID_hsa_amd_agent_memory_pool_get_info: return "hsa_amd_agent_memory_pool_get_info"; + case HSA_API_ID_hsa_amd_agents_allow_access: return "hsa_amd_agents_allow_access"; + case HSA_API_ID_hsa_amd_memory_pool_can_migrate: return "hsa_amd_memory_pool_can_migrate"; + case HSA_API_ID_hsa_amd_memory_migrate: return "hsa_amd_memory_migrate"; + case HSA_API_ID_hsa_amd_memory_lock: return "hsa_amd_memory_lock"; + case HSA_API_ID_hsa_amd_memory_unlock: return "hsa_amd_memory_unlock"; + case HSA_API_ID_hsa_amd_memory_fill: return "hsa_amd_memory_fill"; + case HSA_API_ID_hsa_amd_interop_map_buffer: return "hsa_amd_interop_map_buffer"; + case HSA_API_ID_hsa_amd_interop_unmap_buffer: return "hsa_amd_interop_unmap_buffer"; + case HSA_API_ID_hsa_amd_image_create: return "hsa_amd_image_create"; + case HSA_API_ID_hsa_amd_pointer_info: return "hsa_amd_pointer_info"; + case HSA_API_ID_hsa_amd_pointer_info_set_userdata: return "hsa_amd_pointer_info_set_userdata"; + case HSA_API_ID_hsa_amd_ipc_memory_create: return "hsa_amd_ipc_memory_create"; + case HSA_API_ID_hsa_amd_ipc_memory_attach: return "hsa_amd_ipc_memory_attach"; + case HSA_API_ID_hsa_amd_ipc_memory_detach: return "hsa_amd_ipc_memory_detach"; + case HSA_API_ID_hsa_amd_signal_create: return "hsa_amd_signal_create"; + case HSA_API_ID_hsa_amd_ipc_signal_create: return "hsa_amd_ipc_signal_create"; + case HSA_API_ID_hsa_amd_ipc_signal_attach: return "hsa_amd_ipc_signal_attach"; + case HSA_API_ID_hsa_amd_register_system_event_handler: return "hsa_amd_register_system_event_handler"; + case HSA_API_ID_hsa_amd_queue_intercept_create: return "hsa_amd_queue_intercept_create"; + case HSA_API_ID_hsa_amd_queue_intercept_register: return "hsa_amd_queue_intercept_register"; + case HSA_API_ID_hsa_amd_queue_set_priority: return "hsa_amd_queue_set_priority"; + case HSA_API_ID_hsa_amd_memory_async_copy_rect: return "hsa_amd_memory_async_copy_rect"; + case HSA_API_ID_hsa_amd_runtime_queue_create_register: return "hsa_amd_runtime_queue_create_register"; + + // block: ImageExtTable API + case HSA_API_ID_hsa_ext_image_get_capability: return "hsa_ext_image_get_capability"; + case HSA_API_ID_hsa_ext_image_data_get_info: return "hsa_ext_image_data_get_info"; + case HSA_API_ID_hsa_ext_image_create: return "hsa_ext_image_create"; + case HSA_API_ID_hsa_ext_image_import: return "hsa_ext_image_import"; + case HSA_API_ID_hsa_ext_image_export: return "hsa_ext_image_export"; + case HSA_API_ID_hsa_ext_image_copy: return "hsa_ext_image_copy"; + case HSA_API_ID_hsa_ext_image_clear: return "hsa_ext_image_clear"; + case HSA_API_ID_hsa_ext_image_destroy: return "hsa_ext_image_destroy"; + case HSA_API_ID_hsa_ext_sampler_create: return "hsa_ext_sampler_create"; + case HSA_API_ID_hsa_ext_sampler_destroy: return "hsa_ext_sampler_destroy"; + case HSA_API_ID_hsa_ext_image_get_capability_with_layout: return "hsa_ext_image_get_capability_with_layout"; + case HSA_API_ID_hsa_ext_image_data_get_info_with_layout: return "hsa_ext_image_data_get_info_with_layout"; + case HSA_API_ID_hsa_ext_image_create_with_layout: return "hsa_ext_image_create_with_layout"; + }; + return "unknown"; +}; + +};}; +#endif // PROF_API_IMPL + +#endif // INC_HSA_PROF_STR_H \ No newline at end of file diff --git a/inc/roctracer.h b/inc/roctracer.h index 483ce6c331..d9d886ba1b 100644 --- a/inc/roctracer.h +++ b/inc/roctracer.h @@ -71,7 +71,7 @@ typedef enum { const char* roctracer_error_string(); //////////////////////////////////////////////////////////////////////////////// -// Traced runtime API domains +// Traced runtime domains // Activity domain type typedef activity_domain_t roctracer_domain_t; @@ -83,6 +83,11 @@ const char* roctracer_id_string( const uint32_t& id, // activity ID const uint32_t& kind); // activity kind +// Set properties +roctracer_status_t roctracer_set_properties( + roctracer_domain_t domain, // tracing domain + void* propertes); // tracing properties + //////////////////////////////////////////////////////////////////////////////// // Callback API // @@ -91,18 +96,19 @@ const char* roctracer_id_string( // called on different phases, on enter, on exit, on kernel completion. // Methods return non-zero on error and library errno is set. +// Runtime API callback type typedef activity_rtapi_callback_t roctracer_rtapi_callback_t; // Enable runtime API callbacks roctracer_status_t roctracer_enable_callback( - activity_domain_t domain, // runtime API domain + activity_domain_t domain, // tracing domain uint32_t id, // API call ID activity_rtapi_callback_t callback, // callback function pointer void* arg); // [in/out] callback arg // Disable runtime API callbacks roctracer_status_t roctracer_disable_callback( - activity_domain_t domain, // runtime API domain + activity_domain_t domain, // tracing domain uint32_t id); // API call ID //////////////////////////////////////////////////////////////////////////////// @@ -170,13 +176,13 @@ roctracer_pool_t* roctracer_default_pool( // Enable activity records logging roctracer_status_t roctracer_enable_activity( - activity_domain_t domain, // runtime API domain + activity_domain_t domain, // tracing domain uint32_t id, // activity ID roctracer_pool_t* pool = NULL); // memory pool, NULL is a default one // Disable activity records logging roctracer_status_t roctracer_disable_activity( - activity_domain_t domain, // runtime API domain + activity_domain_t domain, // tracing domain uint32_t id); // activity ID // Flush available activity records diff --git a/inc/roctracer_hsa.h b/inc/roctracer_hsa.h new file mode 100644 index 0000000000..473bb27ad1 --- /dev/null +++ b/inc/roctracer_hsa.h @@ -0,0 +1,74 @@ +/* +Copyright (c) 2018 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. +*/ + +#ifndef INC_ROCTRACER_HSA_H_ +#define INC_ROCTRACER_HSA_H_ +#include + +#include +#include +#include + +#include "ext/prof_protocol.h" +#include "roctracer.h" + +namespace roctracer { +namespace hsa_support { +template +class CbTable { + public: + typedef std::mutex mutex_t; + + CbTable() { + std::lock_guard lck(mutex_); + for (int i = 0; i < N; i++) { + callback_[i] = NULL; + arg_[i] = NULL; + } + } + + void set(uint32_t id, activity_rtapi_callback_t callback, void* arg) { + std::lock_guard lck(mutex_); + callback_[id] = callback; + arg_[id] = arg; + } + + void get(uint32_t id, activity_rtapi_callback_t* callback, void** arg) { + std::lock_guard lck(mutex_); + *callback = callback_[id]; + *arg = arg_[id]; + } + + private: + activity_rtapi_callback_t callback_[N]; + void* arg_[N]; + mutex_t mutex_; +}; + +extern CoreApiTable CoreApiTable_saved; +extern AmdExtTable AmdExtTable_saved; +extern ImageExtTable ImageExtTable_saved; +}; +}; + +#include "inc/hsa_prof_str.h" +#endif // INC_ROCTRACER_HSA_H_ diff --git a/script/hipap.py b/script/hipap.py index 2533affbf6..fe29b73da7 100755 --- a/script/hipap.py +++ b/script/hipap.py @@ -4,26 +4,74 @@ import os, sys, re HEADER = "hip_cbstr.h" REC_MAX_LEN = 1024 -def fill_api_map(out, api_name, args_str): - args_list = [] - +############################################################# +# Filling API map with API call name and args +def filtr_api_args(args_str): args_str = re.sub(r'^\s*', r'', args_str); args_str = re.sub(r'\s*$', r'', args_str); args_str = re.sub(r'\s*,\s*', r',', args_str); args_str = re.sub(r'\s+', r' ', args_str); + args_str = re.sub(r'void \*', r'void* ', args_str); + args_str = re.sub(r'(enum|struct) ', '', args_str); + return args_str +def list_api_args(args_str): + args_list = [] for arg_pair in args_str.split(','): - arg_pair = re.sub(r'\s+=\s+\S+$', '', arg_pair); + arg_pair = re.sub(r'\s+=\s+\S+$','', arg_pair); m = re.match("^(.*)\s(\S+)$", arg_pair); - if m: args_list.append((m.group(1), m.group(2))) + if m: + arg_type = m.group(1) + arg_name = m.group(2) +# m = re.match("^(.*_t)\s(.*)$", arg_type) +# if m: +# arg_type = m.group(1) +# arg_name = m.group(2) + args_list.append((arg_type, arg_name)) + return args_list; - out[api_name] = args_list; +def filtr_api_types(args_str): + args_str = filtr_api_args(args_str) + args_list = list_api_args(args_str) + types_str = '' + for arg_tuple in args_list: + types_str += arg_tuple[0] + ', ' + return types_str +def norm_api_types(types_str): + types_str = re.sub(r'uint32_t,', r'unsigned int,', types_str) + types_str = re.sub(r'unsigned,', r'unsigned int,', types_str) + return types_str + +def filtr_api_opts(args_str): + args_str = filtr_api_args(args_str) + args_list = list_api_args(args_str) + opts_list = [] + for arg_tuple in args_list: + opts_list.append(arg_tuple[1]) + return opts_list + +def fill_api_map(out, api_name, args_str): + args_str = filtr_api_args(args_str) + out[api_name + '.a'] = args_str + out[api_name] = list_api_args(args_str) + +def patch_args(api_opts, eta_opts, content): + api_opts_list = api_opts.split(','); + eta_opts_list = eta_opts.split(','); + length = len(api_opts_list) + for index in range(0, length): + content = re.sub(' ' + api_opts_list[index], ' ' + eta_opts_list[index], content) + return content +############################################################# +# Parsing API header # hipError_t hipSetupArgument(const void* arg, size_t size, size_t offset); -def parse_api(inp, out): - end_pattern = re.compile("Texture"); +def parse_api(inp_file, out): beg_pattern = re.compile("^hipError_t"); api_pattern = re.compile("^hipError_t\s+([^\(]+)\(([^\)]*)\)"); + end_pattern = re.compile("Texture"); + + inp = open(inp_file, 'r') found = 0 record = "" @@ -34,47 +82,185 @@ def parse_api(inp, out): line_num += 1 if len(record) > REC_MAX_LEN: - print "Error: bad record \"" + record + "\"\nfile '" + hfile + ", line (" + str(line_num) + ")" + print "Error: bad record \"" + record + "\"\nfile '" + inp_file + ", line (" + str(line_num) + ")" break; if beg_pattern.match(record): found = 1 - if found: + if found != 0: + record = re.sub("\s__dparm\([^\)]*\)", '', record); m = api_pattern.match(record) if m: found = 0 if end_pattern.search(record): break - fill_api_map(out, m.group(1), m.group(2)) + out[m.group(1)] = filtr_api_args(m.group(2)) else: continue record = "" - + + inp.close() ############################################################# +# Patching API implementation +# hipError_t hipSetupArgument(const void* arg, size_t size, size_t offset) { +# HIP_INIT_CB(hipSetupArgument, arg, size, offset); +def patch_content(inp_file, api_map, out): + beg_pattern = re.compile("^hipError_t"); + api_pattern = re.compile("^hipError_t\s+([^\(]+)\(([^\)]*)\)\s*{"); + target_pattern = re.compile("^(\s*HIP_INIT[^\(]*)(_API\()(.*)\);\s*$"); -if (len(sys.argv) != 2): - print >>sys.stderr, "Usage:", sys.argv[0], " " + inp = open(inp_file, 'r') + + api_name = "" + api_valid = 0 + api_valid_always = 1 + + content = '' + sub_content = '' + record = '' + line_num = -1 + found = 0 + + for line in inp.readlines(): + record += re.sub(r'^\s+', r' ', line[:-1]) + line_num += 1 + + if len(record) > REC_MAX_LEN: + print "Error: bad record \"" + record + "\"\nfile '" + inp_file + ", line (" + str(line_num) + ")" + break; + + if beg_pattern.match(record): found = 1 + + if found != 0: + record = re.sub("\s__dparm\([^\)]*\)", '', record); + m = api_pattern.match(record) + if m: + found = 0 + api_name = m.group(1); + if api_name in api_map: + api_args = filtr_api_args(m.group(2)) + eta_args = api_map[api_name] + api_types = filtr_api_types(api_args) + eta_types = filtr_api_types(eta_args) + if api_types != eta_types: + api_types = norm_api_types(api_types) + eta_types = norm_api_types(eta_types) + if api_types == eta_types: + if api_name in out: + print "Error: API redefined \"" + api_name + "\", record \"" + record + "\"\nfile '" + inp_file + ", line (" + str(line_num) + ")" + sys.exit(1) + api_valid = 1 + out[api_name] = filtr_api_opts(api_args) + elif not api_name in out: + api_diff = '\t\t' + inp_file + " line(" + str(line_num) + ")\n\t\tapi: " + api_types + "\n\t\teta: " + eta_types + print "\t" + api_name + ':\n' + api_diff + '\n' + + content += sub_content + sub_content = '' + else: + sub_content += line + continue + + if (api_valid_always == 1) || (api_valid == 1): + m = target_pattern.match(line) + if m: + api_valid = 0 + if not re.search("_CB_API\(", line): + print (api_name); + api_label = api_name + if m.group(3) != "": api_label += ', ' + line = m.group(1) + '_CB' + m.group(2) + api_label + m.group(3) + ");\n" + + content += line + record = "" + + inp.close() + + if len(out) != 0: + return content + else: + return '' + +# srcs path walk +def patch_src(api_map, src_path, src_patt, out): + pattern = re.compile(src_patt) + src_path = re.sub(r'\s', '', src_path) + for src_dir in src_path.split(':'): + print "Patching " + src_dir + " for '" + src_patt + "'" + for root, dirs, files in os.walk(src_dir): + for fnm in files: + if pattern.search(fnm): + file = root + '/' + fnm + print "\t" + file + content = patch_content(file, api_map, out); + if content != '': + f = open(file, 'w') + f.write(content) + f.close() +############################################################# +# main +# Usage +if (len(sys.argv) < 2): + print >>sys.stderr, "Usage:", sys.argv[0], " [patched srcs path]" sys.exit(1) -hfile = sys.argv[1] -if not os.path.isfile(hfile): - print >>sys.stderr, "Error: input file '" + hfile + "' not found" +# API header file given as an argument +api_hfile = sys.argv[1] +if not os.path.isfile(api_hfile): + print >>sys.stderr, "Error: input file '" + api_hfile + "' not found" sys.exit(1) -inp = open(hfile, 'r') +# API declaration map api_map = {} -parse_api(inp, api_map) +# API options map +opts_map = {} -api_map['hipLaunchKernel'] = [('void*', 'kernel'), ('hipStream_t', 'stream')] +# Parsing API header +parse_api(api_hfile, api_map) + +# Patching API implementation sources +# Sources path is given as an argument +if len(sys.argv) == 3: + src_path = sys.argv[2] + src_patt = "\.cpp$" + patch_src(api_map, src_path, src_patt, opts_map) + +# Converting api map to map of lists +for name in api_map.keys(): + args_str = api_map[name]; + +# Printing not found APIs +if len(opts_map) != 0: + for name in api_map.keys(): + args_str = api_map[name]; + api_map[name] = list_api_args(args_str) + if not name in opts_map: + print "Not found: " + name +############################################################# +# Generating the header +#api_map['hipLaunchKernel'] = [ +# ('void*', 'kernel'), +# ('hipStream_t', 'stream') +#] +#api_map['hipKernel'] = [ +# ('const char*', 'name'), +# ('uint64_t', 'start'), +# ('uint64_t', 'end') +#] f = open(HEADER, 'w') f.write('// automatically generated sources\n') -f.write('#ifndef HIP__CBSTR_H__\n'); -f.write('#define HIP__CBSTR_H__\n'); +f.write('#ifndef _HIP_CBSTR_H\n'); +f.write('#define _HIP_CBSTR_H\n'); +f.write('#include \n'); +f.write('#include \n'); # Generating the callbacks function type f.write('\n// HIP API callbacks function type\n\ struct hip_cb_data_t;\n\ -typedef void (*hip_cb_fun_t)(const hip_cb_data_t* data, void* arg);\n\ +struct hip_act_record_t;\n\ +typedef void (*hip_cb_fun_t)(uint32_t domain, uint32_t cid, const void* data, void* arg);\n\ +typedef void (*hip_cb_act_t)(uint32_t cid, hip_act_record_t** record, const void* data, void* arg);\n\ +typedef void (*hip_cb_async_t)(uint32_t op_id, void* record, void* arg);\n\ ') # Generating the callbacks ID enumaration @@ -87,14 +273,22 @@ for name in api_map.keys(): f.write(' HIP_API_ID_NUMBER = ' + str(cb_id) + ',\n') f.write('};\n') +# Generating the callbacks ID enumaration +f.write('\n// Return HIP API string\n') +f.write('static const char* hip_api_name(const uint32_t& id) {\n') +f.write(' switch(id) {\n') +for name in api_map.keys(): + f.write(' case HIP_API_ID_' + name + ': return "' + name + '";\n') +f.write(' };\n') +f.write(' return "unknown";\n') +f.write('};\n') + # Generating the callbacks data structure f.write('\n// HIP API callbacks data structure\n') f.write( 'struct hip_cb_data_t {\n' + -' const char* name;\n' + -' hip_cb_id_t id;\n' + -' uint32_t correlation_id;\n' + -' bool on_enter;\n' + +' uint64_t correlation_id;\n' + +' uint32_t phase;\n' + ' union {\n' ) for name, args in api_map.items(): @@ -112,78 +306,138 @@ f.write( f.write('\n// HIP API callbacks args data filling macros\n') for name, args in api_map.items(): f.write('#define INIT_' + name + '_CB_ARGS_DATA(cb_data) { \\\n') - for arg_tuple in args: - arg_type = arg_tuple[0]; - arg_name = arg_tuple[1]; - f.write(' cb_data.args.' + name + '.' + arg_name + ' = (' + arg_type + ')' + arg_name + '; \\\n'); + opts_list = [] + if name in opts_map: + opts_list = opts_map[name] + for ind in range(0, len(args)): + arg_tuple = args[ind] + arg_type = arg_tuple[0] + fld_name = arg_tuple[1] + arg_name = arg_tuple[1] + if len(opts_list) != 0: + arg_name = opts_list[ind] + f.write(' cb_data.args.' + name + '.' + fld_name + ' = (' + arg_type + ')' + arg_name + '; \\\n') f.write('};\n') f.write('#define INIT_CB_ARGS_DATA(cb_id, cb_data) INIT_##cb_id##_CB_ARGS_DATA(cb_data)\n') -# Generating the callbacks table -f.write('\n// HIP API callbacks table\n') +# Generating the method for the API string, name and parameters +f.write('\n') +f.write('#if 0\n') +f.write('// HIP API string method, method name and parameters\n') +f.write('const char* hipApiString(hip_cb_id_t id, const hip_cb_data_t* data) {\n') +f.write(' std::ostringstream oss;\n') +f.write(' switch (id) {\n') +for name, args in api_map.items(): + f.write(' case HIP_API_ID_' + name + ':\n') + f.write(' oss << "' + name + '("') + for ind in range(0, len(args)): + arg_tuple = args[ind] + arg_name = arg_tuple[1] + if ind != 0: f.write(' << ","') + f.write('\n << " ' + arg_name + '=" << data->args.' + name + '.' + arg_name) + f.write('\n << ")";\n') + f.write(' break;\n') +f.write(' default: oss << "unknown";\n') +f.write(' };\n') +f.write(' return strdup(oss.str().c_str());\n') +f.write('};\n') +f.write('#endif\n') + +# Generating the activity record type f.write('\ -struct hip_cb_table_t {\n\ - struct { hip_cb_fun_t act; hip_cb_fun_t fun; void* arg; } arr[HIP_API_ID_NUMBER];\n\ +\n\ +// HIP API activity record type\n\ +// Base record type\n\ +struct hip_act_record_t {\n\ + uint32_t domain; // activity domain id\n\ + uint32_t op_id; // operation id, dispatch/copy/barrier\n\ + uint32_t activity_kind; // activity kind\n\ + uint64_t correlation_id; // activity correlation ID\n\ + uint64_t begin_ns; // host begin timestamp, nano-seconds\n\ + uint64_t end_ns; // host end timestamp, nano-seconds\n\ };\n\ -#define HIP_CALLBACKS_TABLE hip_cb_table_t HIP_API_callbacks_table{};\n\ -') -f.write('\ -inline bool HIP_SET_ACTIVITY(uint32_t id, hip_cb_fun_t fun, void* arg = NULL) {\n\ - (void)arg;\n\ - extern hip_cb_table_t HIP_API_callbacks_table;\n\ - if (id < HIP_API_ID_NUMBER) {\n\ - HIP_API_callbacks_table.arr[id].act = fun;\n\ - return true;\n\ - }\n\ - return false;\n\ -}\n') -f.write('\ -inline bool HIP_SET_CALLBACK(uint32_t id, hip_cb_fun_t fun, void* arg) {\n\ - extern hip_cb_table_t HIP_API_callbacks_table; \n\ - if (id < HIP_API_ID_NUMBER) {\n\ - HIP_API_callbacks_table.arr[id].fun = fun;\n\ - HIP_API_callbacks_table.arr[id].arg = arg;\n\ - return true;\n\ - }\n\ - return false;\n\ -}\n') - -# Generating the callback spawning class -f.write('\n// HIP API callbacks spawning class macro\n\ -#define CB_SPAWNER_OBJECT(cb_id) \\\n\ - class api_callbacks_spawner_t { \\\n\ - public: \\\n\ - api_callbacks_spawner_t(hip_cb_data_t& cb_data) : cb_data_(cb_data) { \\\n\ - hip_cb_id_t id = HIP_API_ID_##cb_id; \\\n\ - cb_data_.id = id; \\\n\ - cb_data_.correlation_id = UINT_MAX; \\\n\ - cb_data_.name = #cb_id; \\\n\ - extern const hip_cb_table_t* getApiCallbackTabel(); \\\n\ - const hip_cb_table_t* cb_table = getApiCallbackTabel(); \\\n\ - cb_act_ = cb_table->arr[id].act; \\\n\ - cb_fun_ = cb_table->arr[id].fun; \\\n\ - cb_arg_ = cb_table->arr[id].arg; \\\n\ - cb_data_.on_enter = true; \\\n\ - if (cb_act_ != NULL) cb_act_(&cb_data_, NULL); \\\n\ - if (cb_fun_ != NULL) cb_fun_(&cb_data_, cb_arg_); \\\n\ - } \\\n\ - ~api_callbacks_spawner_t() { \\\n\ - cb_data_.on_enter = false; \\\n\ - if (cb_act_ != NULL) cb_act_(&cb_data_, NULL); \\\n\ - if (cb_fun_ != NULL) cb_fun_(&cb_data_, cb_arg_); \\\n\ - } \\\n\ - private: \\\n\ - hip_cb_data_t& cb_data_; \\\n\ - hip_cb_fun_t cb_act_; \\\n\ - hip_cb_fun_t cb_fun_; \\\n\ - void* cb_arg_; \\\n\ - }; \\\n\ - hip_cb_data_t cb_data{}; \\\n\ - INIT_CB_ARGS_DATA(cb_id, cb_data); \\\n\ - api_callbacks_spawner_t api_callbacks_spawner(cb_data); \n\ +// Async record type\n\ +struct hip_async_record_t : hip_act_record_t {\n\ + int device_id;\n\ + uint64_t stream_id;\n\ +};\n\ +// Dispatch record type\n\ +struct hip_dispatch_record_t : hip_async_record_t {};\n\ +// Barrier record type\n\ +struct hip_barrier_record_t : hip_async_record_t {};\n\ +// Memcpy record type\n\ +struct hip_copy_record_t : hip_async_record_t {\n\ + size_t bytes;\n\ +};\n\ +// Generic async operation record\n\ +typedef hip_copy_record_t hip_ops_record_t;\n\ ') -f.write('#endif // HIP__CBSTR__'); +# # Generating the callbacks table +# f.write('\n// HIP API callbacks table\n') +# f.write('\ +# struct hip_cb_table_t {\n\ +# struct { hip_cb_fun_t act; hip_cb_fun_t fun; void* arg; } arr[HIP_API_ID_NUMBER];\n\ +# };\n\ +# #define HIP_CALLBACKS_TABLE hip_cb_table_t HIP_API_callbacks_table{};\n\ +# ') +# f.write('\ +# inline bool HIP_SET_ACTIVITY(uint32_t id, hip_cb_fun_t fun, void* arg = NULL) {\n\ +# (void)arg;\n\ +# extern hip_cb_table_t HIP_API_callbacks_table;\n\ +# if (id < HIP_API_ID_NUMBER) {\n\ +# HIP_API_callbacks_table.arr[id].act = fun;\n\ +# return true;\n\ +# }\n\ +# return false;\n\ +# }\n') +# f.write('\ +# inline bool HIP_SET_CALLBACK(uint32_t id, hip_cb_fun_t fun, void* arg) {\n\ +# extern hip_cb_table_t HIP_API_callbacks_table; \n\ +# if (id < HIP_API_ID_NUMBER) {\n\ +# HIP_API_callbacks_table.arr[id].fun = fun;\n\ +# HIP_API_callbacks_table.arr[id].arg = arg;\n\ +# return true;\n\ +# }\n\ +# return false;\n\ +# }\n') +# +# # Generating the callback spawning class +# f.write('\n// HIP API callbacks spawning class macro\n\ +# #define CB_SPAWNER_OBJECT(cb_id) \\\n\ +# class api_callbacks_spawner_t { \\\n\ +# public: \\\n\ +# api_callbacks_spawner_t(hip_cb_data_t& cb_data) : cb_data_(cb_data) { \\\n\ +# hip_cb_id_t id = HIP_API_ID_##cb_id; \\\n\ +# cb_data_.id = id; \\\n\ +# cb_data_.correlation_id = UINT_MAX; \\\n\ +# cb_data_.name = #cb_id; \\\n\ +# extern const hip_cb_table_t* getApiCallbackTabel(); \\\n\ +# const hip_cb_table_t* cb_table = getApiCallbackTabel(); \\\n\ +# cb_act_ = cb_table->arr[id].act; \\\n\ +# cb_fun_ = cb_table->arr[id].fun; \\\n\ +# cb_arg_ = cb_table->arr[id].arg; \\\n\ +# cb_data_.on_enter = true; \\\n\ +# if (cb_act_ != NULL) cb_act_(&cb_data_, NULL); \\\n\ +# if (cb_fun_ != NULL) cb_fun_(&cb_data_, cb_arg_); \\\n\ +# } \\\n\ +# ~api_callbacks_spawner_t() { \\\n\ +# cb_data_.on_enter = false; \\\n\ +# if (cb_act_ != NULL) cb_act_(&cb_data_, NULL); \\\n\ +# if (cb_fun_ != NULL) cb_fun_(&cb_data_, cb_arg_); \\\n\ +# } \\\n\ +# private: \\\n\ +# hip_cb_data_t& cb_data_; \\\n\ +# hip_cb_fun_t cb_act_; \\\n\ +# hip_cb_fun_t cb_fun_; \\\n\ +# void* cb_arg_; \\\n\ +# }; \\\n\ +# hip_cb_data_t cb_data{}; \\\n\ +# INIT_CB_ARGS_DATA(cb_id, cb_data); \\\n\ +# api_callbacks_spawner_t api_callbacks_spawner(cb_data); \n\ +# ') + +f.write('#endif // _HIP_CBSTR\n'); print "Header '" + HEADER + "' is generated" ############################################################# diff --git a/script/hsaap.py b/script/hsaap.py new file mode 100755 index 0000000000..fe4e215b88 --- /dev/null +++ b/script/hsaap.py @@ -0,0 +1,424 @@ +#!/usr/bin/python +import os, sys, re + +OUT='inc/hsa_prof_str.h' +API_TABLES_H = 'hsa_api_trace.h' +API_HEADERS_H = ( + ('CoreApiTable', 'hsa.h'), + ('AmdExtTable', 'hsa_ext_amd.h'), + ('ImageExtTable', 'hsa_ext_image.h'), + ('AmdExtTable', API_TABLES_H), +) + +LICENSE = \ +'/*\n' + \ +'Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved.\n' + \ +'\n' + \ +'Permission is hereby granted, free of charge, to any person obtaining a copy\n' + \ +'of this software and associated documentation files (the "Software"), to deal\n' + \ +'in the Software without restriction, including without limitation the rights\n' + \ +'to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n' + \ +'copies of the Software, and to permit persons to whom the Software is\n' + \ +'furnished to do so, subject to the following conditions:\n' + \ +'\n' + \ +'The above copyright notice and this permission notice shall be included in\n' + \ +'all copies or substantial portions of the Software.\n' + \ +'\n' + \ +'THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n' + \ +'IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n' + \ +'FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n' + \ +'AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n' + \ +'LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n' + \ +'OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n' + \ +'THE SOFTWARE.\n' + \ +'*/\n' + +############################################################# +# Error handler +def fatal(module, msg): + print >>sys.stderr, module + ' Error: "' + msg + '"' + sys.exit(1) + +# Get next text block +def NextBlock(pos, record): + if len(record) == 0: return pos + + space_pattern = re.compile(r'(\s+)') + word_pattern = re.compile(r'([\w\*]+)') + if record[pos] != '(': + m = space_pattern.match(record, pos) + if not m: + m = word_pattern.match(record, pos) + if m: + return pos + len(m.group(1)) + else: + fatal('NextBlock', "bad record '" + record + "' pos(" + str(pos) + ")") + else: + count = 0 + for index in range(pos, len(record)): + if record[index] == '(': + count = count + 1 + elif record[index] == ')': + count = count - 1 + if count == 0: + index = index + 1 + break + if count != 0: + fatal('NextBlock', "count is not zero (" + str(count) + ")") + if record[index - 1] != ')': + fatal('NextBlock', "last char is not ')' '" + record[index - 1] + "'") + return index + +############################################################# +# API table parser class +class API_TableParser: + def fatal(self, msg): + fatal('API_TableParser', msg) + + def __init__(self, header, name): + self.name = name + + if not os.path.isfile(header): + self.fatal("file '" + header + "' not found") + + self.inp = open(header, 'r') + + self.beg_pattern = re.compile('^\s*struct\s+' + name + '\s*{\s*$') + self.end_pattern = re.compile('^\s*};\s*$') + self.array = [] + self.parse() + + # normalizing a line + def norm_line(self, line): + return re.sub(r'^\s+', r' ', line[:-1]) + + # check for start record + def is_start(self, record): + return self.beg_pattern.match(record) + + # check for end record + def is_end(self, record): + return self.end_pattern.match(record) + + # check for declaration entry record + def is_entry(self, record): + return re.match(r'^\s*decltype\(([^\)]*)\)', record) + + # parse method + def parse(self): + active = 0 + for line in self.inp.readlines(): + record = self.norm_line(line) + if self.is_start(record): active = 1 + if active != 0: + if self.is_end(record): return + m = self.is_entry(record) + if m: + self.array.append(m.group(1)) + +############################################################# +# API declaration parser class +class API_DeclParser: + def fatal(self, msg): + fatal('API_DeclParser', msg) + + def __init__(self, header, array, data): + if not os.path.isfile(header): + self.fatal("file '" + header + "' not found") + + self.inp = open(header, 'r') + + self.end_pattern = re.compile('\);\s*$') + self.data = data + for call in array: + if call in data: + self.fatal(call + ' is already found') + self.parse(call) + + # api record filter + def api_filter(self, record): + record = re.sub(r'\sHSA_API\s', r' ', record) + record = re.sub(r'\sHSA_DEPRECATED\s', r' ', record) + return record + + # check for start record + def is_start(self, call, record): + return re.search('\s' + call + '\s*\(', record) + + # check for API method record + def is_api(self, call, record): + record = self.api_filter(record) + return re.match('\s+\S+\s+' + call + '\s*\(', record) + + # check for end record + def is_end(self, record): + return self.end_pattern.search(record) + + # parse method args + def get_args(self, record): + struct = { 'ret': '', 'args': '', 'astr': {}, 'alst': []} + record = re.sub(r'^\s+', r'', record) + record = re.sub(r'\s*(\*+)\s*', r'\1 ', record) + rind = NextBlock(0, record) + struct['ret'] = record[0:rind] + pos = record.find('(') + end = NextBlock(pos, record); + args = record[pos:end] + args = re.sub(r'^\(\s*', r'', args) + args = re.sub(r'\s*\)$', r'', args) + args = re.sub(r'\s*,\s*', r',', args) + struct['args'] = re.sub(r',', r', ', args) + if len(args) == 0: return struct + + pos = 0 + args = args + ',' + while pos < len(args): + ind1 = NextBlock(pos, args) # type + ind2 = NextBlock(ind1, args) # space + if args[ind2] != '(': + while ind2 < len(args): + end = NextBlock(ind2, args) + if args[end] == ',': break + else: ind2 = end + name = args[ind2:end] + else: + ind3 = NextBlock(ind2, args) # field + m = re.match(r'\(\s*\*\s*(\S+)\s*\)', args[ind2:ind3]) + if not m: + self.fatal("bad block3 '" + args + "' : '" + args[ind2:ind3] + "'") + name = m.group(1) + end = NextBlock(ind3, args) # the rest + item = args[pos:end] + struct['astr'][name] = item + struct['alst'].append(name) + if args[end] != ',': + self.fatal("no comma '" + args + "'") + pos = end + 1 + + return struct + + # parse given api + def parse(self, call): + record = '' + active = 0 + found = 0 + api_name = '' + prev_line = '' + + self.inp.seek(0) + for line in self.inp.readlines(): + record += ' ' + line[:-1] + record = re.sub(r'^\s*', r' ', record) + + if active == 0: + if self.is_start(call, record): + active = 1 + m = self.is_api(call, record) + if not m: + record = ' ' + prev_line + ' ' + record + m = self.is_api(call, record) + if not m: + self.fatal("bad api '" + line + "'") + + if active == 1: + if self.is_end(record): + args = self.get_args(record) + self.data[call] = args + active = 0 + found = 0 + + if active == 0: record = '' + prev_line = line + +############################################################# +# API description parser class +class API_DescrParser: + def fatal(self, msg): + fatal('API_DescrParser', msg) + + def __init__(self, out_file, hsa_dir, api_table_h, api_headers, license): + out_macro = re.sub(r'[\/\.]', r'_', out_file.upper()) + '_' + + self.content = '' + self.api_names = [] + self.api_calls = {} + self.api_id = {} + + api_data = {} + api_list = [] + ns_calls = [] + + for i in range(0, len(api_headers)): + (name, header) = api_headers[i] + + if i < len(api_headers) - 1: + api = API_TableParser(hsa_dir + api_table_h, name) + api_list = api.array + self.api_names.append(name) + self.api_calls[name] = api_list + else: + api_list = ns_calls + ns_calls = [] + + for call in api_list: + if call in api_data: + self.fatal("call '" + call + "' is already found") + + API_DeclParser(hsa_dir + header, api_list, api_data) + + for call in api_list: + # Not-supported functions + if not call in api_data: ns_calls.append(call) + # API ID map + self.api_id[call] = 'HSA_API_ID_' + call + + self.api_data = api_data + self.ns_calls = ns_calls + + self.content += "// automatically generated\n\n" + license + '\n' + + self.content += "/////////////////////////////////////////////////////////////////////////////\n" + self.content += "//\n" + self.content += "// HSA API tracing primitives\n" + self.content += "//\n" + for (name, header) in api_headers: + self.content += "// '" + name + "', header '" + header + "', " + str(len(self.api_calls[name])) + ' funcs\n' + for call in self.ns_calls: + self.content += '// ' + call + ' was not parsed\n' + self.content += "//\n" + self.content += "/////////////////////////////////////////////////////////////////////////////\n" + self.content += '\n' + self.content += '#ifndef ' + out_macro + '\n' + self.content += '#define ' + out_macro + '\n' + + self.add_section('API ID enumeration', ' ', self.gen_id_enum) + self.add_section('API arg structure', ' ', self.gen_arg_struct) + + self.content += '\n' + self.content += '#if PROF_API_IMPL\n' + self.content += 'namespace roctracer {\n' + self.content += 'namespace hsa_support {\n' + self.add_section('API callback functions', '', self.gen_callbacks) + self.add_section('API intercepting code', '', self.gen_intercept) + self.add_section('API get_name function', ' ', self.gen_get_name) + self.content += '\n};};\n' + self.content += '#endif // PROF_API_IMPL\n' + self.content += '\n' + + self.content += '#endif // ' + out_macro + + # add code section + def add_section(self, title, gap, fun): + n = 0 + self.content += '\n// section: ' + title + '\n\n' + fun(-1, '-', '-', {}) + for index in range(len(self.api_names)): + last = (index == len(self.api_names) - 1) + name = self.api_names[index] + if n != 0: + if gap == '': fun(n, name, '-', {}) + self.content += '\n' + self.content += gap + '// block: ' + name + ' API\n' + for call in self.api_calls[name]: + fun(n, name, call, self.api_data[call]) + n += 1 + fun(n, '-', '-', {}) + + # generate API ID enumeration + def gen_id_enum(self, n, name, call, data): + if n == -1: + self.content += 'enum hsa_api_id_t {\n' + return + if call != '-': + self.content += ' ' + self.api_id[call] + ' = ' + str(n) + ',\n' + else: + self.content += '\n' + self.content += ' HSA_API_ID_NUMBER = ' + str(n) + ',\n' + self.content += ' HSA_API_ID_ANY = ' + str(n + 1) + ',\n' + self.content += '};\n' + + # generate API args structure + def gen_arg_struct(self, n, name, call, struct): + if n == -1: + self.content += 'struct hsa_api_data_t {\n' + self.content += ' uint64_t correlation_id;\n' + self.content += ' uint32_t phase;\n' + self.content += ' union {\n' + return + if call != '-': + self.content += ' struct {\n' + for (var, item) in struct['astr'].items(): + self.content += ' ' + item + ';\n' + self.content += ' } ' + call + ';\n' + else: + self.content += ' } args;\n' + self.content += '};\n' + + # generate API callbacks + def gen_callbacks(self, n, name, call, struct): + if n == -1: + self.content += 'typedef CbTable cb_table_t;\n' + self.content += 'extern cb_table_t cb_table;\n' + self.content += '\n' + if call != '-': + call_id = self.api_id[call]; + ret_type = struct['ret'] + self.content += 'static ' + ret_type + ' ' + call + '_callback(' + struct['args'] + ') {\n' + self.content += ' hsa_api_data_t api_data{};\n' + for var in struct['astr']: + self.content += ' api_data.args.' + call + '.' + var + ' = ' + var + ';\n' + self.content += ' activity_rtapi_callback_t api_callback_fun = NULL;\n' + self.content += ' void* api_callback_arg = NULL;\n' + self.content += ' cb_table.get(' + call_id + ', &api_callback_fun, &api_callback_arg);\n' + self.content += ' api_data.phase = 0;\n' + self.content += ' if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, ' + call_id + ', &api_data, api_callback_arg);\n' + if ret_type != 'void': + self.content += ' ' + ret_type + ' ret =' + self.content += ' ' + name + '_saved.' + call + '_fn(' + ', '.join(struct['alst']) + ');\n' + self.content += ' api_data.phase = 1;\n' + self.content += ' if (api_callback_fun) api_callback_fun(ACTIVITY_DOMAIN_HSA_API, ' + call_id + ', &api_data, api_callback_arg);\n' + if ret_type != 'void': + self.content += ' return ret;\n' + self.content += '}\n' + + # generate API intercepting code + def gen_intercept(self, n, name, call, struct): + if n > 0 and call == '-': + self.content += '};\n' + if n == 0 or (call == '-' and name != '-'): + self.content += 'static void intercept_' + name + '(' + name + '* table) {\n' + self.content += ' ' + name + '_saved = *table;\n' + if call != '-': + self.content += ' table->' + call + '_fn = ' + call + '_callback;\n' + + # generate API name function + def gen_get_name(self, n, name, call, struct): + if n == -1: + self.content += 'static const char* GetApiName(const uint32_t& id) {\n' + self.content += ' switch (id) {\n' + return + if call != '-': + self.content += ' case ' + self.api_id[call] + ': return "' + call + '";\n' + else: + self.content += ' };\n' + self.content += ' return "unknown";\n' + self.content += '};\n' + +############################################################# +# main +# Usage +if len(sys.argv) != 3: + print >>sys.stderr, "Usage:", sys.argv[0], " " + sys.exit(1) +else: + ROOT = sys.argv[1] + '/' + HSA_DIR = sys.argv[2] + '/' + +descr = API_DescrParser(OUT, HSA_DIR, API_TABLES_H, API_HEADERS_H, LICENSE) + +out_file = ROOT + OUT +print 'Generating "' + out_file + '"' +f = open(out_file, 'w') +f.write(descr.content[:-1]) +f.close() +############################################################# diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 46dc131c27..de9c01cae5 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -9,3 +9,4 @@ set ( LIB_SRC add_library ( ${TARGET_LIB} SHARED ${LIB_SRC} ) target_include_directories ( ${TARGET_LIB} PRIVATE ${LIB_DIR} ${ROOT_DIR} ${ROOT_DIR}/inc ${HSA_RUNTIME_INC_PATH} ${HIP_INC_DIR} ${HCC_INC_DIR} ) target_link_libraries( ${TARGET_LIB} PRIVATE ${HSA_RUNTIME_LIB} c stdc++ ${HIP_INC_DIR}/../lib/libhip_hcc.so ) +execute_process ( COMMAND sh -xc "${ROOT_DIR}/script/hsaap.py ${ROOT_DIR} ${HSA_RUNTIME_INC_PATH}" ) diff --git a/src/core/roctracer.cpp b/src/core/roctracer.cpp index 2c22e3d84a..0e19cf6fc3 100644 --- a/src/core/roctracer.cpp +++ b/src/core/roctracer.cpp @@ -24,6 +24,9 @@ THE SOFTWARE. #include "inc/roctracer_hcc.h" #include "inc/roctracer_hip.h" +#define PROF_API_IMPL 1 +#include "inc/roctracer_hsa.h" + #include #include #include @@ -332,6 +335,17 @@ util::Logger* util::Logger::instance_ = NULL; MemoryPool* memory_pool = NULL; typedef std::recursive_mutex memory_pool_mutex_t; memory_pool_mutex_t memory_pool_mutex; + +namespace hsa_support { +// callbacks table +cb_table_t cb_table; +// Table of function pointers to HSA Core Runtime +CoreApiTable CoreApiTable_saved{}; +// Table of function pointers to AMD extensions +AmdExtTable AmdExtTable_saved{}; +// Table of function pointers to HSA Image Extension +ImageExtTable ImageExtTable_saved{}; +} } /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -353,6 +367,10 @@ PUBLIC_API const char* roctracer_error_string() { PUBLIC_API const char* roctracer_id_string(const uint32_t& domain, const uint32_t& id, const uint32_t& kind) { API_METHOD_PREFIX switch (domain) { + case ACTIVITY_DOMAIN_HSA_API: { + return roctracer::hsa_support::GetApiName(id); + break; + } case ACTIVITY_DOMAIN_HCC_OPS: { return Kalmar::CLAMP::GetCmdName(kind); break; @@ -376,9 +394,22 @@ PUBLIC_API roctracer_status_t roctracer_enable_callback( { API_METHOD_PREFIX switch (domain) { - case ACTIVITY_DOMAIN_ANY: - if (id != 0) HIP_EXC_RAISING(ROCTRACER_STATUS_BAD_PARAMETER, "DOMAIN_ANY: id != 0"); - id = HIP_API_ID_ANY; + case ACTIVITY_DOMAIN_ANY: { + if (id != 0) EXC_RAISING(ROCTRACER_STATUS_BAD_PARAMETER, "DOMAIN_ANY: id != 0"); + roctracer_enable_callback(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_ANY, callback, user_data); + roctracer_enable_callback(ACTIVITY_DOMAIN_HIP_API, HIP_API_ID_ANY, callback, user_data); + break; + } + case ACTIVITY_DOMAIN_HSA_API: { + if (id == HSA_API_ID_ANY) { + for (uint32_t i = 0; i < HSA_API_ID_NUMBER; i++) { + roctracer::hsa_support::cb_table.set(i, callback, user_data); + } + } else { + roctracer::hsa_support::cb_table.set(id, callback, user_data); + } + break; + } case ACTIVITY_DOMAIN_HIP_API: { hipError_t hip_err = hipRegisterApiCallback(id, (void*)callback, user_data); if (hip_err != hipSuccess) HIP_EXC_RAISING(ROCTRACER_STATUS_HIP_API_ERR, "hipRegisterApiCallback error(" << hip_err << ")"); @@ -515,4 +546,34 @@ PUBLIC_API roctracer_status_t roctracer_flush_activity(roctracer_pool_t* pool) { API_METHOD_SUFFIX } +// Set properties +PUBLIC_API roctracer_status_t roctracer_set_properties( + roctracer_domain_t domain, + void* propertes) +{ + API_METHOD_PREFIX + switch (domain) { + case ACTIVITY_DOMAIN_HSA_API: { + HsaApiTable* table = reinterpret_cast(propertes); + roctracer::hsa_support::intercept_CoreApiTable(table->core_); + roctracer::hsa_support::intercept_AmdExtTable(table->amd_ext_); + roctracer::hsa_support::intercept_ImageExtTable(table->image_ext_); + break; + } + case ACTIVITY_DOMAIN_HCC_OPS: + case ACTIVITY_DOMAIN_HIP_API: + EXC_RAISING(ROCTRACER_STATUS_BAD_DOMAIN, "properties are not supported, domain ID(" << domain << ")"); + default: + EXC_RAISING(ROCTRACER_STATUS_BAD_DOMAIN, "invalid domain ID(" << domain << ")"); + } + API_METHOD_SUFFIX +} + +// HSA-runtime tool on-load method +PUBLIC_API bool OnLoad(HsaApiTable* table, uint64_t runtime_version, uint64_t failed_tool_count, + const char* const* failed_tool_names) { + roctracer_set_properties(ACTIVITY_DOMAIN_HSA_API, (void*)table); + return true; +} + } // extern "C" diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt new file mode 100644 index 0000000000..542aeb0374 --- /dev/null +++ b/test/CMakeLists.txt @@ -0,0 +1,43 @@ +################################################################################ +# Copyright (c) 2018 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. +################################################################################ + +cmake_minimum_required ( VERSION 2.8.12 ) +set ( CMAKE_VERBOSE_MAKEFILE TRUE CACHE BOOL "Verbose Output" FORCE ) + +set ( RUN_SCRIPT "${TEST_DIR}/run.sh" ) +set ( TEST_HSA "${TEST_DIR}/hsa/test" ) +execute_process ( COMMAND sh -xc "if [ ! -e ${TEST_DIR}/hsa ] ; then git clone https://github.com/ROCmSoftwarePlatform/hsa-class.git ${TEST_DIR}/hsa; fi" ) +execute_process ( COMMAND sh -xc "if [ -e ${TEST_DIR}/hsa ] ; then cd ${TEST_DIR}/hsa && git pull --rebase; fi" ) + +## Util sources +file( GLOB UTIL_SRC "${TEST_HSA}/util/*.cpp" ) + +## Build test library +set ( TEST_LIB "tool" ) +set ( TEST_LIB_SRC ${TEST_DIR}/tool/tool.cpp ${UTIL_SRC} ) +add_library ( ${TEST_LIB} SHARED ${TEST_LIB_SRC} ) +target_include_directories ( ${TEST_LIB} PRIVATE ${TEST_HSA} ${ROOT_DIR} ${HSA_RUNTIME_INC_PATH} ) +target_link_libraries ( ${TEST_LIB} ${ROCTRACER_TARGET} ${HSA_RUNTIME_LIB} c stdc++ dl pthread rt ) + +set ( TEST_DIR ${TEST_HSA} ) +add_subdirectory ( ${TEST_DIR} ${PROJECT_BINARY_DIR}/test/hsa ) +execute_process ( COMMAND sh -xc "cp ${RUN_SCRIPT} ${PROJECT_BINARY_DIR}" ) diff --git a/test/MatrixTranspose/Makefile b/test/MatrixTranspose/Makefile index 1c0022498f..c4cae4c539 100644 --- a/test/MatrixTranspose/Makefile +++ b/test/MatrixTranspose/Makefile @@ -3,7 +3,7 @@ LIB_PATH = $(ROOT_PATH)/build LIB_NAME = roctracer64 ROC_LIBS = -L$(LIB_PATH) -l$(LIB_NAME) -EXECUTABLE = ./MatrixTranspose +EXECUTABLE = ./MatrixTranspose.exe SOURCES = MatrixTranspose.cpp OBJECTS = $(SOURCES:.cpp=.o) diff --git a/test/run.sh b/test/run.sh new file mode 100755 index 0000000000..b562f06421 --- /dev/null +++ b/test/run.sh @@ -0,0 +1,55 @@ +#!/bin/sh + +################################################################################ +# Copyright (c) 2018 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. +################################################################################ + +# enable tools load failure reporting +export HSA_TOOLS_REPORT_LOAD_FAILURE=1 +# test trace +export ROC_TEST_TRACE=1 + +# kernels loading iterations +export ROCP_KITER=1 +# kernels dispatching iterations per kernel load +# dispatching to the same queue +export ROCP_DITER=1 +# GPU agents number +export ROCP_AGENTS=1 +# host threads number +# each thread creates a queue pre GPU agent +export ROCP_THRS=1 + +#eval ./test_hsa/ctrl + +# paths to ROC profiler and oher libraries +export LD_LIBRARY_PATH=$PWD +# ROC profiler library loaded by HSA runtime +export HSA_TOOLS_LIB="test/libtool.so libroctracer64.so" +export LD_PRELOAD="libroctracer64.so" + +eval ./test/hsa/ctrl + +#valgrind --leak-check=full $tbin +#valgrind --tool=massif $tbin +#ms_print massif.out. + +exit 0 diff --git a/test/tool/tool.cpp b/test/tool/tool.cpp new file mode 100644 index 0000000000..f8b46c14d2 --- /dev/null +++ b/test/tool/tool.cpp @@ -0,0 +1,61 @@ +/* +Copyright (c) 2015-2016 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. +*/ + +#include +#include +#include + +#define PUBLIC_API __attribute__((visibility("default"))) +#define CONSTRUCTOR_API __attribute__((constructor)) +#define DESTRUCTOR_API __attribute__((destructor)) + +typedef hsa_rt_utils::Timer::timestamp_t timestamp_t; +hsa_rt_utils::Timer timer; +thread_local timestamp_t begin_timestamp = 0; + +// HSA API callback function +void hsa_api_callback( + uint32_t domain, + uint32_t cid, + const void* callback_data, + void* arg) +{ + (void)arg; + + const hsa_api_data_t* data = reinterpret_cast(callback_data); + if (data->phase == ACTIVITY_API_PHASE_ENTER) { + begin_timestamp = timer.timestamp_fn_ns(); + } else { + timestamp_t duration_ns = (cid == HSA_API_ID_hsa_shut_down) ? 0 : timer.timestamp_fn_ns() - begin_timestamp; + fprintf(stdout, "%s,%luns\n", roctracer_id_string(domain, cid, 0), duration_ns); + } +} + +extern "C" { +// HSA-runtime tool on-load method +PUBLIC_API bool OnLoad(HsaApiTable* table, uint64_t runtime_version, uint64_t failed_tool_count, + const char* const* failed_tool_names) { + timer.init(table->core_->hsa_system_get_info_fn); + roctracer_enable_callback(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_ANY, hsa_api_callback, NULL); + return true; +} +}