Causal profiling (#229)

* Addition of basic structure

* Reworked categories

* More causal integration additions

* Causal implementation

* Update examples

* delete virtual_speedup files

* Update perfetto submodule to v31.0

* Update dyninst submodule

* Update timemory submodule

* ElfUtils build for libdw

* OMNITRACE_LIKELY and OMNITRACE_UNLIKELY

* Update common lib join

* Examples updates for causal profiling

* config updates with causal options

- OMNITRACE_CAUSAL_FIXED_LINE
- OMNITRACE_CAUSAL_FIXED_SPEEDUP
- OMNITRACE_CAUSAL_FILE
- OMNITRACE_CAUSAL_BINARY_SCOPE
- OMNITRACE_CAUSAL_SOURCE_SCOPE
- version info in banner
- support increments in parse_numeric_range
- fix occasional deadlock in first call to get_config

* PTL general task group

* Always include PID in debug/verbose messages

* Add blocking/unblocking gotchas to runtime init bundle

* CausalState

* thread_data updates

- generic component_bundle_cache

* Improve handling of causal in category_region

* components updates

- backtrace_causal component
- backtrace::get_data member func
- decrease ignore_depth in backtrace::sample(int)
- handle "omnitrace_main" in backtrace::filter_and_patch(...)
- tweak internal thread state scope for pthread_mutex_gotcha wrappers

* simplify tracing get_instrumentation_bundles usage

* sampling updates

- include backtrace_causal component
- disable backtrace_metrics if using causal and not using perfetto
- disable backtrace and backtrace_timestamp when using causal
- post_process_causal

* causal updates

- more checks in blocking_gotcha and unblocking_gotcha start/stop
- miscellaneous overhaul of data
- experiment update

* Remove virtual speedup

* libomnitrace code_object

* causal-profiling test

* libomnitrace library.cpp updates

- handle causal profiling
- fini_bundle

* Disable causal profiling by default

* Updated causal code and example

- example: three execution variants: cpu + rng, cpu, rng
- example: three instrumentation variants: none, omni, coz
- fix blocking gotcha credit
- rework perform_experiment_impl
- get_eligible_address_ranges
- compute_eligible_lines
- support fixed lines/speedups/functions
- update selected_entry to support function mode
- fix causal::delay
- experiment updates

* omnitrace_progress / omnitrace_user_progress

- with accompanying omnitrace_annotated_progress / omnitrace_user_annotated_progress

* Update timemory submodule

* CausalMode

- mode indicated whether causal predictions source be at line-level or function-level

* code_object, config, runtime, sampling, thread_data

- code_object: address_range
- code_object: basic::line_info serialize(), name(), hash()
- config updates
- two signals for causal sampling
- thread_data init fixes

* pthread updates

- pthread_create_gotcha processes delays
- pthread_mutex_gotcha does not wrap pthread_join in causal mode

* backtrace_causal update

- dynamic delay period stats

* main wrapper uses basename of argv[0]

* update elfio submodule

* perf support (currently unused)

* Fix experiment JSON serialization

- static_vector.hpp (unused)

* causal executable + config options updates

- omnitrace-causal exe simplifies running multiple causal configs
- changed the causal config option names

* Support both throughput and latency points

* process-causal-json.py script

- will be used later for testing

* stable_vector

* Rework thread_data

* Improve omnitrace-causal exe

- better verbosity handling
- correct diagnosis of status for child process
- execvpe when only one iteration (debugging)

* Update timemory submodule

* exe --version

- omnitrace, omnitrace-avail, and omnitrace-sample all support --version on command-line

* OMNITRACE_INTERNAL_API + OMNITRACE_{LIKELY,UNLIKELY}

* omnitrace-causal cmake format

* omnitrace config update

- OMNITRACE_CAUSAL_FILE_CLOBBER

* custom exception

- wraps STL exception and gets stacktrace during construction

* exit_gotcha supports _Exit

* use global construct_on_init + max threads

- add some safety when exceeding max # of threads

* update code_object binary filter

- exclude dyninst and tbbmalloc library

* containers: c_array, static_vector, stable_vector

- moved utility::c_array to container::c_array
- created static_vector: std::vector bound to std::array
- created stable_vector: vector with stable references

* grow thread_data when new thread created

* causal updates

- data: improve compute_eligible_lines to ignore lambdas
- data: use new thread_data
- delay: use new thread_data
- experiment: properly support latency points
- experiment: support file clobber
- experiment: ensure non-zero experiment time
- progress_point: use new thread_data
- backtrace_causal: use new thread_data

* Update causal-profiling tests

* fix omnitrace-causal backslash escaping

* process-causal-json script

* restructure causal implementation

- update verbose messages for omnitrace-causal diagnose_status
- migrated causal implementation in sampling.cpp to causal/sampling.cpp
- OMNITRACE_USE_CAUSAL does not require OMNITRACE_USE_SAMPLING
- added Mode::Causal
- causal sampling uses same signals as regular sampling
- moved tracing::thread_init to implementation file
- combined tracing::thread_init and tracing::thread_init_sampling
- added causal/components folder
- pthread_create_gotcha::wrapper_config
- omnitrace_preload checks OMNITRACE_USE_CAUSAL
  - updates mode accordingly

* update timemory submodule

* update timemory submodule

* causal example updates

- causal for lulesh

* perf code + utility - helpers

- relocated causal perf code
- placement new when generating unique ptr trait for potentially allocating during sampling
- additions to utility header
- removed previously added helpers.hpp

* update timemory submodule

* Default env variables for omnitrace-causal

- activate OMNITRACE_USE_KOKKOSP, etc.

* update stable_vector and static_vector

- static vector can use atomic for size tracking for thread-safe situations

* update causal example header

- CAUSAL_PROGRESS_NAMED
- use CAUSAL_ prefix for some macros

* Tweak lulesh example

- use CAUSAL_PROGRESS instead of CAUSAL_BEGIN and CAUSAL_END

* omnitrace-sample support for causal mode

- set OMNITRACE_USE_SAMPLING to off when OMNITRACE_MODE=causal

* refactor and cleanup code_object

- scope filter
- fixes to address_range

* overhaul causal data + causal config options

- full support for function and line mode
- support static vector of instruction pointers
- improve line info mapping resolution
- remove thread-locality from miscellanous functions where unnecessary
- causal options for {binary,source,function,fileline} exclusion

* causal experiment, sampling, and backtrace updates

- is_selected + unwind address array
- experiment warning about progress points
- increased buffer size for backtrace_casual sampler
- backtrace_causal only stores IP addresses instead of full unwind info

* category_region updates

- minor refactor
- local_category_region::mark

* Update causal tests

* Bump version to 1.8.0

* omnitrace-causal args + CLOBBER -> RESET

- renamed OMNITRACE_CAUSAL_FILE_CLOBBER to OMNITRACE_CAUSAL_FILE_RESET
- updated omnitrace-causal exe to support recently added configuration options
- other miscellaneous tweaks to data.cpp, experiment.cpp, and sampling.cpp

* Refactor causal and code_object

- code_object.hpp and code_object.cpp moved into binary folder
- causal components namespaced into omnitrace::causal::component
- moved sample_data out of backtrace_causal and into own file
- renamed backtrace_causal to causal::component::backtrace

* preload omnitrace_init + OMNITRACE_DEBUG_MARK

- env OMNITRACE_DEBUG_MARK
- fix omnitrace_init call when LD_PRELOAD-ing omnitrace

* Fix fileline support + line-info output names + experiment log

- line-info log files are prefixed with experiment name
- don't print experiment duration when E2E
- account for fileline scope in analysis

* KokkosP: OMNITRACE_KOKKOSP_NAME_LENGTH_MAX

- config option to limit the name of kokkos tool callbacks
- remove [kokkos] from KokkosP names

* Update causal example

- minor tweaks to decrease probability of overlapping regions in binary

* omnitrace-causal update

- prefix N / Ntot in environment printout

* Miscellaneous updates

- causal::finish_experimenting()
- OMNITRACE_CAUSAL_RANDOM_SEED
- KokkosP causal updates
  - exclude some callbacks, make some callbacks unique, etc.
- address_range::operator+=(address_range)
- combine contiguous ranges in binary/analysis.cpp when file, func, line is same and address range is contiguous
- bfd_line_info reads inline info
- wait for perform_experiment_impl to complete
- causal::delay updates
  - delay::process checks if experiment is active
  - uses threading::get_id()
- experiment scales duration up for larger speedup experiments
- line info samples includes excluded lines
- sampler uses CLOCK_REALTIME
- blocking_gotcha updates
  - is no longer fully static
  - adds audit routine which sets the postblock value to zero if try/timed routine fails
- category::host was added to causal_throughput_categories_t
- pthread_create_gotcha sets new threads local parent delay
  - was using internal value, now uses sequent value

* Causal improvements to KokkosP

* Updates to experiment time scaling

- use stats instead of just max

* binary/link_map.{hpp,cpp}

* update process-causal-json.py

* Folded fileline scope into source scope

* Update documentation

- Add documentation for causal profiling
- Replace 'Omnitrace' with 'OmniTrace' everywhere

* Update causal-helpers.cmake + omnitrace-testing.cmake

- split tests/CMakeLists.txt partially into omnitrace-testing.cmake

* omnitrace/causal.h

- OMNITRACE_CAUSAL_PROGRESS
- OMNITRACE_CAUSAL_PROGRESS_NAMED
- OMNITRACE_CAUSAL_BEGIN
- OMNITRACE_CAUSAL_END

* selected_entry + remove default filters for lambdas and operator()

- selected entry stores range and binary load address

* update process-causal-json.py

* format examples/lulesh/CMakeLists.txt

* causal-helpers find_package(Threads)

* OMNITRACE_KOKKOSP_KERNEL_LOGGER

- was OMNITRACE_KOKKOS_KERNEL_LOGGER

* quiet find of coz-profiler

* Fix rocm_smi exception handling

* Update timemory submodule (binutils)

- fix binutls compile error on some systems
- bump binutils to v2.40

* Fix miscellaneous tests

* OMNITRACE_KOKKOSP_PREFIX

* revert rocm_smi handling

* ElfUtils updates

- default to download version 0.188
- add -Wno-error=null-dereference due to GCC 12 compiler error

* Update causal example

* Remove OMNITRACE_VERBOSE from global workflow envs

* Reliable causal test

* disable compilation of causal perf files

* Remove set_current_selection with unwind stack

* update timemory submodule

* fix for segfault on bionic

- locking in TLS dtor was causing segfault

* remove experiment::is_selected(unwind_stack_t)

* update default init of selected_entry

* Fix for when IP is not offset by load address

* Update CMakeLists.txt

* Miscellaneous updates

- OMNITRACE_WARNING_OR_CI_THROW
- OMNITRACE_REQUIRE
- OMNITRACE_PREFER
- fixed issues with no ASLR
-  added load address variable and ipaddr() func to basic/bfd line info
- removed get_basic() from dwarf_line_info
- TIMEMORY_PREFER -> OMNITRACE_PREFER
- removed previously added binary_address and range variables from selected_entry

* Removed superfluous CausalState

* Additional causal tests (lulesh + kokkos)

* filter, prefer, analysis ASLR handling

- removed default filter on cold functions
- fixed OMNITRACE_PREFER
- fixed analysis ASLR handling

* Tweak line-info output

* Removed some superfluous code

- causal/delay
- causal/selected_entry

* Exclude main.cold in function mode

* Update validate-perfetto-proto.py

- account for occasional http errors

* Add sampling test disabling tmp files

* argparser for process-causal-json

- support validation
- support filtering

* Avoid pthread_{lock,unlock} in sampling offload

- use homemade atomic_mutex/atomic_lock since contention will be low and using pthread tools might trigger our wrappers

* Rename process-causal-json.py

- validate-causal-json.py

* rework omnitrace_add_causal_test

- capable of performing validation
- added validation tests

* Fix kokkosp_begin_deep_copy + causal

* Tweak address range in bfd_line_info::read_pc

* Tweak analysis and data IP handling

- look for gaps

* Disable scaling experiment time by speedup

* Revert change in max threads during CI

* binary updates

- significant overhaul of binary analysis implementation
- removed "basic_line_info" and "bfd_line_info" in lieu of "symbol" class
  - symbol class has basic BFD info + vector of inlines + vector of dwarf info

* Updated causal to use new binary analysis

- Fix symbol.cpp includes

* Updated formatting target

- include *.cmake files

* Updated causal tests

- causal tests should be stable now

* Update timemory and dyninst submodules

- TPLs are stripped + built w/o debug info

* Increase tolerance for causal validation speedups

- higher speedups have more variance (increased to +/- 5 from 3)

* Support causal output for MPI

- i.e. tag with MPI rank

* omnitrace-causal launcher argument

* improve experiment sampling output

* causal data updates

- call compute lines once
- fixed filtered cached binary info
- debugging info when experiment fails to start

* Tweaked causal validation tests

* dwarf_entry ranges

* CI updates

- increase max threads to 64

* Tweak causal E2E validation tests

- more threads
- shorter thread runtime
- more iterations

* Fix shadowed variable

* fix symbol read_bfd last PC calculation

* fix maybe-uninitialized warning

* omnitrace-causal launcher update

- only inject "omnitrace-causal --" once
- throw error if no matches found

* Update causal profiling docs for launcher

* fix address range boundaries

source/lib/omnitrace/library/sampling.cpp

@@ -28,6 +28,7 @@
 #include "library/components/fwd.hpp"
 #include "library/config.hpp"
 #include "library/debug.hpp"
+#include "library/locking.hpp"
 #include "library/ptl.hpp"
 #include "library/runtime.hpp"
 #include "library/state.hpp"
@@ -58,12 +59,14 @@
 #include <timemory/units.hpp>
 #include <timemory/utility/backtrace.hpp>
 #include <timemory/utility/demangle.hpp>
+#include <timemory/utility/procfs/maps.hpp>
 #include <timemory/utility/types.hpp>
 #include <timemory/variadic.hpp>
 
 #include <array>
 #include <chrono>
 #include <condition_variable>
+#include <csignal>
 #include <cstring>
 #include <ctime>
 #include <initializer_list>
@@ -76,20 +79,36 @@
 #include <pthread.h>
 #include <signal.h>
 
+namespace tim
+{
+namespace math
+{
+template <typename Tp, typename Up>
+TIMEMORY_INLINE Tp
+plus(Tp&& _lhs, const Up& _rhs)
+{
+    Tp _v = _lhs;
+    plus(_v, _rhs);
+    return _v;
+}
+}  // namespace math
+}  // namespace tim
 namespace omnitrace
 {
 namespace sampling
 {
+using ::tim::sampling::dynamic;
+using tim::sampling::timer;
+
 using hw_counters               = typename component::backtrace_metrics::hw_counters;
 using signal_type_instances     = thread_data<std::set<int>, category::sampling>;
 using sampler_running_instances = thread_data<bool, category::sampling>;
 using bundle_t =
-    tim::lightweight_tuple<backtrace_timestamp, backtrace, backtrace_metrics>;
-using sampler_t              = tim::sampling::sampler<bundle_t, tim::sampling::dynamic>;
+    tim::lightweight_tuple<component::backtrace_timestamp, component::backtrace,
+                           component::backtrace_metrics>;
+using sampler_t              = tim::sampling::sampler<bundle_t, dynamic>;
 using sampler_instances      = thread_data<sampler_t, category::sampling>;
 using sampler_init_instances = thread_data<bundle_t, category::sampling>;
-
-using tim::sampling::timer;
 }  // namespace sampling
 }  // namespace omnitrace
 
@@ -225,8 +244,7 @@ get_sampler_init(int64_t _tid = threading::get_id())
 unique_ptr_t<bool>&
 get_sampler_running(int64_t _tid)
 {
-    static auto& _v = sampler_running_instances::instances(
-        sampler_running_instances::construct_on_init{}, false);
+    static auto& _v = sampler_running_instances::instances(construct_on_init{}, false);
     return _v.at(_tid);
 }
 
@@ -356,10 +374,10 @@ get_offload_file()
     return _v;
 }
 
