#include "timemory/sampling/sampler.hpp"

Collaboration diagram for tim::sampling::sampler< CompT< Types... >, N, SigIds... >:

Public Types
using	this_type = sampler< CompT< Types... >, N, SigIds... >

using	base_type = component::base< this_type, void >

using	components_t = CompT< Types... >

using	signal_set_t = std::set< int >

using	pid_cb_t = std::function< bool(pid_t, int, int)>

using	array_t = conditional_t< fixed_size_t< N >::value, std::array< components_t, N >, std::vector< components_t > >

using	array_type = array_t

using	tracker_type = policy::instance_tracker< this_type, false >

using	storage_type = empty_storage

Public Member Functions
template<typename Tp = fixed_size_t<N>, enable_if_t< Tp::value > = 0>
	sampler (const std::string &_label, signal_set_t _good, signal_set_t _bad=signal_set_t{})

template<typename Tp = fixed_size_t<N>, enable_if_t<!Tp::value > = 0>
	sampler (const std::string &_label, signal_set_t _good, signal_set_t _bad=signal_set_t{})

	~sampler ()

template<typename Tp = fixed_size_t<N>, enable_if_t< Tp::value > = 0>
void	sample ()

template<typename Tp = fixed_size_t<N>, enable_if_t<!Tp::value > = 0>
void	sample ()

template<typename Tp = fixed_sig_t<SigIds...>, enable_if_t< Tp::value > = 0>
void	start ()

template<typename Tp = fixed_sig_t<SigIds...>, enable_if_t< Tp::value > = 0>
void	stop ()

template<typename Tp = fixed_sig_t<SigIds...>, enable_if_t<!Tp::value > = 0>
void	start ()

template<typename Tp = fixed_sig_t<SigIds...>, enable_if_t<!Tp::value > = 0>
void	stop ()

bool	is_good (int v) const

bool	is_bad (int v) const

auto	good_count () const

auto	bad_count () const

auto	count () const

auto &	get_good ()

auto &	get_bad ()

const auto &	get_good () const

const auto &	get_bad () const

auto	backtrace_enabled () const

void	enable_backtrace (bool val)

components_t *&	get_last ()

components_t *	get_last () const

components_t *&	get_latest ()

components_t *	get_latest () const

template<typename Tp = fixed_size_t<N>, enable_if_t< Tp::value > = 0>
components_t &	get (size_t idx)

template<typename Tp = fixed_size_t<N>, enable_if_t<!Tp::value > = 0>
components_t &	get (size_t idx)

template<typename Tp = fixed_size_t<N>, enable_if_t< Tp::value > = 0>
const components_t &	get (size_t idx) const

template<typename Tp = fixed_size_t<N>, enable_if_t<!Tp::value > = 0>
const components_t &	get (size_t idx) const

array_t &	get_data ()

const array_t &	get_data () const

template<typename Tp , enable_if_t< Tp::value > >
sampler< CompT< Types... >, N, SigIds... >::components_t &	get (size_t idx)

template<typename Tp , enable_if_t< Tp::value > >
const sampler< CompT< Types... >, N, SigIds... >::components_t &	get (size_t idx) const

void	get () const

Static Public Member Functions
static void	execute (int signum)

static void	execute (int signum, siginfo_t , void )

static auto &	get_samplers ()

static auto	get_latest_samples ()

static void	configure (std::set< int > _signals, int _verbose=1)
	Set up the sampler. More...

static void	configure (int _signal=SIGALRM, int _verbose=1)

static void	ignore (const std::set< int > &_signals)
	Ignore the signals. More...

static void	clear ()
	Clear all signals. Recommended to call ignore() prior to clearing all the signals. More...

static void	pause ()
	Pause until a signal is delivered. More...

template<typename Func = pid_cb_t>
static int	wait (pid_t _pid, int _verbose, bool _debug, Func &&_callback=pid_callback())
	Wait function with an optional user callback of type: More...

template<typename Func = pid_cb_t>
static int	wait (int _verbose=settings::verbose(), bool _debug=settings::debug(), Func &&_callback=pid_callback())

template<typename Func , enable_if_t< std::is_function< Func >::value > = 0>
static int	wait (pid_t _pid, Func &&_callback, int _verbose=settings::verbose(), bool _debug=settings::debug())

template<typename Func , enable_if_t< std::is_function< Func >::value > = 0>
static int	wait (Func &&_callback, int _verbose=settings::verbose(), bool _debug=settings::debug())

static void	set_flags (int _flags)
	Set the sigaction flags, e.g. SA_RESTART \| SA_SIGINFO. More...

static void	set_delay (double fdelay)
	Value, expressed in seconds, that sets the length of time the sampler waits before starting sampling of the relevant measurements. More...

static void	set_frequency (double ffreq)

static void	set_rate (double frate)
	Value, expressed in number of interupts per second, that configures the frequency that the sampler samples the relevant measurements. More...

static int64_t	get_delay (int64_t units=units::usec)
	Get the delay of the sampler. More...

static int64_t	get_frequency (int64_t units=units::usec)
	Get the frequency of the sampler. More...

