Handle hsa_queue_destroy after finalization (#679)

* Handle hsa_queue_destroy after finalization

- fixes issue where hsa_queue_destroy(...) is invoked after rocprofiler-sdk has finalized
- hsa::get_queue_controller() returns pointer
- if queue controller is a null pointer, skip invoking QueueController::destroy_queue

* Update HIP/HSA/marker update_table logging

* Update rocprofv3 tests

- remove HSA_TOOLS_LIB env variable
- remove setting ROCPROFILER_LOG_LEVEL env variable
- add timeouts to tests which are missing them

* Disable thread sanitizer deadlock detection

* Update CI workflow

- rename vega20-ubuntu job to core-ci
- enable navi32 in core-ci and sanitizers

* Update run-ci.py

- set gcovr html medium and high threshold

* Update lib/rocprofiler-sdk/hsa/queue_controller.cpp

- remove this capture from enable/disable serialization

* Update lib/rocprofiler-sdk/hsa/{hsa_barrier,profile_serializer}.*

- hsa_barrier::set_barrier accepts const-ref to queue map
- profile_serializer::enable and profile_serializer::disable accept const-ref to queue map

* Logging for HIP/HSA/marker/profile_serializer

* Logging for HIP/HSA/marker/queue_controller

* Improve test_retired_correlation_ids asserts

* Fix tests/counter-collection/validate.py

- scale expected SQ_WAVES counter value based on warp size of GPU

* Tweak github comment for code coverage

* Remove gcovr html high/medium threshold args

* Fix tests/counter-collection/validate.py

- round before casting to int in test_counter_values

* operator bool for profile_serializer

- only wait on CV if profile_serializer is used

* Logging updates (profile_serializer + code_object)

* Update counter-collection validate.py

* QueueController does not wait on CV if finalizing/finalized

* Update CI workflow

- remove navi32 from core job

* Improve HIP/HSA/marker tracing get_functor/functor

- remove lambda wrapper around functor

* Update lib/rocprofiler-sdk/hsa/queue_controller.cpp

- do not acquire cvmutex lock during finalization

* Update lib/rocprofiler-sdk/hsa/hsa_barrier.*

- move ctor and dtor to implementation
- skip signal store screlease and destroy if already finalized

* Update CI workflow

- remove navi32 runners

* bwelton fixes for hangs

* CMake improvements + simplified demangle

- remove amd-comgr from common target (and thus removed from roctx DT_NEEDED)

---------

Co-authored-by: Benjamin Welton <bewelton@amd.com>

source/lib/common/demangle.cpp

@@ -22,10 +22,11 @@
 
 #include "lib/common/demangle.hpp"
 
-#include <amd_comgr/amd_comgr.h>
+#include <glog/logging.h>
 
 #include <cxxabi.h>
 #include <cstdarg>
+#include <cstdint>
 #include <cstdio>
 #include <cstring>
 #include <iomanip>
@@ -34,18 +35,6 @@
 #include <sstream>
 #include <string>
 
-#define amd_comgr_(call)                                                                           \
-    do                                                                                             \
-    {                                                                                              \
-        if(amd_comgr_status_t status = amd_comgr_##call; status != AMD_COMGR_STATUS_SUCCESS)       \
-        {                                                                                          \
-            const char* reason = "";                                                               \
-            amd_comgr_status_string(status, &reason);                                              \
-            fprintf(stderr, #call " failed: %s\n", reason);                                        \
-            abort();                                                                               \
-        }                                                                                          \
-    } while(false)
-
 namespace rocprofiler
 {
 namespace common
@@ -53,7 +42,6 @@ namespace common
 std::string
 cxa_demangle(std::string_view _mangled_name, int* _status)
 {
-    constexpr size_t buffer_len = 4096;
     // return the mangled since there is no buffer
     if(_mangled_name.empty())
     {
@@ -91,26 +79,14 @@ cxa_demangle(std::string_view _mangled_name, int* _status)
         }
         case -1:
         {
-            char _msg[buffer_len];
-            ::memset(_msg, '\0', buffer_len * sizeof(char));
-            ::snprintf(_msg,
-                       buffer_len,
-                       "memory allocation failure occurred demangling %s",
-                       _demangled_name.c_str());
-            ::perror(_msg);
+            PLOG(ERROR) << "memory allocation failure occurred demangling " << _demangled_name;
             break;
         }
         case -2: break;
         case -3:
         {
-            char _msg[buffer_len];
-            ::memset(_msg, '\0', buffer_len * sizeof(char));
-            ::snprintf(_msg,
-                       buffer_len,
-                       "Invalid argument in: (\"%s\", nullptr, nullptr, %p)",
-                       _demangled_name.c_str(),
-                       (void*) _status);
-            ::perror(_msg);
+            PLOG(ERROR) << "Invalid argument in: (\"" << _demangled_name << "\", nullptr, nullptr, "
+                        << _status << ")";
             break;
         }
         default: break;
@@ -130,27 +106,10 @@ cxx_demangle(std::string_view symbol)
 {
     int  _status       = 0;
     auto demangled_str = cxa_demangle(symbol, &_status);
-    if(_status == 0)
-    {
-        return demangled_str;
-    }
 
-    amd_comgr_data_t mangled_data;
-    amd_comgr_(create_data(AMD_COMGR_DATA_KIND_BYTES, &mangled_data));
-    amd_comgr_(set_data(mangled_data, symbol.size(), symbol.data()));
+    if(_status == 0) return demangled_str;
 
-    amd_comgr_data_t demangled_data;
-    amd_comgr_(demangle_symbol_name(mangled_data, &demangled_data));
-
-    size_t demangled_size = 0;
-    amd_comgr_(get_data(demangled_data, &demangled_size, nullptr));
-
-    demangled_str.resize(demangled_size);
-    amd_comgr_(get_data(demangled_data, &demangled_size, demangled_str.data()));
-
-    amd_comgr_(release_data(mangled_data));
-    amd_comgr_(release_data(demangled_data));
-    return demangled_str;
+    return std::string{symbol};
 }
 
 // The function extracts the kernel name from