-std::mutex&
+locking::atomic_mutex&
 get_offload_mutex()
 {
-    static auto _v = std::mutex{};
+    static auto _v = locking::atomic_mutex{};
     return _v;
 }
 
@@ -369,12 +387,25 @@ using sampler_buffer_t = tim::data_storage::ring_buffer<sampler_bundle_t>;
 void
 offload_buffer(int64_t _seq, sampler_buffer_t&& _buf)
 {
-    auto  _lk   = std::unique_lock<std::mutex>{ get_offload_mutex() };
+    OMNITRACE_REQUIRE(get_use_tmp_files())
+        << "Error! sampling allocator tries to offload buffer of samples but "
+           "omnitrace was configured to not use temporary files\n";
+
+    // use homemade atomic_mutex/atomic_lock since contention will be low
+    // and using pthread_lock might trigger our wrappers
+    auto  _lk   = locking::atomic_lock{ get_offload_mutex() };
     auto& _file = get_offload_file();
-    if(!_file) return;
+
+    OMNITRACE_REQUIRE(_file)
+        << "Error! sampling allocator tried to offload buffer of samples but the "
+           "offload file does not exist\n";
 
     OMNITRACE_VERBOSE_F(3, "Saving sampling buffer for thread %li...\n", _seq);
     auto& _fs = _file->stream;
+
+    OMNITRACE_REQUIRE(_fs.good())
+        << "Error! temporary file for offloading buffer is in an invalid state\n";
+
     _fs.write(reinterpret_cast<char*>(&_seq), sizeof(_seq));
     auto _data = std::move(_buf);
     _data.save(_fs);
@@ -388,14 +419,27 @@ load_offload_buffer()
     auto _data = std::map<int64_t, std::vector<sampler_buffer_t>>{};
     if(!get_use_tmp_files()) return _data;
 
-    auto  _lk   = std::unique_lock<std::mutex>{ get_offload_mutex() };
+    // use homemade atomic_mutex/atomic_lock since contention will be low
+    // and using pthread_lock might trigger our wrappers
+    auto  _lk   = locking::atomic_lock{ get_offload_mutex() };
     auto& _file = get_offload_file();
-    if(!_file) return _data;
+    if(!_file)
+    {
+        OMNITRACE_WARNING_F(
+            0, "[sampling] returning no data because the offload file no longer exists");
+        return _data;
+    }
 
     auto& _fs = _file->stream;
 
     _fs.close();
     _file->open(std::ios::binary | std::ios::in);
+
+    if(!_fs)
+    {
+        OMNITRACE_WARNING_F(0, "[sampling] %s failed to open", _file->filename.c_str());
+    }
+
     while(!_fs.eof())
     {
         int64_t _seq = 0;
@@ -421,6 +465,10 @@ configure(bool _setup, int64_t _tid)
     bool        _is_running   = (!_running) ? false : *_running;
     auto&       _signal_types = sampling::get_signal_types(_tid);
 
+    OMNITRACE_CONDITIONAL_THROW(get_use_causal(),
+                                "Internal error! configuring sampling not permitted when "
+                                "causal profiling is enabled");
+
     OMNITRACE_SCOPED_SAMPLING_ON_CHILD_THREADS(false);
 
     auto&& _cpu_tids  = get_sampling_cpu_tids();
@@ -520,7 +568,7 @@ configure(bool _setup, int64_t _tid)
             if(_timer)
             {
                 OMNITRACE_VERBOSE(
-                    1,
+                    2,
                     "[SIG%i] Sampler for thread %lu will be triggered %.1fx per "
                     "second of %s-time (every %.3e milliseconds)...\n",
                     itr, _tid, _timer->get_frequency(units::sec), _type,
@@ -669,19 +717,24 @@ unblock_signals(std::set<int> _signals)
 void
 post_process()
 {
+    OMNITRACE_SCOPED_THREAD_STATE(ThreadState::Internal);
+
+    size_t _total_data       = 0;
+    size_t _total_threads    = 0;
+    auto   _external_samples = std::atomic<size_t>{ 0 };
+    auto   _internal_samples = std::atomic<size_t>{ 0 };
+
+    OMNITRACE_VERBOSE(2 || get_debug_sampling(), "Stopping sampling components...\n");
     omnitrace::component::backtrace::stop();
-    OMNITRACE_VERBOSE(2 || get_debug_sampling(), "Stopping backtrace metrics...\n");
-
-    for(size_t i = 0; i < max_supported_threads; ++i)
-        backtrace_metrics::configure(false, i);
-
-    size_t _total_data    = 0;
-    size_t _total_threads = 0;
-
     for(size_t i = 0; i < max_supported_threads; ++i)
     {
+        backtrace_metrics::configure(false, i);
         auto& _sampler = get_sampler(i);
-        if(_sampler) _sampler->set_offload(nullptr);
+        if(_sampler)
+        {
+            _sampler->stop();
+            _sampler->set_offload(nullptr);
+        }
     }
 
     auto _loaded_data = load_offload_buffer();
@@ -715,7 +768,6 @@ post_process()
         OMNITRACE_VERBOSE(3 || get_debug_sampling(),
                           "Getting sampler data for thread %lu...\n", i);
 
-        _sampler->stop();
         auto _raw_data = _sampler->get_data();
         for(auto litr : _loaded_data[i])
         {
@@ -742,45 +794,58 @@ post_process()
         std::vector<sampling::bundle_t*> _data{};
         for(auto& itr : _raw_data)
         {
-            _data.reserve(_data.size() + itr.size());
             auto* _bt = itr.get<backtrace>();
             auto* _ts = itr.get<backtrace_timestamp>();
-            if(!_bt || !_ts) continue;
-            if(_bt->empty()) continue;
-            if(!_thread_info->is_valid_time(_ts->get_timestamp())) continue;
-            _data.emplace_back(&itr);
+            if(_thread_info && _bt && !_bt->empty() && _ts &&
+               _thread_info->is_valid_time(_ts->get_timestamp()))
+            {
+                _data.emplace_back(&itr);
+            }
         }
 
-        if(_data.empty())
+        _total_data += _data.size();
+        _total_threads += (!_data.empty()) ? 1 : 0;
+
+        if(!_data.empty())
+        {
+            OMNITRACE_VERBOSE(2 || get_debug_sampling(),
+                              "Sampler data for thread %lu has %zu valid entries...\n", i,
+                              _data.size());
+
+            if(get_use_perfetto()) post_process_perfetto(i, _init, _data);
+            if(get_use_timemory()) post_process_timemory(i, _init, _data);
+        }
+        else
         {
             OMNITRACE_VERBOSE(2 || get_debug_sampling(),
                               "Sampler data for thread %lu has zero valid entries out of "
                               "%zu... (skipped)\n",
                               i, _raw_data.size());
-            continue;
         }
-
-        OMNITRACE_VERBOSE(2 || get_debug_sampling(),
-                          "Sampler data for thread %lu has %zu valid entries...\n", i,
-                          _raw_data.size());
-
-        _total_data += _raw_data.size();
-        _total_threads += 1;
-
-        if(get_use_perfetto()) post_process_perfetto(i, _init, _data);
-        if(get_use_timemory()) post_process_timemory(i, _init, _data);
     }
 
-    OMNITRACE_VERBOSE(3 || get_debug_sampling(), "Destroying samplers...\n");
+    OMNITRACE_VERBOSE(3 || get_debug_sampling(),
+                      "Destroying samplers and allocators...\n");
 
     for(size_t i = 0; i < max_supported_threads; ++i)
-    {
         get_sampler(i).reset();
+
+    for(auto& itr : get_sampler_allocators())
+    {
+        if(itr) itr.reset();
+    }
+
+    if(get_offload_file())
+    {
+        get_offload_file()->remove();
+        get_offload_file().reset();
     }
 
     OMNITRACE_VERBOSE(1 || get_debug_sampling(),
-                      "Collected %zu samples from %zu threads...\n", _total_data,
-                      _total_threads);
+                      "Collected %zu samples from %zu threads... %zu samples out of %zu "
+                      "were taken while within instrumented routines\n",
+                      _total_data, _total_threads, _internal_samples.load(),
+                      (_internal_samples + _external_samples));
 }
 
 namespace