SWDEV-403050: Multiple fixes for Memory Leaks in profiler

Change-Id: Ib720a81105af13898ff745ce0cbc2a48c1f4a980

src/core/session/profiler/profiler.cpp

@@ -50,8 +50,17 @@ uint64_t GetCounterID(std::string& counter_name) {
 
 Profiler::Profiler(rocprofiler_buffer_id_t buffer_id, rocprofiler_filter_id_t filter_id,
                    rocprofiler_session_id_t session_id)
-    : buffer_id_(buffer_id), filter_id_(filter_id), session_id_(session_id) {}
-Profiler::~Profiler() {}
+    : buffer_id_(buffer_id), filter_id_(filter_id), session_id_(session_id) {
+  sessions_pending_signals_ = new std::map<uint32_t, std::vector<pending_signal_t*>>();
+}
+Profiler::~Profiler() {
+  for (auto& [thread_id, pending_signals] : *sessions_pending_signals_) {
+    for (auto& pending_signal : pending_signals) {
+      delete pending_signal;
+    }
+  }
+  delete sessions_pending_signals_;
+}
 
 void Profiler::AddCounterName(rocprofiler_counter_id_t counter_id, std::string counter_name) {
   std::lock_guard<std::mutex> lock(counter_names_lock_);
@@ -106,39 +115,39 @@ const char* Profiler::GetCounterInfo(rocprofiler_counter_info_kind_t kind,
   return nullptr;
 }
 
-void Profiler::StartReplayPass(rocprofiler_session_id_t session_id) { warning("Not yet supported!"); }
+void Profiler::StartReplayPass(rocprofiler_session_id_t session_id) {
+  warning("Not yet supported!");
+}
 void Profiler::EndReplayPass() { warning("Not yet supported!"); }
 bool Profiler::HasActivePass() {
   warning("Not yet supported!");
   return true;
 }
 
-void Profiler::AddPendingSignals(uint32_t writer_id, uint64_t kernel_object,
-                                 const hsa_signal_t& completion_signal,
-                                 rocprofiler_session_id_t session_id, rocprofiler_buffer_id_t buffer_id,
-                                 rocmtools::profiling_context_t* context,
-                                 uint64_t session_data_count,
-                                 hsa_ven_amd_aqlprofile_profile_t* profile,
-                                 rocprofiler_kernel_properties_t kernel_properties,
-                                 uint32_t thread_id, uint64_t queue_index) {
+void Profiler::AddPendingSignals(
+    uint32_t writer_id, uint64_t kernel_object, const hsa_signal_t& completion_signal,
+    rocprofiler_session_id_t session_id, rocprofiler_buffer_id_t buffer_id,
+    rocmtools::profiling_context_t* context, uint64_t session_data_count,
+    hsa_ven_amd_aqlprofile_profile_t* profile, rocprofiler_kernel_properties_t kernel_properties,
+    uint32_t thread_id, uint64_t queue_index, uint64_t correlation_id) {
   std::lock_guard<std::mutex> lock(sessions_pending_signals_lock_);
-  if (sessions_pending_signals_.find(writer_id) == sessions_pending_signals_.end())
-    sessions_pending_signals_.emplace(writer_id, std::vector<pending_signal_t>());
-  sessions_pending_signals_.at(writer_id).emplace_back(
-      pending_signal_t{kernel_object, completion_signal, session_id_, buffer_id, context,
-                       session_data_count, profile, kernel_properties, thread_id, queue_index});
+  if (sessions_pending_signals_->find(writer_id) == sessions_pending_signals_->end())
+    sessions_pending_signals_->emplace(writer_id, std::vector<pending_signal_t*>());
+  sessions_pending_signals_->at(writer_id).emplace_back(new pending_signal_t{
+      kernel_object, completion_signal, session_id_, buffer_id, context, session_data_count,
+      profile, kernel_properties, thread_id, queue_index, correlation_id});
 }
 
-const std::vector<pending_signal_t>& Profiler::GetPendingSignals(uint32_t writer_id) {
+const std::vector<pending_signal_t*>& Profiler::GetPendingSignals(uint32_t writer_id) {
   std::lock_guard<std::mutex> lock(sessions_pending_signals_lock_);
-  assert(sessions_pending_signals_.find(writer_id) != sessions_pending_signals_.end() &&
+  assert(sessions_pending_signals_->find(writer_id) != sessions_pending_signals_->end() &&
          "writer_id is not found in the pending_signals");
-  return sessions_pending_signals_.at(writer_id);
+  return sessions_pending_signals_->at(writer_id);
 }
 
 bool Profiler::CheckPendingSignalsIsEmpty() {
   std::lock_guard<std::mutex> lock(sessions_pending_signals_lock_);
-  return sessions_pending_signals_.empty();
+  return sessions_pending_signals_->empty();
 }
 
 }  // namespace profiler

src/core/session/profiler/profiler.h

@@ -53,6 +53,7 @@ typedef struct {
   rocprofiler_kernel_properties_t kernel_properties;
   uint32_t thread_id;
   uint64_t queue_index;
+  uint64_t correlation_id;
 } pending_signal_t;
 
 namespace profiler {
@@ -71,9 +72,9 @@ class Profiler {
                            rocmtools::profiling_context_t* context, uint64_t session_data_count,
                            hsa_ven_amd_aqlprofile_profile_t* profile,
                            rocprofiler_kernel_properties_t kernel_properties, uint32_t thread_id,
-                           uint64_t queue_index);
+                           uint64_t queue_index, uint64_t correlation_id);
 
-  const std::vector<pending_signal_t>& GetPendingSignals(uint32_t writer_id);
+  const std::vector<pending_signal_t*>& GetPendingSignals(uint32_t writer_id);
   bool CheckPendingSignalsIsEmpty();
 
   void AddCounterName(rocprofiler_counter_id_t handler, std::string counter_name);
@@ -97,7 +98,7 @@ class Profiler {
   rocprofiler_session_id_t session_id_;
 
   std::mutex sessions_pending_signals_lock_;
-  std::map<uint32_t, std::vector<pending_signal_t>> sessions_pending_signals_;
+  std::map<uint32_t, std::vector<pending_signal_t*>>* sessions_pending_signals_;
 };
 
 }  // namespace profiler

src/core/session/session.cpp

@@ -41,7 +41,9 @@
 namespace rocmtools {
 
 Session::Session(rocprofiler_replay_mode_t replay_mode, rocprofiler_session_id_t session_id)
-    : session_id_(session_id), is_active_(false), replay_mode_(replay_mode) {}
+    : session_id_(session_id), is_active_(false), replay_mode_(replay_mode) {
+  buffers_ = new std::map<uint64_t, Memory::GenericBuffer*>();
+}
 
 Session::~Session() {
   while (GetCurrentActiveInterruptSignalsCount() > 0) {
@@ -63,6 +65,7 @@ Session::~Session() {
   //   std::lock_guard<std::mutex> lock(filters_lock_);
   //   buffers_.clear();
   // }
+  delete buffers_;
 }
 
 void Session::DisableTools(rocprofiler_buffer_id_t buffer_id) {
@@ -171,6 +174,8 @@ void Session::Start() {
 
 void Session::Terminate() {
   if (is_active_) {
+    while (GetCurrentActiveInterruptSignalsCount() > 0) {
+    }
     rocmtools::queue::ResetSessionID();
     std::lock_guard<std::mutex> lock(session_lock_);
     if (FindFilterWithKind(ROCPROFILER_SPM_COLLECTION)) {
@@ -204,6 +209,11 @@ void Session::Terminate() {
       }
     }
 
+    for (auto& buffer : *buffers_) {
+      buffer.second->Flush();
+      delete buffer.second;
+    }
+
     is_active_ = false;
   }
 }
@@ -289,7 +299,7 @@ rocprofiler_filter_id_t Session::GetFilterIdWithKind(rocprofiler_filter_kind_t k
   return rocprofiler_filter_id_t{0};
 }
 
-bool Session::HasBuffer() { return buffers_.size() > 0; }
+bool Session::HasBuffer() { return buffers_->size() > 0; }
 
 rocprofiler_buffer_id_t Session::CreateBuffer(rocprofiler_buffer_callback_t buffer_callback,
                                               size_t buffer_size) {
@@ -297,8 +307,8 @@ rocprofiler_buffer_id_t Session::CreateBuffer(rocprofiler_buffer_callback_t buff
       rocprofiler_buffer_id_t{buffers_counter_.fetch_add(1, std::memory_order_release)};
   {
     std::lock_guard<std::mutex> lock(buffers_lock_);
-    buffers_.emplace(id.value,
-                     new Memory::GenericBuffer(session_id_, id, buffer_size, buffer_callback));
+    buffers_->emplace(id.value,
+                      new Memory::GenericBuffer(session_id_, id, buffer_size, buffer_callback));
   }
   return id;
 }
@@ -306,7 +316,7 @@ rocprofiler_buffer_id_t Session::CreateBuffer(rocprofiler_buffer_callback_t buff
 bool Session::FindBuffer(rocprofiler_buffer_id_t buffer_id) {
   {
     std::lock_guard<std::mutex> lock(buffers_lock_);
-    return buffers_.find(buffer_id.value) != buffers_.end();
+    return buffers_->find(buffer_id.value) != buffers_->end();
   }
 }
 
@@ -316,8 +326,8 @@ void Session::DestroyTracer() { /* tracer_.reset(); */
 void Session::DestroyBuffer(rocprofiler_buffer_id_t buffer_id) {
   {
     std::lock_guard<std::mutex> lock(filters_lock_);
-    delete buffers_.at(buffer_id.value);
-    buffers_.erase(buffer_id.value);
+    delete buffers_->at(buffer_id.value);
+    buffers_->erase(buffer_id.value);
     // if (buffers_.find(buffer_id.value) != buffers_.end() &&
     // buffers_.at(buffer_id.value)->IsValid())
     //   buffers_.at(buffer_id.value).reset();
@@ -347,7 +357,7 @@ rocprofiler_status_t Session::stopSpm() {
 Memory::GenericBuffer* Session::GetBuffer(rocprofiler_buffer_id_t buffer_id) {
   {
     std::lock_guard<std::mutex> lock(buffers_lock_);
-    return buffers_.at(buffer_id.value);
+    return buffers_->at(buffer_id.value);
   }
 }
 

src/core/session/session.h

@@ -124,7 +124,7 @@ class Session {
 
   std::atomic<uint64_t> buffers_counter_{1};
   std::mutex buffers_lock_;
-  std::map<uint64_t, Memory::GenericBuffer*> buffers_;
+  std::map<uint64_t, Memory::GenericBuffer*>* buffers_;
   std::atomic<uint64_t> records_counter_{1};