Linux Perf Support + Causal Profiling Updates (#276)
* causal backtrace updates
- fix initial causal sampling period value
* causal delay updates
- tweak handling of sleep_for_overhead
* Fix experiment global scaling for prog pts
- results in drastically improved predictions
* pthread_mutex_gotcha updates
- disable all wrappers during causal profiling
* validate-causal-json.py updates
- support decimal stddev
- fix setting stddev from command-line
* causal perform_experiment_impl update
- handle start failing because finalizing
* deprecate causal::component::sample_rate
- appears to not help at all
* Rework sample info
* Increase causal unwind_depth
- use OMNITRACE_MAX_UNWIND_DEPTH
* validate-causal-json updates
- min experiments
- exclude reporting predictions with less than X experiments at a given speedup
- percent samples
- only print samples within X% of the peak (default: 95%)
* Update timemory submodule
- extensions to sampling for signals delivered via non-timer method
- e.g. via HW counter overflow
* dwarf_entry::operator< updates
- sort via file
* causal profiling docs updates
- info about backends
- info about installing/enabling perf
* config updates: causal backend
- CausalBackend enum
- OMNITRACE_CAUSAL_BACKEND: perf, timer, auto
- omnitrace-causal option: --backend
* debug update
- use spin_mutex instead of std::mutex
* address_range::contains update
- range from 0-100 contains range from 10-100 but was returning false because high was == 100 not < 100
* symbol::operator< update
- handle load address differences
* sampling updates (non-causal)
- update get_timer to get_trigger + dynamic_cast
* container::static_vector updates
- support construction from container::c_array
- update_size private member func for handling atomic m_size
* Move perf files
- moved library/causal/perf.{hpp,cpp} to library/perf.{hpp,cpp}
* causal example update
- created impl.hpp (forward decls)
- renamed {cpu,rng}_func_impl to {cpu,rng}_impl_func
- only create two threads which run N iterations instead of two threads each iteration
* Update timemory submodule
- updates to unwind::processed_entry
- updates to procfs::maps
* Updated causal documentation
- fixed line numbers changed by modifications to causal example
* omnitrace-causal exe updates
- set OMNITRACE_THREAD_POOL_SIZE to zero by default
* core/containers updates
- static_vector: provide data() member function
- c_array pop_front() and pop_back() member functions
* core: config and argparse updates + perf
- core/perf.{hpp,cpp}
- forward decl of enums
- config-related capabilities
- argparse: --sample-overflow
- renamed some config functions
- e.g. get_sampling_cpu_freq -> get_sampling_cputime_freq
- added config settings related to overflow sampling via perf
- added timer_sampling and overflow_sampling categories
* Update timemory submodule
- sampling allocator flushing
* binary updates
- lookup_ipaddr_entry
- use bfd_find_nearest_line instead of bfd_find_nearest_line_discriminator
- discriminators are not used
- explicit instantiations of inlined_symbol::serialize
* Bump VERSION to 1.10.0
* sampling and perf updates
- support overflow sampling via Linux Perf
- update perf namespace
- update perf::perf_event
- update record ctor: pointer instead of const ref
- update open member func: return optional string
- add m_batch_size member variable
- sampling updates
- support overflow sampling
- flush allocators
- increase buffer size from 1024 to 2048
- restructure post-processing in light of perf overflow supports
- improve offload memory usage only load buffers for thread
- load_offload_buffer(tid) uses thread-specific filepos
- component updates
- backtrace_metrics::operator-=
- backtrace_metrics::operator-
- backtrace::sample does not record for overflow signal
- callchain: perf overflow sample
* core updates
- component::sampling_percent does not report self + uses_percent_units
* causal updates
- tweak get_line_info
- overloads for set_current_selection (uint64_t, c_array, std::array)
- delay
- use sampling::pause/sampling::resume
- experiment
- experiment::sample derives from unwind::processed_entry
- experiment::samples is vector instead of set
- fixed samples
- overloads for is_selected (uint64_t, c_array, std::array)
- scaling factor defaults to 100 instead of 50
- serialize updates follow change to experiment::sample
- modify algorithm for increasing/decreasing experiment length
- sample_data
- use map<uintptr, uint64_t> instead of set<sample_data>
- get_samples returns vector<sample_data> instead of set<sample_data>
- sampling
- support overflow via Linux Perf
- update causal_offload_buffer
- flush sampling allocator
- backtrace
- overflow component
* libomnitrace-dl updates
- handle dl::InstrumentMode::PythonProfile
* testing updates (causal)
- causal line 155 -> causal line 100
- causal line 165 -> causal line 110
* formatting
* exit_gotcha updates
- exit_info for abort()
- message about non-zero exit code
* testing updates
- fail regex for causal tests
- validate-causal-json: >= min_experiments instead of > min_experiments
- handle OMNITRACE_DEBUG_SETTINGS in omnitrace_write_test_config
* causal sampling updates
- add new lines where appropriate
* causal data updates
- reorder diagnostic info when experiment fails to start
* binary updates
- symbol address range from address to address + symsize + 1
- add 1 based on debug info
* causal data updates
- sample_selection wait_ns defaults to 1,000 instead of 10,000
- sample_selection wait scaled by iteration number
- save_line_info_impl verbosity
- print latest_eligible_pc when experiment does not start
* causal sampling + component updates
- perf backend disables component::backtrace
- ensure get_sampling_(realtime|cputime|overflow)_signal do not malloc
* causal: remove period stats
* validate-causal-json update
- fix --help
* causal data updates
- improve eligible pc history reporting when experiment fails to start
* causal data updates
- fix compute_eligible_lines_impl
- eligible address ranges returning too many ranges
- occasionally, overwrite all *true* eligible address ranges
* causal data updates
- reduce scoped ranges to symbol ranges
- is_eligible_address() returns true contains (not just coarse)
- revert some sample_selection behavior
* binary address_multirange updates
- make coarse_range private
- fix operator+=(pair<coarse, uintptr_t>)
* causal example update
- fix nsync to default to once per iteration
* binary analysis updates
- tweak header file includes
* causal updates
- remove factoring in sleep_for_overhead
- invoke delay::process() even if experiment is not active
* causal data updates
- update latest_eligible_pc structure
* update omnitrace-install.py.in
- fix support for fedora
- /etc/os-release does not have ID_LIKE
- fallback to RHEL 8.7 if version not specified
* update omnitrace-install.py.in
- fix support for debian
- /etc/os-release does not have ID_LIKE
- version mapping
* Update documentation
- update docs on installation
* causal data and experiment updates
- data: reset_sample_selection
* causal set_current_selection debugging
- debug messages for failed e2e runs
* causal data and backtrace component updates
- data: set_current_selection returns the number of eligible addresses added
- backtrace: if cputime signal has selected zero IPs > 5x, then realtime signal starts contributing call-stacks
* core library updates
- move config::parse_numeric_range to utility namespace
- add core/utility.cpp
- support range:increment, e.g. 5-25:10 expands to '5 15 25' instead of '5 10 15 20 25'
* omnitrace-causal update
- end-to-end expands all speedups
- support range:increment in speedups
* causal backtrace updates
- remove select_ival (realtime signal always contributes when select_count == 0)
* containers: static_vector update
- explicit c_array constructor
- explicit std::array constructor
* causal data updates
- remove set_current_selection(uint64_t)
- remove set_current_selection(std::array)
- sample_selection increase default wait time
- report eligible PC candidates
- move reset_sample_selection to perform_experiment_impl
- decrease latest_eligible_pc array size
- set_current_selection does not guard for experiment::active
* core debug updates
- OMNITRACE_PRINT_COLOR macros
* causal data updates
- tweak to experiment never started message
* causal gotcha updates
- remove unused code
* critical trace updates
- remove unused code
* omnitrace-causal
- OMNITRACE_LAUNCHER
* causal data updates
- don't fail on end-to-end + omnitrace-causal
* causal backtrace updates
- reintroduce select_ival behavior
* causal data updates
- tweak verbose messages about number of PC candidates
* core mproc updates
- utilities for waiting on child PID and diagnosing status
- omnitrace::mproc::wait_pid
- omnitrace::mproc::diagnose_status
* omnitrace-run updates
- support --fork argument for executing via fork in current process + execvpe on child instead of execvpe in current process
* omnitrace-causal updates
- wait_pid and diagnose_status just call equivalent functions in omnitrace::mproc
* ubuntu-focal workflow update
- attempt to launch ubuntu-focal-codecov job with CAP_SYS_ADMIN and use perf backend
* tests reorg and updates
- remove binary-rewrite-sampling and runtime-instrument-sampling tests
- rename *-preload tests (which use omnitrace-sample exe) to *-sampling
- split tests/CMakeLists.txt into several tests/omnitrace-<category>-tests.cmake files
- tweak to causal-both-omni-func test
- add args: -n 2 -b timer
* update validate-causal-json.py
- better reasoning info for adjusting tolerance
- always apply tolerance adjustments in CI mode
* causal e2e tests update
- add label "causal-e2e" label
- tweak params
- old: 80 12 432525 500000000
- new: 80 50 432525 100000000
- disable processor affinity for slow-func/line-100 tests
- artificially inflates some speedups with perf
* unblocking_gotcha updates
- overload operator() according to gotcha function index
* blocking_gotcha updates
- overload operator() according to gotcha function index
- fix bug where potentially post block functors (e.g. pthread_mutex_trylock) throw error if lock is not acquired.
* parse_numeric_range update
- support unordered_set
* config update
- OMNITRACE_DEBUG_{TIDS,PIDS} use parse_numeric_range
This commit is contained in:
Jonathan R. Madsen
committed by
GitHub
GitHub
parent
cc14b52584
commit
9de3a6b0b4
@@ -12,9 +12,11 @@ set(core_sources
|
||||
${CMAKE_CURRENT_LIST_DIR}/exception.cpp
|
||||
${CMAKE_CURRENT_LIST_DIR}/gpu.cpp
|
||||
${CMAKE_CURRENT_LIST_DIR}/mproc.cpp
|
||||
${CMAKE_CURRENT_LIST_DIR}/perf.cpp
|
||||
${CMAKE_CURRENT_LIST_DIR}/perfetto.cpp
|
||||
${CMAKE_CURRENT_LIST_DIR}/state.cpp
|
||||
${CMAKE_CURRENT_LIST_DIR}/timemory.cpp)
|
||||
${CMAKE_CURRENT_LIST_DIR}/timemory.cpp
|
||||
${CMAKE_CURRENT_LIST_DIR}/utility.cpp)
|
||||
|
||||
set(core_headers
|
||||
${CMAKE_CURRENT_LIST_DIR}/argparse.hpp
|
||||
@@ -29,6 +31,7 @@ set(core_headers
|
||||
${CMAKE_CURRENT_LIST_DIR}/gpu.hpp
|
||||
${CMAKE_CURRENT_LIST_DIR}/locking.hpp
|
||||
${CMAKE_CURRENT_LIST_DIR}/mproc.hpp
|
||||
${CMAKE_CURRENT_LIST_DIR}/perf.hpp
|
||||
${CMAKE_CURRENT_LIST_DIR}/perfetto.hpp
|
||||
${CMAKE_CURRENT_LIST_DIR}/redirect.hpp
|
||||
${CMAKE_CURRENT_LIST_DIR}/state.hpp
|
||||
|
||||
@@ -272,6 +272,15 @@ add_core_arguments(parser_t& _parser, parser_data& _data)
|
||||
%{INDENT}% to consume more resources since, while idle, the real-clock time increases (and therefore triggers taking samples)
|
||||
%{INDENT}% whereas the CPU-clock time does not.)";
|
||||
|
||||
const auto* _overflow_desc =
|
||||
R"(Sample based on an overflow event. Accepts zero or more arguments:
|
||||
%{INDENT}%0. Enables sampling based on overflow.
|
||||
%{INDENT}%1. Overflow metric, e.g. PERF_COUNT_HW_INSTRUCTIONS
|
||||
%{INDENT}%2. Overflow value. E.g., if metric == PERF_COUNT_HW_INSTRUCTIONS, then 10000000 == sample every 10,000,000 instructions.
|
||||
%{INDENT}%3+ Thread IDs to target for sampling, starting at 0 (the main thread).
|
||||
%{INDENT}% May be specified as index or range, e.g., '0 2-4' will be interpreted as:
|
||||
%{INDENT}% sample the main thread (0), do not sample the first child thread but sample the 2nd, 3rd, and 4th child threads)";
|
||||
|
||||
const auto* _hsa_interrupt_desc =
|
||||
R"(Set the value of the HSA_ENABLE_INTERRUPT environment variable.
|
||||
%{INDENT}% ROCm version 5.2 and older have a bug which will cause a deadlock if a sample is taken while waiting for the signal
|
||||
@@ -1075,7 +1084,7 @@ add_core_arguments(parser_t& _parser, parser_data& _data)
|
||||
"SAMPLING TIMER OPTIONS",
|
||||
"These options determine the heuristic for deciding when to take a sample");
|
||||
|
||||
if(_data.environ_filter("sample_cputime", _data))
|
||||
if(_data.environ_filter("sampling_cputime", _data))
|
||||
{
|
||||
_parser.add_argument({ "--sample-cputime" }, _cputime_desc)
|
||||
.min_count(0)
|
||||
@@ -1103,7 +1112,7 @@ add_core_arguments(parser_t& _parser, parser_data& _data)
|
||||
_data.processed_environs.emplace("sampling_cputime");
|
||||
}
|
||||
|
||||
if(_data.environ_filter("sample_realtime", _data))
|
||||
if(_data.environ_filter("sampling_realtime", _data))
|
||||
{
|
||||
_parser.add_argument({ "--sample-realtime" }, _realtime_desc)
|
||||
.min_count(0)
|
||||
@@ -1132,6 +1141,41 @@ add_core_arguments(parser_t& _parser, parser_data& _data)
|
||||
_data.processed_environs.emplace("sampling_realtime");
|
||||
}
|
||||
|
||||
if(_data.environ_filter("sampling_overflow", _data))
|
||||
{
|
||||
_parser.add_argument({ "--sample-overflow" }, _overflow_desc)
|
||||
.min_count(0)
|
||||
.dtype("[event] [freq] [tids...]")
|
||||
.action([&](parser_t& p) {
|
||||
auto _v = p.get<std::deque<std::string>>("sample-overflow");
|
||||
update_env(_data, "OMNITRACE_SAMPLING_OVERFLOW", true);
|
||||
|
||||
if(!_v.empty())
|
||||
{
|
||||
if(p.exists("sampling-overflow-event") &&
|
||||
_v.front() != p.get<std::string>("sampling-overflow-event"))
|
||||
throw exception<std::runtime_error>(join(
|
||||
"", "'--sample-overflow ", _v.front(),
|
||||
" ...' conflicts with '--sampling-overflow-event ",
|
||||
p.get<std::string>("sampling-overflow-event"), "' option"));
|
||||
update_env(_data, "OMNITRACE_SAMPLING_OVERFLOW_EVENT", _v.front());
|
||||
_v.pop_front();
|
||||
}
|
||||
if(!_v.empty())
|
||||
{
|
||||
update_env(_data, "OMNITRACE_SAMPLING_OVERFLOW_FREQ", _v.front());
|
||||
_v.pop_front();
|
||||
}
|
||||
if(!_v.empty())
|
||||
{
|
||||
update_env(_data, "OMNITRACE_SAMPLING_OVERFLOW_TIDS",
|
||||
join(array_config_t{ "," }, _v));
|
||||
}
|
||||
});
|
||||
|
||||
_data.processed_environs.emplace("sampling_overflow");
|
||||
}
|
||||
|
||||
_parser.start_group(
|
||||
"ADVANCED SAMPLING OPTIONS",
|
||||
"These options determine the heuristic for deciding when to take a sample");
|
||||
|
||||
@@ -80,7 +80,7 @@ address_range::contains(uintptr_t _v) const
|
||||
bool
|
||||
address_range::contains(address_range _v) const
|
||||
{
|
||||
return (*this == _v) || (contains(_v.low) && contains(_v.high));
|
||||
return (*this == _v) || (contains(_v.low) && (contains(_v.high) || _v.high == high));
|
||||
}
|
||||
|
||||
bool
|
||||
|
||||
@@ -130,6 +130,8 @@ OMNITRACE_DEFINE_CATEGORY(category, thread_context_switch, OMNITRACE_CATEGORY_TH
|
||||
OMNITRACE_DEFINE_CATEGORY(category, thread_hardware_counter, OMNITRACE_CATEGORY_THREAD_HARDWARE_COUNTER, "thread_hardware_counter", "Hardware counter value on thread (derived from sampling)")
|
||||
OMNITRACE_DEFINE_CATEGORY(category, kernel_hardware_counter, OMNITRACE_CATEGORY_KERNEL_HARDWARE_COUNTER, "kernel_hardware_counter", "Hardware counter value for kernel (deterministic)")
|
||||
OMNITRACE_DEFINE_CATEGORY(category, numa, OMNITRACE_CATEGORY_NUMA, "numa", "Non-unified memory architecture")
|
||||
OMNITRACE_DEFINE_CATEGORY(category, timer_sampling, OMNITRACE_CATEGORY_TIMER_SAMPLING, "timer_sampling", "Sampling based on a timer")
|
||||
OMNITRACE_DEFINE_CATEGORY(category, overflow_sampling, OMNITRACE_CATEGORY_OVERFLOW_SAMPLING, "overflow_sampling", "Sampling based on a counter overflow")
|
||||
|
||||
OMNITRACE_DECLARE_CATEGORY(category, sampling, OMNITRACE_CATEGORY_SAMPLING, "sampling", "Host-side call-stack sampling")
|
||||
// clang-format on
|
||||
@@ -192,6 +194,8 @@ using name = perfetto_category<Tp...>;
|
||||
OMNITRACE_PERFETTO_CATEGORY(category::thread_hardware_counter), \
|
||||
OMNITRACE_PERFETTO_CATEGORY(category::kernel_hardware_counter), \
|
||||
OMNITRACE_PERFETTO_CATEGORY(category::numa), \
|
||||
OMNITRACE_PERFETTO_CATEGORY(category::timer_sampling), \
|
||||
OMNITRACE_PERFETTO_CATEGORY(category::overflow_sampling), \
|
||||
::perfetto::Category("timemory").SetDescription("Events from the timemory API")
|
||||
|
||||
#if defined(TIMEMORY_USE_PERFETTO)
|
||||
|
||||
@@ -233,6 +233,8 @@ OMNITRACE_DEFINE_CONCRETE_TRAIT(uses_timing_units, component::sampling_cpu_clock
|
||||
// enable percent units
|
||||
OMNITRACE_DEFINE_CONCRETE_TRAIT(uses_percent_units, component::sampling_gpu_busy,
|
||||
true_type)
|
||||
OMNITRACE_DEFINE_CONCRETE_TRAIT(uses_percent_units, component::sampling_percent,
|
||||
true_type)
|
||||
|
||||
// enable memory units
|
||||
OMNITRACE_DEFINE_CONCRETE_TRAIT(is_memory_category, component::sampling_gpu_memory,
|
||||
@@ -253,6 +255,9 @@ OMNITRACE_DEFINE_CONCRETE_TRAIT(report_mean, component::sampling_percent, false_
|
||||
OMNITRACE_DEFINE_CONCRETE_TRAIT(report_statistics, component::sampling_percent,
|
||||
false_type)
|
||||
|
||||
// reporting categories (self)
|
||||
OMNITRACE_DEFINE_CONCRETE_TRAIT(report_self, component::sampling_percent, false_type)
|
||||
|
||||
#define OMNITRACE_DECLARE_EXTERN_COMPONENT(NAME, HAS_DATA, ...) \
|
||||
TIMEMORY_DECLARE_EXTERN_TEMPLATE( \
|
||||
struct tim::component::base<TIMEMORY_ESC(omnitrace::component::NAME), \
|
||||
|
||||
+170
-135
@@ -27,7 +27,9 @@
|
||||
#include "defines.hpp"
|
||||
#include "gpu.hpp"
|
||||
#include "mproc.hpp"
|
||||
#include "perf.hpp"
|
||||
#include "perfetto.hpp"
|
||||
#include "utility.hpp"
|
||||
|
||||
#include <timemory/backends/dmp.hpp>
|
||||
#include <timemory/backends/mpi.hpp>
|
||||
@@ -109,59 +111,7 @@ get_available_categories()
|
||||
return _v;
|
||||
}
|
||||
|
||||
template <typename Tp = int64_t, typename ContainerT = std::set<Tp>, typename Up = Tp>
|
||||
ContainerT
|
||||
parse_numeric_range(std::string _input_string, const std::string& _label, Up _incr)
|
||||
{
|
||||
auto _get_value = [](const std::string& _inp) {
|
||||
std::stringstream iss{ _inp };
|
||||
auto var = Tp{};
|
||||
iss >> var;
|
||||
return var;
|
||||
};
|
||||
|
||||
for(auto& itr : _input_string)
|
||||
itr = tolower(itr);
|
||||
auto _result = ContainerT{};
|
||||
for(const auto& _v : tim::delimit(_input_string, ",; \t\n\r"))
|
||||
{
|
||||
if(_v.find_first_not_of("0123456789-") != std::string::npos)
|
||||
{
|
||||
OMNITRACE_VERBOSE_F(
|
||||
0,
|
||||
"Invalid %s specification. Only numerical values (e.g., 0) or "
|
||||
"ranges (e.g., 0-7) are permitted. Ignoring %s...",
|
||||
_label.c_str(), _v.c_str());
|
||||
continue;
|
||||
}
|
||||
if(_v.find('-') != std::string::npos)
|
||||
{
|
||||
auto _vv = tim::delimit(_v, "-");
|
||||
OMNITRACE_CONDITIONAL_THROW(
|
||||
_vv.size() != 2,
|
||||
"Invalid %s range specification: %s. Required format N-M, e.g. 0-4",
|
||||
_label.c_str(), _v.c_str());
|
||||
Tp _vn = _get_value(_vv.at(0));
|
||||
Tp _vN = _get_value(_vv.at(1));
|
||||
do
|
||||
{
|
||||
if constexpr(std::is_same<ContainerT, std::set<Tp>>::value)
|
||||
_result.emplace(_vn);
|
||||
else
|
||||
_result.emplace_back(_vn);
|
||||
_vn += _incr;
|
||||
} while(_vn <= _vN);
|
||||
}
|
||||
else
|
||||
{
|
||||
if constexpr(std::is_same<ContainerT, std::set<Tp>>::value)
|
||||
_result.emplace(std::stol(_v));
|
||||
else
|
||||
_result.emplace_back(std::stol(_v));
|
||||
}
|
||||
}
|
||||
return _result;
|
||||
}
|
||||
using utility::parse_numeric_range;
|
||||
|
||||
#define OMNITRACE_CONFIG_SETTING(TYPE, ENV_NAME, DESCRIPTION, INITIAL_VALUE, ...) \
|
||||
[&]() { \
|
||||
@@ -454,6 +404,11 @@ configure_settings(bool _init)
|
||||
"Defaults to OMNITRACE_SAMPLING_FREQ when <= 0.0",
|
||||
-1.0, "sampling", "advanced");
|
||||
|
||||
OMNITRACE_CONFIG_SETTING(double, "OMNITRACE_SAMPLING_OVERFLOW_FREQ",
|
||||
"Number of events in between each sample. "
|
||||
"Defaults to OMNITRACE_SAMPLING_FREQ when <= 0.0",
|
||||
-1.0, "sampling", "advanced");
|
||||
|
||||
OMNITRACE_CONFIG_SETTING(
|
||||
double, "OMNITRACE_SAMPLING_DELAY",
|
||||
"Time (in seconds) to wait before the first sampling signal is delivered, "
|
||||
@@ -518,15 +473,22 @@ configure_settings(bool _init)
|
||||
OMNITRACE_CONFIG_SETTING(
|
||||
std::string, "OMNITRACE_SAMPLING_CPUTIME_TIDS",
|
||||
"Same as OMNITRACE_SAMPLING_TIDS but applies specifically to samplers whose "
|
||||
"timers are based on the CPU-time. This is useful when both "
|
||||
"OMNITRACE_SAMPLING_CPUTIME=ON and OMNITRACE_SAMPLING_REALTIME=ON",
|
||||
"timers are based on the CPU-time. This is useful when you want to restrict "
|
||||
"samples to particular threads.",
|
||||
std::string{}, "sampling", "advanced");
|
||||
|
||||
OMNITRACE_CONFIG_SETTING(
|
||||
std::string, "OMNITRACE_SAMPLING_REALTIME_TIDS",
|
||||
"Same as OMNITRACE_SAMPLING_TIDS but applies specifically to samplers whose "
|
||||
"timers are based on the real (wall) time. This is useful when both "
|
||||
"OMNITRACE_SAMPLING_CPUTIME=ON and OMNITRACE_SAMPLING_REALTIME=ON",
|
||||
"timers are based on the real (wall) time. This is useful when you want to "
|
||||
"restrict samples to particular threads.",
|
||||
std::string{}, "sampling", "advanced");
|
||||
|
||||
OMNITRACE_CONFIG_SETTING(
|
||||
std::string, "OMNITRACE_SAMPLING_OVERFLOW_TIDS",
|
||||
"Same as OMNITRACE_SAMPLING_TIDS but applies specifically to samplers whose "
|
||||
"samples are based on the overflow of a particular event. This is useful when "
|
||||
"you want to restrict samples to particular threads.",
|
||||
std::string{}, "sampling", "advanced");
|
||||
|
||||
auto _backend = tim::get_env_choice<std::string>(
|
||||
@@ -593,29 +555,45 @@ configure_settings(bool _init)
|
||||
"thread started by the application.",
|
||||
8, "sampling", "debugging", "advanced");
|
||||
|
||||
OMNITRACE_CONFIG_SETTING(bool, "OMNITRACE_SAMPLING_OVERFLOW",
|
||||
"Enable sampling via an overflow of a HW counter. This "
|
||||
"requires Linux perf (/proc/sys/kernel/perf_event_paranoid "
|
||||
"created by OS) with a value of 2 or less in that file",
|
||||
false, "sampling", "advanced");
|
||||
|
||||
OMNITRACE_CONFIG_SETTING(
|
||||
bool, "OMNITRACE_SAMPLING_REALTIME",
|
||||
"Enable sampling frequency via a wall-clock timer on child threads. This may "
|
||||
"result in typically idle child threads consuming an unnecessary large amount of "
|
||||
"CPU time. The main thread always has this enabled.",
|
||||
"Enable sampling frequency via a wall-clock timer. This may result in typically "
|
||||
"idle child threads consuming an unnecessary large amount of CPU time.",
|
||||
false, "sampling", "advanced");
|
||||
|
||||
OMNITRACE_CONFIG_SETTING(bool, "OMNITRACE_SAMPLING_CPUTIME",
|
||||
"Enable sampling frequency via a timer that measures both "
|
||||
"CPU time used by the current process, "
|
||||
"and CPU time expended on behalf of the process by the "
|
||||
"system. This is recommended.",
|
||||
true, "sampling", "advanced");
|
||||
|
||||
auto _sigrt_range = SIGRTMAX - SIGRTMIN;
|
||||
|
||||
OMNITRACE_CONFIG_SETTING(
|
||||
int, "OMNITRACE_SAMPLING_REALTIME_OFFSET",
|
||||
std::string{
|
||||
"Modify this value only if the target process is also using SIGRTMIN. E.g. "
|
||||
"the signal used is SIGRTMIN + <THIS_VALUE>. Value must be <= " } +
|
||||
std::to_string(_sigrt_range),
|
||||
0, "sampling", "advanced");
|
||||
bool, "OMNITRACE_SAMPLING_CPUTIME",
|
||||
"Enable sampling frequency via a timer that measures both CPU time used by the "
|
||||
"current process, and CPU time expended on behalf of the process by the system. "
|
||||
"This is recommended.",
|
||||
false, "sampling", "advanced");
|
||||
|
||||
OMNITRACE_CONFIG_SETTING(int, "OMNITRACE_SAMPLING_CPUTIME_SIGNAL",
|
||||
"Modify this value only if the target process is also using "
|
||||
"the same signal (SIGPROF)",
|
||||
SIGPROF, "sampling", "advanced");
|
||||
|
||||
OMNITRACE_CONFIG_SETTING(int, "OMNITRACE_SAMPLING_REALTIME_SIGNAL",
|
||||
"Modify this value only if the target process is also using "
|
||||
"the same signal (SIGRTMIN)",
|
||||
SIGRTMIN, "sampling", "advanced");
|
||||
|
||||
OMNITRACE_CONFIG_SETTING(int, "OMNITRACE_SAMPLING_OVERFLOW_SIGNAL",
|
||||
"Modify this value only if the target process is also using "
|
||||
"the same signal (SIGRTMIN + 1)",
|
||||
SIGRTMIN + 1, "sampling", "advanced");
|
||||
|
||||
OMNITRACE_CONFIG_SETTING(std::string, "OMNITRACE_SAMPLING_OVERFLOW_EVENT",
|
||||
"Metric for overflow sampling",
|
||||
std::string{ "perf::PERF_COUNT_HW_CACHE_REFERENCES" },
|
||||
"sampling", "hardware_counters")
|
||||
->set_choices(perf::get_config_choices());
|
||||
|
||||
OMNITRACE_CONFIG_SETTING(bool, "OMNITRACE_ROCTRACER_HIP_API",
|
||||
"Enable HIP API tracing support", true, "roctracer", "rocm",
|
||||
@@ -757,12 +735,22 @@ configure_settings(bool _init)
|
||||
std::string, "OMNITRACE_TMPDIR", "Base directory for temporary files",
|
||||
get_env<std::string>("TMPDIR", "/tmp"), "io", "data", "advanced");
|
||||
|
||||
OMNITRACE_CONFIG_SETTING(
|
||||
std::string, "OMNITRACE_CAUSAL_BACKEND",
|
||||
"Backend for call-stack sampling. See "
|
||||
"https://amdresearch.github.io/omnitrace/causal_profiling.html#backends for more "
|
||||
"info. If set to \"auto\", omnitrace will attempt to use the perf backend and "
|
||||
"fallback on the timer backend if unavailable",
|
||||
std::string{ "auto" }, "causal", "analysis")
|
||||
->set_choices({ "auto", "perf", "timer" });
|
||||
|
||||
OMNITRACE_CONFIG_SETTING(
|
||||
std::string, "OMNITRACE_CAUSAL_MODE",
|
||||
"Perform causal experiments at the function-scope or line-scope. Ideally, use "
|
||||
"function first to locate function with highest impact and then switch to line "
|
||||
"mode + OMNITRACE_CAUSAL_FUNCTION_SCOPE set to the function being targeted.",
|
||||
std::string{ "function" }, "causal", "analysis", "advanced");
|
||||
std::string{ "function" }, "causal", "analysis")
|
||||
->set_choices({ "func", "line", "function" });
|
||||
|
||||
OMNITRACE_CONFIG_SETTING(
|
||||
double, "OMNITRACE_CAUSAL_DELAY",
|
||||
@@ -1306,16 +1294,25 @@ configure_signal_handler(const std::shared_ptr<settings>& _config)
|
||||
}
|
||||
}
|
||||
|
||||
int
|
||||
get_realtime_signal()
|
||||
bool
|
||||
get_use_sampling_overflow()
|
||||
{
|
||||
return SIGRTMIN + get_sampling_rtoffset();
|
||||
static auto _v = get_config()->find("OMNITRACE_SAMPLING_OVERFLOW");
|
||||
return static_cast<tim::tsettings<bool>&>(*_v->second).get();
|
||||
}
|
||||
|
||||
int
|
||||
get_cputime_signal()
|
||||
bool
|
||||
get_use_sampling_realtime()
|
||||
{
|
||||
return SIGPROF;
|
||||
static auto _v = get_config()->find("OMNITRACE_SAMPLING_REALTIME");
|
||||
return static_cast<tim::tsettings<bool>&>(*_v->second).get();
|
||||
}
|
||||
|
||||
bool
|
||||
get_use_sampling_cputime()
|
||||
{
|
||||
static auto _v = get_config()->find("OMNITRACE_SAMPLING_CPUTIME");
|
||||
return static_cast<tim::tsettings<bool>&>(*_v->second).get();
|
||||
}
|
||||
|
||||
std::set<int> get_sampling_signals(int64_t)
|
||||
@@ -1323,13 +1320,22 @@ std::set<int> get_sampling_signals(int64_t)
|
||||
auto _v = std::set<int>{};
|
||||
if(get_use_causal())
|
||||
{
|
||||
_v.emplace(get_cputime_signal());
|
||||
_v.emplace(get_realtime_signal());
|
||||
_v.emplace(get_sampling_cputime_signal());
|
||||
_v.emplace(get_sampling_realtime_signal());
|
||||
}
|
||||
else
|
||||
{
|
||||
if(get_use_sampling_cputime()) _v.emplace(get_cputime_signal());
|
||||
if(get_use_sampling_realtime()) _v.emplace(get_realtime_signal());
|
||||
if(get_use_sampling() && !get_use_sampling_cputime() &&
|
||||
!get_use_sampling_realtime() && !get_use_sampling_overflow())
|
||||
{
|
||||
OMNITRACE_VERBOSE_F(1, "sampling enabled by cputime/realtime/overflow not "
|
||||
"specified. defaulting to cputime...\n");
|
||||
set_setting_value("OMNITRACE_SAMPLING_CPUTIME", true);
|
||||
}
|
||||
|
||||
if(get_use_sampling_cputime()) _v.emplace(get_sampling_cputime_signal());
|
||||
if(get_use_sampling_realtime()) _v.emplace(get_sampling_realtime_signal());
|
||||
if(get_use_sampling_overflow()) _v.emplace(get_sampling_overflow_signal());
|
||||
}
|
||||
|
||||
return _v;
|
||||
@@ -2008,24 +2014,24 @@ get_sampling_keep_internal()
|
||||
return static_cast<tim::tsettings<bool>&>(*_v->second).get();
|
||||
}
|
||||
|
||||
bool
|
||||
get_use_sampling_realtime()
|
||||
int
|
||||
get_sampling_overflow_signal()
|
||||
{
|
||||
static auto _v = get_config()->find("OMNITRACE_SAMPLING_REALTIME");
|
||||
return static_cast<tim::tsettings<bool>&>(*_v->second).get();
|
||||
}
|
||||
|
||||
bool
|
||||
get_use_sampling_cputime()
|
||||
{
|
||||
static auto _v = get_config()->find("OMNITRACE_SAMPLING_CPUTIME");
|
||||
return static_cast<tim::tsettings<bool>&>(*_v->second).get();
|
||||
static auto _v = get_config()->find("OMNITRACE_SAMPLING_OVERFLOW_SIGNAL");
|
||||
return static_cast<tim::tsettings<int>&>(*_v->second).get();
|
||||
}
|
||||
|
||||
int
|
||||
get_sampling_rtoffset()
|
||||
get_sampling_realtime_signal()
|
||||
{
|
||||
static auto _v = get_config()->find("OMNITRACE_SAMPLING_REALTIME_OFFSET");
|
||||
static auto _v = get_config()->find("OMNITRACE_SAMPLING_REALTIME_SIGNAL");
|
||||
return static_cast<tim::tsettings<int>&>(*_v->second).get();
|
||||
}
|
||||
|
||||
int
|
||||
get_sampling_cputime_signal()
|
||||
{
|
||||
static auto _v = get_config()->find("OMNITRACE_SAMPLING_CPUTIME_SIGNAL");
|
||||
return static_cast<tim::tsettings<int>&>(*_v->second).get();
|
||||
}
|
||||
|
||||
@@ -2241,7 +2247,7 @@ get_sampling_freq()
|
||||
}
|
||||
|
||||
double
|
||||
get_sampling_cpu_freq()
|
||||
get_sampling_cputime_freq()
|
||||
{
|
||||
static auto _v = get_config()->find("OMNITRACE_SAMPLING_CPUTIME_FREQ");
|
||||
auto& _val = static_cast<tim::tsettings<double>&>(*_v->second).get();
|
||||
@@ -2250,7 +2256,7 @@ get_sampling_cpu_freq()
|
||||
}
|
||||
|
||||
double
|
||||
get_sampling_real_freq()
|
||||
get_sampling_realtime_freq()
|
||||
{
|
||||
static auto _v = get_config()->find("OMNITRACE_SAMPLING_REALTIME_FREQ");
|
||||
auto& _val = static_cast<tim::tsettings<double>&>(*_v->second).get();
|
||||
@@ -2258,6 +2264,15 @@ get_sampling_real_freq()
|
||||
return _val;
|
||||
}
|
||||
|
||||
double
|
||||
get_sampling_overflow_freq()
|
||||
{
|
||||
static auto _v = get_config()->find("OMNITRACE_SAMPLING_OVERFLOW_FREQ");
|
||||
auto& _val = static_cast<tim::tsettings<double>&>(*_v->second).get();
|
||||
if(_val <= 0.0) _val = get_sampling_freq();
|
||||
return _val;
|
||||
}
|
||||
|
||||
double
|
||||
get_sampling_delay()
|
||||
{
|
||||
@@ -2266,7 +2281,7 @@ get_sampling_delay()
|
||||
}
|
||||
|
||||
double
|
||||
get_sampling_cpu_delay()
|
||||
get_sampling_cputime_delay()
|
||||
{
|
||||
static auto _v = get_config()->find("OMNITRACE_SAMPLING_CPUTIME_DELAY");
|
||||
auto& _val = static_cast<tim::tsettings<double>&>(*_v->second).get();
|
||||
@@ -2275,7 +2290,7 @@ get_sampling_cpu_delay()
|
||||
}
|
||||
|
||||
double
|
||||
get_sampling_real_delay()
|
||||
get_sampling_realtime_delay()
|
||||
{
|
||||
static auto _v = get_config()->find("OMNITRACE_SAMPLING_REALTIME_DELAY");
|
||||
auto& _val = static_cast<tim::tsettings<double>&>(*_v->second).get();
|
||||
@@ -2293,32 +2308,40 @@ get_sampling_duration()
|
||||
std::string
|
||||
get_sampling_cpus()
|
||||
{
|
||||
static auto _v = get_config()->find("OMNITRACE_SAMPLING_CPUS");
|
||||
auto _v = get_config()->find("OMNITRACE_SAMPLING_CPUS");
|
||||
return static_cast<tim::tsettings<std::string>&>(*_v->second).get();
|
||||
}
|
||||
|
||||
std::set<int64_t>
|
||||
get_sampling_tids()
|
||||
{
|
||||
static auto _v = get_config()->find("OMNITRACE_SAMPLING_TIDS");
|
||||
auto _v = get_config()->find("OMNITRACE_SAMPLING_TIDS");
|
||||
return parse_numeric_range<>(
|
||||
static_cast<tim::tsettings<std::string>&>(*_v->second).get(), "thread IDs", 1);
|
||||
static_cast<tim::tsettings<std::string>&>(*_v->second).get(), "thread IDs", 1L);
|
||||
}
|
||||
|
||||
std::set<int64_t>
|
||||
get_sampling_cpu_tids()
|
||||
get_sampling_cputime_tids()
|
||||
{
|
||||
static auto _v = get_config()->find("OMNITRACE_SAMPLING_CPUTIME_TIDS");
|
||||
auto _v = get_config()->find("OMNITRACE_SAMPLING_CPUTIME_TIDS");
|
||||
return parse_numeric_range<>(
|
||||
static_cast<tim::tsettings<std::string>&>(*_v->second).get(), "thread IDs", 1);
|
||||
static_cast<tim::tsettings<std::string>&>(*_v->second).get(), "thread IDs", 1L);
|
||||
}
|
||||
|
||||
std::set<int64_t>
|
||||
get_sampling_real_tids()
|
||||
get_sampling_realtime_tids()
|
||||
{
|
||||
static auto _v = get_config()->find("OMNITRACE_SAMPLING_REALTIME_TIDS");
|
||||
auto _v = get_config()->find("OMNITRACE_SAMPLING_REALTIME_TIDS");
|
||||
return parse_numeric_range<>(
|
||||
static_cast<tim::tsettings<std::string>&>(*_v->second).get(), "thread IDs", 1);
|
||||
static_cast<tim::tsettings<std::string>&>(*_v->second).get(), "thread IDs", 1L);
|
||||
}
|
||||
|
||||
std::set<int64_t>
|
||||
get_sampling_overflow_tids()
|
||||
{
|
||||
auto _v = get_config()->find("OMNITRACE_SAMPLING_OVERFLOW_TIDS");
|
||||
return parse_numeric_range<>(
|
||||
static_cast<tim::tsettings<std::string>&>(*_v->second).get(), "thread IDs", 1L);
|
||||
}
|
||||
|
||||
bool
|
||||
@@ -2415,14 +2438,8 @@ get_trace_thread_join()
|
||||
bool
|
||||
get_debug_tid()
|
||||
{
|
||||
static auto _vlist = []() {
|
||||
std::unordered_set<int64_t> _tids{};
|
||||
for(auto itr : tim::delimit<std::vector<int64_t>>(
|
||||
tim::get_env<std::string>("OMNITRACE_DEBUG_TIDS", ""),
|
||||
",: ", [](const std::string& _v) { return std::stoll(_v); }))
|
||||
_tids.insert(itr);
|
||||
return _tids;
|
||||
}();
|
||||
static auto _vlist = parse_numeric_range<int64_t, std::unordered_set<int64_t>>(
|
||||
tim::get_env<std::string>("OMNITRACE_DEBUG_TIDS", ""), "debug tids", 1L);
|
||||
static thread_local bool _v =
|
||||
_vlist.empty() || _vlist.count(tim::threading::get_id()) > 0;
|
||||
return _v;
|
||||
@@ -2431,14 +2448,8 @@ get_debug_tid()
|
||||
bool
|
||||
get_debug_pid()
|
||||
{
|
||||
static auto _vlist = []() {
|
||||
std::unordered_set<int64_t> _pids{};
|
||||
for(auto itr : tim::delimit<std::vector<int64_t>>(
|
||||
tim::get_env<std::string>("OMNITRACE_DEBUG_PIDS", ""),
|
||||
",: ", [](const std::string& _v) { return std::stoll(_v); }))
|
||||
_pids.insert(itr);
|
||||
return _pids;
|
||||
}();
|
||||
static auto _vlist = parse_numeric_range<int64_t, std::unordered_set<int64_t>>(
|
||||
tim::get_env<std::string>("OMNITRACE_DEBUG_PIDS", ""), "debug pids", 1L);
|
||||
static bool _v = _vlist.empty() || _vlist.count(tim::process::get_id()) > 0 ||
|
||||
_vlist.count(dmp::rank()) > 0;
|
||||
return _v;
|
||||
@@ -2589,6 +2600,31 @@ get_tmp_file(std::string _basename, std::string _ext)
|
||||
return _existing_files.at(_fname);
|
||||
}
|
||||
|
||||
CausalBackend
|
||||
get_causal_backend()
|
||||
{
|
||||
static auto _m = std::unordered_map<std::string_view, CausalBackend>{
|
||||
{ "auto", CausalBackend::Auto },
|
||||
{ "perf", CausalBackend::Perf },
|
||||
{ "timer", CausalBackend::Timer },
|
||||
};
|
||||
|
||||
auto _v = get_config()->find("OMNITRACE_CAUSAL_BACKEND");
|
||||
try
|
||||
{
|
||||
return _m.at(static_cast<tim::tsettings<std::string>&>(*_v->second).get());
|
||||
} catch(std::runtime_error& _e)
|
||||
{
|
||||
auto _mode = static_cast<tim::tsettings<std::string>&>(*_v->second).get();
|
||||
OMNITRACE_THROW("[%s] invalid causal backend %s. Choices: %s\n", __FUNCTION__,
|
||||
_mode.c_str(),
|
||||
timemory::join::join(timemory::join::array_config{ ", ", "", "" },
|
||||
_v->second->get_choices())
|
||||
.c_str());
|
||||
}
|
||||
return CausalBackend::Auto;
|
||||
}
|
||||
|
||||
CausalMode
|
||||
get_causal_mode()
|
||||
{
|
||||
@@ -2612,12 +2648,11 @@ get_causal_mode()
|
||||
} catch(std::runtime_error& _e)
|
||||
{
|
||||
auto _mode = static_cast<tim::tsettings<std::string>&>(*_v->second).get();
|
||||
std::stringstream _ss{};
|
||||
for(const auto& itr : _v->second->get_choices())
|
||||
_ss << ", " << itr;
|
||||
auto _msg = (_ss.str().length() > 2) ? _ss.str().substr(2) : std::string{};
|
||||
OMNITRACE_THROW("[%s] invalid causal mode %s. Choices: %s\n", __FUNCTION__,
|
||||
_mode.c_str(), _msg.c_str());
|
||||
OMNITRACE_THROW(
|
||||
"[%s] invalid causal mode %s. Choices: %s\n", __FUNCTION__, _mode.c_str(),
|
||||
timemory::join::join(timemory::join::array_config{ ", ", "", "" },
|
||||
_v->second->get_choices())
|
||||
.c_str());
|
||||
}
|
||||
return CausalMode::Function;
|
||||
}();
|
||||
@@ -2637,7 +2672,7 @@ get_causal_fixed_speedup()
|
||||
static auto _v = get_config()->find("OMNITRACE_CAUSAL_FIXED_SPEEDUP");
|
||||
return parse_numeric_range<int64_t, std::vector<int64_t>>(
|
||||
static_cast<tim::tsettings<std::string>&>(*_v->second).get(),
|
||||
"causal fixed speedup", 5);
|
||||
"causal fixed speedup", 5L);
|
||||
}
|
||||
|
||||
std::string
|
||||
|
||||
+20
-17
@@ -64,10 +64,13 @@ void
|
||||
configure_disabled_settings(const std::shared_ptr<settings>&);
|
||||
|
||||
int
|
||||
get_realtime_signal();
|
||||
get_sampling_overflow_signal();
|
||||
|
||||
int
|
||||
get_cputime_signal();
|
||||
get_sampling_realtime_signal();
|
||||
|
||||
int
|
||||
get_sampling_cputime_signal();
|
||||
|
||||
std::set<int>
|
||||
get_sampling_signals(int64_t _tid = 0);
|
||||
@@ -233,15 +236,6 @@ get_use_code_coverage();
|
||||
bool
|
||||
get_sampling_keep_internal();
|
||||
|
||||
bool
|
||||
get_use_sampling_realtime();
|
||||
|
||||
bool
|
||||
get_use_sampling_cputime();
|
||||
|
||||
int
|
||||
get_sampling_rtoffset();
|
||||
|
||||
bool
|
||||
get_use_rcclp();
|
||||
|
||||
@@ -316,19 +310,22 @@ double
|
||||
get_sampling_freq();
|
||||
|
||||
double
|
||||
get_sampling_cpu_freq();
|
||||
get_sampling_cputime_freq();
|
||||
|
||||
double
|
||||
get_sampling_real_freq();
|
||||
get_sampling_realtime_freq();
|
||||
|
||||
double
|
||||
get_sampling_overflow_freq();
|
||||
|
||||
double
|
||||
get_sampling_delay();
|
||||
|
||||
double
|
||||
get_sampling_cpu_delay();
|
||||
get_sampling_cputime_delay();
|
||||
|
||||
double
|
||||
get_sampling_real_delay();
|
||||
get_sampling_realtime_delay();
|
||||
|
||||
double
|
||||
get_sampling_duration();
|
||||
@@ -337,10 +334,13 @@ std::string
|
||||
get_sampling_cpus();
|
||||
|
||||
std::set<int64_t>
|
||||
get_sampling_cpu_tids();
|
||||
get_sampling_cputime_tids();
|
||||
|
||||
std::set<int64_t>
|
||||
get_sampling_real_tids();
|
||||
get_sampling_realtime_tids();
|
||||
|
||||
std::set<int64_t>
|
||||
get_sampling_overflow_tids();
|
||||
|
||||
bool
|
||||
get_sampling_include_inlines();
|
||||
@@ -408,6 +408,9 @@ struct tmp_file
|
||||
std::shared_ptr<tmp_file>
|
||||
get_tmp_file(std::string _basename, std::string _ext = "dat");
|
||||
|
||||
CausalBackend
|
||||
get_causal_backend();
|
||||
|
||||
CausalMode
|
||||
get_causal_mode();
|
||||
|
||||
|
||||
@@ -82,6 +82,14 @@ struct c_array
|
||||
return c_array<Tp>(&m_base[start], end - start);
|
||||
}
|
||||
|
||||
void pop_front()
|
||||
{
|
||||
++m_base;
|
||||
--m_size;
|
||||
}
|
||||
|
||||
void pop_back() { --m_size; }
|
||||
|
||||
operator Tp*() const { return m_base; }
|
||||
|
||||
// Iterator class for convenient range-based for loop support
|
||||
|
||||
@@ -23,6 +23,7 @@
|
||||
#pragma once
|
||||
|
||||
#include "core/common.hpp"
|
||||
#include "core/containers/c_array.hpp"
|
||||
#include "core/debug.hpp"
|
||||
#include "core/exception.hpp"
|
||||
|
||||
@@ -50,6 +51,10 @@ struct static_vector
|
||||
static_vector& operator=(static_vector&&) noexcept = default;
|
||||
|
||||
static_vector(size_t _n, Tp _v = {});
|
||||
explicit static_vector(c_array<Tp>&&);
|
||||
|
||||
template <size_t M>
|
||||
explicit static_vector(std::array<Tp, M>&&);
|
||||
|
||||
static_vector& operator=(std::initializer_list<Tp>&& _v);
|
||||
static_vector& operator=(std::pair<std::array<Tp, N>, size_t>&&);
|
||||
@@ -92,10 +97,16 @@ struct static_vector
|
||||
decltype(auto) back() { return *(m_data.begin() + size() - 1); }
|
||||
decltype(auto) back() const { return *(m_data.begin() + size() - 1); }
|
||||
|
||||
auto* data() { return m_data.data(); }
|
||||
const auto* data() const { return m_data.data(); }
|
||||
|
||||
void swap(this_type& _v);
|
||||
|
||||
friend void swap(this_type& _lhs, this_type& _rhs) { _lhs.swap(_rhs); }
|
||||
|
||||
private:
|
||||
void update_size(size_t);
|
||||
|
||||
private:
|
||||
count_type m_size = count_type{ 0 };
|
||||
std::array<Tp, N> m_data = {};
|
||||
@@ -104,8 +115,25 @@ private:
|
||||
template <typename Tp, size_t N, bool AtomicSizeV>
|
||||
static_vector<Tp, N, AtomicSizeV>::static_vector(size_t _n, Tp _v)
|
||||
{
|
||||
m_size.store(_n);
|
||||
m_data.fill(_v);
|
||||
update_size(_n);
|
||||
}
|
||||
|
||||
template <typename Tp, size_t N, bool AtomicSizeV>
|
||||
static_vector<Tp, N, AtomicSizeV>::static_vector(c_array<Tp>&& _v)
|
||||
{
|
||||
auto _n = std::min<size_t>(N, _v.size());
|
||||
for(size_t i = 0; i < _n; ++i, ++m_size)
|
||||
m_data[i] = _v[i];
|
||||
}
|
||||
|
||||
template <typename Tp, size_t N, bool AtomicSizeV>
|
||||
template <size_t M>
|
||||
static_vector<Tp, N, AtomicSizeV>::static_vector(std::array<Tp, M>&& _v)
|
||||
{
|
||||
auto _n = std::min<size_t>(N, M);
|
||||
for(size_t i = 0; i < _n; ++i, ++m_size)
|
||||
m_data[i] = _v[i];
|
||||
}
|
||||
|
||||
template <typename Tp, size_t N, bool AtomicSizeV>
|
||||
@@ -129,14 +157,9 @@ template <typename Tp, size_t N, bool AtomicSizeV>
|
||||
static_vector<Tp, N, AtomicSizeV>&
|
||||
static_vector<Tp, N, AtomicSizeV>::operator=(std::pair<std::array<Tp, N>, size_t>&& _v)
|
||||
{
|
||||
if constexpr(AtomicSizeV) m_size.store(0);
|
||||
|
||||
update_size(0);
|
||||
m_data = std::move(_v.first);
|
||||
|
||||
if constexpr(AtomicSizeV)
|
||||
m_size.store(_v.second);
|
||||
else
|
||||
m_size = _v.second;
|
||||
update_size(_v.second);
|
||||
|
||||
return *this;
|
||||
}
|
||||
@@ -145,10 +168,7 @@ template <typename Tp, size_t N, bool AtomicSizeV>
|
||||
void
|
||||
static_vector<Tp, N, AtomicSizeV>::clear()
|
||||
{
|
||||
if constexpr(AtomicSizeV)
|
||||
m_size.store(0);
|
||||
else
|
||||
m_size = 0;
|
||||
update_size(0);
|
||||
}
|
||||
|
||||
template <typename Tp, size_t N, bool AtomicSizeV>
|
||||
@@ -160,8 +180,8 @@ static_vector<Tp, N, AtomicSizeV>::swap(this_type& _v)
|
||||
auto _t_size = m_size;
|
||||
auto _v_size = _v.m_size;
|
||||
std::swap(m_data, _v.m_data);
|
||||
m_size.store(_v_size);
|
||||
_v.m_size.store(_t_size);
|
||||
update_size(_v_size);
|
||||
_v.update_size(_t_size);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -190,5 +210,14 @@ static_vector<Tp, N, AtomicSizeV>::emplace_back(Args&&... _v)
|
||||
return m_data[_idx];
|
||||
}
|
||||
|
||||
template <typename Tp, size_t N, bool AtomicSizeV>
|
||||
void
|
||||
static_vector<Tp, N, AtomicSizeV>::update_size(size_t _n)
|
||||
{
|
||||
if constexpr(AtomicSizeV)
|
||||
m_size.store(_n);
|
||||
else
|
||||
m_size = _n;
|
||||
}
|
||||
} // namespace container
|
||||
} // namespace omnitrace
|
||||
|
||||
@@ -22,6 +22,7 @@
|
||||
|
||||
#include "debug.hpp"
|
||||
#include "binary/address_range.hpp"
|
||||
#include "locking.hpp"
|
||||
#include "state.hpp"
|
||||
|
||||
#include <timemory/log/color.hpp>
|
||||
@@ -87,7 +88,8 @@ set_source_location(source_location&& _v)
|
||||
}
|
||||
|
||||
lock::lock()
|
||||
: m_lk{ tim::type_mutex<decltype(std::cerr)>(), std::defer_lock }
|
||||
: m_lk{ tim::type_mutex<decltype(std::cerr), TIMEMORY_API, 1, locking::atomic_mutex>(),
|
||||
std::defer_lock }
|
||||
{
|
||||
if(!m_lk.owns_lock() && !_protect_lock)
|
||||
{
|
||||
|
||||
@@ -24,6 +24,7 @@
|
||||
|
||||
#include "defines.hpp"
|
||||
#include "exception.hpp"
|
||||
#include "locking.hpp"
|
||||
|
||||
#include <timemory/api.hpp>
|
||||
#include <timemory/backends/dmp.hpp>
|
||||
@@ -109,7 +110,7 @@ struct lock
|
||||
~lock();
|
||||
|
||||
private:
|
||||
tim::auto_lock_t m_lk;
|
||||
locking::atomic_lock m_lk;
|
||||
};
|
||||
//
|
||||
template <typename Arg, typename... Args>
|
||||
@@ -220,6 +221,43 @@ as_hex<void*>(void*, size_t);
|
||||
|
||||
//--------------------------------------------------------------------------------------//
|
||||
|
||||
#define OMNITRACE_CONDITIONAL_PRINT_COLOR(COLOR, COND, ...) \
|
||||
if((COND) && ::omnitrace::config::get_debug_tid() && \
|
||||
::omnitrace::config::get_debug_pid()) \
|
||||
{ \
|
||||
::omnitrace::debug::flush(); \
|
||||
::omnitrace::debug::lock _debug_lk{}; \
|
||||
OMNITRACE_FPRINTF_STDERR_COLOR(COLOR); \
|
||||
fprintf(::omnitrace::debug::get_file(), "[omnitrace][%i][%li]%s", \
|
||||
OMNITRACE_DEBUG_PROCESS_IDENTIFIER, OMNITRACE_DEBUG_THREAD_IDENTIFIER, \
|
||||
::omnitrace::debug::is_bracket(__VA_ARGS__) ? "" : " "); \
|
||||
fprintf(::omnitrace::debug::get_file(), __VA_ARGS__); \
|
||||
::omnitrace::debug::flush(); \
|
||||
}
|
||||
|
||||
#define OMNITRACE_CONDITIONAL_PRINT_COLOR_F(COLOR, COND, ...) \
|
||||
if((COND) && ::omnitrace::config::get_debug_tid() && \
|
||||
::omnitrace::config::get_debug_pid()) \
|
||||
{ \
|
||||
::omnitrace::debug::flush(); \
|
||||
::omnitrace::debug::lock _debug_lk{}; \
|
||||
OMNITRACE_FPRINTF_STDERR_COLOR(COLOR); \
|
||||
fprintf(::omnitrace::debug::get_file(), "[omnitrace][%i][%li][%s]%s", \
|
||||
OMNITRACE_DEBUG_PROCESS_IDENTIFIER, OMNITRACE_DEBUG_THREAD_IDENTIFIER, \
|
||||
OMNITRACE_FUNCTION, \
|
||||
::omnitrace::debug::is_bracket(__VA_ARGS__) ? "" : " "); \
|
||||
fprintf(::omnitrace::debug::get_file(), __VA_ARGS__); \
|
||||
::omnitrace::debug::flush(); \
|
||||
}
|
||||
|
||||
#define OMNITRACE_PRINT_COLOR(COLOR, ...) \
|
||||
OMNITRACE_CONDITIONAL_PRINT_COLOR(COLOR, true, __VA_ARGS__)
|
||||
|
||||
#define OMNITRACE_PRINT_COLOR_F(COLOR, ...) \
|
||||
OMNITRACE_CONDITIONAL_PRINT_COLOR_F(COLOR, true, __VA_ARGS__)
|
||||
|
||||
//--------------------------------------------------------------------------------------//
|
||||
|
||||
#define OMNITRACE_CONDITIONAL_PRINT(COND, ...) \
|
||||
if((COND) && ::omnitrace::config::get_debug_tid() && \
|
||||
::omnitrace::config::get_debug_pid()) \
|
||||
|
||||
@@ -28,6 +28,8 @@
|
||||
#include <set>
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
#include <sys/wait.h>
|
||||
#include <thread>
|
||||
#include <unistd.h>
|
||||
|
||||
namespace omnitrace
|
||||
@@ -70,5 +72,123 @@ get_process_index(int _pid, int _ppid)
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
int
|
||||
wait_pid(pid_t _pid, int _opts)
|
||||
{
|
||||
int _status = 0;
|
||||
pid_t _pid_v = -1;
|
||||
_opts |= WUNTRACED;
|
||||
do
|
||||
{
|
||||
if((_opts & WNOHANG) > 0)
|
||||
{
|
||||
std::this_thread::yield();
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds{ 100 });
|
||||
}
|
||||
_pid_v = waitpid(_pid, &_status, _opts);
|
||||
} while(_pid_v <= 0);
|
||||
return _status;
|
||||
}
|
||||
|
||||
int
|
||||
diagnose_status(pid_t _pid, int _status, int _verbose)
|
||||
{
|
||||
if(_verbose >= 3)
|
||||
{
|
||||
fflush(stderr);
|
||||
fflush(stdout);
|
||||
std::cout << std::flush;
|
||||
std::cerr << std::flush;
|
||||
}
|
||||
|
||||
bool _normal_exit = (WIFEXITED(_status) > 0);
|
||||
bool _unhandled_signal = (WIFSIGNALED(_status) > 0);
|
||||
bool _core_dump = (WCOREDUMP(_status) > 0);
|
||||
bool _stopped = (WIFSTOPPED(_status) > 0);
|
||||
int _exit_status = WEXITSTATUS(_status);
|
||||
int _stop_signal = (_stopped) ? WSTOPSIG(_status) : 0;
|
||||
int _ec = (_unhandled_signal) ? WTERMSIG(_status) : 0;
|
||||
|
||||
if(_verbose >= 4)
|
||||
{
|
||||
TIMEMORY_PRINTF_INFO(
|
||||
stderr,
|
||||
"diagnosing status for process %i :: status: %i... normal exit: %s, "
|
||||
"unhandled signal: %s, core dump: %s, stopped: %s, exit status: %i, stop "
|
||||
"signal: %i, exit code: %i\n",
|
||||
_pid, _status, std::to_string(_normal_exit).c_str(),
|
||||
std::to_string(_unhandled_signal).c_str(), std::to_string(_core_dump).c_str(),
|
||||
std::to_string(_stopped).c_str(), _exit_status, _stop_signal, _ec);
|
||||
}
|
||||
else if(_verbose >= 3)
|
||||
{
|
||||
TIMEMORY_PRINTF_INFO(stderr,
|
||||
"diagnosing status for process %i :: status: %i ...\n", _pid,
|
||||
_status);
|
||||
}
|
||||
|
||||
if(!_normal_exit)
|
||||
{
|
||||
if(_ec == 0) _ec = EXIT_FAILURE;
|
||||
if(_verbose >= 0)
|
||||
{
|
||||
TIMEMORY_PRINTF_FATAL(
|
||||
stderr, "process %i terminated abnormally. exit code: %i\n", _pid, _ec);
|
||||
}
|
||||
}
|
||||
|
||||
if(_stopped)
|
||||
{
|
||||
if(_verbose >= 0)
|
||||
{
|
||||
TIMEMORY_PRINTF_FATAL(stderr,
|
||||
"process %i stopped with signal %i. exit code: %i\n",
|
||||
_pid, _stop_signal, _ec);
|
||||
}
|
||||
}
|
||||
|
||||
if(_core_dump)
|
||||
{
|
||||
if(_verbose >= 0)
|
||||
{
|
||||
TIMEMORY_PRINTF_FATAL(
|
||||
stderr, "process %i terminated and produced a core dump. exit code: %i\n",
|
||||
_pid, _ec);
|
||||
}
|
||||
}
|
||||
|
||||
if(_unhandled_signal)
|
||||
{
|
||||
if(_verbose >= 0)
|
||||
{
|
||||
TIMEMORY_PRINTF_FATAL(stderr,
|
||||
"process %i terminated because it received a signal "
|
||||
"(%i) that was not handled. exit code: %i\n",
|
||||
_pid, _ec, _ec);
|
||||
}
|
||||
}
|
||||
|
||||
if(!_normal_exit && _exit_status > 0)
|
||||
{
|
||||
if(_verbose >= 0)
|
||||
{
|
||||
if(_exit_status == 127)
|
||||
{
|
||||
TIMEMORY_PRINTF_FATAL(
|
||||
stderr, "execv in process %i failed. exit code: %i\n", _pid, _ec);
|
||||
}
|
||||
else
|
||||
{
|
||||
TIMEMORY_PRINTF_FATAL(
|
||||
stderr,
|
||||
"process %i terminated with a non-zero status. exit code: %i\n", _pid,
|
||||
_ec);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return _ec;
|
||||
}
|
||||
} // namespace mproc
|
||||
} // namespace omnitrace
|
||||
|
||||
@@ -35,5 +35,11 @@ get_concurrent_processes(int _ppid = getppid());
|
||||
|
||||
int
|
||||
get_process_index(int _pid = getpid(), int _ppid = getppid());
|
||||
|
||||
int
|
||||
wait_pid(pid_t _pid, int _opts = 0);
|
||||
|
||||
int
|
||||
diagnose_status(pid_t _pid, int _status, int _verbose = 0);
|
||||
} // namespace mproc
|
||||
} // namespace omnitrace
|
||||
|
||||
@@ -0,0 +1,244 @@
|
||||
// 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 "perf.hpp"
|
||||
#include "debug.hpp"
|
||||
|
||||
#include <timemory/units.hpp>
|
||||
|
||||
namespace omnitrace
|
||||
{
|
||||
namespace perf
|
||||
{
|
||||
namespace units = ::tim::units;
|
||||
|
||||
std::vector<std::string>
|
||||
get_config_choices()
|
||||
{
|
||||
namespace regex_const = ::std::regex_constants;
|
||||
|
||||
auto _data = std::vector<std::string>{};
|
||||
auto _papi_events = tim::papi::available_events_info();
|
||||
const auto _prefix = std::string_view{ "perf::" };
|
||||
auto _regex =
|
||||
std::regex{ "^(perf::|)PERF_COUNT_(HW|SW|HW_CACHE)_([A-Z_]+)(|:[A-Z]+)$",
|
||||
regex_const::optimize };
|
||||
|
||||
for(const auto& itr : _papi_events)
|
||||
{
|
||||
if(std::regex_match(itr.symbol(), _regex))
|
||||
{
|
||||
auto _symbol = itr.symbol();
|
||||
auto _pos = _symbol.find(_prefix);
|
||||
if(_pos == 0) _symbol = _symbol.substr(_prefix.length());
|
||||
_data.emplace_back(_symbol);
|
||||
}
|
||||
}
|
||||
|
||||
std::sort(_data.begin(), _data.end());
|
||||
_data.erase(std::unique(_data.begin(), _data.end()), _data.end());
|
||||
|
||||
return _data;
|
||||
}
|
||||
|
||||
event_type
|
||||
get_event_type(std::string_view _v)
|
||||
{
|
||||
if(_v.find("PERF_COUNT_SW_") != std::string_view::npos)
|
||||
return event_type::software;
|
||||
else if(_v.find("PERF_COUNT_SW_") != std::string_view::npos &&
|
||||
!std::regex_search(_v.data(),
|
||||
std::regex{ "PERF_COUNT_HW_CACHE_(MISSES|REFERENCES)$" }))
|
||||
return event_type::hw_cache;
|
||||
else if(_v.find("PERF_COUNT_HW_") != std::string_view::npos)
|
||||
return event_type::hardware;
|
||||
return event_type::max;
|
||||
}
|
||||
|
||||
hw_config
|
||||
get_hw_config(std::string_view _v)
|
||||
{
|
||||
#define HW_CONFIG_REGEX(KEY) std::regex_search(_v.data(), std::regex{ "(HW_" KEY ")$" })
|
||||
|
||||
if(HW_CONFIG_REGEX("CPU_CYCLES"))
|
||||
return hw_config::cpu_cycles;
|
||||
else if(HW_CONFIG_REGEX("INSTRUCTIONS"))
|
||||
return hw_config::instructions;
|
||||
else if(HW_CONFIG_REGEX("CACHE_REFERENCES"))
|
||||
return hw_config::cache_references;
|
||||
else if(HW_CONFIG_REGEX("CACHE_MISSES"))
|
||||
return hw_config::cache_misses;
|
||||
else if(HW_CONFIG_REGEX("BRANCH_INSTRUCTIONS"))
|
||||
return hw_config::branch_instructions;
|
||||
else if(HW_CONFIG_REGEX("BRANCH_MISSES"))
|
||||
return hw_config::branch_misses;
|
||||
else if(HW_CONFIG_REGEX("BUS_CYCLES"))
|
||||
return hw_config::bus_cycles;
|
||||
else if(HW_CONFIG_REGEX("STALLED_CYCLES_FRONTEND"))
|
||||
return hw_config::stalled_cycles_frontend;
|
||||
else if(HW_CONFIG_REGEX("STALLED_CYCLES_BACKEND"))
|
||||
return hw_config::stalled_cycles_backend;
|
||||
else if(HW_CONFIG_REGEX("REF_CPU_CYCLES"))
|
||||
return hw_config::reference_cpu_cycles;
|
||||
else
|
||||
{
|
||||
OMNITRACE_THROW("Unknown perf hardware config: %s", _v.data());
|
||||
}
|
||||
|
||||
#undef HW_CONFIG_REGEX
|
||||
|
||||
return hw_config::max;
|
||||
}
|
||||
|
||||
sw_config
|
||||
get_sw_config(std::string_view _v)
|
||||
{
|
||||
#define SW_CONFIG_REGEX(KEY) std::regex_search(_v.data(), std::regex{ "(SW_" KEY ")$" })
|
||||
|
||||
if(SW_CONFIG_REGEX("CPU_CLOCK"))
|
||||
return sw_config::cpu_clock;
|
||||
else if(SW_CONFIG_REGEX("TASK_CLOCK"))
|
||||
return sw_config::task_clock;
|
||||
else if(SW_CONFIG_REGEX("PAGE_FAULTS"))
|
||||
return sw_config::page_faults;
|
||||
else if(SW_CONFIG_REGEX("CONTEXT_SWITCHES"))
|
||||
return sw_config::context_switches;
|
||||
else if(SW_CONFIG_REGEX("CPU_MIGRATIONS"))
|
||||
return sw_config::cpu_migrations;
|
||||
else if(SW_CONFIG_REGEX("PAGE_FAULTS_MIN"))
|
||||
return sw_config::page_faults_minor;
|
||||
else if(SW_CONFIG_REGEX("PAGE_FAULTS_MAJ"))
|
||||
return sw_config::page_faults_major;
|
||||
else if(SW_CONFIG_REGEX("ALIGNMENT_FAULTS"))
|
||||
return sw_config::alignment_faults;
|
||||
else if(SW_CONFIG_REGEX("EMULATION_FAULTS"))
|
||||
return sw_config::emulation_faults;
|
||||
else
|
||||
{
|
||||
OMNITRACE_THROW("Unknown perf hw cache config: %s", _v.data());
|
||||
}
|
||||
|
||||
#undef SW_CONFIG_REGEX
|
||||
|
||||
return sw_config::max;
|
||||
}
|
||||
|
||||
int
|
||||
get_hw_cache_config(std::string_view _v)
|
||||
{
|
||||
int _value = 0;
|
||||
|
||||
#define HW_CACHE_CONFIG_REGEX(KEY) \
|
||||
std::regex_search(_v.data(), std::regex{ "(HW_CACHE_" KEY ")" })
|
||||
|
||||
if(HW_CACHE_CONFIG_REGEX("L1D"))
|
||||
_value |= static_cast<int>(hw_cache_config::l1d);
|
||||
else if(HW_CACHE_CONFIG_REGEX("L1I"))
|
||||
_value |= static_cast<int>(hw_cache_config::l1i);
|
||||
else if(HW_CACHE_CONFIG_REGEX("LL"))
|
||||
_value |= static_cast<int>(hw_cache_config::ll);
|
||||
else if(HW_CACHE_CONFIG_REGEX("DTLB"))
|
||||
_value |= static_cast<int>(hw_cache_config::dtlb);
|
||||
else if(HW_CACHE_CONFIG_REGEX("ITLB"))
|
||||
_value |= static_cast<int>(hw_cache_config::itlb);
|
||||
else if(HW_CACHE_CONFIG_REGEX("BPU"))
|
||||
_value |= static_cast<int>(hw_cache_config::bpu);
|
||||
else if(HW_CACHE_CONFIG_REGEX("NODE"))
|
||||
_value |= static_cast<int>(hw_cache_config::node);
|
||||
else
|
||||
OMNITRACE_THROW("Unknown perf software config: %s", _v.data());
|
||||
|
||||
#undef HW_CACHE_CONFIG_REGEX
|
||||
#define HW_CACHE_OP_REGEX(KEY) \
|
||||
std::regex_search(_v.data(), std::regex{ "(HW_CACHE_([A-Z1]+):" KEY ")" })
|
||||
|
||||
if(HW_CACHE_OP_REGEX("READ"))
|
||||
_value |= (static_cast<int>(hw_cache_op::read) << 8);
|
||||
else if(HW_CACHE_OP_REGEX("WRITE"))
|
||||
_value |= (static_cast<int>(hw_cache_op::write) << 8);
|
||||
else if(HW_CACHE_OP_REGEX("PREFETCH"))
|
||||
_value |= (static_cast<int>(hw_cache_op::prefetch) << 8);
|
||||
else
|
||||
_value |= (static_cast<int>(hw_cache_op::read) << 8);
|
||||
|
||||
#undef HW_CACHE_OP_REGEX
|
||||
#define HW_CACHE_OP_RESULT_REGEX(KEY) \
|
||||
std::regex_search(_v.data(), std::regex{ "(HW_CACHE_([A-Z1]+):" KEY ")" })
|
||||
|
||||
if(HW_CACHE_OP_RESULT_REGEX("READ"))
|
||||
_value |= (static_cast<int>(hw_cache_op_result::access) << 16);
|
||||
else if(HW_CACHE_OP_RESULT_REGEX("WRITE"))
|
||||
_value |= (static_cast<int>(hw_cache_op_result::miss) << 16);
|
||||
else
|
||||
_value |= (static_cast<int>(hw_cache_op_result::access) << 16);
|
||||
|
||||
#undef HW_CACHE_OP_RESULT_REGEX
|
||||
|
||||
return _value;
|
||||
}
|
||||
|
||||
void
|
||||
config_overflow_sampling(struct perf_event_attr& _pe, std::string_view _event,
|
||||
double _freq)
|
||||
{
|
||||
auto _period = (1.0 / _freq) * units::sec;
|
||||
|
||||
_pe.type = static_cast<int>(perf::get_event_type(_event));
|
||||
switch(_pe.type)
|
||||
{
|
||||
case PERF_TYPE_HARDWARE:
|
||||
{
|
||||
_pe.config = static_cast<int>(perf::get_hw_config(_event));
|
||||
break;
|
||||
}
|
||||
case PERF_TYPE_SOFTWARE:
|
||||
{
|
||||
_pe.config = static_cast<int>(perf::get_sw_config(_event));
|
||||
break;
|
||||
}
|
||||
case PERF_TYPE_HW_CACHE:
|
||||
{
|
||||
_pe.config = static_cast<int>(perf::get_hw_cache_config(_event));
|
||||
break;
|
||||
}
|
||||
case PERF_TYPE_BREAKPOINT:
|
||||
case PERF_TYPE_TRACEPOINT:
|
||||
case PERF_TYPE_RAW:
|
||||
case PERF_TYPE_MAX:
|
||||
default:
|
||||
{
|
||||
OMNITRACE_THROW("unsupported perf type");
|
||||
}
|
||||
};
|
||||
|
||||
if(_pe.type == PERF_TYPE_SOFTWARE &&
|
||||
(_pe.config == PERF_COUNT_SW_CPU_CLOCK || _pe.config == PERF_COUNT_SW_TASK_CLOCK))
|
||||
{
|
||||
_pe.sample_period = static_cast<uint64_t>(_period);
|
||||
}
|
||||
else
|
||||
{
|
||||
_pe.sample_period = static_cast<uint64_t>(_freq);
|
||||
}
|
||||
}
|
||||
} // namespace perf
|
||||
} // namespace omnitrace
|
||||
@@ -0,0 +1,291 @@
|
||||
// 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 "core/defines.hpp"
|
||||
|
||||
#include <timemory/backends/papi.hpp>
|
||||
|
||||
#include <cstdint>
|
||||
#include <linux/perf_event.h>
|
||||
|
||||
#if __GLIBC__ == 2 && __GLIBC_MINOR__ < 30
|
||||
# include <sys/syscall.h>
|
||||
# define gettid() syscall(SYS_gettid)
|
||||
#endif
|
||||
|
||||
// Workaround for missing hw_breakpoint.h include file:
|
||||
// This include file just defines constants used to configure watchpoint registers.
|
||||
// This will be constant across x86 systems.
|
||||
enum
|
||||
{
|
||||
HW_BREAKPOINT_X = 4
|
||||
};
|
||||
|
||||
namespace omnitrace
|
||||
{
|
||||
namespace perf
|
||||
{
|
||||
/// An enum class with all the available sampling data
|
||||
enum class sample : uint64_t
|
||||
{
|
||||
ip = PERF_SAMPLE_IP,
|
||||
pid_tid = PERF_SAMPLE_TID,
|
||||
time = PERF_SAMPLE_TIME,
|
||||
addr = PERF_SAMPLE_ADDR,
|
||||
id = PERF_SAMPLE_ID,
|
||||
stream_id = PERF_SAMPLE_STREAM_ID,
|
||||
cpu = PERF_SAMPLE_CPU,
|
||||
period = PERF_SAMPLE_PERIOD,
|
||||
|
||||
#if defined(PERF_SAMPLE_READ)
|
||||
read = PERF_SAMPLE_READ,
|
||||
#else
|
||||
read = 0,
|
||||
#endif
|
||||
|
||||
callchain = PERF_SAMPLE_CALLCHAIN,
|
||||
raw = PERF_SAMPLE_RAW,
|
||||
|
||||
#if defined(PERF_SAMPLE_BRANCH_STACK)
|
||||
branch_stack = PERF_SAMPLE_BRANCH_STACK,
|
||||
#else
|
||||
branch_stack = 0,
|
||||
#endif
|
||||
|
||||
#if defined(PERF_SAMPLE_REGS_USER)
|
||||
regs = PERF_SAMPLE_REGS_USER,
|
||||
#else
|
||||
regs = 0,
|
||||
#endif
|
||||
|
||||
#if defined(PERF_SAMPLE_STACK_USER)
|
||||
stack = PERF_SAMPLE_STACK_USER,
|
||||
#else
|
||||
stack = 0,
|
||||
#endif
|
||||
|
||||
#if defined(PERF_SAMPLE_WEIGHT)
|
||||
weight = PERF_SAMPLE_WEIGHT,
|
||||
#else
|
||||
weight = 0,
|
||||
#endif
|
||||
|
||||
#if defined(PERF_SAMPLE_DATA_SRC)
|
||||
data_src = PERF_SAMPLE_DATA_SRC,
|
||||
#else
|
||||
data_src = 0,
|
||||
#endif
|
||||
|
||||
#if defined(PERF_SAMPLE_IDENTIFIER)
|
||||
identifier = PERF_SAMPLE_IDENTIFIER,
|
||||
#else
|
||||
identifier = 0,
|
||||
#endif
|
||||
|
||||
#if defined(PERF_SAMPLE_TRANSACTION)
|
||||
transaction = PERF_SAMPLE_TRANSACTION,
|
||||
#else
|
||||
transaction = 0,
|
||||
#endif
|
||||
|
||||
#if defined(PERF_SAMPLE_REGS_INTR)
|
||||
regs_intr = PERF_SAMPLE_REGS_INTR,
|
||||
#else
|
||||
regs_intr = 0,
|
||||
#endif
|
||||
|
||||
#if defined(PERF_SAMPLE_PHYS_ADDR)
|
||||
phys_addr = PERF_SAMPLE_PHYS_ADDR,
|
||||
#else
|
||||
phys_addr = 0,
|
||||
#endif
|
||||
|
||||
#if defined(PERF_SAMPLE_CGROUP)
|
||||
cgroup = PERF_SAMPLE_CGROUP,
|
||||
#else
|
||||
cgroup = 0,
|
||||
#endif
|
||||
|
||||
last = PERF_SAMPLE_MAX
|
||||
};
|
||||
|
||||
enum class event_type : int
|
||||
{
|
||||
hardware = PERF_TYPE_HARDWARE,
|
||||
software = PERF_TYPE_SOFTWARE,
|
||||
tracepoint = PERF_TYPE_TRACEPOINT,
|
||||
hw_cache = PERF_TYPE_HW_CACHE,
|
||||
raw = PERF_TYPE_RAW,
|
||||
breakpoint = PERF_TYPE_BREAKPOINT,
|
||||
max = PERF_TYPE_MAX,
|
||||
};
|
||||
|
||||
enum class hw_config : int
|
||||
{
|
||||
cpu_cycles = PERF_COUNT_HW_CPU_CYCLES,
|
||||
instructions = PERF_COUNT_HW_INSTRUCTIONS,
|
||||
cache_references = PERF_COUNT_HW_CACHE_REFERENCES,
|
||||
cache_misses = PERF_COUNT_HW_CACHE_MISSES,
|
||||
branch_instructions = PERF_COUNT_HW_BRANCH_INSTRUCTIONS,
|
||||
branch_misses = PERF_COUNT_HW_BRANCH_MISSES,
|
||||
bus_cycles = PERF_COUNT_HW_BUS_CYCLES,
|
||||
stalled_cycles_frontend = PERF_COUNT_HW_STALLED_CYCLES_FRONTEND,
|
||||
stalled_cycles_backend = PERF_COUNT_HW_STALLED_CYCLES_BACKEND,
|
||||
reference_cpu_cycles = PERF_COUNT_HW_REF_CPU_CYCLES,
|
||||
max = PERF_COUNT_HW_MAX,
|
||||
};
|
||||
|
||||
enum class sw_config : int
|
||||
{
|
||||
cpu_clock = PERF_COUNT_SW_CPU_CLOCK,
|
||||
task_clock = PERF_COUNT_SW_TASK_CLOCK,
|
||||
page_faults = PERF_COUNT_SW_PAGE_FAULTS,
|
||||
context_switches = PERF_COUNT_SW_CONTEXT_SWITCHES,
|
||||
cpu_migrations = PERF_COUNT_SW_CPU_MIGRATIONS,
|
||||
page_faults_minor = PERF_COUNT_SW_PAGE_FAULTS_MIN,
|
||||
page_faults_major = PERF_COUNT_SW_PAGE_FAULTS_MAJ,
|
||||
alignment_faults = PERF_COUNT_SW_ALIGNMENT_FAULTS,
|
||||
emulation_faults = PERF_COUNT_SW_EMULATION_FAULTS,
|
||||
max = PERF_COUNT_SW_MAX,
|
||||
};
|
||||
|
||||
enum class hw_cache_config : int
|
||||
{
|
||||
l1d = PERF_COUNT_HW_CACHE_L1D,
|
||||
l1i = PERF_COUNT_HW_CACHE_L1I,
|
||||
ll = PERF_COUNT_HW_CACHE_LL,
|
||||
dtlb = PERF_COUNT_HW_CACHE_DTLB,
|
||||
itlb = PERF_COUNT_HW_CACHE_ITLB,
|
||||
bpu = PERF_COUNT_HW_CACHE_BPU,
|
||||
node = PERF_COUNT_HW_CACHE_NODE,
|
||||
max = PERF_COUNT_HW_CACHE_MAX,
|
||||
};
|
||||
|
||||
enum class hw_cache_op : int
|
||||
{
|
||||
read = PERF_COUNT_HW_CACHE_OP_READ,
|
||||
write = PERF_COUNT_HW_CACHE_OP_WRITE,
|
||||
prefetch = PERF_COUNT_HW_CACHE_OP_PREFETCH,
|
||||
max = PERF_COUNT_HW_CACHE_OP_MAX,
|
||||
};
|
||||
|
||||
enum class hw_cache_op_result : int
|
||||
{
|
||||
access = PERF_COUNT_HW_CACHE_RESULT_ACCESS,
|
||||
miss = PERF_COUNT_HW_CACHE_RESULT_MISS,
|
||||
max = PERF_COUNT_HW_CACHE_RESULT_MAX,
|
||||
};
|
||||
|
||||
/// An enum to distinguish types of records in the mmapped ring buffer
|
||||
enum class record_type
|
||||
{
|
||||
mmap = PERF_RECORD_MMAP,
|
||||
lost = PERF_RECORD_LOST,
|
||||
comm = PERF_RECORD_COMM,
|
||||
exit = PERF_RECORD_EXIT,
|
||||
throttle = PERF_RECORD_THROTTLE,
|
||||
unthrottle = PERF_RECORD_UNTHROTTLE,
|
||||
fork = PERF_RECORD_FORK,
|
||||
read = PERF_RECORD_READ,
|
||||
sample = PERF_RECORD_SAMPLE,
|
||||
|
||||
#if defined(PERF_RECORD_MMAP2)
|
||||
mmap2 = PERF_RECORD_MMAP2,
|
||||
#else
|
||||
mmap2 = 0,
|
||||
#endif
|
||||
|
||||
#if defined(PERF_RECORD_AUX)
|
||||
aux = PERF_RECORD_AUX,
|
||||
#else
|
||||
aux = 0,
|
||||
#endif
|
||||
|
||||
#if defined(PERF_RECORD_ITRACE_START)
|
||||
itrace_start = PERF_RECORD_ITRACE_START,
|
||||
#else
|
||||
itrace_start = 0,
|
||||
#endif
|
||||
|
||||
#if defined(PERF_RECORD_LOST_SAMPLES)
|
||||
lost_samples = PERF_RECORD_LOST_SAMPLES,
|
||||
#else
|
||||
lost_samples = 0,
|
||||
#endif
|
||||
|
||||
#if defined(PERF_RECORD_SWITCH)
|
||||
switch_record = PERF_RECORD_SWITCH,
|
||||
#else
|
||||
switch_record = 0,
|
||||
#endif
|
||||
|
||||
#if defined(PERF_RECORD_SWITCH_CPU_WIDE)
|
||||
switch_cpu_wide = PERF_RECORD_SWITCH_CPU_WIDE,
|
||||
#else
|
||||
switch_cpu_wide = 0,
|
||||
#endif
|
||||
|
||||
#if defined(PERF_RECORD_NAMESPACES)
|
||||
namespaces = PERF_RECORD_NAMESPACES,
|
||||
#else
|
||||
namespaces = 0,
|
||||
#endif
|
||||
|
||||
#if defined(PERF_RECORD_KSYMBOL)
|
||||
ksymbol = PERF_RECORD_KSYMBOL,
|
||||
#else
|
||||
ksymbol = 0,
|
||||
#endif
|
||||
|
||||
#if defined(PERF_RECORD_BPF_EVENT)
|
||||
bpf_event = PERF_RECORD_BPF_EVENT,
|
||||
#else
|
||||
bpf_event = 0,
|
||||
#endif
|
||||
|
||||
#if defined(PERF_RECORD_CGROUP)
|
||||
cgroup = PERF_RECORD_CGROUP,
|
||||
#else
|
||||
cgroup = 0,
|
||||
#endif
|
||||
|
||||
#if defined(PERF_RECORD_TEXT_POKE)
|
||||
text_poke = PERF_RECORD_TEXT_POKE,
|
||||
#else
|
||||
text_poke = 0,
|
||||
#endif
|
||||
};
|
||||
|
||||
std::vector<std::string>
|
||||
get_config_choices();
|
||||
|
||||
event_type get_event_type(std::string_view);
|
||||
hw_config get_hw_config(std::string_view);
|
||||
sw_config get_sw_config(std::string_view);
|
||||
int get_hw_cache_config(std::string_view);
|
||||
|
||||
void
|
||||
config_overflow_sampling(struct perf_event_attr&, std::string_view, double);
|
||||
} // namespace perf
|
||||
} // namespace omnitrace
|
||||
@@ -57,6 +57,13 @@ enum class Mode : unsigned short
|
||||
Coverage
|
||||
};
|
||||
|
||||
enum class CausalBackend : unsigned short
|
||||
{
|
||||
Perf = 0,
|
||||
Timer,
|
||||
Auto,
|
||||
};
|
||||
|
||||
enum class CausalMode : unsigned short
|
||||
{
|
||||
Line = 0,
|
||||
|
||||
@@ -0,0 +1,123 @@
|
||||
// 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 "utility.hpp"
|
||||
#include "debug.hpp"
|
||||
|
||||
namespace omnitrace
|
||||
{
|
||||
namespace utility
|
||||
{
|
||||
namespace
|
||||
{
|
||||
template <typename ContainerT, typename Arg>
|
||||
auto
|
||||
emplace_impl(ContainerT& _targ, Arg&& _v, int)
|
||||
-> decltype(_targ.emplace(std::forward<Arg>(_v)))
|
||||
{
|
||||
return _targ.emplace(std::forward<Arg>(_v));
|
||||
}
|
||||
|
||||
template <typename ContainerT, typename Arg>
|
||||
auto
|
||||
emplace_impl(ContainerT& _targ, Arg&& _v, long)
|
||||
-> decltype(_targ.emplace_back(std::forward<Arg>(_v)))
|
||||
{
|
||||
return _targ.emplace_back(std::forward<Arg>(_v));
|
||||
}
|
||||
|
||||
template <typename ContainerT, typename Arg>
|
||||
decltype(auto)
|
||||
emplace(ContainerT& _targ, Arg&& _v)
|
||||
{
|
||||
return emplace_impl(_targ, std::forward<Arg>(_v), 0);
|
||||
}
|
||||
} // namespace
|
||||
|
||||
template <typename Tp, typename ContainerT, typename Up>
|
||||
ContainerT
|
||||
parse_numeric_range(std::string _input_string, const std::string& _label, Up _incr)
|
||||
{
|
||||
auto _get_value = [](const std::string& _inp) {
|
||||
std::stringstream iss{ _inp };
|
||||
auto var = Tp{};
|
||||
iss >> var;
|
||||
return var;
|
||||
};
|
||||
|
||||
for(auto& itr : _input_string)
|
||||
itr = tolower(itr);
|
||||
auto _result = ContainerT{};
|
||||
for(auto _v : tim::delimit(_input_string, ",; \t\n\r"))
|
||||
{
|
||||
if(_v.find_first_not_of("0123456789-:") != std::string::npos)
|
||||
{
|
||||
OMNITRACE_BASIC_VERBOSE_F(
|
||||
0,
|
||||
"Invalid %s specification. Only numerical values (e.g., 0), ranges "
|
||||
"(e.g., 0-7), and ranges with increments (e.g. 20-40:10) are permitted. "
|
||||
"Ignoring %s...",
|
||||
_label.c_str(), _v.c_str());
|
||||
continue;
|
||||
}
|
||||
|
||||
auto _incr_v = _incr;
|
||||
auto _incr_pos = _v.find(':');
|
||||
if(_incr_pos != std::string::npos)
|
||||
{
|
||||
auto _incr_str = _v.substr(_incr_pos + 1);
|
||||
if(!_incr_str.empty()) _incr_v = static_cast<Up>(std::stoull(_incr_str));
|
||||
_v = _v.substr(0, _incr_pos);
|
||||
}
|
||||
|
||||
if(_v.find('-') != std::string::npos)
|
||||
{
|
||||
auto _vv = tim::delimit(_v, "-");
|
||||
OMNITRACE_CONDITIONAL_THROW(
|
||||
_vv.size() != 2,
|
||||
"Invalid %s range specification: %s. Required format N-M, e.g. 0-4",
|
||||
_label.c_str(), _v.c_str());
|
||||
Tp _vn = _get_value(_vv.at(0));
|
||||
Tp _vN = _get_value(_vv.at(1));
|
||||
do
|
||||
{
|
||||
emplace(_result, _vn);
|
||||
_vn += _incr_v;
|
||||
} while(_vn <= _vN);
|
||||
}
|
||||
else
|
||||
{
|
||||
emplace(_result, std::stoll(_v));
|
||||
}
|
||||
}
|
||||
return _result;
|
||||
}
|
||||
|
||||
template std::set<int64_t>
|
||||
parse_numeric_range<int64_t, std::set<int64_t>>(std::string, const std::string&, long);
|
||||
template std::vector<int64_t>
|
||||
parse_numeric_range<int64_t, std::vector<int64_t>>(std::string, const std::string&, long);
|
||||
template std::unordered_set<int64_t>
|
||||
parse_numeric_range<int64_t, std::unordered_set<int64_t>>(std::string, const std::string&,
|
||||
long);
|
||||
} // namespace utility
|
||||
} // namespace omnitrace
|
||||
@@ -25,6 +25,7 @@
|
||||
#include "concepts.hpp"
|
||||
|
||||
#include <timemory/mpl/concepts.hpp>
|
||||
#include <timemory/utility/delimit.hpp>
|
||||
#include <timemory/utility/join.hpp>
|
||||
|
||||
#include <algorithm>
|
||||
@@ -32,6 +33,7 @@
|
||||
#include <atomic>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <set>
|
||||
#include <sstream>
|
||||
#include <stdexcept>
|
||||
#include <vector>
|
||||
@@ -238,5 +240,17 @@ convert(std::string_view _inp)
|
||||
_iss >> _ret;
|
||||
return _ret;
|
||||
}
|
||||
|
||||
template <typename Tp = int64_t, typename ContainerT = std::set<Tp>, typename Up = Tp>
|
||||
ContainerT
|
||||
parse_numeric_range(std::string _input_string, const std::string& _label, Up _incr);
|
||||
|
||||
extern template std::set<int64_t>
|
||||
parse_numeric_range<int64_t, std::set<int64_t>>(std::string, const std::string&, long);
|
||||
extern template std::vector<int64_t>
|
||||
parse_numeric_range<int64_t, std::vector<int64_t>>(std::string, const std::string&, long);
|
||||
extern template std::unordered_set<int64_t>
|
||||
parse_numeric_range<int64_t, std::unordered_set<int64_t>>(std::string, const std::string&,
|
||||
long);
|
||||
} // namespace utility
|
||||
} // namespace omnitrace
|
||||
|
||||
Reference in New Issue
Block a user