static int	get_itimer (int _signal)
	Returns the itimer value associated with the given signal. More...

static bool	check_itimer (int _stat, bool _throw_exception=false)
	Checks to see if there was an error setting or getting itimer val. More...

template<typename... Args>
static opaque	get_opaque (Args &&...)

Protected Attributes
bool	m_backtrace = false

size_t	m_idx = 0

components_t *	m_last = nullptr

signal_set_t	m_good = {}

signal_set_t	m_bad = {}

array_t	m_data = {}

Detailed Description

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>
struct tim::sampling::sampler< CompT< Types... >, N, SigIds... >

Definition at line 157 of file sampler.hpp.

Member Typedef Documentation

◆ array_t

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

using tim::sampling::sampler< CompT< Types... >, N, SigIds... >::array_t = conditional_t<fixed_size_t<N>::value, std::array<components_t, N>, std::vector<components_t> >

Definition at line 166 of file sampler.hpp.

◆ array_type

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

using tim::sampling::sampler< CompT< Types... >, N, SigIds... >::array_type = array_t

Definition at line 169 of file sampler.hpp.

◆ base_type

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

using tim::sampling::sampler< CompT< Types... >, N, SigIds... >::base_type = component::base<this_type, void>

Definition at line 162 of file sampler.hpp.

◆ components_t

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

using tim::sampling::sampler< CompT< Types... >, N, SigIds... >::components_t = CompT<Types...>

Definition at line 163 of file sampler.hpp.

◆ pid_cb_t

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

using tim::sampling::sampler< CompT< Types... >, N, SigIds... >::pid_cb_t = std::function<bool(pid_t, int, int)>

Definition at line 165 of file sampler.hpp.

◆ signal_set_t

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

using tim::sampling::sampler< CompT< Types... >, N, SigIds... >::signal_set_t = std::set<int>

Definition at line 164 of file sampler.hpp.

◆ storage_type

using tim::component::empty_base::storage_type = empty_storage

inherited

Definition at line 66 of file declaration.hpp.

◆ this_type

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

using tim::sampling::sampler< CompT< Types... >, N, SigIds... >::this_type = sampler<CompT<Types...>, N, SigIds...>

Definition at line 161 of file sampler.hpp.

◆ tracker_type

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

using tim::sampling::sampler< CompT< Types... >, N, SigIds... >::tracker_type = policy::instance_tracker<this_type, false>

Definition at line 170 of file sampler.hpp.

Constructor & Destructor Documentation

◆ sampler() [1/2]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

template<typename Tp , enable_if_t<!Tp::value > >

tim::sampling::sampler< CompT< Types... >, N, SigIds... >::sampler	(	const std::string &	_label,
		signal_set_t	_good,
		signal_set_t	_bad = `signal_set_t{}`
	)

Definition at line 406 of file sampler.hpp.

: m_last(nullptr)
, m_good(std::move(_good))
, m_bad(std::move(_bad))
{
    TIMEMORY_FOLD_EXPRESSION(m_good.insert(SigIds));
    m_data.fill(components_t(_label));
    m_last = &m_data.front();
    auto_lock_t lk(type_mutex<this_type>());
    get_samplers().push_back(this);
}

References TIMEMORY_FOLD_EXPRESSION.

◆ sampler() [2/2]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

template<typename Tp = fixed_size_t<N>, enable_if_t<!Tp::value > = 0>

tim::sampling::sampler< CompT< Types... >, N, SigIds... >::sampler	(	const std::string &	_label,
		signal_set_t	_good,
		signal_set_t	_bad = `signal_set_t{}`
	)

◆ ~sampler()

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

tim::sampling::sampler< CompT< Types... >, N, SigIds... >::~sampler

Definition at line 439 of file sampler.hpp.

{
    auto_lock_t lk(type_mutex<this_type>());
    auto&       _samplers = get_samplers();
    auto        itr       = std::find(_samplers.begin(), _samplers.end(), this);
    if(itr != _samplers.end())
        _samplers.erase(itr);
}

Member Function Documentation

◆ backtrace_enabled()

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

auto tim::sampling::sampler< CompT< Types... >, N, SigIds... >::backtrace_enabled ( ) const

inline

Definition at line 218 of file sampler.hpp.

218{ return m_backtrace; }

tim::sampling::sampler< CompT< Types... >, N, SigIds... >::m_backtrace

bool m_backtrace

Definition: sampler.hpp:349

◆ bad_count()

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

auto tim::sampling::sampler< CompT< Types... >, N, SigIds... >::bad_count ( ) const

inline

Definition at line 209 of file sampler.hpp.

209{ return m_bad.size(); }

◆ check_itimer()

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

bool tim::sampling::sampler< CompT< Types... >, N, SigIds... >::check_itimer	(	int	_stat,
		bool	_throw_exception = `false`
	)

static

Checks to see if there was an error setting or getting itimer val.

Definition at line 1002 of file sampler.hpp.

