SWDEV-389161:Adding fix for tensorflow app hang with rocprofv2

Change-Id: I48ade2e853468940aa5e1fca58ba22f686d89f26
2023-05-11 20:28:31 +00:00
commit cdc74d31db
@@ -22,5 +22,5 @@

 add_subdirectory(file)
 add_subdirectory(perfetto)
-add_subdirectory(ctf)
+#add_subdirectory(ctf)
 add_subdirectory(att)
@@ -55,7 +55,7 @@ class att_plugin_t {
  bool is_valid_{true};

  inline bool att_file_exists(const std::string& name) {
-    struct stat buffer;   
+    struct stat buffer;
    return stat(name.c_str(), &buffer) == 0;
  }

@@ -189,8 +189,9 @@ ROCPROFILER_EXPORT int rocprofiler_plugin_write_buffer_records(const rocprofiler
  return att_plugin->WriteBufferRecords(begin, end, session_id, buffer_id);
 }

-ROCPROFILER_EXPORT int rocprofiler_plugin_write_record(rocprofiler_record_tracer_t record,
-                                                   rocprofiler_session_id_t session_id) {
+ROCPROFILER_EXPORT int rocprofiler_plugin_write_record(
+    rocprofiler_record_tracer_t record,
+    rocprofiler_plugin_tracer_extra_data_t tracer_extra_data) {
  if (!att_plugin || !att_plugin->IsValid()) return -1;
  if (record.header.id.handle == 0) return 0;
  return 0;
@@ -33,7 +33,7 @@ set_target_properties(ctf_plugin PROPERTIES
                      LINK_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/../exportmap"
                      LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}")
 set(METADATA_STREAM_FILE_DIR "${CMAKE_INSTALL_DATADIR}/${PROJECT_NAME}/plugin/ctf")
-target_compile_definitions(ctf_plugin PRIVATE
+target_compile_definitions(ctf_plugin PUBLIC AMD_INTERNAL_BUILD PRIVATE
                           HIP_PROF_HIP_API_STRING=1
                           __HIP_PLATFORM_HCC__=1
                           CTF_PLUGIN_METADATA_FILE_PATH="${CMAKE_INSTALL_PREFIX}/${METADATA_STREAM_FILE_DIR}/metadata")
@@ -88,8 +88,9 @@ ROCPROFILER_EXPORT int rocprofiler_plugin_write_buffer_records(
  return 0;
 }

-ROCPROFILER_EXPORT int rocprofiler_plugin_write_record(const rocprofiler_record_tracer_t record,
-                                                   const rocprofiler_session_id_t session_id) {
+ROCPROFILER_EXPORT int rocprofiler_plugin_write_record(
+    const rocprofiler_record_tracer_t record, const void* data,
+    rocprofiler_plugin_trace_record_data_t tracer_data) {
  assert(the_plugin);

  if (record.header.id.handle == 0) {
@@ -97,7 +98,7 @@ ROCPROFILER_EXPORT int rocprofiler_plugin_write_record(const rocprofiler_record_
  }

  try {
-    the_plugin->HandleTracerRecord(record, session_id);
+    the_plugin->HandleTracerRecord(record, rocprofiler_session_id_t{0}, tracer_data, data);
  } catch (const std::exception& exc) {
    std::cerr << "rocprofiler_plugin_write_record(): " << exc.what() << std::endl;
    return -1;
@@ -137,6 +137,11 @@ class RocTxEventRecord final : public TracerEventRecord<barectf_roctx_ctx> {
      : TracerEventRecord<barectf_roctx_ctx>{record, GetRecordBeginClockVal(record)},
        id_{QueryId(record, session_id)},
        msg_{QueryMsg(record, session_id)} {}
+  explicit RocTxEventRecord(const rocprofiler_record_tracer_t& record, uint64_t roctx_id,
+                            std::string roctx_msg)
+      : TracerEventRecord<barectf_roctx_ctx>{record, GetRecordBeginClockVal(record)},
+        id_{roctx_id},
+        msg_{roctx_msg} {}

  void Write(barectf_roctx_ctx& barectf_ctx) const override {
    barectf_roctx_trace_roctx(&barectf_ctx, GetThreadId(), id_, msg_.c_str());
@@ -209,7 +214,9 @@ class HsaApiEventRecord : public TracerEventRecord<barectf_hsa_api_ctx> {
                             const rocprofiler_session_id_t session_id, const std::uint64_t clock_val)
      : TracerEventRecord<barectf_hsa_api_ctx>{record, clock_val},
        api_data_{QueryApiData(record, session_id)} {}
-
+  explicit HsaApiEventRecord(const rocprofiler_record_tracer_t& record,
+                             const std::uint64_t clock_val, hsa_api_data_t& api_data)
+      : TracerEventRecord<barectf_hsa_api_ctx>{record, clock_val}, api_data_(api_data) {}
  const hsa_api_data_t& GetApiData() const noexcept { return api_data_; }

 private:
@@ -246,6 +253,10 @@ class HsaApiEventRecordBegin final : public HsaApiEventRecord {
  explicit HsaApiEventRecordBegin(const rocprofiler_record_tracer_t& record,
                                  const rocprofiler_session_id_t session_id)
      : HsaApiEventRecord{record, session_id, GetRecordBeginClockVal(record)} {}
+  explicit HsaApiEventRecordBegin(const rocprofiler_record_tracer_t& record,
+                                  hsa_api_data_t& api_data)
+      : HsaApiEventRecord{record, GetRecordBeginClockVal(record),
+                          api_data} {}

  void Write(barectf_hsa_api_ctx& barectf_ctx) const override {
    // Include generated switch statement.
@@ -259,6 +270,9 @@ class HsaApiEventRecordEnd final : public HsaApiEventRecord {
  explicit HsaApiEventRecordEnd(const rocprofiler_record_tracer_t& record,
                                const rocprofiler_session_id_t session_id)
      : HsaApiEventRecord{record, session_id, GetRecordEndClockVal(record)} {}
+  explicit HsaApiEventRecordEnd(const rocprofiler_record_tracer_t& record,
+                                  hsa_api_data_t& api_data)
+      : HsaApiEventRecord{record, GetRecordBeginClockVal(record), api_data} {}

  void Write(barectf_hsa_api_ctx& barectf_ctx) const override {
    // Include generated switch statement.
@@ -270,11 +284,17 @@ class HsaApiEventRecordEnd final : public HsaApiEventRecord {
 class HipApiEventRecord : public TracerEventRecord<barectf_hip_api_ctx> {
 protected:
  explicit HipApiEventRecord(const rocprofiler_record_tracer_t& record,
-                             const rocprofiler_session_id_t session_id, const std::uint64_t clock_val)
+                             const rocprofiler_session_id_t session_id,
+                             const std::uint64_t clock_val)
      : TracerEventRecord<barectf_hip_api_ctx>{record, clock_val},
        api_data_{QueryApiData(record, session_id)},
        kernel_name_{QueryKernelName(record, session_id)} {}
-
+  explicit HipApiEventRecord(const rocprofiler_record_tracer_t& record,
+                             const std::uint64_t clock_val, hip_api_data_t& api_data,
+                             std::string kernel_name)
+      : TracerEventRecord<barectf_hip_api_ctx>{record, clock_val},
+        api_data_{api_data},
+        kernel_name_{kernel_name} {}
  const hip_api_data_t& GetApiData() const noexcept { return api_data_; }
  const std::string& GetKernelName() const noexcept { return kernel_name_; }

@@ -339,6 +359,9 @@ class HipApiEventRecordBegin final : public HipApiEventRecord {
  explicit HipApiEventRecordBegin(const rocprofiler_record_tracer_t& record,
                                  const rocprofiler_session_id_t session_id)
      : HipApiEventRecord{record, session_id, GetRecordBeginClockVal(record)} {}
+  explicit HipApiEventRecordBegin(const rocprofiler_record_tracer_t& record,
+                                  hip_api_data_t& api_data, std::string kernel_name)
+      : HipApiEventRecord{record, GetRecordBeginClockVal(record), api_data, kernel_name} {}

  void Write(barectf_hip_api_ctx& barectf_ctx) const override {
    // Include generated switch statement.
@@ -352,6 +375,9 @@ class HipApiEventRecordEnd final : public HipApiEventRecord {
  explicit HipApiEventRecordEnd(const rocprofiler_record_tracer_t& record,
                                const rocprofiler_session_id_t session_id)
      : HipApiEventRecord{record, session_id, GetRecordEndClockVal(record)} {}
+  explicit HipApiEventRecordEnd(const rocprofiler_record_tracer_t& record, hip_api_data_t& api_data,
+                                std::string kernel_name)
+      : HipApiEventRecord{record, GetRecordBeginClockVal(record), api_data, kernel_name} {}

  void Write(barectf_hip_api_ctx& barectf_ctx) const override {
    // Include generated switch statement.
@@ -686,27 +712,60 @@ Plugin::Plugin(const std::size_t packet_size, const fs::path& trace_dir,
 }

 void Plugin::HandleTracerRecord(const rocprofiler_record_tracer_t& record,
-                                const rocprofiler_session_id_t session_id) {
+                                const rocprofiler_session_id_t session_id,
+                                rocprofiler_plugin_trace_record_data_t tracer_data,
+                                const void* data) {
  std::lock_guard<std::mutex> lock{lock_};

  // Depending on the domain, create and add an event record to the
  // corresponding tracer.
  switch (record.domain) {
    case ACTIVITY_DOMAIN_ROCTX:
-      roctx_tracer_.AddEventRecord(std::make_shared<const RocTxEventRecord>(record, session_id));
+    /*If data is nullptr then the call is asynchromous*/
+      if (data == nullptr)
+        roctx_tracer_.AddEventRecord(std::make_shared<const RocTxEventRecord>(record, session_id));
+      else {
+        const char* roctx_message = reinterpret_cast<const char*>(data);
+        std::string roctx_msg(roctx_message);
+        roctx_tracer_.AddEventRecord(
+            std::make_shared<const RocTxEventRecord>(record, tracer_data.roctx_id, roctx_msg));
+      }
      break;
    case ACTIVITY_DOMAIN_HSA_API: {
-      hsa_api_tracer_.AddEventRecord(
-          std::make_shared<const HsaApiEventRecordBegin>(record, session_id));
-      hsa_api_tracer_.AddEventRecord(
-          std::make_shared<const HsaApiEventRecordEnd>(record, session_id));
+      /*If data is nullptr then the call is asynchromous*/
+      if (data == nullptr) {
+        hsa_api_tracer_.AddEventRecord(
+            std::make_shared<const HsaApiEventRecordBegin>(record, session_id));
+        hsa_api_tracer_.AddEventRecord(
+            std::make_shared<const HsaApiEventRecordEnd>(record, session_id));
+      } else {
+        hsa_api_data_t hsa_api_data = *reinterpret_cast<const hsa_api_data_t*>(data);
+        hsa_api_tracer_.AddEventRecord(
+            std::make_shared<const HsaApiEventRecordBegin>(record, hsa_api_data));
+        hsa_api_tracer_.AddEventRecord(
+            std::make_shared<const HsaApiEventRecordEnd>(record, hsa_api_data));
+      }
      break;
    }
    case ACTIVITY_DOMAIN_HIP_API: {
-      hip_api_tracer_.AddEventRecord(
-          std::make_shared<const HipApiEventRecordBegin>(record, session_id));
-      hip_api_tracer_.AddEventRecord(
-          std::make_shared<const HipApiEventRecordEnd>(record, session_id));
+      /*If data is nullptr then the call is asynchromous*/
+      if (data == nullptr) {
+        hip_api_tracer_.AddEventRecord(
+            std::make_shared<const HipApiEventRecordBegin>(record, session_id));
+        hip_api_tracer_.AddEventRecord(
+            std::make_shared<const HipApiEventRecordEnd>(record, session_id));
+      } else {
+        std::string kernel_name;
+        hip_api_data_t hip_api_data = *reinterpret_cast<const hip_api_data_t*>(data);
+        if (tracer_data.kernel_name != nullptr)
+          kernel_name = rocmtools::cxx_demangle(std::string(tracer_data.kernel_name));
+        else
+          kernel_name = "";
+        hip_api_tracer_.AddEventRecord(
+            std::make_shared<const HipApiEventRecordBegin>(record, hip_api_data, kernel_name));
+        hip_api_tracer_.AddEventRecord(
+            std::make_shared<const HipApiEventRecordEnd>(record, hip_api_data, kernel_name));
+      }
      break;
    }
    case ACTIVITY_DOMAIN_HSA_OPS:
@@ -738,7 +797,9 @@ void Plugin::HandleBufferRecords(const rocprofiler_record_header_t* begin,
                                 const rocprofiler_buffer_id_t buffer_id) {
  while (begin && begin < end) {
    if (begin->kind == ROCPROFILER_TRACER_RECORD) {
-      HandleTracerRecord(*reinterpret_cast<const rocprofiler_record_tracer_t*>(begin), session_id);
+      rocprofiler_plugin_trace_record_data_t tracer_data = {};
+      HandleTracerRecord(*reinterpret_cast<const rocprofiler_record_tracer_t*>(begin), session_id,
+                         tracer_data);
    } else {
      assert(begin->kind == ROCPROFILER_PROFILER_RECORD);
      HandleProfilerRecord(*reinterpret_cast<const rocprofiler_record_profiler_t*>(begin),
@@ -54,7 +54,10 @@ class Plugin final {

  // Handles a tracer record.
  void HandleTracerRecord(const rocprofiler_record_tracer_t& record,
-                          rocprofiler_session_id_t session_id);
+                          rocprofiler_session_id_t session_id,
+                          rocprofiler_plugin_trace_record_data_t tracer_data,
+                          const void* data = nullptr);
+

  // Handles a profiler record.
  void HandleProfilerRecord(const rocprofiler_record_profiler_t& record,
@@ -198,7 +198,8 @@ class file_plugin_t {

  void FlushTracerRecord(rocprofiler_record_tracer_t tracer_record,
                         rocprofiler_session_id_t session_id,
-                         rocprofiler_buffer_id_t buffer_id = rocprofiler_buffer_id_t{0}) {
+                         rocprofiler_plugin_tracer_extra_data_t tracer_extra_data,
+                         rocprofiler_buffer_id_t buffer_id = rocprofiler_buffer_id_t{0}){
    std::lock_guard<std::mutex> lock(writing_lock);
    std::string kernel_name;
    std::string function_name;
@@ -211,81 +212,29 @@ class file_plugin_t {
            reinterpret_cast<const char*>(tracer_record.api_data_handle.handle));
    }
    if (tracer_record.domain == ACTIVITY_DOMAIN_HSA_API) {
-      size_t function_name_size = 0;
-      CHECK_ROCPROFILER(rocprofiler_query_hsa_tracer_api_data_info_size(
-          session_id, ROCPROFILER_HSA_FUNCTION_NAME, tracer_record.api_data_handle,
-          tracer_record.operation_id, &function_name_size));
-      if (function_name_size > 1) {
-        char* function_name_c = nullptr;
-        CHECK_ROCPROFILER(rocprofiler_query_hsa_tracer_api_data_info(
-            session_id, ROCPROFILER_HSA_FUNCTION_NAME, tracer_record.api_data_handle,
-            tracer_record.operation_id, &function_name_c));
-        if (function_name_c) function_name = std::string(function_name_c);
-      }
+      if (tracer_extra_data.function_name)
+         function_name = std::string(tracer_extra_data.function_name);
    }
    if (tracer_record.domain == ACTIVITY_DOMAIN_HIP_API) {
-      size_t function_name_size = 0;
-      CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info_size(
-          session_id, ROCPROFILER_HIP_FUNCTION_NAME, tracer_record.api_data_handle,
-          tracer_record.operation_id, &function_name_size));
-      if (function_name_size > 1) {
-        char* function_name_c = nullptr;
-        CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info(
-            session_id, ROCPROFILER_HIP_FUNCTION_NAME, tracer_record.api_data_handle,
-            tracer_record.operation_id, &function_name_c));
-        if (function_name_c) function_name = std::string(function_name_c);
-      }
-      size_t kernel_name_size = 0;
-      CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info_size(
-          session_id, ROCPROFILER_HIP_KERNEL_NAME, tracer_record.api_data_handle,
-          tracer_record.operation_id, &kernel_name_size));
-      if (kernel_name_size > 1) {
-        char* kernel_name_str = nullptr;
-        CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info(
-            session_id, ROCPROFILER_HIP_KERNEL_NAME, tracer_record.api_data_handle,
-            tracer_record.operation_id, &kernel_name_str));
-        if (kernel_name_str) {
-          kernel_name = rocmtools::cxx_demangle(std::string(kernel_name_str));
-          free(kernel_name_str);
-          // TODO: Change how this API returns a string.
-        }
-      }
+        if (tracer_extra_data.kernel_name)
+          kernel_name = rocmtools::cxx_demangle(std::string(tracer_extra_data.kernel_name));
+        if(tracer_extra_data.function_name)
+	  function_name = std::string(tracer_extra_data.function_name);
    }
    if (tracer_record.domain == ACTIVITY_DOMAIN_ROCTX) {
-      size_t roctx_message_size = 0;
-      CHECK_ROCPROFILER(rocprofiler_query_roctx_tracer_api_data_info_size(
-          session_id, ROCPROFILER_ROCTX_MESSAGE, tracer_record.api_data_handle,
-          tracer_record.operation_id, &roctx_message_size));
-      if (roctx_message_size > 1) {
-        [[maybe_unused]] char* roctx_message_str =
-            static_cast<char*>(malloc(roctx_message_size * sizeof(char)));
-        CHECK_ROCPROFILER(rocprofiler_query_roctx_tracer_api_data_info(
-            session_id, ROCPROFILER_ROCTX_MESSAGE, tracer_record.api_data_handle,
-            tracer_record.operation_id, &roctx_message_str));
-        if (roctx_message_str)
-          roctx_message = rocmtools::cxx_demangle(std::string(strdup(roctx_message_str)));
-      }
-      size_t roctx_id_size = 0;
-      CHECK_ROCPROFILER(rocprofiler_query_roctx_tracer_api_data_info_size(
-          session_id, ROCPROFILER_ROCTX_ID, tracer_record.api_data_handle,
-          tracer_record.operation_id, &roctx_id_size));
-      if (roctx_id_size > 1) {
-        [[maybe_unused]] char* roctx_id_str =
-            static_cast<char*>(malloc(roctx_id_size * sizeof(char)));
-        CHECK_ROCPROFILER(rocprofiler_query_roctx_tracer_api_data_info(
-            session_id, ROCPROFILER_ROCTX_ID, tracer_record.api_data_handle,
-            tracer_record.operation_id, &roctx_id_str));
-        if (roctx_id_str) {
-          roctx_id = std::stoll(std::string(strdup(roctx_id_str)));
-          free(roctx_id_str);
-        }
-      }
+        const char* roctx_msg = reinterpret_cast<const char*>(tracer_record.api_data_handle.handle);
+	if(roctx_msg)
+         roctx_message = rocmtools::cxx_demangle(std::string(roctx_msg));
+       roctx_id = tracer_record.operation_id.id;
    }
+    // return;
    output_file_t* output_file = get_output_file(output_type_t::TRACER, tracer_record.domain);
    *output_file << "Record(" << tracer_record.header.id.handle << "), Domain("
                 << GetDomainName(tracer_record.domain) << "),";
-    if (tracer_record.domain == ACTIVITY_DOMAIN_ROCTX && roctx_id >= 0) *output_file << " ROCTX_ID(" << roctx_id << "),";
-    if (tracer_record.domain == ACTIVITY_DOMAIN_ROCTX && roctx_message.size() > 1) *output_file << " ROCTX_Message(" << roctx_message << "),";
+    if (tracer_record.domain == ACTIVITY_DOMAIN_ROCTX && roctx_id >= 0)
+      *output_file << " ROCTX_ID(" << roctx_id << "),";
+    if (tracer_record.domain == ACTIVITY_DOMAIN_ROCTX && roctx_message.size() > 1)
+      *output_file << " ROCTX_Message(" << roctx_message << "),";
    if (function_name.size() > 1) *output_file << " Function(" << function_name << "),";
    if (kernel_name.size() > 1) *output_file << " Kernel_Name(" << kernel_name.c_str() << "),";
    if (tracer_record.domain == ACTIVITY_DOMAIN_HSA_OPS || tracer_record.domain == ACTIVITY_DOMAIN_HIP_OPS) {
@@ -304,15 +253,17 @@ class file_plugin_t {
      }
    }
    if (tracer_record.phase == ROCPROFILER_PHASE_NONE) {
-      *output_file << " Begin(" << tracer_record.timestamps.begin.value
-                   << "), End(" << tracer_record.timestamps.end.value << "),";
+      *output_file << " Begin(" << tracer_record.timestamps.begin.value << "), End("
+                   << tracer_record.timestamps.end.value << "),";
    } else {
-      if(tracer_record.phase == ROCPROFILER_PHASE_ENTER && tracer_record.domain != ACTIVITY_DOMAIN_ROCTX){
+      if (tracer_record.phase == ROCPROFILER_PHASE_ENTER &&
+          tracer_record.domain != ACTIVITY_DOMAIN_ROCTX) {
        rocprofiler_timestamp_t timestamp;
        rocprofiler_get_timestamp(&timestamp);
        *output_file << " Begin(" << timestamp.value << "),";
      }
-      if(tracer_record.phase == ROCPROFILER_PHASE_ENTER && tracer_record.domain == ACTIVITY_DOMAIN_ROCTX) {
+      if (tracer_record.phase == ROCPROFILER_PHASE_ENTER &&
+          tracer_record.domain == ACTIVITY_DOMAIN_ROCTX) {
        rocprofiler_timestamp_t timestamp;
        rocprofiler_get_timestamp(&timestamp);
        *output_file << " timestamp(" << timestamp.value << "),";
@@ -418,7 +369,6 @@ class file_plugin_t {
                 << "pc-sample(" << std::hex << std::showbase << sample.pc << "), "
                 << "se(" << sample.se << ')' << std::endl;
  }
-
  int WriteBufferRecords(const rocprofiler_record_header_t* begin,
                         const rocprofiler_record_header_t* end,
                         rocprofiler_session_id_t session_id, rocprofiler_buffer_id_t buffer_id) {
@@ -432,9 +382,11 @@ class file_plugin_t {
          break;
        }
        case ROCPROFILER_TRACER_RECORD: {
+          rocprofiler_plugin_tracer_extra_data_t tracer_extra_data;
+	  tracer_extra_data.function_name = nullptr;
          rocprofiler_record_tracer_t* tracer_record = const_cast<rocprofiler_record_tracer_t*>(
              reinterpret_cast<const rocprofiler_record_tracer_t*>(begin));
-          FlushTracerRecord(*tracer_record, session_id, buffer_id);
+          FlushTracerRecord(*tracer_record, session_id, tracer_extra_data, buffer_id);
          break;
        }
        case ROCPROFILER_ATT_TRACER_RECORD: {
@@ -454,16 +406,16 @@ class file_plugin_t {
    return 0;
  }

-  bool is_valid() const { return valid_; }
+    bool is_valid() const { return valid_; }

- private:
-  bool valid_{false};
+   private:
+    bool valid_{false};

-  output_file_t roctx_file_{"roctx_trace.txt"}, hsa_api_file_{"hsa_api_trace.txt"},
-      hip_api_file_{"hip_api_trace.txt"}, hip_activity_file_{"hcc_ops_trace.txt"},
-      hsa_async_copy_file_{"async_copy_trace.txt"}, pc_sample_file_{"pcs_trace.txt"},
-      output_file_{"results.txt"};
-};
+    output_file_t roctx_file_{"roctx_trace.txt"}, hsa_api_file_{"hsa_api_trace.txt"},
+        hip_api_file_{"hip_api_trace.txt"}, hip_activity_file_{"hcc_ops_trace.txt"},
+        hsa_async_copy_file_{"async_copy_trace.txt"}, pc_sample_file_{"pcs_trace.txt"},
+        output_file_{"results.txt"};
+  };

 file_plugin_t* file_plugin = nullptr;

@@ -500,9 +452,9 @@ ROCPROFILER_EXPORT int rocprofiler_plugin_write_buffer_records(
 }

 ROCPROFILER_EXPORT int rocprofiler_plugin_write_record(rocprofiler_record_tracer_t record,
-                                                       rocprofiler_session_id_t session_id) {
+                                                      rocprofiler_plugin_tracer_extra_data_t tracer_extra_data){
  if (!file_plugin || !file_plugin->is_valid()) return -1;
  if (record.header.id.handle == 0) return 0;
-  file_plugin->FlushTracerRecord(record, session_id);
+  file_plugin->FlushTracerRecord(record, rocprofiler_session_id_t{0}, tracer_extra_data, rocprofiler_buffer_id_t{0});
  return 0;
 }
@@ -340,12 +340,13 @@ class perfetto_plugin_t {
    return 0;
  }

-  int FlushTracerRecord(rocprofiler_record_tracer_t tracer_record,
-                        rocprofiler_session_id_t session_id) {
+int FlushTracerRecord(rocprofiler_record_tracer_t tracer_record,
+                        rocprofiler_session_id_t session_id,
+                        rocprofiler_plugin_tracer_extra_data_t tracer_extra_data) {
    std::lock_guard<std::mutex> lock(writing_lock);
    if (!tracing_session_) rocmtools::warning("Tracing session is deleted!\n");
    std::string kernel_name;
-    char* function_name;
+    const char* function_name;
    char* activity_name;
    std::string roctx_message;
    uint64_t roctx_id = 0;
@@ -424,35 +425,11 @@ class perfetto_plugin_t {
          }
        }
        auto& roctx_track = roctx_track_it->second;
-
-        size_t roctx_message_size = 0;
-        CHECK_ROCPROFILER(rocprofiler_query_roctx_tracer_api_data_info_size(
-            session_id, ROCPROFILER_ROCTX_MESSAGE, tracer_record.api_data_handle,
-            tracer_record.operation_id, &roctx_message_size));
-        if (roctx_message_size > 1) {
-          char* roctx_message_str = nullptr;
-          CHECK_ROCPROFILER(rocprofiler_query_roctx_tracer_api_data_info(
-              session_id, ROCPROFILER_ROCTX_MESSAGE, tracer_record.api_data_handle,
-              tracer_record.operation_id, &roctx_message_str));
-          if (roctx_message_str)
-            roctx_message = rocmtools::cxx_demangle(std::string(strdup(roctx_message_str)));
-        }
-        size_t roctx_id_size = 0;
-        CHECK_ROCPROFILER(rocprofiler_query_roctx_tracer_api_data_info_size(
-            session_id, ROCPROFILER_ROCTX_ID, tracer_record.api_data_handle,
-            tracer_record.operation_id, &roctx_id_size));
-        if (roctx_id_size > 1) {
-          char* roctx_id_str = nullptr;
-          CHECK_ROCPROFILER(rocprofiler_query_roctx_tracer_api_data_info(
-              session_id, ROCPROFILER_ROCTX_ID, tracer_record.api_data_handle,
-              tracer_record.operation_id, &roctx_id_str));
-          if (roctx_id_str) {
-            roctx_id = std::stoll(std::string(strdup(roctx_id_str)));
-            free(roctx_id_str);
-          }
-        }
-
-        if(tracer_record.phase == ROCPROFILER_PHASE_NONE) {
+        roctx_id = tracer_record.operation_id.id;
+	if (reinterpret_cast<const char*>(tracer_record.api_data_handle.handle))
+          roctx_message = std::string(reinterpret_cast<const char*>(tracer_record.api_data_handle.handle));
+        
+        if (tracer_record.phase == ROCPROFILER_PHASE_NONE) {
          if (tracer_record.operation_id.id == 1) {
            perfetto::StaticString roctx_message_pft(
                (!roctx_message.empty() ? roctx_message.c_str() : ""));
@@ -465,19 +442,18 @@ class perfetto_plugin_t {
            roctx_track_entries_--;
          }
        } else {
-          rocprofiler_timestamp_t timestamp;
+        rocprofiler_timestamp_t timestamp;
          rocprofiler_get_timestamp(&timestamp);
          if (tracer_record.operation_id.id == 1) {
-          perfetto::StaticString roctx_message_pft(
-              (!roctx_message.empty() ? roctx_message.c_str() : ""));
-          TRACE_EVENT_BEGIN("ROCTX_API", roctx_message_pft, roctx_track,
-                            timestamp.value, "Timestamp(ns)",
-                            timestamp.value, "RocTx ID", roctx_id);
-          roctx_track_entries_++;
-        } else {
-          TRACE_EVENT_END("ROCTX_API", roctx_track, timestamp.value);
-          roctx_track_entries_--;
-        }
+            perfetto::StaticString roctx_message_pft(
+                (!roctx_message.empty() ? roctx_message.c_str() : ""));
+            TRACE_EVENT_BEGIN("ROCTX_API", roctx_message_pft, roctx_track, timestamp.value,
+                              "Timestamp(ns)", timestamp.value, "RocTx ID", roctx_id);
+            roctx_track_entries_++;
+          } else {
+            TRACE_EVENT_END("ROCTX_API", roctx_track, timestamp.value);
+            roctx_track_entries_--;
+          }
        }
        break;
      }
@@ -505,23 +481,15 @@ class perfetto_plugin_t {
          }
        }
        auto& hsa_track = hsa_track_it->second;
-        size_t function_name_size = 0;
-        CHECK_ROCPROFILER(rocprofiler_query_hsa_tracer_api_data_info_size(
-            session_id, ROCPROFILER_HSA_FUNCTION_NAME, tracer_record.api_data_handle,
-            tracer_record.operation_id, &function_name_size));
-        if (function_name_size > 1) {
-          function_name = nullptr;
-          CHECK_ROCPROFILER(rocprofiler_query_hsa_tracer_api_data_info(
-              session_id, ROCPROFILER_HSA_FUNCTION_NAME, tracer_record.api_data_handle,
-              tracer_record.operation_id, &function_name));
-        }
+	function_name = tracer_extra_data.function_name;
+        
        rocprofiler_timestamp_t timestamp;
        rocprofiler_get_timestamp(&timestamp);
-        if(tracer_record.phase == ROCPROFILER_PHASE_ENTER)
+        if (tracer_record.phase == ROCPROFILER_PHASE_ENTER)
          TRACE_EVENT_BEGIN("HSA_API", perfetto::StaticString(function_name), hsa_track,
-                          timestamp.value,
-                          perfetto::Flow::ProcessScoped(tracer_record.correlation_id.value));
-        if(tracer_record.phase == ROCPROFILER_PHASE_EXIT)
+                            timestamp.value,
+                            perfetto::Flow::ProcessScoped(tracer_record.correlation_id.value));
+        if (tracer_record.phase == ROCPROFILER_PHASE_EXIT)
          TRACE_EVENT_END("HSA_API", hsa_track, timestamp.value);
        break;
      }
@@ -550,34 +518,13 @@ class perfetto_plugin_t {
          }
        }
        auto& hip_track = hip_track_it->second;
-        size_t function_name_size = 0;
-        CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info_size(
-            session_id, ROCPROFILER_HIP_FUNCTION_NAME, tracer_record.api_data_handle,
-            tracer_record.operation_id, &function_name_size));
-        if (function_name_size > 1) {
-          function_name = nullptr;
-          CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info(
-              session_id, ROCPROFILER_HIP_FUNCTION_NAME, tracer_record.api_data_handle,
-              tracer_record.operation_id, &function_name));
-        }
-        size_t kernel_name_size = 0;
-        CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info_size(
-            session_id, ROCPROFILER_HIP_KERNEL_NAME, tracer_record.api_data_handle,
-            tracer_record.operation_id, &kernel_name_size));
-        char* kernel_name_str;
-        if (kernel_name_size > 1) {
-          kernel_name_str = nullptr;
-          CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info(
-              session_id, ROCPROFILER_HIP_KERNEL_NAME, tracer_record.api_data_handle,
-              tracer_record.operation_id, &kernel_name_str));
-          if (kernel_name_str) {
-            kernel_name = rocmtools::cxx_demangle(std::string(kernel_name_str));
-            free(kernel_name_str);
-          }
-        }
+        function_name = tracer_extra_data.function_name;
+        if (tracer_extra_data.kernel_name != nullptr)
+            kernel_name = std::string(tracer_extra_data.kernel_name);
+        
        rocprofiler_timestamp_t timestamp;
        rocprofiler_get_timestamp(&timestamp);
-        if(tracer_record.phase == ROCPROFILER_PHASE_ENTER) {
+        if (tracer_record.phase == ROCPROFILER_PHASE_ENTER) {
          if (kernel_name.size() > 0) {
            TRACE_EVENT_BEGIN("HIP_API", perfetto::StaticString(function_name), hip_track,
                              timestamp.value, "Kernel Name", kernel_name,
@@ -588,10 +535,10 @@ class perfetto_plugin_t {
                              perfetto::Flow::ProcessScoped(tracer_record.correlation_id.value));
          }
        }
-        if(tracer_record.phase == ROCPROFILER_PHASE_EXIT) {
+        if (tracer_record.phase == ROCPROFILER_PHASE_EXIT) {
          TRACE_EVENT_END("HIP_API", hip_track, timestamp.value);
        }
-        if(tracer_record.phase == ROCPROFILER_PHASE_NONE) {
+        if (tracer_record.phase == ROCPROFILER_PHASE_NONE) {
          if (kernel_name.size() > 0) {
            TRACE_EVENT_BEGIN("HIP_API", perfetto::StaticString(function_name), hip_track,
                              tracer_record.timestamps.begin.value, "Kernel Name", kernel_name,
@@ -616,13 +563,14 @@ class perfetto_plugin_t {
        // size_t stream_id_str_size = 0;
        // char* stream_id_str;
        // CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info_size(
-        //     session_id, ROCPROFILER_HIP_STREAM_ID, rocprofiler_tracer_api_data_handle_t{nullptr, 0},
-        //     rocprofiler_tracer_operation_id_t{(uint32_t)tracer_record.correlation_id.value},
+        //     session_id, ROCPROFILER_HIP_STREAM_ID, rocprofiler_tracer_api_data_handle_t{nullptr,
+        //     0}, rocprofiler_tracer_operation_id_t{(uint32_t)tracer_record.correlation_id.value},
        //     &stream_id_str_size));
        // if (stream_id_str_size > 1) {
        //   stream_id_str = static_cast<char*>(malloc(stream_id_str_size * sizeof(char)));
        //   CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info(
-        //       session_id, ROCPROFILER_HIP_STREAM_ID, rocprofiler_tracer_api_data_handle_t{nullptr, 0},
+        //       session_id, ROCPROFILER_HIP_STREAM_ID,
+        //       rocprofiler_tracer_api_data_handle_t{nullptr, 0},
        //       rocprofiler_tracer_operation_id_t{(uint32_t)tracer_record.correlation_id.value},
        //       &stream_id_str));
        //   if (stream_id_str != nullptr) stream_id = std::stoll(stream_id_str);
@@ -671,20 +619,20 @@ class perfetto_plugin_t {
          } else {
            activity_name = const_cast<char*>(std::string("N/A").c_str());
          }
-          if(tracer_record.phase == ROCPROFILER_PHASE_NONE)
+          if (tracer_record.phase == ROCPROFILER_PHASE_NONE)
            TRACE_EVENT_BEGIN("HIP_OPS", perfetto::StaticString(activity_name), stream_track,
-                            tracer_record.timestamps.begin.value, "Agent ID",
-                            tracer_record.agent_id.handle, "Process ID", GetPid(),
-                            perfetto::Flow::ProcessScoped(tracer_record.correlation_id.value));
-          else if(tracer_record.phase == ROCPROFILER_PHASE_ENTER)
+                              tracer_record.timestamps.begin.value, "Agent ID",
+                              tracer_record.agent_id.handle, "Process ID", GetPid(),
+                              perfetto::Flow::ProcessScoped(tracer_record.correlation_id.value));
+          else if (tracer_record.phase == ROCPROFILER_PHASE_ENTER)
            TRACE_EVENT_BEGIN("HIP_OPS", perfetto::StaticString(activity_name), stream_track,
-                            timestamp.value, "Agent ID",
-                            tracer_record.agent_id.handle, "Process ID", GetPid(),
-                            perfetto::Flow::ProcessScoped(tracer_record.correlation_id.value));
+                              timestamp.value, "Agent ID", tracer_record.agent_id.handle,
+                              "Process ID", GetPid(),
+                              perfetto::Flow::ProcessScoped(tracer_record.correlation_id.value));
        }
-        if(tracer_record.phase == ROCPROFILER_PHASE_NONE)
+        if (tracer_record.phase == ROCPROFILER_PHASE_NONE)
          TRACE_EVENT_END("HIP_OPS", stream_track, tracer_record.timestamps.end.value);
-        else if(tracer_record.phase == ROCPROFILER_PHASE_EXIT)
+        else if (tracer_record.phase == ROCPROFILER_PHASE_EXIT)
          TRACE_EVENT_END("HIP_OPS", stream_track, timestamp.value);
        break;
      }
@@ -754,9 +702,11 @@ class perfetto_plugin_t {
          break;
        }
        case ROCPROFILER_TRACER_RECORD: {
+	  rocprofiler_plugin_tracer_extra_data_t tracer_extra_data;
+	  tracer_extra_data.function_name = nullptr; 
          rocprofiler_record_tracer_t* tracer_record = const_cast<rocprofiler_record_tracer_t*>(
              reinterpret_cast<const rocprofiler_record_tracer_t*>(begin));
-          FlushTracerRecord(*tracer_record, session_id);
+          FlushTracerRecord(*tracer_record, session_id, tracer_extra_data);
          break;
        }
        default:
@@ -837,10 +787,11 @@ ROCPROFILER_EXPORT int rocprofiler_plugin_write_buffer_records(const rocprofiler
  return perfetto_plugin->WriteBufferRecords(begin, end, session_id, buffer_id);
 }

-ROCPROFILER_EXPORT int rocprofiler_plugin_write_record(rocprofiler_record_tracer_t record,
-                                                   rocprofiler_session_id_t session_id) {
+ROCPROFILER_EXPORT int rocprofiler_plugin_write_record(
+    rocprofiler_record_tracer_t record, 
+    rocprofiler_plugin_tracer_extra_data_t tracer_extra_data) {
  if (!perfetto_plugin || !perfetto_plugin->IsValid()) return -1;
  if (record.header.id.handle == 0) return 0;
-  perfetto_plugin->FlushTracerRecord(record, session_id);
+  perfetto_plugin->FlushTracerRecord(record, rocprofiler_session_id_t{0}, tracer_extra_data);
  return 0;
 }