Support for tracing mutex locking (#52)

* Parallel overhead example with locks

* Support tracing mutex locking + more

- support wrapping pthread_mutex_lock
- support wrapping pthread_mutex_unlock
- support wrapping pthread_mutex_trylock
- get_perfetto_combined_traces setting
- OMNITRACE_TRACE_THREAD_LOCKS option
- ThreadState
- critical trace includes queue id
- enabled/disabled settings in timemory
- fix OMNITRACE_TIMEMORY_COMPONENTS
- fix reading config
- fix setting categories
- applied ThreadState::Internal in various places
- utility::get_filled_array
- utility::get_reserved_vector
- utility::get_thread_index
- fork_gotcha messages about forks
- split out some pthread_gotcha functionality into pthread_create_gotcha
- handle queue id in roctracer callbacks

* Update timemory and PTL submodules

* Misc CMake updates

- Includes fix to omnitrace-static-lib{gcc,stdcxx}

* Misc cleanup to pthread_mutex_gotcha and backtrace

* Fix to duplicate field in module_function json

* Improvement to debug messages

* omnitrace-dl and common improvements

- tweak to delimit
- common::ignore message
- common::join quoting of strings
- omnitrace_set_env ignores if inited and active
- omnitrace_set_mpi ignores if inited and active

* nsync for transpose example

* Fix to thread_deleter<void> functor invoke

* Fix thread state and HIP stream enums

[ROCm/rocprofiler-systems commit: b208047741]

projects/rocprofiler-systems/source/lib/common/delimit.hpp

@@ -22,6 +22,7 @@
 
 #pragma once
 
+#include <cstring>
 #include <string>
 #include <vector>
 
@@ -31,6 +32,51 @@ inline namespace common
 {
 namespace
 {
+template <typename ContainerT, typename... Args>
+inline auto
+emplace_impl(ContainerT& _c, int, Args&&... _args)
+    -> decltype(_c.emplace_back(std::forward<Args>(_args)...))
+{
+    return _c.emplace_back(std::forward<Args>(_args)...);
+}
+
+template <typename ContainerT, typename... Args>
+inline auto
+emplace_impl(ContainerT& _c, long, Args&&... _args)
+    -> decltype(_c.emplace(std::forward<Args>(_args)...))
+{
+    return _c.emplace(std::forward<Args>(_args)...);
+}
+
+template <typename ContainerT, typename... Args>
+inline auto
+emplace(ContainerT& _c, Args&&... _args)
+{
+    return emplace_impl(_c, 0, std::forward<Args>(_args)...);
+}
+
+template <typename ContainerT, typename ArgT>
+inline auto
+reserve_impl(ContainerT& _c, int, ArgT _arg) -> decltype(_c.reserve(_arg), bool())
+{
+    _c.reserve(_arg);
+    return true;
+}
+
+template <typename ContainerT, typename ArgT>
+inline auto
+reserve_impl(ContainerT&, long, ArgT)
+{
+    return false;
+}
+
+template <typename ContainerT, typename ArgT>
+inline auto
+reserve(ContainerT& _c, ArgT _arg)
+{
+    return reserve_impl(_c, 0, _arg);
+}
+
 template <typename ContainerT = std::vector<std::string>>
 inline ContainerT
 delimit(const std::string& line, const char* delimiters = "\"',;: ");
@@ -42,6 +88,18 @@ delimit(const std::string& line, const char* delimiters)
     ContainerT _result{};
     size_t     _beginp = 0;  // position that is the beginning of the new string
     size_t     _delimp = 0;  // position of the delimiter in the string
+    if(reserve(_result, 0))
+    {
+        size_t _nmax = 0;
+        for(char itr : line)
+        {
+            for(size_t j = 0; j < strlen(delimiters); ++j)
+            {
+                if(itr == delimiters[j]) ++_nmax;
+            }
+        }
+        reserve(_result, _nmax);
+    }
     while(_beginp < line.length() && _delimp < line.length())
     {
         // find the first character (starting at _delimp) that is not a delimiter
@@ -56,7 +114,7 @@ delimit(const std::string& line, const char* delimiters)
         // between this position and the next delimiter
         _tmp = line.substr(_beginp, _delimp - _beginp);
         // don't add empty strings
-        if(!_tmp.empty()) _result.emplace(_result.end(), _tmp);
+        if(!_tmp.empty()) emplace(_result, _tmp);
     }
     return _result;
 }

projects/rocprofiler-systems/source/lib/common/invoke.hpp

@@ -60,6 +60,21 @@ get_thread_index()
     return _v;
 }
 
+template <typename... Args>
+auto
+ignore(const char* _name, int _verbose, int _value, const char* _reason, Args... _args)
+{
+    if(_verbose >= _value)
+    {
+        fflush(stderr);
+        fprintf(stderr,
+                "[omnitrace][" OMNITRACE_COMMON_LIBRARY_NAME
+                "][%li] %s(%s) was ignored :: %s\n",
+                get_thread_index(), _name, join(", ", _args...).c_str(), _reason);
+        fflush(stderr);
+    }
+}
+
 template <typename FuncT, typename... Args>
 auto
 invoke(const char* _name, int _verbose, bool& _toggle, FuncT&& _func, Args... _args)

projects/rocprofiler-systems/source/lib/common/join.hpp

@@ -22,8 +22,10 @@
 
 #pragma once
 
+#include <ios>
 #include <sstream>
 #include <string>
+#include <type_traits>
 
 #if !defined(OMNITRACE_FOLD_EXPRESSION)
 #    define OMNITRACE_FOLD_EXPRESSION(...) ((__VA_ARGS__), ...)
@@ -35,12 +37,51 @@ inline namespace common
 {
 namespace
 {
+template <typename Tp>
+struct is_string_impl : std::false_type
+{};
+
+template <>
+struct is_string_impl<std::string> : std::true_type
+{};
+
+template <>
+struct is_string_impl<std::string_view> : std::true_type
+{};
+
+template <>
+struct is_string_impl<const char*> : std::true_type
+{};
+
+template <>
+struct is_string_impl<char*> : std::true_type
+{};
+
+template <typename Tp>
+struct is_string : is_string_impl<std::remove_cv_t<std::decay_t<Tp>>>
+{};
+
+template <typename ArgT>
+auto
+as_string(ArgT&& _v, std::enable_if_t<is_string<ArgT>::value, int> = 0)
+{
+    return std::string{ "\"" } + _v + std::string{ "\"" };
+}
+
+template <typename ArgT>
+auto
+as_string(ArgT&& _v, std::enable_if_t<!is_string<ArgT>::value, long> = 0)
+{
+    return _v;
+}
+
 template <typename DelimT, typename... Args>
 auto
 join(DelimT&& _delim, Args&&... _args)
 {
     std::stringstream _ss{};
-    OMNITRACE_FOLD_EXPRESSION(_ss << _delim << _args);
+    _ss << std::boolalpha;
+    OMNITRACE_FOLD_EXPRESSION(_ss << _delim << as_string(_args));
     auto _ret = _ss.str();
     if constexpr(std::is_same<DelimT, char>::value)
     {