{
    if(_stat == EFAULT)
    {
        auto msg =
            TIMEMORY_JOIN(" ", "Warning! setitimer returned EFAULT.",
                          "Either the new itimerval or the old itimerval was invalid");
        if(_throw_exception)
        {
            TIMEMORY_EXCEPTION(msg)
        }
        else
        {
            std::cerr << msg << '\n';
        }
    }
    else if(_stat == EINVAL)
    {
        auto msg = TIMEMORY_JOIN(" ", "Warning! setitimer returned EINVAL.",
                                 "Either the timer was not one of: ['ITIMER_REAL', "
                                 "'ITIMER_VIRTUAL', "
                                 "'ITIMER_PROF'] or the old itimerval was invalid");
        if(_throw_exception)
        {
            TIMEMORY_EXCEPTION(msg)
        }
        else
        {
            std::cerr << msg << '\n';
        }
    }
    return (_stat != EFAULT && _stat != EINVAL);
}

References TIMEMORY_EXCEPTION, and TIMEMORY_JOIN.

◆ clear()

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

void tim::sampling::sampler< CompT< Types... >, N, SigIds... >::clear ( )

inlinestatic

Clear all signals. Recommended to call ignore() prior to clearing all the signals.

Definition at line 261 of file sampler.hpp.

261{ get_persistent_data().m_signals.clear(); }

◆ configure() [1/2]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

static void tim::sampling::sampler< CompT< Types... >, N, SigIds... >::configure	(	int	_signal = `SIGALRM`,
		int	_verbose = `1`
	)

inlinestatic

Definition at line 247 of file sampler.hpp.

    {
        configure({ _signal }, _verbose);
    }

References tim::configure().

◆ configure() [2/2]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

void tim::sampling::sampler< CompT< Types... >, N, SigIds... >::configure	(	std::set< int >	_signals,
		int	_verb = `1`
	)

static

Set up the sampler.

Parameters

[in]	_signals	A set of signals to catch
[in]	_verb	Logging Verbosity

Definition at line 649 of file sampler.hpp.

{
    // already active
    if(get_persistent_data().m_active)
        return;
 
    size_t wait_count = 0;
    {
        auto_lock_t lk(type_mutex<this_type>());
        for(auto& itr : get_samplers())
            wait_count += itr->count();
    }
 
    if(wait_count == 0)
    {
        if(_verbose > 0)
        {
            fprintf(stderr,
                    "[sampler::configure]> No existing sampler has been configured to "
                    "sample at a specific signal or fail at a specific signal. itimer "
                    "for will not be set. Sampler will only wait for target pid to "
                    "exit\n");
        }
        _signals.clear();
    }
    else
    {
        TIMEMORY_FOLD_EXPRESSION(_signals.insert(SigIds));
    }
 
    if(!_signals.empty())
    {
        auto& _custom_sa   = get_persistent_data().m_custom_sigaction;
        auto& _custom_it   = get_persistent_data().m_custom_itimerval;
        auto& _original_sa = get_persistent_data().m_original_sigaction;
        auto& _original_it = get_persistent_data().m_original_itimerval;
 
        memset(&_custom_sa, 0, sizeof(_custom_sa));
 
        _custom_sa.sa_handler   = &this_type::execute;
        _custom_sa.sa_sigaction = &this_type::execute;
        _custom_sa.sa_flags     = SA_RESTART | SA_SIGINFO;
 
        // start the interval timer
        for(const auto& itr : _signals)
        {
            // get the associated itimer type
            auto _itimer = get_itimer(itr);
            if(_itimer < 0)
            {
                TIMEMORY_EXCEPTION(
                    TIMEMORY_JOIN(" ", "Error! Alarm cannot be set for signal", itr,
                                  "because the signal does not map to a known itimer "
                                  "value\n"));
            }
 
            // configure the sigaction
            int _sret = sigaction(itr, &_custom_sa, &_original_sa);
            if(_sret == 0)
            {
                get_persistent_data().m_signals.insert(itr);
            }
            else
            {
                TIMEMORY_EXCEPTION(TIMEMORY_JOIN(
                    " ", "Error! sigaction could not be set for signal", itr));
            }
 
            // start the alarm (throws if fails)
            check_itimer(setitimer(_itimer, &_custom_it, &_original_it), true);
        }
    }
 
    // if active field based on whether there are signals
    get_persistent_data().m_active = !get_persistent_data().m_signals.empty();
}

References tim::ert::execute(), TIMEMORY_EXCEPTION, TIMEMORY_FOLD_EXPRESSION, and TIMEMORY_JOIN.

◆ count()

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

auto tim::sampling::sampler< CompT< Types... >, N, SigIds... >::count ( ) const

inline

Definition at line 210 of file sampler.hpp.

210{ return good_count() + bad_count(); }

tim::sampling::sampler< CompT< Types... >, N, SigIds... >::bad_count

auto bad_count() const

Definition: sampler.hpp:209

tim::sampling::sampler< CompT< Types... >, N, SigIds... >::good_count

auto good_count() const

Definition: sampler.hpp:208

◆ enable_backtrace()

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

void tim::sampling::sampler< CompT< Types... >, N, SigIds... >::enable_backtrace ( bool val )

