diff --git a/inc/ext/hsa_rt_utils.hpp b/inc/ext/hsa_rt_utils.hpp index 6c04a3dafe..784b06eaaa 100644 --- a/inc/ext/hsa_rt_utils.hpp +++ b/inc/ext/hsa_rt_utils.hpp @@ -28,6 +28,7 @@ THE SOFTWARE. #include #include #include +#include #define HSART_CALL(call) \ do { \ @@ -80,12 +81,9 @@ class Timer { return timestamp_to_ns(timestamp); } - Timer() { - init(hsa_system_get_info); - } - - Timer(hsa_system_get_info_fn_t f) { - init(f); + Timer(hsa_system_get_info_fn_t f = NULL) { + if (f != NULL) init(f); + else init(hsa_system_get_info); } private: @@ -95,6 +93,27 @@ class Timer { freq_t timestamp_rate_; }; +class TimerFactory { + public: + typedef std::mutex mutex_t; + + static Timer* Create(Timer::hsa_system_get_info_fn_t f = NULL) { + if (instance_ == NULL) { + std::lock_guard lck(mutex_); + if (instance_ == NULL) instance_ = new Timer(f); + } + return instance_; + } + + static Timer& Instance() { + return *instance_; + } + + private: + static Timer* instance_; + static mutex_t mutex_; +}; + } // namespace hsa_rt_utils #endif // INC_ROCTRACER_HSA_RT_UTILS_HPP_ diff --git a/inc/ext/prof_protocol.h b/inc/ext/prof_protocol.h index 9416d9ddfc..65cf616b92 100644 --- a/inc/ext/prof_protocol.h +++ b/inc/ext/prof_protocol.h @@ -23,15 +23,12 @@ THE SOFTWARE. #ifndef INC_EXT_PROF_PROTOCOL_H_ #define INC_EXT_PROF_PROTOCOL_H_ -#define HCC_ENABLED 1 - // Traced API domains typedef enum { - ACTIVITY_DOMAIN_ANY = 0, // Any domain - ACTIVITY_DOMAIN_HSA_API = 1, // HSA domain - ACTIVITY_DOMAIN_HCC_OPS = 2, // HCC domain - ACTIVITY_DOMAIN_HIP_API = 3, // HIP domain - ACTIVITY_DOMAIN_NUMBER = 4 + ACTIVITY_DOMAIN_HSA_API = 0, // HSA domain + ACTIVITY_DOMAIN_HCC_OPS = 1, // HCC domain + ACTIVITY_DOMAIN_HIP_API = 2, // HIP domain + ACTIVITY_DOMAIN_NUMBER = 3 } activity_domain_t; // API calback type @@ -53,7 +50,7 @@ typedef uint64_t activity_correlation_id_t; struct activity_record_t { uint32_t domain; // activity domain id activity_kind_t kind; // activity kind - activity_op_t activity_id; // activity op + activity_op_t op; // activity op activity_correlation_id_t correlation_id; // activity ID uint64_t begin_ns; // host begin timestamp uint64_t end_ns; // host end timestamp diff --git a/inc/roctracer.h b/inc/roctracer.h index d9d886ba1b..61c7debaaf 100644 --- a/inc/roctracer.h +++ b/inc/roctracer.h @@ -78,9 +78,9 @@ typedef activity_domain_t roctracer_domain_t; // Return ID string by given domain and activity/API ID // NULL returned on the error and the library errno is set -const char* roctracer_id_string( +const char* roctracer_op_string( const uint32_t& domain, // tracing domain - const uint32_t& id, // activity ID + const uint32_t& op, // activity op ID const uint32_t& kind); // activity kind // Set properties @@ -100,16 +100,26 @@ roctracer_status_t roctracer_set_properties( typedef activity_rtapi_callback_t roctracer_rtapi_callback_t; // Enable runtime API callbacks -roctracer_status_t roctracer_enable_callback( +roctracer_status_t roctracer_enable_op_callback( activity_domain_t domain, // tracing domain - uint32_t id, // API call ID + uint32_t op, // API call ID + activity_rtapi_callback_t callback, // callback function pointer + void* arg); // [in/out] callback arg +roctracer_status_t roctracer_enable_domain_callback( + activity_domain_t domain, // tracing domain + activity_rtapi_callback_t callback, // callback function pointer + void* arg); // [in/out] callback arg +roctracer_status_t roctracer_enable_callback( activity_rtapi_callback_t callback, // callback function pointer void* arg); // [in/out] callback arg // Disable runtime API callbacks -roctracer_status_t roctracer_disable_callback( +roctracer_status_t roctracer_disable_op_callback( activity_domain_t domain, // tracing domain - uint32_t id); // API call ID + uint32_t op); // API call ID +roctracer_status_t roctracer_disable_domain_callback( + activity_domain_t domain); // tracing domain +roctracer_status_t roctracer_disable_callback(); //////////////////////////////////////////////////////////////////////////////// // Activity API @@ -175,15 +185,23 @@ roctracer_pool_t* roctracer_default_pool( roctracer_pool_t* pool = NULL); // [in] new default pool if not NULL // Enable activity records logging -roctracer_status_t roctracer_enable_activity( +roctracer_status_t roctracer_enable_op_activity( activity_domain_t domain, // tracing domain - uint32_t id, // activity ID + uint32_t op, // activity op ID + roctracer_pool_t* pool = NULL); // memory pool, NULL is a default one +roctracer_status_t roctracer_enable_domain_activity( + activity_domain_t domain, // tracing domain + roctracer_pool_t* pool = NULL); // memory pool, NULL is a default one +roctracer_status_t roctracer_enable_activity( roctracer_pool_t* pool = NULL); // memory pool, NULL is a default one // Disable activity records logging -roctracer_status_t roctracer_disable_activity( +roctracer_status_t roctracer_disable_op_activity( activity_domain_t domain, // tracing domain - uint32_t id); // activity ID + uint32_t op); // activity op ID +roctracer_status_t roctracer_disable_domain_activity( + activity_domain_t domain); // tracing domain +roctracer_status_t roctracer_disable_activity(); // Flush available activity records roctracer_status_t roctracer_flush_activity( diff --git a/inc/roctracer_hcc.h b/inc/roctracer_hcc.h index f55586e351..3f8c7bfa7f 100644 --- a/inc/roctracer_hcc.h +++ b/inc/roctracer_hcc.h @@ -24,10 +24,8 @@ THE SOFTWARE. #define INC_ROCTRACER_HCC_H_ #if (LOCAL_BUILD == 1) -#include #include #else -#include #include #endif diff --git a/src/core/roctracer.cpp b/src/core/roctracer.cpp index be46f2b392..7e6d4a844b 100644 --- a/src/core/roctracer.cpp +++ b/src/core/roctracer.cpp @@ -21,9 +21,7 @@ THE SOFTWARE. */ #include "inc/roctracer.h" -#ifdef HCC_ENABLED #include "inc/roctracer_hcc.h" -#endif #include "inc/roctracer_hip.h" #define PROF_API_IMPL 1 #include "inc/roctracer_hsa.h" @@ -303,7 +301,7 @@ static inline activity_correlation_id_t CorrelationIdLookup(const activity_corre } roctracer_record_t* HIP_SyncActivityCallback( - uint32_t activity_id, + uint32_t op_id, roctracer_record_t* record, const void* callback_data, void* arg) @@ -315,7 +313,7 @@ roctracer_record_t* HIP_SyncActivityCallback( if (pool == NULL) EXC_ABORT(ROCTRACER_STATUS_ERROR, "ActivityCallback pool is NULL"); if (data->phase == ACTIVITY_API_PHASE_ENTER) { record->domain = ACTIVITY_DOMAIN_HIP_API; - record->activity_id = activity_id; + record->op = op_id; record->begin_ns = timer.timestamp_ns(); // Correlation ID generating uint64_t correlation_id = data->correlation_id; @@ -324,20 +322,16 @@ roctracer_record_t* HIP_SyncActivityCallback( const_cast(data)->correlation_id = correlation_id; } record->correlation_id = correlation_id; -#ifdef HCC_ENABLED // Passing correlatin ID correlation_id_tls = correlation_id; -#endif return record; } else { record->end_ns = timer.timestamp_ns(); record->process_id = syscall(__NR_getpid); record->thread_id = syscall(__NR_gettid); pool->Write(*record); -#ifdef HCC_ENABLED // Clearing correlatin ID correlation_id_tls = 0; -#endif return NULL; } } @@ -394,7 +388,7 @@ PUBLIC_API const char* roctracer_error_string() { // Return ID string by given domain and activity/API ID // NULL returned on the error and the library errno is set -PUBLIC_API const char* roctracer_id_string(const uint32_t& domain, const uint32_t& id, const uint32_t& kind) { +PUBLIC_API const char* roctracer_op_string(const uint32_t& domain, const uint32_t& id, const uint32_t& kind) { API_METHOD_PREFIX switch (domain) { case ACTIVITY_DOMAIN_HSA_API: { @@ -402,9 +396,7 @@ PUBLIC_API const char* roctracer_id_string(const uint32_t& domain, const uint32_ break; } case ACTIVITY_DOMAIN_HCC_OPS: { -#ifdef HCC_ENABLED return roctracer::HccLoader::Instance().GetCmdName(kind); -#endif break; } case ACTIVITY_DOMAIN_HIP_API: { @@ -417,60 +409,119 @@ PUBLIC_API const char* roctracer_id_string(const uint32_t& domain, const uint32_ API_METHOD_CATCH(NULL) } +static inline uint32_t get_op_num(const uint32_t& domain) { + switch (domain) { + case ACTIVITY_DOMAIN_HCC_OPS: return hc::HSA_OP_ID_NUMBER; + case ACTIVITY_DOMAIN_HIP_API: return HIP_API_ID_NUMBER; + case ACTIVITY_DOMAIN_HSA_API: return HSA_API_ID_NUMBER; + default: + EXC_RAISING(ROCTRACER_STATUS_BAD_DOMAIN, "invalid domain ID(" << domain << ")"); + } + return 0; +} + // Enable runtime API callbacks -PUBLIC_API roctracer_status_t roctracer_enable_callback( - roctracer_domain_t domain, - uint32_t id, +static void roctracer_enable_callback_impl( + uint32_t domain, + uint32_t op, roctracer_rtapi_callback_t callback, void* user_data) { - API_METHOD_PREFIX switch (domain) { - 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); - } + roctracer::hsa_support::cb_table.set(op, callback, user_data); break; } + case ACTIVITY_DOMAIN_HCC_OPS: break; case ACTIVITY_DOMAIN_HIP_API: { - hipError_t hip_err = roctracer::HipLoader::Instance().RegisterApiCallback(id, (void*)callback, user_data); + hipError_t hip_err = roctracer::HipLoader::Instance().RegisterApiCallback(op, (void*)callback, user_data); if (hip_err != hipSuccess) HIP_EXC_RAISING(ROCTRACER_STATUS_HIP_API_ERR, "hipRegisterApiCallback error(" << hip_err << ")"); break; } default: EXC_RAISING(ROCTRACER_STATUS_BAD_DOMAIN, "invalid domain ID(" << domain << ")"); } +} + +PUBLIC_API roctracer_status_t roctracer_enable_op_callback( + roctracer_domain_t domain, + uint32_t op, + roctracer_rtapi_callback_t callback, + void* user_data) +{ + API_METHOD_PREFIX + roctracer_enable_callback_impl(domain, op, callback, user_data); API_METHOD_SUFFIX } -// Enable runtime API callbacks -PUBLIC_API roctracer_status_t roctracer_disable_callback( +PUBLIC_API roctracer_status_t roctracer_enable_domain_callback( roctracer_domain_t domain, - uint32_t id) + roctracer_rtapi_callback_t callback, + void* user_data) { API_METHOD_PREFIX + const uint32_t op_num = get_op_num(domain); + for (uint32_t op = 0; op < op_num; op++) roctracer_enable_callback_impl(domain, op, callback, user_data); + API_METHOD_SUFFIX +} + +PUBLIC_API roctracer_status_t roctracer_enable_callback( + roctracer_rtapi_callback_t callback, + void* user_data) +{ + API_METHOD_PREFIX + for (uint32_t domain = 0; domain < ACTIVITY_DOMAIN_NUMBER; domain++) { + const uint32_t op_num = get_op_num(domain); + for (uint32_t op = 0; op < op_num; op++) roctracer_enable_callback_impl(domain, op, callback, user_data); + } + API_METHOD_SUFFIX +} + +// Disable runtime API callbacks +static void roctracer_disable_callback_impl( + uint32_t domain, + uint32_t op) +{ 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_HSA_API: { + break; + } + case ACTIVITY_DOMAIN_HCC_OPS: break; case ACTIVITY_DOMAIN_HIP_API: { - hipError_t hip_err = roctracer::HipLoader::Instance().RemoveApiCallback(id); + hipError_t hip_err = roctracer::HipLoader::Instance().RemoveApiCallback(op); if (hip_err != hipSuccess) HIP_EXC_RAISING(ROCTRACER_STATUS_HIP_API_ERR, "hipRemoveApiCallback error(" << hip_err << ")"); break; } default: EXC_RAISING(ROCTRACER_STATUS_BAD_DOMAIN, "invalid domain ID(" << domain << ")"); } +} + +PUBLIC_API roctracer_status_t roctracer_disable_op_callback( + roctracer_domain_t domain, + uint32_t op) +{ + API_METHOD_PREFIX + roctracer_disable_callback_impl(domain, op); + API_METHOD_SUFFIX +} + +PUBLIC_API roctracer_status_t roctracer_disable_domain_callback( + roctracer_domain_t domain) +{ + API_METHOD_PREFIX + const uint32_t op_num = get_op_num(domain); + for (uint32_t op = 0; op < op_num; op++) roctracer_disable_callback_impl(domain, op); + API_METHOD_SUFFIX +} + +PUBLIC_API roctracer_status_t roctracer_disable_callback() +{ + API_METHOD_PREFIX + for (uint32_t domain = 0; domain < ACTIVITY_DOMAIN_NUMBER; domain++) { + const uint32_t op_num = get_op_num(domain); + for (uint32_t op = 0; op < op_num; op++) roctracer_disable_callback_impl(domain, op); + } API_METHOD_SUFFIX } @@ -512,69 +563,108 @@ PUBLIC_API roctracer_status_t roctracer_close_pool(roctracer_pool_t* pool) { } // Enable activity records logging -PUBLIC_API roctracer_status_t roctracer_enable_activity( - roctracer_domain_t domain, - uint32_t id, +static void roctracer_enable_activity_impl( + uint32_t domain, + uint32_t op, roctracer_pool_t* pool) { - API_METHOD_PREFIX if (pool == NULL) pool = roctracer_default_pool(); switch (domain) { - case ACTIVITY_DOMAIN_ANY: - if (id != 0) HIP_EXC_RAISING(ROCTRACER_STATUS_BAD_PARAMETER, "DOMAIN_ANY: id != 0"); -#ifdef HCC_ENABLED - roctracer_enable_activity(ACTIVITY_DOMAIN_HCC_OPS, hc::HSA_OP_ID_ANY, pool); -#endif - roctracer_enable_activity(ACTIVITY_DOMAIN_HIP_API, HIP_API_ID_ANY, pool); - break; + case ACTIVITY_DOMAIN_HSA_API: break; case ACTIVITY_DOMAIN_HCC_OPS: { -#ifdef HCC_ENABLED roctracer::HccLoader::Instance().SetActivityIdCallback((void*)roctracer::HCC_ActivityIdCallback); - const bool err = roctracer::HccLoader::Instance().SetActivityCallback(id, (void*)roctracer::HCC_AsyncActivityCallback, (void*)pool); - if (err == true) HCC_EXC_RAISING(ROCTRACER_STATUS_HCC_OPS_ERR, "HCC::SetActivityCallback error"); -#endif + const bool succ = roctracer::HccLoader::Instance().SetActivityCallback(op, (void*)roctracer::HCC_AsyncActivityCallback, (void*)pool); + if (succ == false) HCC_EXC_RAISING(ROCTRACER_STATUS_HCC_OPS_ERR, "HCC::SetActivityCallback error"); break; } case ACTIVITY_DOMAIN_HIP_API: { - const hipError_t hip_err = roctracer::HipLoader::Instance().RegisterActivityCallback(id, (void*)roctracer::HIP_SyncActivityCallback, (void*)pool); + const hipError_t hip_err = roctracer::HipLoader::Instance().RegisterActivityCallback(op, (void*)roctracer::HIP_SyncActivityCallback, (void*)pool); if (hip_err != hipSuccess) HIP_EXC_RAISING(ROCTRACER_STATUS_HIP_API_ERR, "hipRegisterActivityCallback error(" << hip_err << ")"); break; } default: EXC_RAISING(ROCTRACER_STATUS_BAD_DOMAIN, "invalid domain ID(" << domain << ")"); } +} + +PUBLIC_API roctracer_status_t roctracer_enable_op_activity( + roctracer_domain_t domain, + uint32_t op, + roctracer_pool_t* pool) +{ + API_METHOD_PREFIX + roctracer_enable_activity_impl(domain, op, pool); + API_METHOD_SUFFIX +} + +PUBLIC_API roctracer_status_t roctracer_enable_domain_activity( + roctracer_domain_t domain, + roctracer_pool_t* pool) +{ + API_METHOD_PREFIX + const uint32_t op_num = get_op_num(domain); + for (uint32_t op = 0; op < op_num; op++) roctracer_enable_activity_impl(domain, op, pool); + API_METHOD_SUFFIX +} + +PUBLIC_API roctracer_status_t roctracer_enable_activity( + roctracer_pool_t* pool) +{ + API_METHOD_PREFIX + for (uint32_t domain = 0; domain < ACTIVITY_DOMAIN_NUMBER; domain++) { + const uint32_t op_num = get_op_num(domain); + for (uint32_t op = 0; op < op_num; op++) roctracer_enable_activity_impl(domain, op, pool); + } API_METHOD_SUFFIX } // Disable activity records logging -PUBLIC_API roctracer_status_t roctracer_disable_activity( - roctracer_domain_t domain, - uint32_t id) +static void roctracer_disable_activity_impl( + uint32_t domain, + uint32_t op) { - API_METHOD_PREFIX switch (domain) { - case ACTIVITY_DOMAIN_ANY: - if (id != 0) HIP_EXC_RAISING(ROCTRACER_STATUS_BAD_PARAMETER, "DOMAIN_ANY: id != 0"); -#ifdef HCC_ENABLED - roctracer_disable_activity(ACTIVITY_DOMAIN_HCC_OPS, hc::HSA_OP_ID_ANY); -#endif - roctracer_disable_activity(ACTIVITY_DOMAIN_HIP_API, HIP_API_ID_ANY); - break; + case ACTIVITY_DOMAIN_HSA_API: break; case ACTIVITY_DOMAIN_HCC_OPS: { -#ifdef HCC_ENABLED - const bool err = roctracer::HccLoader::Instance().SetActivityCallback(id, NULL, NULL); - if (err == true) HCC_EXC_RAISING(ROCTRACER_STATUS_HCC_OPS_ERR, "HCC::SetActivityCallback(NULL) error"); -#endif + const bool succ = roctracer::HccLoader::Instance().SetActivityCallback(op, NULL, NULL); + if (succ == false) HCC_EXC_RAISING(ROCTRACER_STATUS_HCC_OPS_ERR, "HCC::SetActivityCallback(NULL) error domain(" << domain << ") op(" << op << ")"); break; } case ACTIVITY_DOMAIN_HIP_API: { - const hipError_t hip_err = roctracer::HipLoader::Instance().RemoveActivityCallback(id); + const hipError_t hip_err = roctracer::HipLoader::Instance().RemoveActivityCallback(op); if (hip_err != hipSuccess) HIP_EXC_RAISING(ROCTRACER_STATUS_HIP_API_ERR, "hipRemoveActivityCallback error(" << hip_err << ")"); break; } default: EXC_RAISING(ROCTRACER_STATUS_BAD_DOMAIN, "invalid domain ID(" << domain << ")"); } +} + +PUBLIC_API roctracer_status_t roctracer_disable_op_activity( + roctracer_domain_t domain, + uint32_t op) +{ + API_METHOD_PREFIX + roctracer_disable_activity_impl(domain, op); + API_METHOD_SUFFIX +} + +PUBLIC_API roctracer_status_t roctracer_disable_domain_activity( + roctracer_domain_t domain) +{ + API_METHOD_PREFIX + const uint32_t op_num = get_op_num(domain); + for (uint32_t op = 0; op < op_num; op++) roctracer_disable_activity_impl(domain, op); + API_METHOD_SUFFIX +} + +PUBLIC_API roctracer_status_t roctracer_disable_activity() +{ + API_METHOD_PREFIX + for (uint32_t domain = 0; domain < ACTIVITY_DOMAIN_NUMBER; domain++) { + const uint32_t op_num = get_op_num(domain); + for (uint32_t op = 0; op < op_num; op++) roctracer_disable_activity_impl(domain, op); + } API_METHOD_SUFFIX } diff --git a/test/MatrixTranspose_test/MatrixTranspose.cpp b/test/MatrixTranspose_test/MatrixTranspose.cpp index 7dadf38cc6..fe8dde97d6 100644 --- a/test/MatrixTranspose_test/MatrixTranspose.cpp +++ b/test/MatrixTranspose_test/MatrixTranspose.cpp @@ -161,7 +161,7 @@ void hip_api_callback( (void)arg; const hip_api_data_t* data = reinterpret_cast(callback_data); fprintf(stdout, "<%s id(%u)\tcorrelation_id(%lu) %s> ", - roctracer_id_string(ACTIVITY_DOMAIN_HIP_API, cid, 0), + roctracer_op_string(ACTIVITY_DOMAIN_HIP_API, cid, 0), cid, data->correlation_id, (data->phase == ACTIVITY_API_PHASE_ENTER) ? "on-enter" : "on-exit"); @@ -211,7 +211,7 @@ void activity_callback(const char* begin, const char* end, void* arg) { const roctracer_record_t* end_record = reinterpret_cast(end); fprintf(stdout, "\tActivity records:\n"); fflush(stdout); while (record < end_record) { - const char * name = roctracer_id_string(record->domain, record->activity_id, record->kind); + const char * name = roctracer_op_string(record->domain, record->op, record->kind); fprintf(stdout, "\t%s\tcorrelation_id(%lu) time_ns(%lu:%lu)", name, record->correlation_id, @@ -232,7 +232,7 @@ void activity_callback(const char* begin, const char* end, void* arg) { fprintf(stderr, "Bad domain %d\n", record->domain); abort(); } - if (record->activity_id == hc::HSA_OP_ID_COPY) fprintf(stdout, " bytes(0x%zx)", record->bytes); + if (record->op == hc::HSA_OP_ID_COPY) fprintf(stdout, " bytes(0x%zx)", record->bytes); fprintf(stdout, "\n"); fflush(stdout); ROCTRACER_CALL(roctracer_next_record(record, &record)); @@ -248,15 +248,15 @@ void start_tracing() { properties.buffer_callback_fun = activity_callback; ROCTRACER_CALL(roctracer_open_pool(&properties)); // Enable HIP API callbacks - ROCTRACER_CALL(roctracer_enable_callback(ACTIVITY_DOMAIN_ANY, 0, hip_api_callback, NULL)); + ROCTRACER_CALL(roctracer_enable_callback(hip_api_callback, NULL)); // Enable HIP activity tracing - ROCTRACER_CALL(roctracer_enable_activity(ACTIVITY_DOMAIN_ANY, 0)); + ROCTRACER_CALL(roctracer_enable_activity()); } // Stop tracing routine void stop_tracing() { - ROCTRACER_CALL(roctracer_disable_callback(ACTIVITY_DOMAIN_ANY, 0)); - ROCTRACER_CALL(roctracer_disable_activity(ACTIVITY_DOMAIN_ANY, 0)); + ROCTRACER_CALL(roctracer_disable_callback()); + ROCTRACER_CALL(roctracer_disable_activity()); ROCTRACER_CALL(roctracer_close_pool()); std::cout << "# STOP #############################" << std::endl << std::flush; } diff --git a/test/tool/tracer_tool.cpp b/test/tool/tracer_tool.cpp index 5f48c562bf..d367ba25a7 100644 --- a/test/tool/tracer_tool.cpp +++ b/test/tool/tracer_tool.cpp @@ -82,7 +82,7 @@ void hip_api_callback( hsa_begin_timestamp = timer.timestamp_fn_ns(); } else { const timestamp_t end_timestamp = timer.timestamp_fn_ns(); - fprintf(stdout, "(%lu:%lu) %s(", hsa_begin_timestamp, end_timestamp, roctracer_id_string(ACTIVITY_DOMAIN_HIP_API, cid, 0)); + fprintf(stdout, "(%lu:%lu) %s(", hsa_begin_timestamp, end_timestamp, roctracer_op_string(ACTIVITY_DOMAIN_HIP_API, cid, 0)); switch (cid) { case HIP_API_ID_hipMemcpy: fprintf(stdout, "dst(%p) src(%p) size(0x%x) kind(%u)", @@ -119,7 +119,7 @@ void activity_callback(const char* begin, const char* end, void* arg) { const roctracer_record_t* end_record = reinterpret_cast(end); fprintf(stdout, "\tActivity records:\n"); fflush(stdout); while (record < end_record) { - const char * name = roctracer_id_string(record->domain, record->activity_id, record->kind); + const char * name = roctracer_op_string(record->domain, record->op, record->kind); fprintf(stdout, "\t%s\tcorrelation_id(%lu) time_ns(%lu:%lu)", name, record->correlation_id, @@ -140,7 +140,7 @@ void activity_callback(const char* begin, const char* end, void* arg) { fprintf(stderr, "Bad domain %d\n", record->domain); abort(); } - if (record->activity_id == hc::HSA_OP_ID_COPY) fprintf(stdout, " bytes(0x%zx)", record->bytes); + if (record->op == hc::HSA_OP_ID_COPY) fprintf(stdout, " bytes(0x%zx)", record->bytes); fprintf(stdout, "\n"); fflush(stdout); ROCTRACER_CALL(roctracer_next_record(record, &record)); @@ -158,7 +158,7 @@ PUBLIC_API bool OnLoad(HsaApiTable* table, uint64_t runtime_version, uint64_t fa // Enable HSA API callbacks if (trace_hsa) { - ROCTRACER_CALL(roctracer_enable_callback(ACTIVITY_DOMAIN_HSA_API, HSA_API_ID_ANY, hsa_api_callback, NULL)); + ROCTRACER_CALL(roctracer_enable_domain_callback(ACTIVITY_DOMAIN_HSA_API, hsa_api_callback, NULL)); } // Enable HIP API callbacks/activity @@ -168,9 +168,9 @@ PUBLIC_API bool OnLoad(HsaApiTable* table, uint64_t runtime_version, uint64_t fa properties.buffer_size = 12; properties.buffer_callback_fun = activity_callback; ROCTRACER_CALL(roctracer_open_pool(&properties)); - - ROCTRACER_CALL(roctracer_enable_callback(ACTIVITY_DOMAIN_HIP_API, HIP_API_ID_ANY, hip_api_callback, NULL)); - ROCTRACER_CALL(roctracer_enable_activity(ACTIVITY_DOMAIN_ANY, 0)); + ROCTRACER_CALL(roctracer_enable_domain_activity(ACTIVITY_DOMAIN_HCC_OPS)); + ROCTRACER_CALL(roctracer_enable_domain_activity(ACTIVITY_DOMAIN_HIP_API)); + ROCTRACER_CALL(roctracer_enable_domain_callback(ACTIVITY_DOMAIN_HIP_API, hip_api_callback, NULL)); } return true; @@ -178,8 +178,8 @@ PUBLIC_API bool OnLoad(HsaApiTable* table, uint64_t runtime_version, uint64_t fa // HSA-runtime tool on-unload method PUBLIC_API void OnUnload() { - ROCTRACER_CALL(roctracer_disable_callback(ACTIVITY_DOMAIN_ANY, 0)); - ROCTRACER_CALL(roctracer_disable_activity(ACTIVITY_DOMAIN_ANY, 0)); + ROCTRACER_CALL(roctracer_disable_callback()); + ROCTRACER_CALL(roctracer_disable_activity()); ROCTRACER_CALL(roctracer_close_pool()); }