AI/rocm-systems
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

removing _ANY ops

Browse Source
This commit is contained in:
Evgeny
2019-01-11 22:15:35 -06:00
parent a0169f594c
commit 0cde85dbb7
7 changed files with 232 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files
inc/ext/hsa_rt_utils.hpp
+25 -6
View File
@@ -28,6 +28,7 @@ THE SOFTWARE.
#include <cstdint> #include <cstdint>
#include <cstddef> #include <cstddef>
#include <iostream> #include <iostream>
#include <mutex>
#define HSART_CALL(call) \ #define HSART_CALL(call) \
do { \ do { \
@@ -80,12 +81,9 @@ class Timer {
return timestamp_to_ns(timestamp); return timestamp_to_ns(timestamp);
} }
Timer() { Timer(hsa_system_get_info_fn_t f = NULL) {
init(hsa_system_get_info); if (f != NULL) init(f);
} else init(hsa_system_get_info);
Timer(hsa_system_get_info_fn_t f) {
init(f);
} }
private: private:
@@ -95,6 +93,27 @@ class Timer {
freq_t timestamp_rate_; 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<mutex_t> 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 } // namespace hsa_rt_utils
#endif // INC_ROCTRACER_HSA_RT_UTILS_HPP_ #endif // INC_ROCTRACER_HSA_RT_UTILS_HPP_
inc/ext/prof_protocol.h
+5 -8
View File
@@ -23,15 +23,12 @@ THE SOFTWARE.
#ifndef INC_EXT_PROF_PROTOCOL_H_ #ifndef INC_EXT_PROF_PROTOCOL_H_
#define INC_EXT_PROF_PROTOCOL_H_ #define INC_EXT_PROF_PROTOCOL_H_
#define HCC_ENABLED 1
// Traced API domains // Traced API domains
typedef enum { typedef enum {
ACTIVITY_DOMAIN_ANY = 0, // Any domain ACTIVITY_DOMAIN_HSA_API = 0, // HSA domain
ACTIVITY_DOMAIN_HSA_API = 1, // HSA domain ACTIVITY_DOMAIN_HCC_OPS = 1, // HCC domain
ACTIVITY_DOMAIN_HCC_OPS = 2, // HCC domain ACTIVITY_DOMAIN_HIP_API = 2, // HIP domain
ACTIVITY_DOMAIN_HIP_API = 3, // HIP domain ACTIVITY_DOMAIN_NUMBER = 3
ACTIVITY_DOMAIN_NUMBER = 4
} activity_domain_t; } activity_domain_t;
// API calback type // API calback type
@@ -53,7 +50,7 @@ typedef uint64_t activity_correlation_id_t;
struct activity_record_t { struct activity_record_t {
uint32_t domain; // activity domain id uint32_t domain; // activity domain id
activity_kind_t kind; // activity kind 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 activity_correlation_id_t correlation_id; // activity ID
uint64_t begin_ns; // host begin timestamp uint64_t begin_ns; // host begin timestamp
uint64_t end_ns; // host end timestamp uint64_t end_ns; // host end timestamp
inc/roctracer.h
+28 -10
View File
@@ -78,9 +78,9 @@ typedef activity_domain_t roctracer_domain_t;
// Return ID string by given domain and activity/API ID // Return ID string by given domain and activity/API ID
// NULL returned on the error and the library errno is set // 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& domain, // tracing domain
const uint32_t& id, // activity ID const uint32_t& op, // activity op ID
const uint32_t& kind); // activity kind const uint32_t& kind); // activity kind
// Set properties // Set properties
@@ -100,16 +100,26 @@ roctracer_status_t roctracer_set_properties(
typedef activity_rtapi_callback_t roctracer_rtapi_callback_t; typedef activity_rtapi_callback_t roctracer_rtapi_callback_t;
// Enable runtime API callbacks // Enable runtime API callbacks
roctracer_status_t roctracer_enable_callback( roctracer_status_t roctracer_enable_op_callback(
activity_domain_t domain, // tracing domain 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 activity_rtapi_callback_t callback, // callback function pointer
void* arg); // [in/out] callback arg void* arg); // [in/out] callback arg
// Disable runtime API callbacks // Disable runtime API callbacks
roctracer_status_t roctracer_disable_callback( roctracer_status_t roctracer_disable_op_callback(
activity_domain_t domain, // tracing domain 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 // Activity API
@@ -175,15 +185,23 @@ roctracer_pool_t* roctracer_default_pool(
roctracer_pool_t* pool = NULL); // [in] new default pool if not NULL roctracer_pool_t* pool = NULL); // [in] new default pool if not NULL
// Enable activity records logging // Enable activity records logging
roctracer_status_t roctracer_enable_activity( roctracer_status_t roctracer_enable_op_activity(
activity_domain_t domain, // tracing domain 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 roctracer_pool_t* pool = NULL); // memory pool, NULL is a default one
// Disable activity records logging // Disable activity records logging
roctracer_status_t roctracer_disable_activity( roctracer_status_t roctracer_disable_op_activity(
activity_domain_t domain, // tracing domain 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 // Flush available activity records
roctracer_status_t roctracer_flush_activity( roctracer_status_t roctracer_flush_activity(
inc/roctracer_hcc.h
-2
View File
@@ -24,10 +24,8 @@ THE SOFTWARE.
#define INC_ROCTRACER_HCC_H_ #define INC_ROCTRACER_HCC_H_
#if (LOCAL_BUILD == 1) #if (LOCAL_BUILD == 1)
#include <hc_hsa_op_id.h>
#include <hc_prof_runtime.h> #include <hc_prof_runtime.h>
#else #else
#include <hcc/hc_hsa_op_id.h>
#include <hcc/hc_prof_runtime.h> #include <hcc/hc_prof_runtime.h>
#endif #endif
src/core/roctracer.cpp
+158 -68
View File
@@ -21,9 +21,7 @@ THE SOFTWARE.
*/ */
#include "inc/roctracer.h" #include "inc/roctracer.h"
#ifdef HCC_ENABLED
#include "inc/roctracer_hcc.h" #include "inc/roctracer_hcc.h"
#endif
#include "inc/roctracer_hip.h" #include "inc/roctracer_hip.h"
#define PROF_API_IMPL 1 #define PROF_API_IMPL 1
#include "inc/roctracer_hsa.h" #include "inc/roctracer_hsa.h"
@@ -303,7 +301,7 @@ static inline activity_correlation_id_t CorrelationIdLookup(const activity_corre
} }
roctracer_record_t* HIP_SyncActivityCallback( roctracer_record_t* HIP_SyncActivityCallback(
uint32_t activity_id, uint32_t op_id,
roctracer_record_t* record, roctracer_record_t* record,
const void* callback_data, const void* callback_data,
void* arg) void* arg)
@@ -315,7 +313,7 @@ roctracer_record_t* HIP_SyncActivityCallback(
if (pool == NULL) EXC_ABORT(ROCTRACER_STATUS_ERROR, "ActivityCallback pool is NULL"); if (pool == NULL) EXC_ABORT(ROCTRACER_STATUS_ERROR, "ActivityCallback pool is NULL");
if (data->phase == ACTIVITY_API_PHASE_ENTER) { if (data->phase == ACTIVITY_API_PHASE_ENTER) {
record->domain = ACTIVITY_DOMAIN_HIP_API; record->domain = ACTIVITY_DOMAIN_HIP_API;
record->activity_id = activity_id; record->op = op_id;
record->begin_ns = timer.timestamp_ns(); record->begin_ns = timer.timestamp_ns();
// Correlation ID generating // Correlation ID generating
uint64_t correlation_id = data->correlation_id; uint64_t correlation_id = data->correlation_id;
@@ -324,20 +322,16 @@ roctracer_record_t* HIP_SyncActivityCallback(
const_cast<hip_api_data_t*>(data)->correlation_id = correlation_id; const_cast<hip_api_data_t*>(data)->correlation_id = correlation_id;
} }
record->correlation_id = correlation_id; record->correlation_id = correlation_id;
#ifdef HCC_ENABLED
// Passing correlatin ID // Passing correlatin ID
correlation_id_tls = correlation_id; correlation_id_tls = correlation_id;
#endif
return record; return record;
} else { } else {
record->end_ns = timer.timestamp_ns(); record->end_ns = timer.timestamp_ns();
record->process_id = syscall(__NR_getpid); record->process_id = syscall(__NR_getpid);
record->thread_id = syscall(__NR_gettid); record->thread_id = syscall(__NR_gettid);
pool->Write(*record); pool->Write(*record);
#ifdef HCC_ENABLED
// Clearing correlatin ID // Clearing correlatin ID
correlation_id_tls = 0; correlation_id_tls = 0;
#endif
return NULL; return NULL;
} }
} }
@@ -394,7 +388,7 @@ PUBLIC_API const char* roctracer_error_string() {
// Return ID string by given domain and activity/API ID // Return ID string by given domain and activity/API ID
// NULL returned on the error and the library errno is set // 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 API_METHOD_PREFIX
switch (domain) { switch (domain) {
case ACTIVITY_DOMAIN_HSA_API: { case ACTIVITY_DOMAIN_HSA_API: {
@@ -402,9 +396,7 @@ PUBLIC_API const char* roctracer_id_string(const uint32_t& domain, const uint32_
break; break;
} }
case ACTIVITY_DOMAIN_HCC_OPS: { case ACTIVITY_DOMAIN_HCC_OPS: {
#ifdef HCC_ENABLED
return roctracer::HccLoader::Instance().GetCmdName(kind); return roctracer::HccLoader::Instance().GetCmdName(kind);
#endif
break; break;
} }
case ACTIVITY_DOMAIN_HIP_API: { 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) 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 // Enable runtime API callbacks
PUBLIC_API roctracer_status_t roctracer_enable_callback( static void roctracer_enable_callback_impl(
roctracer_domain_t domain, uint32_t domain,
uint32_t id, uint32_t op,
roctracer_rtapi_callback_t callback, roctracer_rtapi_callback_t callback,
void* user_data) void* user_data)
{ {
API_METHOD_PREFIX
switch (domain) { 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: { case ACTIVITY_DOMAIN_HSA_API: {
if (id == HSA_API_ID_ANY) { roctracer::hsa_support::cb_table.set(op, callback, user_data);
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; break;
} }
case ACTIVITY_DOMAIN_HCC_OPS: break;
case ACTIVITY_DOMAIN_HIP_API: { 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 << ")"); if (hip_err != hipSuccess) HIP_EXC_RAISING(ROCTRACER_STATUS_HIP_API_ERR, "hipRegisterApiCallback error(" << hip_err << ")");
break; break;
} }
default: default:
EXC_RAISING(ROCTRACER_STATUS_BAD_DOMAIN, "invalid domain ID(" << domain << ")"); 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 API_METHOD_SUFFIX
} }
// Enable runtime API callbacks PUBLIC_API roctracer_status_t roctracer_enable_domain_callback(
PUBLIC_API roctracer_status_t roctracer_disable_callback(
roctracer_domain_t domain, roctracer_domain_t domain,
uint32_t id) roctracer_rtapi_callback_t callback,
void* user_data)
{ {
API_METHOD_PREFIX 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) { switch (domain) {
case ACTIVITY_DOMAIN_ANY: case ACTIVITY_DOMAIN_HSA_API: {
if (id != 0) HIP_EXC_RAISING(ROCTRACER_STATUS_BAD_PARAMETER, "DOMAIN_ANY: id != 0"); break;
id = HIP_API_ID_ANY; }
case ACTIVITY_DOMAIN_HCC_OPS: break;
case ACTIVITY_DOMAIN_HIP_API: { 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 << ")"); if (hip_err != hipSuccess) HIP_EXC_RAISING(ROCTRACER_STATUS_HIP_API_ERR, "hipRemoveApiCallback error(" << hip_err << ")");
break; break;
} }
default: default:
EXC_RAISING(ROCTRACER_STATUS_BAD_DOMAIN, "invalid domain ID(" << domain << ")"); 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 API_METHOD_SUFFIX
} }
@@ -512,69 +563,108 @@ PUBLIC_API roctracer_status_t roctracer_close_pool(roctracer_pool_t* pool) {
} }
// Enable activity records logging // Enable activity records logging
PUBLIC_API roctracer_status_t roctracer_enable_activity( static void roctracer_enable_activity_impl(
roctracer_domain_t domain, uint32_t domain,
uint32_t id, uint32_t op,
roctracer_pool_t* pool) roctracer_pool_t* pool)
{ {
API_METHOD_PREFIX
if (pool == NULL) pool = roctracer_default_pool(); if (pool == NULL) pool = roctracer_default_pool();
switch (domain) { switch (domain) {
case ACTIVITY_DOMAIN_ANY: case ACTIVITY_DOMAIN_HSA_API: break;
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_HCC_OPS: { case ACTIVITY_DOMAIN_HCC_OPS: {
#ifdef HCC_ENABLED
roctracer::HccLoader::Instance().SetActivityIdCallback((void*)roctracer::HCC_ActivityIdCallback); roctracer::HccLoader::Instance().SetActivityIdCallback((void*)roctracer::HCC_ActivityIdCallback);
const bool err = roctracer::HccLoader::Instance().SetActivityCallback(id, (void*)roctracer::HCC_AsyncActivityCallback, (void*)pool); const bool succ = roctracer::HccLoader::Instance().SetActivityCallback(op, (void*)roctracer::HCC_AsyncActivityCallback, (void*)pool);
if (err == true) HCC_EXC_RAISING(ROCTRACER_STATUS_HCC_OPS_ERR, "HCC::SetActivityCallback error"); if (succ == false) HCC_EXC_RAISING(ROCTRACER_STATUS_HCC_OPS_ERR, "HCC::SetActivityCallback error");
#endif
break; break;
} }
case ACTIVITY_DOMAIN_HIP_API: { 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 << ")"); if (hip_err != hipSuccess) HIP_EXC_RAISING(ROCTRACER_STATUS_HIP_API_ERR, "hipRegisterActivityCallback error(" << hip_err << ")");
break; break;
} }
default: default:
EXC_RAISING(ROCTRACER_STATUS_BAD_DOMAIN, "invalid domain ID(" << domain << ")"); 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 API_METHOD_SUFFIX
} }
// Disable activity records logging // Disable activity records logging
PUBLIC_API roctracer_status_t roctracer_disable_activity( static void roctracer_disable_activity_impl(
roctracer_domain_t domain, uint32_t domain,
uint32_t id) uint32_t op)
{ {
API_METHOD_PREFIX
switch (domain) { switch (domain) {
case ACTIVITY_DOMAIN_ANY: case ACTIVITY_DOMAIN_HSA_API: break;
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_HCC_OPS: { case ACTIVITY_DOMAIN_HCC_OPS: {
#ifdef HCC_ENABLED const bool succ = roctracer::HccLoader::Instance().SetActivityCallback(op, NULL, NULL);
const bool err = roctracer::HccLoader::Instance().SetActivityCallback(id, NULL, NULL); if (succ == false) HCC_EXC_RAISING(ROCTRACER_STATUS_HCC_OPS_ERR, "HCC::SetActivityCallback(NULL) error domain(" << domain << ") op(" << op << ")");
if (err == true) HCC_EXC_RAISING(ROCTRACER_STATUS_HCC_OPS_ERR, "HCC::SetActivityCallback(NULL) error");
#endif
break; break;
} }
case ACTIVITY_DOMAIN_HIP_API: { 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 << ")"); if (hip_err != hipSuccess) HIP_EXC_RAISING(ROCTRACER_STATUS_HIP_API_ERR, "hipRemoveActivityCallback error(" << hip_err << ")");
break; break;
} }
default: default:
EXC_RAISING(ROCTRACER_STATUS_BAD_DOMAIN, "invalid domain ID(" << domain << ")"); 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 API_METHOD_SUFFIX
} }
test/MatrixTranspose_test/MatrixTranspose.cpp
+7 -7
View File
@@ -161,7 +161,7 @@ void hip_api_callback(
(void)arg; (void)arg;
const hip_api_data_t* data = reinterpret_cast<const hip_api_data_t*>(callback_data); const hip_api_data_t* data = reinterpret_cast<const hip_api_data_t*>(callback_data);
fprintf(stdout, "<%s id(%u)\tcorrelation_id(%lu) %s> ", 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, cid,
data->correlation_id, data->correlation_id,
(data->phase == ACTIVITY_API_PHASE_ENTER) ? "on-enter" : "on-exit"); (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<const roctracer_record_t*>(end); const roctracer_record_t* end_record = reinterpret_cast<const roctracer_record_t*>(end);
fprintf(stdout, "\tActivity records:\n"); fflush(stdout); fprintf(stdout, "\tActivity records:\n"); fflush(stdout);
while (record < end_record) { 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)", fprintf(stdout, "\t%s\tcorrelation_id(%lu) time_ns(%lu:%lu)",
name, name,
record->correlation_id, 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); fprintf(stderr, "Bad domain %d\n", record->domain);
abort(); 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"); fprintf(stdout, "\n");
fflush(stdout); fflush(stdout);
ROCTRACER_CALL(roctracer_next_record(record, &record)); ROCTRACER_CALL(roctracer_next_record(record, &record));
@@ -248,15 +248,15 @@ void start_tracing() {
properties.buffer_callback_fun = activity_callback; properties.buffer_callback_fun = activity_callback;
ROCTRACER_CALL(roctracer_open_pool(&properties)); ROCTRACER_CALL(roctracer_open_pool(&properties));
// Enable HIP API callbacks // 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 // Enable HIP activity tracing
ROCTRACER_CALL(roctracer_enable_activity(ACTIVITY_DOMAIN_ANY, 0)); ROCTRACER_CALL(roctracer_enable_activity());
} }
// Stop tracing routine // Stop tracing routine
void stop_tracing() { void stop_tracing() {
ROCTRACER_CALL(roctracer_disable_callback(ACTIVITY_DOMAIN_ANY, 0)); ROCTRACER_CALL(roctracer_disable_callback());
ROCTRACER_CALL(roctracer_disable_activity(ACTIVITY_DOMAIN_ANY, 0)); ROCTRACER_CALL(roctracer_disable_activity());
ROCTRACER_CALL(roctracer_close_pool()); ROCTRACER_CALL(roctracer_close_pool());
std::cout << "# STOP #############################" << std::endl << std::flush; std::cout << "# STOP #############################" << std::endl << std::flush;
} }
test/tool/tracer_tool.cpp
+9 -9
View File
@@ -82,7 +82,7 @@ void hip_api_callback(
hsa_begin_timestamp = timer.timestamp_fn_ns(); hsa_begin_timestamp = timer.timestamp_fn_ns();
} else { } else {
const timestamp_t end_timestamp = timer.timestamp_fn_ns(); 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) { switch (cid) {
case HIP_API_ID_hipMemcpy: case HIP_API_ID_hipMemcpy:
fprintf(stdout, "dst(%p) src(%p) size(0x%x) kind(%u)", 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<const roctracer_record_t*>(end); const roctracer_record_t* end_record = reinterpret_cast<const roctracer_record_t*>(end);
fprintf(stdout, "\tActivity records:\n"); fflush(stdout); fprintf(stdout, "\tActivity records:\n"); fflush(stdout);
while (record < end_record) { 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)", fprintf(stdout, "\t%s\tcorrelation_id(%lu) time_ns(%lu:%lu)",
name, name,
record->correlation_id, 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); fprintf(stderr, "Bad domain %d\n", record->domain);
abort(); 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"); fprintf(stdout, "\n");
fflush(stdout); fflush(stdout);
ROCTRACER_CALL(roctracer_next_record(record, &record)); 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 // Enable HSA API callbacks
if (trace_hsa) { 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 // 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_size = 12;
properties.buffer_callback_fun = activity_callback; properties.buffer_callback_fun = activity_callback;
ROCTRACER_CALL(roctracer_open_pool(&properties)); ROCTRACER_CALL(roctracer_open_pool(&properties));
ROCTRACER_CALL(roctracer_enable_domain_activity(ACTIVITY_DOMAIN_HCC_OPS));
ROCTRACER_CALL(roctracer_enable_callback(ACTIVITY_DOMAIN_HIP_API, HIP_API_ID_ANY, hip_api_callback, NULL)); ROCTRACER_CALL(roctracer_enable_domain_activity(ACTIVITY_DOMAIN_HIP_API));
ROCTRACER_CALL(roctracer_enable_activity(ACTIVITY_DOMAIN_ANY, 0)); ROCTRACER_CALL(roctracer_enable_domain_callback(ACTIVITY_DOMAIN_HIP_API, hip_api_callback, NULL));
} }
return true; 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 // HSA-runtime tool on-unload method
PUBLIC_API void OnUnload() { PUBLIC_API void OnUnload() {
ROCTRACER_CALL(roctracer_disable_callback(ACTIVITY_DOMAIN_ANY, 0)); ROCTRACER_CALL(roctracer_disable_callback());
ROCTRACER_CALL(roctracer_disable_activity(ACTIVITY_DOMAIN_ANY, 0)); ROCTRACER_CALL(roctracer_disable_activity());
ROCTRACER_CALL(roctracer_close_pool()); ROCTRACER_CALL(roctracer_close_pool());
} }