inline

Definition at line 219 of file sampler.hpp.

219{ m_backtrace = val; }

◆ execute() [1/2]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

void tim::sampling::sampler< CompT< Types... >, N, SigIds... >::execute ( int signum )

static

Definition at line 589 of file sampler.hpp.

{
    if(settings::debug())
    {
        printf("[pid=%i][tid=%i][%s]> sampling...\n", (int) process::get_id(),
               (int) threading::get_id(), demangle<this_type>().c_str());
    }
 
    for(auto& itr : get_samplers())
    {
        if(itr->is_good(signum))
        {
            itr->sample();
        }
        else if(itr->is_bad(signum))
        {
            char msg[1024];
            sprintf(msg, "[timemory]> sampler instance caught bad signal: %i ...",
                    signum);
            perror(msg);
            signal(signum, SIG_DFL);
            raise(signum);
        }
    }
}

References tim::debug.

◆ execute() [2/2]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

void tim::sampling::sampler< CompT< Types... >, N, SigIds... >::execute	(	int	signum,
		siginfo_t *	,
		void *
	)

static

Definition at line 619 of file sampler.hpp.

{
    if(settings::debug())
    {
        printf("[pid=%i][tid=%i][%s]> sampling...\n", (int) process::get_id(),
               (int) threading::get_id(), demangle<this_type>().c_str());
    }
 
    for(auto& itr : get_samplers())
    {
        if(itr->is_good(signum))
        {
            itr->sample();
        }
        else if(itr->is_bad(signum))
        {
            char msg[1024];
            sprintf(msg, "[timemory]> sampler instance caught bad signal: %i ...",
                    signum);
            perror(msg);
            signal(signum, SIG_DFL);
            raise(signum);
        }
    }
}

References tim::debug.

◆ get() [1/7]

void tim::component::empty_base::get ( ) const

inlineinherited

Definition at line 69 of file declaration.hpp.

69{}

◆ get() [2/7]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

template<typename Tp = fixed_size_t<N>, enable_if_t< Tp::value > = 0>

components_t & tim::sampling::sampler< CompT< Types... >, N, SigIds... >::get ( size_t idx )

◆ get() [3/7]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

template<typename Tp = fixed_size_t<N>, enable_if_t<!Tp::value > = 0>

components_t & tim::sampling::sampler< CompT< Types... >, N, SigIds... >::get ( size_t idx )

◆ get() [4/7]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

template<typename Tp , enable_if_t<!Tp::value > >

sampler< CompT< Types... >, N, SigIds... >::components_t & tim::sampling::sampler< CompT< Types... >, N, SigIds... >::get ( size_t idx )

Definition at line 550 of file sampler.hpp.

{
    return m_data.at(idx % N);
}

◆ get() [5/7]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

template<typename Tp = fixed_size_t<N>, enable_if_t< Tp::value > = 0>

const components_t & tim::sampling::sampler< CompT< Types... >, N, SigIds... >::get ( size_t idx ) const

◆ get() [6/7]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

template<typename Tp = fixed_size_t<N>, enable_if_t<!Tp::value > = 0>

const components_t & tim::sampling::sampler< CompT< Types... >, N, SigIds... >::get ( size_t idx ) const

◆ get() [7/7]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

template<typename Tp , enable_if_t<!Tp::value > >

const sampler< CompT< Types... >, N, SigIds... >::components_t & tim::sampling::sampler< CompT< Types... >, N, SigIds... >::get ( size_t idx ) const

Definition at line 560 of file sampler.hpp.

{
    return m_data.at(idx % N);
}

◆ get_bad() [1/2]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

auto & tim::sampling::sampler< CompT< Types... >, N, SigIds... >::get_bad ( )

inline

Definition at line 213 of file sampler.hpp.

213{ return m_bad; }

◆ get_bad() [2/2]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

const auto & tim::sampling::sampler< CompT< Types... >, N, SigIds... >::get_bad ( ) const

inline

Definition at line 216 of file sampler.hpp.

216{ return m_bad; }

◆ get_data() [1/2]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

array_t & tim::sampling::sampler< CompT< Types... >, N, SigIds... >::get_data ( )

inline

Definition at line 237 of file sampler.hpp.

237{ return m_data; }

◆ get_data() [2/2]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

const array_t & tim::sampling::sampler< CompT< Types... >, N, SigIds... >::get_data ( ) const

inline

Definition at line 238 of file sampler.hpp.

238{ return m_data; }

◆ get_delay()

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

int64_t tim::sampling::sampler< CompT< Types... >, N, SigIds... >::get_delay ( int64_t units = units::usec )

inlinestatic

Get the delay of the sampler.

Definition at line 960 of file sampler.hpp.

{
    double _us = (get_persistent_data().m_custom_itimerval.it_value.tv_sec * 1000000) +
                 get_persistent_data().m_custom_itimerval.it_value.tv_usec;
    _us *= units::usec;
    _us /= units;
    return std::max<int64_t>(_us, 1);
}

◆ get_frequency()

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

