Multiple python versions (#42)

* Support multiple Python versions in single build

* RPATH + Split up config into config and runtime

* pybind11 submodule

* Docker build updates

source/lib/CMakeLists.txt

@@ -8,6 +8,19 @@
 #
 # ----------------------------------------------------------------------------- #
 
+string(REPLACE ":" ";" _INSTALL_RPATH "${CMAKE_INSTALL_RPATH}")
+if(_INSTALL_RPATH)
+    list(REMOVE_DUPLICATES _INSTALL_RPATH)
+endif()
+string(REPLACE ";" ":" _INSTALL_RPATH "${_INSTALL_RPATH}")
+string(
+    REPLACE
+        "::"
+        ":"
+        OMNITRACE_LIB_INSTALL_RPATH
+        "\$ORIGIN:\$ORIGIN/omnitrace:\$ORIGIN/timemory/libunwind:\$ORIGIN/dyninst-tpls/libs:${_INSTALL_RPATH}"
+    )
+
 add_subdirectory(common)
 add_subdirectory(omnitrace)
 add_subdirectory(omnitrace-dl)

source/lib/omnitrace/CMakeLists.txt

@@ -59,6 +59,7 @@ set(library_sources
     ${CMAKE_CURRENT_LIST_DIR}/src/library/ompt.cpp
     ${CMAKE_CURRENT_LIST_DIR}/src/library/perfetto.cpp
     ${CMAKE_CURRENT_LIST_DIR}/src/library/ptl.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/library/runtime.cpp
     ${CMAKE_CURRENT_LIST_DIR}/src/library/sampling.cpp
     ${CMAKE_CURRENT_LIST_DIR}/src/library/state.cpp
     ${CMAKE_CURRENT_LIST_DIR}/src/library/thread_data.cpp
@@ -84,6 +85,7 @@ set(library_headers
     ${CMAKE_CURRENT_LIST_DIR}/include/library/ompt.hpp
     ${CMAKE_CURRENT_LIST_DIR}/include/library/perfetto.hpp
     ${CMAKE_CURRENT_LIST_DIR}/include/library/ptl.hpp
+    ${CMAKE_CURRENT_LIST_DIR}/include/library/runtime.hpp
     ${CMAKE_CURRENT_LIST_DIR}/include/library/sampling.hpp
     ${CMAKE_CURRENT_LIST_DIR}/include/library/state.hpp
     ${CMAKE_CURRENT_LIST_DIR}/include/library/thread_data.hpp
@@ -139,8 +141,7 @@ set_target_properties(
     PROPERTIES OUTPUT_NAME omnitrace
                VERSION ${PROJECT_VERSION}
                SOVERSION ${PROJECT_VERSION_MAJOR}
-               INSTALL_RPATH
-               "\$ORIGIN:\$ORIGIN/timemory/libunwind:\$ORIGIN/dyninst-tpls/libs")
+               INSTALL_RPATH "${OMNITRACE_LIB_INSTALL_RPATH}")
 
 omnitrace_strip_target(omnitrace-library)
 

source/lib/omnitrace/include/library/config.hpp

@@ -24,10 +24,6 @@
 
 #include "library/api.hpp"
 #include "library/common.hpp"
-#include "library/components/fork_gotcha.hpp"
-#include "library/components/mpi_gotcha.hpp"
-#include "library/components/pthread_gotcha.hpp"
-#include "library/components/roctracer.hpp"
 #include "library/defines.hpp"
 #include "library/state.hpp"
 #include "library/timemory.hpp"
@@ -41,38 +37,13 @@
 
 namespace omnitrace
 {
-// bundle of components around omnitrace_init and omnitrace_finalize
-using main_bundle_t =
-    tim::lightweight_tuple<comp::wall_clock, comp::peak_rss, comp::cpu_clock,
-                           comp::cpu_util, pthread_gotcha_t>;
-
-using gotcha_bundle_t = tim::lightweight_tuple<fork_gotcha_t, mpi_gotcha_t>;
-
-// bundle of components used in instrumentation
-using instrumentation_bundle_t =
-    tim::component_bundle<api::omnitrace, comp::wall_clock*, comp::user_global_bundle*>;
-
-// allocator for instrumentation_bundle_t
-using bundle_allocator_t = tim::data::ring_buffer_allocator<instrumentation_bundle_t>;
-
-// bundle of components around each thread
-#if defined(TIMEMORY_RUSAGE_THREAD) && TIMEMORY_RUSAGE_THREAD > 0
-using omnitrace_thread_bundle_t =
-    tim::lightweight_tuple<comp::wall_clock, comp::thread_cpu_clock,
-                           comp::thread_cpu_util, comp::peak_rss>;
-#else
-using omnitrace_thread_bundle_t =
-    tim::lightweight_tuple<comp::wall_clock, comp::thread_cpu_clock,
-                           comp::thread_cpu_util>;
-#endif
-
 //
 //      Initialization routines
 //
 inline namespace config
 {
 void
-configure_settings();
+configure_settings(bool _init = true);
 
 void
 print_banner(std::ostream& _os = std::cout);
@@ -253,30 +224,4 @@ get_state();
 
 /// returns old state
 State set_state(State);
-
-std::unique_ptr<main_bundle_t>&
-get_main_bundle();
-
-std::unique_ptr<gotcha_bundle_t>&
-get_gotcha_bundle();
-
-std::atomic<uint64_t>&
-get_cpu_cid();
-
-std::unique_ptr<std::vector<uint64_t>>&
-get_cpu_cid_stack(int64_t _tid = threading::get_id(), int64_t _parent = 0);
-
-using cpu_cid_data_t       = std::tuple<uint64_t, uint64_t, uint16_t>;
-using cpu_cid_pair_t       = std::tuple<uint64_t, uint16_t>;
-using cpu_cid_parent_map_t = std::unordered_map<uint64_t, cpu_cid_pair_t>;
-
-std::unique_ptr<cpu_cid_parent_map_t>&
-get_cpu_cid_parents(int64_t _tid = threading::get_id());
-
-cpu_cid_data_t
-create_cpu_cid_entry(int64_t _tid = threading::get_id());
-
-cpu_cid_pair_t
-get_cpu_cid_entry(uint64_t _cid, int64_t _tid = threading::get_id());
-
 }  // namespace omnitrace

source/lib/omnitrace/include/library/runtime.hpp

@@ -0,0 +1,94 @@
+// MIT License
+//
+// Copyright (c) 2022 Advanced Micro Devices, Inc. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include "library/api.hpp"
+#include "library/common.hpp"
+#include "library/components/fork_gotcha.hpp"
+#include "library/components/mpi_gotcha.hpp"
+#include "library/components/pthread_gotcha.hpp"
+#include "library/components/roctracer.hpp"
+#include "library/defines.hpp"
+#include "library/state.hpp"
+#include "library/timemory.hpp"
+
+#include <timemory/backends/threading.hpp>
+#include <timemory/macros/language.hpp>
+
+#include <string>
+#include <string_view>
+#include <unordered_set>
+
+namespace omnitrace
+{
+// bundle of components around omnitrace_init and omnitrace_finalize
+using main_bundle_t =
+    tim::lightweight_tuple<comp::wall_clock, comp::peak_rss, comp::cpu_clock,
+                           comp::cpu_util, pthread_gotcha_t>;
+
+using gotcha_bundle_t = tim::lightweight_tuple<fork_gotcha_t, mpi_gotcha_t>;
+
+// bundle of components used in instrumentation
+using instrumentation_bundle_t =
+    tim::component_bundle<api::omnitrace, comp::wall_clock*, comp::user_global_bundle*>;
+
+// allocator for instrumentation_bundle_t
+using bundle_allocator_t = tim::data::ring_buffer_allocator<instrumentation_bundle_t>;
+
+// bundle of components around each thread
+#if defined(TIMEMORY_RUSAGE_THREAD) && TIMEMORY_RUSAGE_THREAD > 0
+using omnitrace_thread_bundle_t =
+    tim::lightweight_tuple<comp::wall_clock, comp::thread_cpu_clock,
+                           comp::thread_cpu_util, comp::peak_rss>;
+#else
+using omnitrace_thread_bundle_t =
+    tim::lightweight_tuple<comp::wall_clock, comp::thread_cpu_clock,
+                           comp::thread_cpu_util>;
+#endif
+
+std::unique_ptr<main_bundle_t>&
+get_main_bundle();
+
+std::unique_ptr<gotcha_bundle_t>&
+get_gotcha_bundle();
+
+std::atomic<uint64_t>&
+get_cpu_cid();
+
+std::unique_ptr<std::vector<uint64_t>>&
+get_cpu_cid_stack(int64_t _tid = threading::get_id(), int64_t _parent = 0);
+
+using cpu_cid_data_t       = std::tuple<uint64_t, uint64_t, uint16_t>;
+using cpu_cid_pair_t       = std::tuple<uint64_t, uint16_t>;
+using cpu_cid_parent_map_t = std::unordered_map<uint64_t, cpu_cid_pair_t>;
+
+std::unique_ptr<cpu_cid_parent_map_t>&
+get_cpu_cid_parents(int64_t _tid = threading::get_id());
+
+cpu_cid_data_t
+create_cpu_cid_entry(int64_t _tid = threading::get_id());
+
+cpu_cid_pair_t
+get_cpu_cid_entry(uint64_t _cid, int64_t _tid = threading::get_id());
+
+}  // namespace omnitrace

source/lib/omnitrace/include/library/thread_data.hpp

@@ -22,8 +22,8 @@
 
 #pragma once
 
-#include "library/config.hpp"
 #include "library/defines.hpp"
+#include "library/runtime.hpp"
 
 #include <array>
 #include <cstdint>

source/lib/omnitrace/src/library/config.cpp

@@ -21,10 +21,8 @@
 // SOFTWARE.
 
 #include "library/config.hpp"
-#include "library/api.hpp"
 #include "library/debug.hpp"
 #include "library/defines.hpp"
-#include "library/thread_data.hpp"
 
 #include <timemory/backends/dmp.hpp>
 #include <timemory/backends/mpi.hpp>
@@ -87,7 +85,7 @@ get_setting_name(std::string _v)
 inline namespace config
 {
 void
-configure_settings()
+configure_settings(bool _init)
 {
     static bool _once = false;
     if(_once) return;
@@ -372,9 +370,12 @@ configure_settings()
     }
     if(!_found_sep && _cmd.size() > 1) _cmd.insert(_cmd.begin() + 1, "--");
 
-    using argparser_t = tim::argparse::argument_parser;
-    argparser_t _parser{ _exe };
-    tim::timemory_init(_cmd, _parser, "omnitrace-");
+    if(_init)
+    {
+        using argparser_t = tim::argparse::argument_parser;
+        argparser_t _parser{ _exe };
+        tim::timemory_init(_cmd, _parser, "omnitrace-");
+    }
 
     settings::suppress_parsing()  = true;
     settings::suppress_config()   = true;
@@ -1040,98 +1041,4 @@ set_state(State _n)
     get_state() = _n;
     return _o;
 }
-
-std::atomic<uint64_t>&
-get_cpu_cid()
-{
-    static std::atomic<uint64_t> _v{ 0 };
-    return _v;
-}
-
-std::unique_ptr<std::vector<uint64_t>>&
-get_cpu_cid_stack(int64_t _tid, int64_t _parent)
-{
-    struct omnitrace_cpu_cid_stack
-    {};
-    using thread_data_t = thread_data<std::vector<uint64_t>, omnitrace_cpu_cid_stack>;
-    static auto&             _v      = thread_data_t::instances();
-    static thread_local auto _v_copy = [_tid, _parent]() {
-        auto _parent_tid = _parent;
-        // if tid != parent and there is not a valid pointer for the provided parent
-        // thread id set it to zero since that will always be valid
-        if(_tid != _parent_tid && !_v.at(_parent_tid)) _parent_tid = 0;
-        // copy over the thread ids from the parent if tid != parent
-        thread_data_t::construct((_tid != _parent_tid) ? *(_v.at(_parent_tid))
-                                                       : std::vector<uint64_t>{});
-        return true;
-    }();
-    return _v.at(_tid);
-    (void) _v_copy;
-}
-
-std::unique_ptr<cpu_cid_parent_map_t>&
-get_cpu_cid_parents(int64_t _tid)
-{
-    struct omnitrace_cpu_cid_stack
-    {};
-    using thread_data_t = thread_data<cpu_cid_parent_map_t, omnitrace_cpu_cid_stack>;
-    static auto& _v     = thread_data_t::instances(thread_data_t::construct_on_init{},
-                                               cpu_cid_parent_map_t{});
-    return _v.at(_tid);
-}
-
-std::tuple<uint64_t, uint64_t, uint16_t>
-create_cpu_cid_entry(int64_t _tid)
-{
-    auto&& _cid        = get_cpu_cid()++;
-    auto&& _parent_cid = (get_cpu_cid_stack(_tid)->empty()) ? get_cpu_cid_stack(0)->back()
-                                                            : get_cpu_cid_stack()->back();
-    uint16_t&& _depth  = (get_cpu_cid_stack(_tid)->empty())
-                             ? get_cpu_cid_stack(0)->size()
-                             : get_cpu_cid_stack()->size() - 1;
-    get_cpu_cid_parents(_tid)->emplace(_cid, std::make_tuple(_parent_cid, _depth));
-    return std::make_tuple(_cid, _parent_cid, _depth);
-}
-
-cpu_cid_pair_t
-get_cpu_cid_entry(uint64_t _cid, int64_t _tid)
-{
-    return get_cpu_cid_parents(_tid)->at(_cid);
-}
-
-namespace
-{
-void
-setup_gotchas()
-{
-    static bool _initialized = false;
-    if(_initialized) return;
-    _initialized = true;
-
-    OMNITRACE_CONDITIONAL_PRINT_F(
-        get_debug_env(),
-        "Configuring gotcha wrapper around fork, MPI_Init, and MPI_Init_thread\n");
-
-    mpi_gotcha::configure();
-    fork_gotcha::configure();
-    pthread_gotcha::configure();
-}
-}  // namespace
-
-std::unique_ptr<main_bundle_t>&
-get_main_bundle()
-{
-    static auto _v =
-        std::make_unique<main_bundle_t>("omnitrace", quirk::config<quirk::auto_start>{});
-    return _v;
-}
-
-std::unique_ptr<gotcha_bundle_t>&
-get_gotcha_bundle()
-{
-    static auto _v =
-        (setup_gotchas(), std::make_unique<gotcha_bundle_t>(
-                              "omnitrace", quirk::config<quirk::auto_start>{}));
-    return _v;
-}
 }  // namespace omnitrace

source/lib/omnitrace/src/library/runtime.cpp

@@ -0,0 +1,146 @@
+// MIT License
+//
+// Copyright (c) 2022 Advanced Micro Devices, Inc. All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "library/runtime.hpp"
+#include "library/api.hpp"
+#include "library/config.hpp"
+#include "library/debug.hpp"
+#include "library/defines.hpp"
+#include "library/thread_data.hpp"
+
+#include <timemory/backends/dmp.hpp>
+#include <timemory/backends/mpi.hpp>
+#include <timemory/backends/process.hpp>
+#include <timemory/backends/threading.hpp>
+#include <timemory/environment.hpp>
+#include <timemory/sampling/allocator.hpp>
+#include <timemory/settings.hpp>
+#include <timemory/settings/types.hpp>
+#include <timemory/utility/argparse.hpp>
+#include <timemory/utility/declaration.hpp>
+#include <timemory/utility/signals.hpp>
+
+#include <array>
+#include <csignal>
+#include <cstdint>
+#include <cstdlib>
+#include <numeric>
+#include <ostream>
+#include <string>
+#include <unistd.h>
+
+namespace omnitrace
+{
+std::atomic<uint64_t>&
+get_cpu_cid()
+{
+    static std::atomic<uint64_t> _v{ 0 };
+    return _v;
+}
+
+std::unique_ptr<std::vector<uint64_t>>&
+get_cpu_cid_stack(int64_t _tid, int64_t _parent)
+{
+    struct omnitrace_cpu_cid_stack
+    {};
+    using thread_data_t = thread_data<std::vector<uint64_t>, omnitrace_cpu_cid_stack>;
+    static auto&             _v      = thread_data_t::instances();
+    static thread_local auto _v_copy = [_tid, _parent]() {
+        auto _parent_tid = _parent;
+        // if tid != parent and there is not a valid pointer for the provided parent
+        // thread id set it to zero since that will always be valid
+        if(_tid != _parent_tid && !_v.at(_parent_tid)) _parent_tid = 0;
+        // copy over the thread ids from the parent if tid != parent
+        thread_data_t::construct((_tid != _parent_tid) ? *(_v.at(_parent_tid))
+                                                       : std::vector<uint64_t>{});
+        return true;
+    }();
+    return _v.at(_tid);
+    (void) _v_copy;
+}
+
+std::unique_ptr<cpu_cid_parent_map_t>&
+get_cpu_cid_parents(int64_t _tid)
+{
+    struct omnitrace_cpu_cid_stack
+    {};
+    using thread_data_t = thread_data<cpu_cid_parent_map_t, omnitrace_cpu_cid_stack>;
+    static auto& _v     = thread_data_t::instances(thread_data_t::construct_on_init{},
+                                               cpu_cid_parent_map_t{});
+    return _v.at(_tid);
+}
+
+std::tuple<uint64_t, uint64_t, uint16_t>
+create_cpu_cid_entry(int64_t _tid)
+{
+    auto&& _cid        = get_cpu_cid()++;
+    auto&& _parent_cid = (get_cpu_cid_stack(_tid)->empty()) ? get_cpu_cid_stack(0)->back()
+                                                            : get_cpu_cid_stack()->back();
+    uint16_t&& _depth  = (get_cpu_cid_stack(_tid)->empty())
+                             ? get_cpu_cid_stack(0)->size()
+                             : get_cpu_cid_stack()->size() - 1;
+    get_cpu_cid_parents(_tid)->emplace(_cid, std::make_tuple(_parent_cid, _depth));
+    return std::make_tuple(_cid, _parent_cid, _depth);
+}
+
+cpu_cid_pair_t
+get_cpu_cid_entry(uint64_t _cid, int64_t _tid)
+{
+    return get_cpu_cid_parents(_tid)->at(_cid);
+}
+
+namespace
+{
+void
+setup_gotchas()
+{
+    static bool _initialized = false;
+    if(_initialized) return;
+    _initialized = true;
+
+    OMNITRACE_CONDITIONAL_PRINT_F(
+        get_debug_env(),
+        "Configuring gotcha wrapper around fork, MPI_Init, and MPI_Init_thread\n");
+
+    mpi_gotcha::configure();
+    fork_gotcha::configure();
+    pthread_gotcha::configure();
+}
+}  // namespace
+
+std::unique_ptr<main_bundle_t>&
+get_main_bundle()
+{
+    static auto _v =
+        std::make_unique<main_bundle_t>("omnitrace", quirk::config<quirk::auto_start>{});
+    return _v;
+}
+
+std::unique_ptr<gotcha_bundle_t>&
+get_gotcha_bundle()
+{
+    static auto _v =
+        (setup_gotchas(), std::make_unique<gotcha_bundle_t>(
+                              "omnitrace", quirk::config<quirk::auto_start>{}));
+    return _v;
+}
+}  // namespace omnitrace