Correlation ID Retirement + misc (#527)

* Correlation ID Retirement

- include/rocprofiler-sdk/buffer_tracing.h
  - add rocprofiler_buffer_tracing_correlation_id_retirement_record_t
- include/rocprofiler-sdk/fwd.h
  - ROCPROFILER_BUFFER_TRACING_CORRELATION_ID_RETIREMENT
- lib/rocprofiler-sdk/buffer_tracing.cpp
  - kind string for correlation id retirement
- lib/rocprofiler-sdk/buffer.hpp
  - emplace returns bool
- lib/rocprofiler-sdk/registration.cpp
  - pass lib_instance to copy_table functions
- lib/rocprofiler-sdk/context/context.*
  - update correlation_id struct
    - make ref_count private
    - {get,add,sub}_ref_count() functions
      - sub_ref_count() performs correlation id retirement
    - use stack for "latest" thread-local correlation id
- lib/rocprofiler-sdk/hip/hip.*
  - migrate to new {get,add,sub}_ref_count() for correlation ids
  - return in iterate_args
  - handle table instance in copy_table
- lib/rocprofiler-sdk/hsa/hsa.*
  - migrate to new {get,add,sub}_ref_count() for correlation ids
  - return in iterate_args
  - handle table instance in copy_table
- lib/rocprofiler-sdk/marker/marker.*
  - migrate to new {get,add,sub}_ref_count() for correlation ids
  - return in iterate_args
  - handle table instance in copy_table
- lib/rocprofiler-sdk/hsa/async_copy.cpp
  - migrate to new {get,add,sub}_ref_count() for correlation ids
  - handle table instance in async_copy_init / async_copy_save
- lib/rocprofiler-sdk/hsa/queue.cpp
  - migrate to new {get,add,sub}_ref_count() for correlation ids
  - tweak to external correlation id mapping in WriteInterceptor
- tests/async-copy-tracing/validate.py
  - check retired_correlation_ids
- tests/common/serialization.hpp
  - support rocprofiler_buffer_tracing_correlation_id_retirement_record_t
- tests/kernel-tracing/validate.py
  - check retired_correlation_ids
- tests/common/CMakeLists.txt
  - perfetto external project
- tests/common/perfetto.hpp
  - perfetto categories + aliases
  - add_perfetto_annotation
  - metaprogramming helpers
- tests/tools/CMakeLists.txt
  - link to tests-perfetto
- tests/tools/json-tool.cpp
  - demangling functions
  - serialization of marker API callback args
  - reduce parallel bottleneck in tool_tracing_callback
  - support correlation id retirement
  - Multiple threads for buffers
  - Support ROCPROFILER_TOOL_CONTEXTS_EXCLUDE env variable
  - write_perfetto() function

* Update tests/rocprofv3/tracing/validate.py

- tweak test_hsa_api_trace

* Update PTL submodule

- fixes for data race during destruction of task

* Update lib/rocprofiler-sdk/buffer.*

- unique_buffer_vec_t uses std::unique_ptr instead of allocator::unique_static_ptr_t

* Reduce timeouts in counter collection samples [skip ci]

* Update tests/tools/json-tool.cpp

- tweak demangle(string_view, int*) -> demangle(string_view, int&)

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

- move sub_ref_count() to later in async_copy_handler to delay retirement slightly more

source/lib/rocprofiler-sdk/context/context.cpp

@@ -24,6 +24,7 @@
 #include <rocprofiler-sdk/fwd.h>
 #include <rocprofiler-sdk/rocprofiler.h>
 
+#include "lib/common/container/small_vector.hpp"
 #include "lib/common/container/stable_vector.hpp"
 #include "lib/common/static_object.hpp"
 #include "lib/common/synchronized.hpp"
@@ -118,10 +119,10 @@ get_correlation_id_map()
     return _v;
 }
 
-auto*&
+auto&
 get_latest_correlation_id_impl()
 {
-    static thread_local correlation_id* _v = nullptr;
+    static thread_local auto _v = common::container::small_vector<correlation_id*, 16>{};
     return _v;
 }
 
