Adding Async output for API Tracing

If rocprofiler_set_api_trace_sync_callback is not called by the API client then it will be automatically saved in the buffer and it will be in async to the user to see the API trace data, sample for async api tracing is added to samples/tracer

Change-Id: I01266a12b0eec172fdcffd7f04c89c2fe96174bb

src/core/session/filter.cpp

@@ -233,9 +233,16 @@ std::variant<std::vector<std::string>, uint32_t*> Filter::GetProperty(
   return property;
 }
 
-void Filter::SetCallback(rocprofiler_sync_callback_t& callback) { callback_ = callback; }
+void Filter::SetCallback(rocprofiler_sync_callback_t& callback) {
+  callback_ = callback;
+  has_sync_callback_ = true;
+}
 
-rocprofiler_sync_callback_t& Filter::GetCallback() { return callback_; }
+bool Filter::HasCallback() { return has_sync_callback_; }
+
+rocprofiler_sync_callback_t& Filter::GetCallback() {
+  return callback_;
+}
 
 size_t Filter::GetPropertiesCount(rocprofiler_filter_property_kind_t kind) {
   switch (kind) {

src/core/session/filter.h

@@ -50,6 +50,7 @@ class Filter {
   std::vector<rocprofiler_att_parameter_t> GetAttParametersData();
   void SetCallback(rocprofiler_sync_callback_t& callback);
   rocprofiler_sync_callback_t& GetCallback();
+  bool HasCallback();
 
   void SetProperty(rocprofiler_filter_property_t property);
   std::variant<std::vector<std::string>, uint32_t*> GetProperty(
@@ -75,6 +76,7 @@ class Filter {
   std::vector<rocprofiler_att_parameter_t> att_parameters_;  // ATT Parameters
   rocprofiler_counters_sampler_parameters_t counters_sampler_parameters_;        // sampled counters parameters
 
+  bool has_sync_callback_{false};
   rocprofiler_sync_callback_t callback_;
 };
 

src/core/session/session.cpp

@@ -131,7 +131,9 @@ void Session::Start() {
           GetFilter(GetFilterIdWithKind(ROCPROFILER_API_TRACE))->GetTraceData();
       if (!tracer_started_.load(std::memory_order_release)) {
         tracer_ = new tracer::Tracer(
-            session_id_, GetFilter(GetFilterIdWithKind(ROCPROFILER_API_TRACE))->GetCallback(),
+            session_id_, (GetFilter(
+              GetFilterIdWithKind(ROCPROFILER_API_TRACE))->HasCallback() ? GetFilter(
+                GetFilterIdWithKind(ROCPROFILER_API_TRACE))->GetCallback() : nullptr),
             GetFilter(GetFilterIdWithKind(ROCPROFILER_API_TRACE))->GetBufferId(), domains);
         tracer_started_.exchange(true, std::memory_order_release);
       }

src/core/session/tracer/tracer.cpp

@@ -39,9 +39,7 @@ Tracer::Tracer(rocprofiler_session_id_t session_id, rocprofiler_sync_callback_t
     : domains_(domains), callback_(callback), buffer_id_(buffer_id), session_id_(session_id) {
   assert(!is_active_.load(std::memory_order_release) && "Error: The tracer was initialized!");
   std::lock_guard<std::mutex> lock(tracer_lock_);
-
   callback_data_ = api_callback_data_t{callback, session_id};
-
   is_active_.exchange(true, std::memory_order_release);
 }
 
@@ -406,12 +404,20 @@ void Tracer::InitRoctracer(
     switch (domain.first) {
       case ACTIVITY_DOMAIN_ROCTX: {
         assert(!domain.second && "Error: ROCTX API can't be filtered!");
-        roctracer_enable_domain_callback(ACTIVITY_DOMAIN_ROCTX, api_callback, &callback_data_);
+        if(callback_data_.user_sync_callback)
+          roctracer_enable_domain_callback(ACTIVITY_DOMAIN_ROCTX, api_callback, &callback_data_);
+        else
+          roctracer_enable_domain_activity(ACTIVITY_DOMAIN_ROCTX,
+                                         session_buffer_id_t{session_id_, buffer_id_});
         break;
       }
       case ACTIVITY_DOMAIN_HSA_API: {
         if (!domain.second) {
-          roctracer_enable_domain_callback(ACTIVITY_DOMAIN_HSA_API, api_callback, &callback_data_);
+          if(callback_data_.user_sync_callback)
+            roctracer_enable_domain_callback(ACTIVITY_DOMAIN_HSA_API, api_callback, &callback_data_);
+          else
+            roctracer_enable_domain_activity(ACTIVITY_DOMAIN_HSA_API,
+                                         session_buffer_id_t{session_id_, buffer_id_});
         } else {
           assert(!api_filter_data_vector.empty() &&
                  "Error: HSA API calls filter data is empty and domain "
@@ -421,7 +427,11 @@ void Tracer::InitRoctracer(
       }
       case ACTIVITY_DOMAIN_HIP_API: {
         if (!domain.second) {
-          roctracer_enable_domain_callback(ACTIVITY_DOMAIN_HIP_API, api_callback, &callback_data_);
+          if(callback_data_.user_sync_callback)
+            roctracer_enable_domain_callback(ACTIVITY_DOMAIN_HIP_API, api_callback, &callback_data_);
+          else
+            roctracer_enable_domain_activity(ACTIVITY_DOMAIN_HIP_API,
+                                         session_buffer_id_t{session_id_, buffer_id_});
         } else {
           assert(!api_filter_data_vector.empty() &&
                  "Error: HIP API calls filter data is empty and domain "

src/core/session/tracer/tracer.h

@@ -91,6 +91,7 @@ class Tracer {
       roctx_report_activity_;
 
   std::vector<rocprofiler_tracer_activity_domain_t> domains_;
+  bool is_sync_;
   rocprofiler_sync_callback_t callback_;
   rocprofiler_buffer_id_t buffer_id_;
   rocprofiler_session_id_t session_id_;