int64_t tim::sampling::sampler< CompT< Types... >, N, SigIds... >::get_frequency ( int64_t units = units::usec )

inlinestatic

Get the frequency of the sampler.

Definition at line 973 of file sampler.hpp.

{
    double _us = (get_persistent_data().m_custom_itimerval.it_interval.tv_sec * 1000000) +
                 get_persistent_data().m_custom_itimerval.it_interval.tv_usec;
    _us *= units::usec;
    _us /= units;
    return std::max<int64_t>(_us, 1);
}

◆ get_good() [1/2]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

auto & tim::sampling::sampler< CompT< Types... >, N, SigIds... >::get_good ( )

inline

Definition at line 212 of file sampler.hpp.

212{ return m_good; }

◆ get_good() [2/2]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

const auto & tim::sampling::sampler< CompT< Types... >, N, SigIds... >::get_good ( ) const

inline

Definition at line 215 of file sampler.hpp.

215{ return m_good; }

◆ get_itimer()

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

int tim::sampling::sampler< CompT< Types... >, N, SigIds... >::get_itimer ( int _signal )

static

Returns the itimer value associated with the given signal.

Definition at line 986 of file sampler.hpp.

{
    int _itimer = -1;
    switch(_signal)
    {
        case SIGALRM: _itimer = ITIMER_REAL; break;
        case SIGVTALRM: _itimer = ITIMER_VIRTUAL; break;
        case SIGPROF: _itimer = ITIMER_PROF; break;
    }
    return _itimer;
}

◆ get_last() [1/2]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

components_t *& tim::sampling::sampler< CompT< Types... >, N, SigIds... >::get_last ( )

inline

Definition at line 221 of file sampler.hpp.

221{ return m_last; }

◆ get_last() [2/2]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

components_t * tim::sampling::sampler< CompT< Types... >, N, SigIds... >::get_last ( ) const

inline

Definition at line 222 of file sampler.hpp.

222{ return m_last; }

◆ get_latest() [1/2]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

components_t *& tim::sampling::sampler< CompT< Types... >, N, SigIds... >::get_latest ( )

inline

Definition at line 224 of file sampler.hpp.

224{ return m_last; }

◆ get_latest() [2/2]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

components_t * tim::sampling::sampler< CompT< Types... >, N, SigIds... >::get_latest ( ) const

inline

Definition at line 225 of file sampler.hpp.

225{ return m_last; }

◆ get_latest_samples()

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

auto tim::sampling::sampler< CompT< Types... >, N, SigIds... >::get_latest_samples

inlinestatic

Definition at line 392 of file sampler.hpp.

{
    std::vector<components_t*> _last{};
    auto_lock_t                lk(type_mutex<this_type>());
    _last.reserve(get_persistent_data().m_instances.size());
    for(auto& itr : get_persistent_data().m_instances)
        _last.emplace_back(itr->get_last());
    return _last;
}

◆ get_opaque()

template<typename... Args>

static opaque tim::component::empty_base::get_opaque ( Args && ... )

inlinestaticinherited

Definition at line 72 of file declaration.hpp.

    {
        return opaque{};
    }

◆ get_samplers()

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

static auto & tim::sampling::sampler< CompT< Types... >, N, SigIds... >::get_samplers ( )

inlinestatic

Definition at line 174 of file sampler.hpp.

174{ return get_persistent_data().m_instances; }

◆ good_count()

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

auto tim::sampling::sampler< CompT< Types... >, N, SigIds... >::good_count ( ) const

inline

Definition at line 208 of file sampler.hpp.

208{ return m_good.size(); }

◆ ignore()

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

void tim::sampling::sampler< CompT< Types... >, N, SigIds... >::ignore ( const std::set< int > & _signals )

inlinestatic

Ignore the signals.

Parameters

[in] _signals Set of signals

Definition at line 730 of file sampler.hpp.

{
    for(const auto& itr : _signals)
        signal(itr, SIG_IGN);
 
    auto& _original_it = get_persistent_data().m_original_itimerval;
    for(const auto& itr : _signals)
    {
        itimerval_t _curr;
        auto        _itimer = get_itimer(itr);
        if(_itimer < 0)
            continue;
        check_itimer(getitimer(_itimer, &_curr));
        // stop the alarm
        if(_curr.it_interval.tv_usec > 0 || _curr.it_interval.tv_sec > 0)
            check_itimer(setitimer(_itimer, &_original_it, &_curr));
    }
 
    // if active field based on whether there are signals
    get_persistent_data().m_active = !get_persistent_data().m_signals.empty();
}

◆ is_bad()

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

bool tim::sampling::sampler< CompT< Types... >, N, SigIds... >::is_bad ( int v ) const

inline

Definition at line 206 of file sampler.hpp.

206{ return m_bad.count(v) > 0; }

◆ is_good()

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

bool tim::sampling::sampler< CompT< Types... >, N, SigIds... >::is_good ( int v ) const

inline

Definition at line 205 of file sampler.hpp.

205{ return m_good.count(v) > 0; }

◆ pause()

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

