rocprofiler library unit tests (#81)

* Update CI and linting workflows

- delete linting workflow
- compile default CI job with clang-tidy
- split out code coverage matrix entry to separate job
- code coverage job runs code coverage 3x
  - once for total code coverage
  - once for unittests code coverage
  - once for samples code coverage

* Update PTL submodule

- improves handling of when thread pool is destroyed in atexit handler

* Update lib/rocprofiler/buffer

- buffer::instance::get_internal_buffer()
- allocate_buffer invokes internal_threading::initialize() on first entry
- update flush routine
 - if wait is false, does not wait for task group to finish syncing
 - checks for callback pointer

* Update lib/rocprofiler/internal_threading

- modifications to handle destruction of statics before atexit handler is invoked

* Update lib/rocprofiler/registration.cpp

- reorder atexit call in initialize()
- protect finalize from executing more than once

* Add unittests for rocprofiler buffer

* Update CI workflow

- disable fail-fast for sanitizers
- move AddressSanitizer job to top of the list

* Update lib/rocprofiler/tests/buffer/CMakeLists.txt

- do not set memcheck LD_PRELOAD for rocprofiler-lib-buffer-tests

* Update lib/rocprofiler/registration.{hpp,cpp}

- only invoke client finalizers if initialized
- remove invoke_client_initializer
- move invoke_client functions to anonymous namespace (no declaration in header)
- set fini status in finalize

* Update scripts/thread-sanitizer-suppr.txt

- suppress false positive for double mutex lock in external/ptl/source/PTL/TaskGroup.hh

* Restructure lib/rocprofiler/tests

* Update lib/common

- add utility.cpp
- move read_command_line to utility.{hpp,cpp}
  - was formerly in config.cpp

* Update lib/rocprofiler

- checks for init status return configuration locked if status is not greater than -1
  - in other words, this prevents calling these functions directly (which was possible when check was for greater than 0

* Update lib/rocprofiler/context/context.{hpp,cpp}

- provide deactivate_client_contexts and deregister_client_contexts
  - these functions are used when the tool fails to configure

* Update lib/rocprofiler/registration.{hpp,cpp}

- internal "public" get_client_offet()
- client ids are offset by a random value to avoid default values behaving correctly

* Update lib/rocprofiler/tests

- fix rocprofiler_lib.registration_lambda_no_result

* Update lib/rocprofiler/tests

- fix rocprofiler_lib.registration_lambda_with_result

* Update lib/rocprofiler/tests

- remove deep bind from rocprofiler_lib.registration_lambda_with_result

* Update lib/rocprofiler/tests

- use RTLD_NOW when dlopen'ing in rocprofiler_lib.registration_lambda_with_result

* Update rocprofiler registration tests

- split registration tests into separate exe that links to shared library

* Formatting

* Update CI workflow

- always checkout submodules via actions/checkout

* Update lib/rocprofiler/buffer.{hpp,cpp}

- fix issue with buffer flushing not working when only called once

* Update rocprofiler lib registration test

- test for buffered callback

* Update include/rocprofiler/rocprofiler.h

- include internal_threading.h header

* Update rocprofiler lib registration test

- add in internal threading for buffered test

[ROCm/rocprofiler-sdk commit: a646c1546c]

projects/rocprofiler-sdk/source/lib/rocprofiler/buffer.hpp

@@ -22,7 +22,6 @@
 
 #pragma once
 
-#include <bits/stdint-uintn.h>
 #include <rocprofiler/buffer.h>
 #include <rocprofiler/fwd.h>
 
@@ -43,20 +42,23 @@ struct instance
 {
     using buffer_t = common::container::record_header_buffer;
 
-    mutable std::array<buffer_t, 2>     buffers       = {};
-    mutable std::atomic<unsigned short> buffer_idx    = {};
-    mutable std::atomic_flag            syncer        = ATOMIC_FLAG_INIT;
-    mutable std::atomic<uint64_t>       drop_count    = {};
-    uint64_t                            watermark     = 0;
-    uint64_t                            context_id    = 0;
-    uint64_t                            buffer_id     = 0;
-    uint64_t                            task_group_id = 0;
-    rocprofiler_buffer_tracing_cb_t     callback      = nullptr;
-    void*                               callback_data = nullptr;
-    rocprofiler_buffer_policy_t         policy        = ROCPROFILER_BUFFER_POLICY_NONE;
+    mutable std::array<buffer_t, 2> buffers       = {};
+    mutable std::atomic_flag        syncer        = ATOMIC_FLAG_INIT;
+    mutable std::atomic<uint32_t>   buffer_idx    = {};
+    mutable std::atomic<uint64_t>   drop_count    = {};
+    uint64_t                        watermark     = 0;
+    uint64_t                        context_id    = 0;
+    uint64_t                        buffer_id     = 0;
+    uint64_t                        task_group_id = 0;
+    rocprofiler_buffer_tracing_cb_t callback      = nullptr;
+    void*                           callback_data = nullptr;
+    rocprofiler_buffer_policy_t     policy        = ROCPROFILER_BUFFER_POLICY_NONE;
 
     template <typename Tp>
     void emplace(uint32_t, uint32_t, Tp&);
+
+    buffer_t& get_internal_buffer();
+    buffer_t& get_internal_buffer(size_t);
 };
 
 using unique_buffer_vec_t = common::container::stable_vector<std::unique_ptr<instance>, 4>;
@@ -67,16 +69,44 @@ allocate_buffer();
 unique_buffer_vec_t&
 get_buffers();
 
+instance*
+get_buffer(rocprofiler_buffer_id_t buffer_id);
+
+instance*
+get_buffer(uint64_t buffer_idx);
+
 rocprofiler_status_t
 flush(rocprofiler_buffer_id_t buffer_id, bool wait);
 
+rocprofiler_status_t
+flush(uint64_t buffer_idx, bool wait);
+}  // namespace buffer
+}  // namespace rocprofiler
+
+inline rocprofiler::buffer::instance::buffer_t&
+rocprofiler::buffer::instance::get_internal_buffer()
+{
+    auto idx = buffer_idx.load() % buffers.size();
+    return buffers.at(idx);
+}
+
+inline rocprofiler::buffer::instance::buffer_t&
+rocprofiler::buffer::instance::get_internal_buffer(size_t idx)
+{
+    return buffers.at(idx % buffers.size());
+}
+
+inline rocprofiler::buffer::instance*
+rocprofiler::buffer::get_buffer(uint64_t buffer_idx)
+{
+    return get_buffer(rocprofiler_buffer_id_t{buffer_idx});
+}
+
 inline rocprofiler_status_t
-flush(uint64_t buffer_idx, bool wait)
+rocprofiler::buffer::flush(uint64_t buffer_idx, bool wait)
 {
     return flush(rocprofiler_buffer_id_t{buffer_idx}, wait);
 }
-}  // namespace buffer
-}  // namespace rocprofiler
 
 template <typename Tp>
 inline void
@@ -88,10 +118,10 @@ rocprofiler::buffer::instance::emplace(uint32_t category, uint32_t kind, Tp& val
     auto idx = get_idx();
     if(!buffers.at(idx).emplace(category, kind, value))
     {
-        if(buffers.at(idx).size() < sizeof(value))
+        if(buffers.at(idx).capacity() < sizeof(value))
         {
             auto msg = std::stringstream{};
-            msg << "buffer " << buffer_id << " to small (size=" << buffers.at(idx).size()
+            msg << "buffer " << buffer_id << " to small (size=" << buffers.at(idx).capacity()
                 << ") to hold an object of type " << common::cxx_demangle(typeid(value).name())
                 << " with size " << sizeof(value);
             throw std::runtime_error(msg.str());