Reduced overhead of codeobj track

Change-Id: If2b2c1fd110793b92964a55e5dcb4c449eaed4a2

src/core/isa_capture/code_object_track.cpp

@@ -44,19 +44,22 @@
 #include "src/core/isa_capture/code_object_track.hpp"
 #include <amd_comgr/amd_comgr.h>
 
-std::mutex codeobj_capture_instance::mutex;
 std::mutex codeobj_record::mutex;
 
-std::unordered_map<uint64_t, CodeobjPtr> codeobj_capture_instance::codeobjs{};
+std::unordered_map<uint64_t, CodeobjPtr> codeobj_record::codeobjs{};
 std::unordered_map<uint64_t, codeobj_record::RecordInstance> codeobj_record::record_id_map{};
 std::unordered_set<codeobj_record*> codeobj_record::listeners;
 
 // Codeobj Record
 codeobj_record::codeobj_record(rocprofiler_codeobj_capture_mode_t mode) : capture_mode(mode){};
 
+static uint64_t timestamp() {
+  return rocprofiler::ROCProfiler_Singleton::GetInstance().timestamp_ns().value;
+}
+
 void codeobj_record::start_capture() {
   listeners.insert(this);
-  for (auto& [addr, capture] : codeobj_capture_instance::codeobjs) this->addcapture(capture);
+  for (auto& [addr, capture] : codeobjs) this->addcapture(capture);
 }
 
 void codeobj_record::addcapture(CodeobjPtr& capture) {
@@ -66,29 +69,25 @@ void codeobj_record::addcapture(CodeobjPtr& capture) {
 }
 
 void codeobj_record::stop_capture() {
-  try {
-    listeners.erase(this);
-  } catch (...) {
-  };
+  listeners.erase(this);
 }
 
 // Codeobj Capture
 void codeobj_capture_instance::Load(uint64_t addr, const std::string& URI, uint64_t mem_addr,
-                                    uint64_t mem_size) {
-  std::lock_guard<std::mutex> lock(mutex);
-  codeobjs[addr] = std::make_shared<codeobj_capture_instance>(
-      addr, URI, mem_addr, mem_size, rocprofiler::ROCProfiler_Singleton::GetInstance().timestamp_ns().value);
-  std::atomic_thread_fence(std::memory_order_release);  // Fencing the state of the map
-  {
-    std::lock_guard<std::mutex> lock(codeobj_record::mutex);
-    for (auto* listen : codeobj_record::listeners) listen->addcapture(codeobjs.at(addr));
-  }
+                                    uint64_t size) {
+  std::lock_guard<std::mutex> lock(codeobj_record::mutex);
+  auto inst = std::make_shared<codeobj_capture_instance>(addr, URI, mem_addr, size, timestamp());
+  codeobj_record::codeobjs[addr] = inst;
+  for (auto* listen : codeobj_record::listeners) listen->addcapture(inst);
 }
 
 void codeobj_capture_instance::Unload(uint64_t addr) {
-  std::lock_guard<std::mutex> lock(mutex);
-  codeobjs.at(addr)->end_time = rocprofiler::ROCProfiler_Singleton::GetInstance().timestamp_ns().value;
-  codeobjs.erase(addr);
+  std::lock_guard<std::mutex> lock(codeobj_record::mutex);
+
+  if (codeobj_record::codeobjs.find(addr) == codeobj_record::codeobjs.end()) return;
+
+  codeobj_record::codeobjs.at(addr)->end_time = timestamp();
+  codeobj_record::codeobjs.erase(addr);
 }
 
 void codeobj_capture_instance::copyCodeobjFromFile(uint64_t offset, uint64_t size,
@@ -184,38 +183,32 @@ std::pair<size_t, size_t> codeobj_capture_instance::parse_uri() {
 codeobj_capture_instance::codeobj_capture_instance(uint64_t _addr, const std::string& _uri,
                                                    uint64_t mem_addr, uint64_t mem_size,
                                                    uint64_t start_time)
-    : addr(_addr), start_time(start_time), URI(_uri), mem_addr(mem_addr), mem_size(mem_size) {
-  reset(ROCPROFILER_CAPTURE_SYMBOLS_ONLY);
-};
+    : addr(_addr), start_time(start_time), URI(_uri), mem_addr(mem_addr), mem_size(mem_size) {};
 
 void codeobj_capture_instance::setmode(rocprofiler_codeobj_capture_mode_t mode) {
   // Only reset when needed & check if codeobj was not unloaded
-  if (end_time == 0 && static_cast<int>(mode) > static_cast<int>(capture_mode))
-    reset(mode);
+  if (static_cast<int>(mode) > capture_mode) reset(mode);
 }
 
 void codeobj_capture_instance::reset(rocprofiler_codeobj_capture_mode_t mode) {
-  capture_mode = mode;
+  capture_mode = static_cast<int>(mode);
+  if (!buffer.empty()) return;
 
   size_t offset, size;
   try {
     std::tie(offset, size) = parse_uri();
   } catch (...) {
+    rocprofiler::warning("Error parsing URI %s", URI.c_str());
     return;
   }
-
-  buffer = std::vector<char>{};
-
-  if (mode == ROCPROFILER_CAPTURE_SYMBOLS_ONLY) return;
-
   if (protocol == "file") {
     if (mode == ROCPROFILER_CAPTURE_COPY_FILE_AND_MEMORY)
       copyCodeobjFromFile(offset, size, decoded_path);
   } else if (protocol == "memory") {
-    copyCodeobjFromMemory(mem_addr, mem_size);
+    if (mode != ROCPROFILER_CAPTURE_SYMBOLS_ONLY && end_time == 0)
+      copyCodeobjFromMemory(mem_addr, mem_size);
   } else {
     printf("\"%s\" protocol not supported\n", protocol.c_str());
-    return;
   }
 }
 
@@ -242,7 +235,7 @@ void codeobj_record::stop_capture(rocprofiler_record_id_t id) {
 }
 
 rocprofiler_codeobj_symbols_t codeobj_record::get_capture(rocprofiler_record_id_t id) {
-  std::lock_guard<std::mutex> lock(mutex);  // Fencing the state of the map
+  std::lock_guard<std::mutex> lock(mutex);
   auto& pair = record_id_map.at(id.handle);
   return pair.second->get(pair.first);
 }

src/core/isa_capture/code_object_track.hpp

@@ -50,8 +50,6 @@ class codeobj_capture_instance {
   static void Load(uint64_t addr, const std::string& URI, uint64_t mem_addr, uint64_t mem_size);
   static void Unload(uint64_t addr);
 
-  static std::unordered_map<uint64_t, std::shared_ptr<codeobj_capture_instance>> codeobjs;
-
  private:
   void reset(rocprofiler_codeobj_capture_mode_t mode);
 
@@ -68,10 +66,7 @@ class codeobj_capture_instance {
   uint64_t mem_addr;
   uint64_t mem_size;
   uint64_t end_time = 0;
-  rocprofiler_codeobj_capture_mode_t capture_mode;
-
-  // Address -> codeobj
-  static std::mutex mutex;
+  int capture_mode = -1;
 };
 
 typedef std::shared_ptr<codeobj_capture_instance> CodeobjPtr;
@@ -112,6 +107,7 @@ class codeobj_record {
 
   static std::unordered_set<codeobj_record*> listeners;
   static std::mutex mutex;
+  static std::unordered_map<uint64_t, CodeobjPtr> codeobjs;
 
  private:
   rocprofiler_codeobj_symbols_t get(uint64_t userdata) {