void tim::sampling::sampler< CompT< Types... >, N, SigIds... >::pause ( )

inlinestatic

Pause until a signal is delivered.

Definition at line 265 of file sampler.hpp.

    {
        if(!get_persistent_data().m_signals.empty())
            ::pause();
    }

◆ sample() [1/2]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

template<typename Tp , enable_if_t<!Tp::value > >

void tim::sampling::sampler< CompT< Types... >, N, SigIds... >::sample

Definition at line 453 of file sampler.hpp.

{
    // if(!base_type::get_is_running())
    //    return;
    m_last = &(m_data.at((m_idx++) % N));
    // get last 4 of 7 backtrace entries (i.e. offset by 3)
    if(m_backtrace)
    {
        m_last->sample(get_backtrace<4, 3>());
    }
    else
    {
        m_last->sample();
    }
}

◆ sample() [2/2]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

template<typename Tp = fixed_size_t<N>, enable_if_t<!Tp::value > = 0>

void tim::sampling::sampler< CompT< Types... >, N, SigIds... >::sample ( )

◆ set_delay()

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

void tim::sampling::sampler< CompT< Types... >, N, SigIds... >::set_delay ( double fdelay )

static

Value, expressed in seconds, that sets the length of time the sampler waits before starting sampling of the relevant measurements.

Definition at line 922 of file sampler.hpp.

{
    get_persistent_data().m_freq = fdelay;
    int delay_sec                = fdelay;
    int delay_usec               = static_cast<int>(fdelay * 1000000) % 1000000;
    if(settings::debug() || settings::verbose() > 0)
    {
        fprintf(stderr, "sampler delay         : %i sec + %i usec\n", delay_sec,
                delay_usec);
    }
    // Configure the timer to expire after designated delay...
    get_persistent_data().m_custom_itimerval.it_value.tv_sec  = delay_sec;
    get_persistent_data().m_custom_itimerval.it_value.tv_usec = delay_usec;
}

References tim::debug, and tim::verbose.

◆ set_flags()

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

void tim::sampling::sampler< CompT< Types... >, N, SigIds... >::set_flags ( int _flags )

inlinestatic

Set the sigaction flags, e.g. SA_RESTART | SA_SIGINFO.

Parameters

flags[in] the sigaction flags to use

Definition at line 315 of file sampler.hpp.

315{ get_persistent_data().m_flags = _flags; }

◆ set_frequency()

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

void tim::sampling::sampler< CompT< Types... >, N, SigIds... >::set_frequency ( double ffreq )

static

Definition at line 941 of file sampler.hpp.

{
    get_persistent_data().m_freq = ffreq;
    int freq_sec                 = ffreq;
    int freq_usec                = static_cast<int>(ffreq * 1000000) % 1000000;
    if(settings::debug() || settings::verbose() > 0)
    {
        fprintf(stderr, "sampler frequency     : %i sec + %i usec\n", freq_sec,
                freq_usec);
    }
    // Configure the timer to expire after designated delay...
    get_persistent_data().m_custom_itimerval.it_interval.tv_sec  = freq_sec;
    get_persistent_data().m_custom_itimerval.it_interval.tv_usec = freq_usec;
}

References tim::debug, and tim::verbose.

◆ set_rate()

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

void tim::sampling::sampler< CompT< Types... >, N, SigIds... >::set_rate ( double frate )

inlinestatic

Value, expressed in number of interupts per second, that configures the frequency that the sampler samples the relevant measurements.

Definition at line 330 of file sampler.hpp.

330{ set_frequency(1.0 / frate); }

tim::sampling::sampler< CompT< Types... >, N, SigIds... >::set_frequency

static void set_frequency(double ffreq)

Definition: sampler.hpp:941

◆ start() [1/2]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

template<typename Tp , enable_if_t<!Tp::value > >

void tim::sampling::sampler< CompT< Types... >, N, SigIds... >::start

Definition at line 496 of file sampler.hpp.

{
    auto cnt = tracker_type::start();
    base_type::set_started();
    for(auto& itr : m_data)
        itr.start();
    if(cnt == 0)
        configure({ SigIds... });
}

References tim::configure(), and tim::invoke::start().

◆ start() [2/2]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

template<typename Tp = fixed_sig_t<SigIds...>, enable_if_t<!Tp::value > = 0>

void tim::sampling::sampler< CompT< Types... >, N, SigIds... >::start ( )

◆ stop() [1/2]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

template<typename Tp , enable_if_t<!Tp::value > >

void tim::sampling::sampler< CompT< Types... >, N, SigIds... >::stop

Definition at line 511 of file sampler.hpp.

{
    auto cnt = tracker_type::stop();
    base_type::set_stopped();
    for(auto& itr : m_data)
        itr.stop();
    if(cnt == 0)
        ignore({ SigIds... });
}

References tim::invoke::stop().

◆ stop() [2/2]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

template<typename Tp = fixed_sig_t<SigIds...>, enable_if_t<!Tp::value > = 0>

void tim::sampling::sampler< CompT< Types... >, N, SigIds... >::stop ( )

◆ wait() [1/4]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

