removing _ANY ops

inc/ext/hsa_rt_utils.hpp

@@ -28,6 +28,7 @@ THE SOFTWARE.
 #include <cstdint>
 #include <cstddef>
 #include <iostream>
+#include <mutex>
 
 #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<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
 
 #endif  // INC_ROCTRACER_HSA_RT_UTILS_HPP_

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

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(

inc/roctracer_hcc.h

@@ -24,10 +24,8 @@ THE SOFTWARE.
 #define INC_ROCTRACER_HCC_H_
 
 #if (LOCAL_BUILD == 1)
-#include <hc_hsa_op_id.h>
 #include <hc_prof_runtime.h>
 #else
-#include <hcc/hc_hsa_op_id.h>
 #include <hcc/hc_prof_runtime.h>
 #endif
 

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<hip_api_data_t*>(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
 }
 

test/MatrixTranspose_test/MatrixTranspose.cpp

@@ -161,7 +161,7 @@ void hip_api_callback(
   (void)arg;
   const hip_api_data_t* data = reinterpret_cast<const hip_api_data_t*>(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<const roctracer_record_t*>(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;
 }

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<const roctracer_record_t*>(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());
 }