@@ -133,6 +134,53 @@ get_unique_internal_id()
 }
 }  // namespace
 
+uint32_t
+correlation_id::add_ref_count()
+{
+    return m_ref_count.fetch_add(1);
+}
+
+uint32_t
+correlation_id::sub_ref_count()
+{
+    auto _ret = m_ref_count.fetch_sub(1);
+
+    LOG_IF(FATAL, _ret == 0) << "correlation id underflow";
+
+    if(_ret == 1)
+    {
+        auto ctxs = get_active_contexts([](const context* ctx) {
+            return (ctx->buffered_tracer &&
+                    (ctx->buffered_tracer->domains(
+                        ROCPROFILER_BUFFER_TRACING_CORRELATION_ID_RETIREMENT)));
+        });
+
+        auto record = rocprofiler_buffer_tracing_correlation_id_retirement_record_t{
+            .size      = sizeof(rocprofiler_buffer_tracing_correlation_id_retirement_record_t),
+            .kind      = ROCPROFILER_BUFFER_TRACING_CORRELATION_ID_RETIREMENT,
+            .timestamp = common::timestamp_ns(),
+            .internal_correlation_id = internal};
+
+        if(!ctxs.empty())
+        {
+            for(const auto* itr : ctxs)
+            {
+                auto* _buffer = buffer::get_buffer(itr->buffered_tracer->buffer_data.at(
+                    ROCPROFILER_BUFFER_TRACING_CORRELATION_ID_RETIREMENT));
+
+                auto success = CHECK_NOTNULL(_buffer)->emplace(
+                    ROCPROFILER_BUFFER_CATEGORY_TRACING,
+                    ROCPROFILER_BUFFER_TRACING_CORRELATION_ID_RETIREMENT,
+                    record);
+
+                LOG_IF(FATAL, !success) << "failed to emplace correlation id retirement";
+            }
+        }
+    }
+
+    return _ret;
+}
+
 correlation_id*
 correlation_tracing_service::construct(uint32_t _init_ref_count)
 {
@@ -142,7 +190,7 @@ correlation_tracing_service::construct(uint32_t _init_ref_count)
     auto& ret = corr_id_map->wlock([](auto& data) -> auto& { return data.emplace_back(); });
     ret       = std::make_unique<correlation_id>(_init_ref_count, common::get_tid(), _internal_id);
 
-    get_latest_correlation_id_impl() = ret.get();
+    get_latest_correlation_id_impl().emplace_back(ret.get());
 
     return ret.get();
 }
@@ -150,13 +198,33 @@ correlation_tracing_service::construct(uint32_t _init_ref_count)
 correlation_id*
 get_latest_correlation_id()
 {
-    return get_latest_correlation_id_impl();
+    return (get_latest_correlation_id_impl().empty()) ? nullptr
+                                                      : get_latest_correlation_id_impl().back();
 }
 
-void
-pop_latest_correlation_id(const correlation_id* val)
+const correlation_id*
+pop_latest_correlation_id(correlation_id* val)
 {
-    if(get_latest_correlation_id_impl() == val) get_latest_correlation_id_impl() = nullptr;
+    if(!val)
+    {
+        LOG(ERROR) << "passed nullptr to correlation id";
+        return nullptr;
+    }
+
+    if(get_latest_correlation_id_impl().empty())
+    {
+        LOG(ERROR) << "empty thread-local correlation id stack";
+        return nullptr;
+    }
+
+    LOG_IF(ERROR, get_latest_correlation_id_impl().back() != val)
+        << "pop_latest_correlation_id is happening out of order for " << val->internal
+        << ". top of stack is " << get_latest_correlation_id_impl().back()->internal;
+
+    get_latest_correlation_id_impl().pop_back();
+
+    return (get_latest_correlation_id_impl().empty()) ? nullptr
+                                                      : get_latest_correlation_id_impl().back();
 }
 
 context_array_t&