template<typename Func , enable_if_t< std::is_function< Func >::value > = 0>

static int tim::sampling::sampler< CompT< Types... >, N, SigIds... >::wait	(	Func &&	_callback,
		int	_verbose = `settings::verbose()`,
		bool	_debug = `settings::debug()`
	)

inlinestatic

Definition at line 304 of file sampler.hpp.

    {
        return wait(process::get_target_id(), _verbose, _debug,
                    std::forward<Func>(_callback));
    }

◆ wait() [2/4]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

template<typename Func = pid_cb_t>

static int tim::sampling::sampler< CompT< Types... >, N, SigIds... >::wait	(	int	_verbose = `settings::verbose()`,
		bool	_debug = `settings::debug()`,
		Func &&	_callback = `pid_callback()`
	)

inlinestatic

Definition at line 289 of file sampler.hpp.

    {
        return wait(process::get_target_id(), _verbose, _debug,
                    std::forward<Func>(_callback));
    }

◆ wait() [3/4]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

template<typename Func , enable_if_t< std::is_function< Func >::value > = 0>

static int tim::sampling::sampler< CompT< Types... >, N, SigIds... >::wait	(	pid_t	_pid,
		Func &&	_callback,
		int	_verbose = `settings::verbose()`,
		bool	_debug = `settings::debug()`
	)

inlinestatic

Definition at line 297 of file sampler.hpp.

    {
        return wait(_pid, _verbose, _debug, std::forward<Func>(_callback));
    }

◆ wait() [4/4]

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

template<typename Func >

int tim::sampling::sampler< CompT< Types... >, N, SigIds... >::wait	(	pid_t	_pid,
		int	_verb,
		bool	_debug,
		Func &&	_cb = `pid_callback()`
	)

static

Wait function with an optional user callback of type:

Parameters

[in]	_pid	Process id to wait on
[in]	_verb	Logging verbosity
[in]	_debug	Enable debug logging
[in]	_cb	Callback for checking whether to exit

bool (*)(int a, int b)

where 'a' is the status, 'b' is the error value, and returns true if waiting should continue

Definition at line 757 of file sampler.hpp.

{
    if(_verbose > 2 || _debug)
        fprintf(stderr, "[%i]> waiting for pid %i...\n", process::get_id(), wait_pid);
 
    //----------------------------------------------------------------------------------//
    //
    auto print_info = [=](pid_t _pid, int _status, int _errv, int _retv) {
        if(_debug || _verbose > 2)
        {
            fprintf(stderr, "[%i]> return code: %i, error value: %i, status: %i\n", _pid,
                    _retv, _errv, _status);
            fflush(stderr);
        }
    };
    //
    //----------------------------------------------------------------------------------//
    //
    auto diagnose_status = [=](pid_t _pid, int status) {
        if(_verbose > 2 || _debug)
            fprintf(stderr, "[%i]> diagnosing status %i...\n", _pid, status);
 
        if(WIFEXITED(status) && WEXITSTATUS(status) == EXIT_SUCCESS)
        {
            if(_verbose > 2 || (_debug && _verbose > 0))
            {
                fprintf(stderr, "[%i]> program terminated normally with exit code: %i\n",
                        _pid, WEXITSTATUS(status));
            }
            // normal terminatation
            return 0;
        }
 
        int ret = WEXITSTATUS(status);
        if(WIFSTOPPED(status))
        {
            int sig = WSTOPSIG(status);
            // stopped with signal 'sig'
            if(_debug || _verbose > 3)
            {
                fprintf(stderr, "[%i]> program stopped with signal %i. Exit code: %i\n",
                        _pid, sig, ret);
            }
        }
        else if(WCOREDUMP(status))
        {
            if(_debug || _verbose > 3)
            {
                fprintf(stderr,
                        "[%i]> program terminated and produced a core dump. Exit "
                        "code: %i\n",
                        _pid, ret);
            }
        }
        else if(WIFSIGNALED(status))
        {
            ret = WTERMSIG(status);
            if(_debug || _verbose > 3)
            {
                fprintf(stderr,
                        "[%i]> program terminated because it received a signal "
                        "(%i) that was not handled. Exit code: %i\n",
                        _pid, WTERMSIG(status), ret);
            }
        }
        else if(WIFEXITED(status) && WEXITSTATUS(status))
        {
            if(ret == 127 && (_debug || _verbose > 3))
            {
                fprintf(stderr, "[%i]> execv failed\n", _pid);
            }
            else if(_debug || _verbose > 3)
            {
                fprintf(stderr,
                        "[%i]> program terminated with a non-zero status. Exit "
                        "code: %i\n",
                        _pid, ret);
            }
        }
        else
        {
            if(_debug || _verbose > 3)
                fprintf(stderr, "[%i]> program terminated abnormally.\n", _pid);
            ret = EXIT_FAILURE;
        }
 
        return ret;
    };
    //
    //----------------------------------------------------------------------------------//
    //
    auto waitpid_eintr = [&](pid_t _pid, int& status) {
        pid_t pid    = 0;
        int   errval = 0;
        int   retval = 0;
 
        while((pid = waitpid(WAIT_ANY, &status, 0)) == -1)
        {
            errval = errno;
            if(errval == EINTR)
                continue;
            if(errno != errval)
                perror("Unexpected error in waitpid_eitr");
            retval = diagnose_status(pid, status);
            print_info(pid, status, errval, retval);
            break;
        }
 
        if(errval == ECHILD)
        {
            do
            {
                retval = kill(_pid, 0);
                errval = errno;
                // retval = diagnose_status(_pid, status);
                // print_info(_pid, status, errval, retval);
                if(errval == ESRCH || retval == -1)
                    break;
                std::this_thread::sleep_for(
                    std::chrono::microseconds(get_frequency(units::usec)));
            } while(true);
        }
 
        return errval;
    };
    //
    //----------------------------------------------------------------------------------//
 
    auto _signals = get_persistent_data().m_signals;
    int  status   = 0;
    int  errval   = 0;
 
    // do not wait on self to exit so execute callback until
    if(_signals.empty() && wait_pid == process::get_id())
    {
        do
        {
            std::this_thread::sleep_for(
                std::chrono::microseconds(get_frequency(units::usec)));
        } while(_callback(wait_pid, status, errval));
        return diagnose_status(wait_pid, status);
    }
 
    // loop while the errno is not EINTR (interrupt) and status designates
    // it was stopped because of signal
    int retval = 0;
    do
    {
        status = 0;
        errval = waitpid_eintr(wait_pid, status);
        print_info(wait_pid, status, errval, retval);
    } while((errval == EINTR &&
             _signals.count(retval = diagnose_status(wait_pid, status)) != 0) &&
            (_callback(wait_pid, status, errval)));
 
    print_info(wait_pid, status, errval, retval);
 
    return diagnose_status(wait_pid, status);
}

Member Data Documentation

◆ m_backtrace

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

bool tim::sampling::sampler< CompT< Types... >, N, SigIds... >::m_backtrace = false

protected

Definition at line 349 of file sampler.hpp.

◆ m_bad

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

signal_set_t tim::sampling::sampler< CompT< Types... >, N, SigIds... >::m_bad = {}

protected

Definition at line 353 of file sampler.hpp.

◆ m_data

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

array_t tim::sampling::sampler< CompT< Types... >, N, SigIds... >::m_data = {}

protected

Definition at line 354 of file sampler.hpp.

◆ m_good

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

signal_set_t tim::sampling::sampler< CompT< Types... >, N, SigIds... >::m_good = {}

protected

Definition at line 352 of file sampler.hpp.

◆ m_idx

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

size_t tim::sampling::sampler< CompT< Types... >, N, SigIds... >::m_idx = 0

protected

Definition at line 350 of file sampler.hpp.

◆ m_last

template<template< typename... > class CompT, size_t N, typename... Types, int... SigIds>

components_t* tim::sampling::sampler< CompT< Types... >, N, SigIds... >::m_last = nullptr

protected

Definition at line 351 of file sampler.hpp.

The documentation for this struct was generated from the following file:

timemory/sampling/sampler.hpp

Public Types

Public Member Functions

Static Public Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ array_t

◆ array_type

◆ base_type

◆ components_t

◆ pid_cb_t

◆ signal_set_t

◆ storage_type

◆ this_type

◆ tracker_type

Constructor & Destructor Documentation

◆ sampler() [1/2]

◆ sampler() [2/2]

◆ ~sampler()

Member Function Documentation

◆ backtrace_enabled()

◆ bad_count()

◆ check_itimer()

◆ clear()

◆ configure() [1/2]

◆ configure() [2/2]

◆ count()

◆ enable_backtrace()

◆ execute() [1/2]

◆ execute() [2/2]

◆ get() [1/7]

◆ get() [2/7]

◆ get() [3/7]

◆ get() [4/7]

◆ get() [5/7]

◆ get() [6/7]

◆ get() [7/7]

◆ get_bad() [1/2]

◆ get_bad() [2/2]

◆ get_data() [1/2]

◆ get_data() [2/2]

◆ get_delay()

◆ get_frequency()

◆ get_good() [1/2]

◆ get_good() [2/2]

◆ get_itimer()

◆ get_last() [1/2]

◆ get_last() [2/2]

◆ get_latest() [1/2]

◆ get_latest() [2/2]

◆ get_latest_samples()

◆ get_opaque()

◆ get_samplers()

◆ good_count()

◆ ignore()

◆ is_bad()

◆ is_good()

◆ pause()

◆ sample() [1/2]

◆ sample() [2/2]

◆ set_delay()

◆ set_flags()

◆ set_frequency()

◆ set_rate()

◆ start() [1/2]

◆ start() [2/2]

◆ stop() [1/2]

◆ stop() [2/2]

◆ wait() [1/4]

◆ wait() [2/4]

◆ wait() [3/4]

◆ wait() [4/4]

Member Data Documentation

◆ m_backtrace

◆ m_bad

◆ m_data

◆ m_good

◆ m_idx

◆ m_last