The gotcha component rewrites the global offset table such that calling the wrapped function actually invokes either a function which is wrapped by timemory instrumentation or is replaced by a timemory component with an function call operator (operator()) whose return value and arguments exactly match the original function. This component is only available on Linux and can only by applied to external, dynamically-linked functions (i.e. functions defined in a shared library). If the BundleT template parameter is a non-empty component bundle, this component will surround the original function call with: More...

#include "timemory/components/gotcha/components.hpp"

Collaboration diagram for tim::component::gotcha< Nt, BundleT, DiffT >:

Classes
struct	instrument

Public Types
using	value_type = void

using	this_type = gotcha< Nt, BundleT, DiffT >

using	base_type = base< this_type, value_type >

using	storage_type = typename base_type::storage_type

using	tuple_type = concepts::tuple_type_t< BundleT >

using	bundle_type = concepts::component_type_t< BundleT >

template<typename Tp >
using	array_t = std::array< Tp, Nt >

using	binding_t = backend::gotcha::binding_t

using	wrappee_t = backend::gotcha::wrappee_t

using	wrappid_t = backend::gotcha::string_t

using	error_t = backend::gotcha::error_t

using	constructor_t = std::function< void()>

using	destructor_t = std::function< void()>

using	atomic_bool_t = std::atomic< bool >

using	select_list_t = std::set< std::string >

using	config_t = void

using	get_initializer_t = std::function< config_t()>

using	get_select_list_t = std::function< select_list_t()>

using	operator_type = typename std::conditional< differ_is_component, DiffT, void >::type

Public Member Functions
void	start ()

void	stop ()

Static Public Member Functions
static std::string	label ()

static std::string	description ()

static value_type	record ()

static get_initializer_t &	get_initializer ()

static get_select_list_t &	get_permit_list ()
	when a permit list is provided, only these functions are wrapped by GOTCHA More...

static get_select_list_t &	get_reject_list ()
	reject listed functions are never wrapped by GOTCHA More...

static bool &	get_default_ready ()

static void	add_global_suppression (const std::string &func)
	add function names at runtime to suppress wrappers More...

static auto	get_ready ()
	get an array of whether the wrappers are filled and ready More...

static auto	set_ready (bool val)
	set filled wrappers to array of ready values More...

static auto	set_ready (const std::array< bool, Nt > &values)
	set filled wrappers to array of ready values More...

template<size_t N, typename Ret , typename... Args>
static bool	construct (const std::string &_func, int _priority=0, const std::string &_tool="")

template<size_t N, typename Ret , typename... Args>
static auto	configure (const std::string &_func, int _priority=0, const std::string &_tool="")

template<size_t N, typename Ret , typename... Args>
static auto	configure (const std::vector< std::string > &_funcs, int _priority=0, const std::string &_tool="")

template<size_t N>
static bool	revert ()

static bool &	is_configured ()

static std::mutex &	get_mutex ()

static auto	get_info ()

static void	configure ()

static void	enable ()

static void	disable ()

static void	global_finalize ()

static void	thread_init ()

template<size_t N, typename Ret , typename... Args>
static void	gotcha_factory (const std::string &_func, const std::string &_tool="", int _priority=0)

Static Public Attributes
static constexpr size_t	components_size = mpl::get_tuple_size<tuple_type>::value

static constexpr bool	differ_is_component

static constexpr bool	differentiator_is_component = differ_is_component

Friends
struct	operation::record< this_type >

struct	operation::start< this_type >

struct	operation::stop< this_type >

struct	operation::set_started< this_type >

struct	operation::set_stopped< this_type >

Detailed Description

template<size_t Nt, typename BundleT, typename DiffT>
struct tim::component::gotcha< Nt, BundleT, DiffT >

The gotcha component rewrites the global offset table such that calling the wrapped function actually invokes either a function which is wrapped by timemory instrumentation or is replaced by a timemory component with an function call operator (operator()) whose return value and arguments exactly match the original function. This component is only available on Linux and can only by applied to external, dynamically-linked functions (i.e. functions defined in a shared library). If the BundleT template parameter is a non-empty component bundle, this component will surround the original function call with:

Template Parameters

Nt	Max number of functions which will wrapped by this component
BundleT	Component bundle to wrap around the function(s)
DiffT	Differentiator type to distinguish different sets of wrappers with identical values of `Nt` and `BundleT` (or provide function call operator if replacing functions instead of wrapping functions)

bundle_type _obj{ "<NAME-OF-ORIGINAL-FUNCTION>" };
_obj.construct(_args...);
_obj.start();
_obj.audit("<NAME-OF-ORIGINAL-FUNCTION>", _args...);
 
Ret _ret = <CALL-ORIGINAL-FUNCTION>
 
_obj.audit("<NAME-OF-ORIGINAL-FUNCTION>", _ret);
_obj.stop();

If the BundleT template parameter is an empty variadic class, e.g. std::tuple<>, tim::component_tuple<>, etc., and the DiffT template parameter is a timemory component, the assumption is that the DiffT component has a function call operator which should replace the original function call, e.g. void* malloc(size_t) can be replaced with a component with void* operator()(size_t), e.g.:

// replace 'double exp(double)'
struct exp_replace : base<exp_replace, void>
{
    double operator()(double value)
    {
        float result = expf(static_cast<float>(value));
        return static_cast<double>(result);
    }
};

Example usage:

#include <timemory/timemory.hpp>
 
#include <cassert>
#include <cmath>
#include <tuple>
 
using empty_tuple_t = std::tuple<>;
using base_bundle_t = tim::component_tuple<wall_clock, cpu_clock>;
using gotcha_wrap_t = tim::component::gotcha<2, base_bundle_t, void>;
using gotcha_repl_t = tim::component::gotcha<2, empty_tuple_t, exp_replace>;
using impl_bundle_t = tim::mpl::append_type_t<base_bundle_t,
                                              tim::type_list<gotcha_wrap_t,
                                                             gotcha_repl_t>>;
 
void init_wrappers()
{
    // wraps the sin and cos math functions
    gotcha_wrap_t::get_initializer() = []()
    {
        TIMEMORY_C_GOTCHA(gotcha_wrap_t, 0, sin);   // index 0 replaces sin
        TIMEMORY_C_GOTCHA(gotcha_wrap_t, 1, cos);   // index 1 replace cos
    };
 
    // replaces the 'exp' function which may be 'exp' in symbols table
    // or '__exp_finite' in symbols table (use `nm <bindary>` to determine)
    gotcha_repl_t::get_initializer() = []()
    {
        TIMEMORY_C_GOTCHA(gotcha_repl_t, 0, exp);
        TIMEMORY_DERIVED_GOTCHA(gotcha_repl_t, 1, exp, "__exp_finite");
    };
}
 
// the following is useful to avoid having to call 'init_wrappers()' explicitly:
// use comma operator to call 'init_wrappers' and return true
static auto called_init_at_load = (init_wrappers(), true);
 
int main()
{
    assert(called_init_at_load == true);
 
    double angle = 45.0 * (M_PI / 180.0);
 
    impl_bundle_t _obj{ "main" };
 
    // gotcha wrappers not activated yet
    printf("cos(%f) = %f\n", angle, cos(angle));
    printf("sin(%f) = %f\n", angle, sin(angle));
    printf("exp(%f) = %f\n", angle, exp(angle));
 
    // gotcha wrappers are reference counted according to start/stop
    _obj.start();
 
    printf("cos(%f) = %f\n", angle, cos(angle));
    printf("sin(%f) = %f\n", angle, sin(angle));
    printf("exp(%f) = %f\n", angle, exp(angle));
 
    _obj.stop();
 
    // gotcha wrappers will be deactivated
    printf("cos(%f) = %f\n", angle, cos(angle));
    printf("sin(%f) = %f\n", angle, sin(angle));
    printf("exp(%f) = %f\n", angle, exp(angle));
 
    return 0;
}

Definition at line 175 of file components.hpp.

Member Typedef Documentation

◆ array_t

template<size_t Nt, typename BundleT , typename DiffT >

template<typename Tp >

using tim::component::gotcha< Nt, BundleT, DiffT >::array_t = std::array<Tp, Nt>

Definition at line 197 of file components.hpp.

◆ atomic_bool_t

template<size_t Nt, typename BundleT , typename DiffT >

using tim::component::gotcha< Nt, BundleT, DiffT >::atomic_bool_t = std::atomic<bool>

Definition at line 205 of file components.hpp.

◆ base_type

template<size_t Nt, typename BundleT , typename DiffT >

using tim::component::gotcha< Nt, BundleT, DiffT >::base_type = base<this_type, value_type>

Definition at line 185 of file components.hpp.

◆ binding_t

template<size_t Nt, typename BundleT , typename DiffT >

using tim::component::gotcha< Nt, BundleT, DiffT >::binding_t = backend::gotcha::binding_t

Definition at line 199 of file components.hpp.

◆ bundle_type

template<size_t Nt, typename BundleT , typename DiffT >

using tim::component::gotcha< Nt, BundleT, DiffT >::bundle_type = concepts::component_type_t<BundleT>

Definition at line 188 of file components.hpp.

◆ config_t

template<size_t Nt, typename BundleT , typename DiffT >

using tim::component::gotcha< Nt, BundleT, DiffT >::config_t = void

Definition at line 209 of file components.hpp.

◆ constructor_t

template<size_t Nt, typename BundleT , typename DiffT >

using tim::component::gotcha< Nt, BundleT, DiffT >::constructor_t = std::function<void()>

Definition at line 203 of file components.hpp.

◆ destructor_t

template<size_t Nt, typename BundleT , typename DiffT >

using tim::component::gotcha< Nt, BundleT, DiffT >::destructor_t = std::function<void()>

Definition at line 204 of file components.hpp.

◆ error_t

template<size_t Nt, typename BundleT , typename DiffT >

using tim::component::gotcha< Nt, BundleT, DiffT >::error_t = backend::gotcha::error_t

Definition at line 202 of file components.hpp.

◆ get_initializer_t

template<size_t Nt, typename BundleT , typename DiffT >

using tim::component::gotcha< Nt, BundleT, DiffT >::get_initializer_t = std::function<config_t()>

Definition at line 210 of file components.hpp.

◆ get_select_list_t

template<size_t Nt, typename BundleT , typename DiffT >

using tim::component::gotcha< Nt, BundleT, DiffT >::get_select_list_t = std::function<select_list_t()>

Definition at line 211 of file components.hpp.

◆ operator_type

template<size_t Nt, typename BundleT , typename DiffT >

using tim::component::gotcha< Nt, BundleT, DiffT >::operator_type = typename std::conditional<differ_is_component, DiffT, void>::type

Definition at line 220 of file components.hpp.

◆ select_list_t

template<size_t Nt, typename BundleT , typename DiffT >

using tim::component::gotcha< Nt, BundleT, DiffT >::select_list_t = std::set<std::string>

Definition at line 207 of file components.hpp.

◆ storage_type

template<size_t Nt, typename BundleT , typename DiffT >

using tim::component::gotcha< Nt, BundleT, DiffT >::storage_type = typename base_type::storage_type

Definition at line 186 of file components.hpp.

◆ this_type

template<size_t Nt, typename BundleT , typename DiffT >

using tim::component::gotcha< Nt, BundleT, DiffT >::this_type = gotcha<Nt, BundleT, DiffT>

Definition at line 184 of file components.hpp.

◆ tuple_type

template<size_t Nt, typename BundleT , typename DiffT >

using tim::component::gotcha< Nt, BundleT, DiffT >::tuple_type = concepts::tuple_type_t<BundleT>

Definition at line 187 of file components.hpp.

◆ value_type

template<size_t Nt, typename BundleT , typename DiffT >

using tim::component::gotcha< Nt, BundleT, DiffT >::value_type = void

Definition at line 183 of file components.hpp.

◆ wrappee_t

template<size_t Nt, typename BundleT , typename DiffT >

using tim::component::gotcha< Nt, BundleT, DiffT >::wrappee_t = backend::gotcha::wrappee_t

Definition at line 200 of file components.hpp.

◆ wrappid_t

template<size_t Nt, typename BundleT , typename DiffT >

using tim::component::gotcha< Nt, BundleT, DiffT >::wrappid_t = backend::gotcha::string_t

Definition at line 201 of file components.hpp.

Member Function Documentation

◆ add_global_suppression()

template<size_t Nt, typename BundleT , typename DiffT >

static void tim::component::gotcha< Nt, BundleT, DiffT >::add_global_suppression ( const std::string & func )

inlinestatic

add function names at runtime to suppress wrappers

Definition at line 262 of file components.hpp.

     {
         get_suppresses().insert(func);
     }

◆ configure() [1/3]

template<size_t Nt, typename BundleT , typename DiffT >

static void tim::component::gotcha< Nt, BundleT, DiffT >::configure ( )

inlinestatic

Definition at line 449 of file components.hpp.

     {
         std::unique_lock<std::mutex> lk(get_mutex(), std::defer_lock);
         if(!lk.owns_lock())
             lk.lock();
  
         if(!is_configured())
         {
             is_configured() = true;
             lk.unlock();
             auto& _init = get_initializer();
             _init();
         }
     }

References tim::component::gotcha< Nt, BundleT, DiffT >::get_initializer(), tim::component::gotcha< Nt, BundleT, DiffT >::get_mutex(), and tim::component::gotcha< Nt, BundleT, DiffT >::is_configured().

Referenced by tim::component::gotcha< Nt, BundleT, DiffT >::enable(), tim::component::gotcha< Nt, BundleT, DiffT >::instrument< N, Ret, Args >::generate(), and tim::component::gotcha< Nt, BundleT, DiffT >::start().

◆ configure() [2/3]

template<size_t Nt, typename BundleT , typename DiffT >

template<size_t N, typename Ret , typename... Args>

static auto tim::component::gotcha< Nt, BundleT, DiffT >::configure	(	const std::string &	_func,
		int	_priority = `0`,
		const std::string &	_tool = `""`
	)

inlinestatic

Definition at line 371 of file components.hpp.

     {
         return construct<N, Ret, Args...>(_func, _priority, _tool);
     }

References tim::component::gotcha< Nt, BundleT, DiffT >::construct().

◆ configure() [3/3]

template<size_t Nt, typename BundleT , typename DiffT >

template<size_t N, typename Ret , typename... Args>

static auto tim::component::gotcha< Nt, BundleT, DiffT >::configure	(	const std::vector< std::string > &	_funcs,
		int	_priority = `0`,
		const std::string &	_tool = `""`
	)

inlinestatic

Definition at line 380 of file components.hpp.

     {
         auto itr = _funcs.begin();
         auto ret = false;
         while(!ret && itr != _funcs.end())
         {
             ret = construct<N, Ret, Args...>(*itr, _priority, _tool);
             ++itr;
         }
     }

References tim::component::gotcha< Nt, BundleT, DiffT >::construct().

◆ construct()

template<size_t Nt, typename BundleT , typename DiffT >

template<size_t N, typename Ret , typename... Args>

static bool tim::component::gotcha< Nt, BundleT, DiffT >::construct	(	const std::string &	_func,
		int	_priority = `0`,
		const std::string &	_tool = `""`
	)

inlinestatic

Definition at line 304 of file components.hpp.

     {
         gotcha_suppression::auto_toggle suppress_lock(gotcha_suppression::get());
  
         init_storage<bundle_type>(0);
  
         static_assert(N < Nt, "Error! N must be less than Nt!");
         auto& _data = get_data()[N];
  
         if(!is_permitted<N, Ret, Args...>(_func))
             return false;
  
         if(_data.debug == nullptr)
             _data.debug = &settings::debug();
  
         if(!_data.filled)
         {
             auto _label = demangle(_func);
             if(_tool.length() > 0 && _label.find(_tool + "/") != 0)
             {
                 _label = _tool + "/" + _label;
                 while(_label.find("//") != std::string::npos)
                     _label.erase(_label.find("//"), 1);
             }
  
             // ensure the hash to string pairing is stored
             storage_type::instance()->add_hash_id(_label);
  
             _data.filled   = true;
             _data.priority = _priority;
             _data.tool_id  = _label;
             _data.wrap_id  = _func;
             _data.ready    = get_default_ready();
  
             if(get_suppresses().find(_func) != get_suppresses().end())
             {
                 _data.suppression = &gotcha_suppression::get();
                 _data.ready       = false;
             }
  
             _data.constructor = [_func, _priority, _tool]() {
                 this_type::construct<N, Ret, Args...>(_func, _priority, _tool);
             };
             _data.destructor = []() { this_type::revert<N>(); };
             _data.binding = std::move(construct_binder<N, Ret, Args...>(_data.wrap_id));
             error_t ret_wrap = backend::gotcha::wrap(_data.binding, _data.tool_id);
             check_error<N>(ret_wrap, "binding");
         }
  
         if(!_data.is_active)
         {
             _data.is_active = true;
             error_t ret_prio =
                 backend::gotcha::set_priority(_data.tool_id, _data.priority);
             check_error<N>(ret_prio, "set priority");
         }
  
         if(!_data.ready)
             revert<N>();
  
         return _data.filled;
     }

References tim::debug, tim::demangle(), tim::get(), and tim::component::gotcha< Nt, BundleT, DiffT >::get_default_ready().

Referenced by tim::component::gotcha< Nt, BundleT, DiffT >::configure().

◆ description()

template<size_t Nt, typename BundleT , typename DiffT >

static std::string tim::component::gotcha< Nt, BundleT, DiffT >::description ( )

inlinestatic

Definition at line 224 of file components.hpp.

     {
         return "Generates GOTCHA wrappers which can be used to wrap or replace "
                "dynamically linked function calls";
     }

◆ disable()

template<size_t Nt, typename BundleT , typename DiffT >

static void tim::component::gotcha< Nt, BundleT, DiffT >::disable ( )

inlinestatic

Definition at line 470 of file components.hpp.

     {
         std::unique_lock<std::mutex> lk(get_mutex(), std::defer_lock);
         if(!lk.owns_lock())
             lk.lock();
  
         if(is_configured())
         {
             is_configured() = false;
             lk.unlock();
             for(auto& itr : get_data())
             {
                 if(!itr.is_finalized)
                 {
                     itr.is_finalized = true;
                     itr.destructor();
                 }
             }
         }
     }

References tim::component::gotcha< Nt, BundleT, DiffT >::get_mutex(), and tim::component::gotcha< Nt, BundleT, DiffT >::is_configured().

Referenced by tim::component::gotcha< Nt, BundleT, DiffT >::global_finalize().

◆ enable()

template<size_t Nt, typename BundleT , typename DiffT >

static void tim::component::gotcha< Nt, BundleT, DiffT >::enable ( )

inlinestatic

Definition at line 466 of file components.hpp.

466 { configure(); }

tim::component::gotcha::configure

static void configure()

Definition: components.hpp:449

References tim::component::gotcha< Nt, BundleT, DiffT >::configure().

◆ get_default_ready()

template<size_t Nt, typename BundleT , typename DiffT >

static bool& tim::component::gotcha< Nt, BundleT, DiffT >::get_default_ready ( )

inlinestatic

Definition at line 254 of file components.hpp.

     {
         static bool _instance = false;
         return _instance;
     }

Referenced by tim::component::gotcha< Nt, BundleT, DiffT >::construct(), tim::component::gotcha< Nt, BundleT, DiffT >::revert(), and tim::component::gotcha< Nt, BundleT, DiffT >::thread_init().

◆ get_info()

template<size_t Nt, typename BundleT , typename DiffT >

static auto tim::component::gotcha< Nt, BundleT, DiffT >::get_info ( )

inlinestatic

Definition at line 432 of file components.hpp.

     {
         std::array<size_t, 5> _info{};
         _info.fill(0);
         for(auto& itr : get_data())
         {
             _info.at(0) += (itr.ready) ? 1 : 0;
             _info.at(1) += (itr.filled) ? 1 : 0;
             _info.at(2) += (itr.is_active) ? 1 : 0;
             _info.at(3) += (itr.is_finalized) ? 1 : 0;
             _info.at(4) += (itr.suppression && !(*itr.suppression)) ? 1 : 0;
         }
         return _info;
     }

References tim::plotting::_info.

◆ get_initializer()

template<size_t Nt, typename BundleT , typename DiffT >

static get_initializer_t& tim::component::gotcha< Nt, BundleT, DiffT >::get_initializer ( )

inlinestatic

Definition at line 233 of file components.hpp.

     {
         return get_persistent_data().m_initializer;
     }

Referenced by tim::component::gotcha< Nt, BundleT, DiffT >::configure(), and setup_pthread_gotcha().

◆ get_mutex()

template<size_t Nt, typename BundleT , typename DiffT >

static std::mutex& tim::component::gotcha< Nt, BundleT, DiffT >::get_mutex ( )

inlinestatic

Definition at line 428 of file components.hpp.

428 { return get_persistent_data().m_mutex; }

Referenced by tim::component::gotcha< Nt, BundleT, DiffT >::configure(), and tim::component::gotcha< Nt, BundleT, DiffT >::disable().

◆ get_permit_list()

template<size_t Nt, typename BundleT , typename DiffT >

static get_select_list_t& tim::component::gotcha< Nt, BundleT, DiffT >::get_permit_list ( )

inlinestatic

when a permit list is provided, only these functions are wrapped by GOTCHA

Definition at line 240 of file components.hpp.

     {
         return get_persistent_data().m_permit_list;
     }

◆ get_ready()

template<size_t Nt, typename BundleT , typename DiffT >

static auto tim::component::gotcha< Nt, BundleT, DiffT >::get_ready ( )

inlinestatic

get an array of whether the wrappers are filled and ready

Definition at line 269 of file components.hpp.

     {
         std::array<std::pair<bool, bool>, Nt> _ready;
         for(size_t i = 0; i < Nt; ++i)
             _ready.at(i) = { get_data().at(i).filled, get_data().at(i).ready };
         return _ready;
     }

Referenced by tim::component::gotcha< Nt, BundleT, DiffT >::set_ready().

◆ get_reject_list()

template<size_t Nt, typename BundleT , typename DiffT >

static get_select_list_t& tim::component::gotcha< Nt, BundleT, DiffT >::get_reject_list ( )

inlinestatic

reject listed functions are never wrapped by GOTCHA

Definition at line 247 of file components.hpp.

     {
         return get_persistent_data().m_reject_list;
     }

◆ global_finalize()

template<size_t Nt, typename BundleT , typename DiffT >

static void tim::component::gotcha< Nt, BundleT, DiffT >::global_finalize ( )

inlinestatic

Definition at line 493 of file components.hpp.

     {
         while(get_started() > 0)
             --get_started();
         while(get_thread_started() > 0)
             --get_thread_started();
         disable();
     }

References tim::component::gotcha< Nt, BundleT, DiffT >::disable().

◆ gotcha_factory()

template<size_t Nt, typename BundleT , typename DiffT >

template<size_t N, typename Ret , typename... Args>

static void tim::component::gotcha< Nt, BundleT, DiffT >::gotcha_factory	(	const std::string &	_func,
		const std::string &	_tool = `""`,
		int	_priority = `0`
	)

inlinestatic

Definition at line 610 of file components.hpp.

     {
         instrument<N, Ret, Args...>::generate(_func, _tool, _priority);
     }

References tim::component::gotcha< Nt, BundleT, DiffT >::instrument< N, Ret, Args >::generate().

◆ is_configured()

template<size_t Nt, typename BundleT , typename DiffT >

static bool& tim::component::gotcha< Nt, BundleT, DiffT >::is_configured ( )

inlinestatic

Definition at line 424 of file components.hpp.

424 { return get_persistent_data().m_is_configured; }

Referenced by tim::component::gotcha< Nt, BundleT, DiffT >::configure(), tim::component::gotcha< Nt, BundleT, DiffT >::disable(), and tim::component::gotcha< Nt, BundleT, DiffT >::start().

◆ label()

template<size_t Nt, typename BundleT , typename DiffT >

static std::string tim::component::gotcha< Nt, BundleT, DiffT >::label ( )

inlinestatic

Definition at line 223 of file components.hpp.

223 { return "gotcha"; }

◆ record()

template<size_t Nt, typename BundleT , typename DiffT >

static value_type tim::component::gotcha< Nt, BundleT, DiffT >::record ( )

inlinestatic

Definition at line 229 of file components.hpp.

229 {}

◆ revert()

template<size_t Nt, typename BundleT , typename DiffT >

template<size_t N>

static bool tim::component::gotcha< Nt, BundleT, DiffT >::revert ( )

inlinestatic

Definition at line 395 of file components.hpp.

     {
         gotcha_suppression::auto_toggle suppress_lock(gotcha_suppression::get());
  
         static_assert(N < Nt, "Error! N must be less than Nt!");
         auto& _data = get_data()[N];
  
         if(_data.filled && _data.is_active)
         {
             _data.is_active = false;
  
             error_t ret_prio = backend::gotcha::set_priority(_data.tool_id, -1);
             check_error<N>(ret_prio, "get priority");
  
             if(get_suppresses().find(_data.tool_id) != get_suppresses().end())
             {
                 _data.ready = false;
             }
             else
             {
                 _data.ready = get_default_ready();
             }
         }
  
         return _data.filled;
     }

References tim::get(), and tim::component::gotcha< Nt, BundleT, DiffT >::get_default_ready().

◆ set_ready() [1/2]

template<size_t Nt, typename BundleT , typename DiffT >

static auto tim::component::gotcha< Nt, BundleT, DiffT >::set_ready ( bool val )

inlinestatic

set filled wrappers to array of ready values

Definition at line 279 of file components.hpp.

     {
         for(size_t i = 0; i < Nt; ++i)
         {
             if(get_data().at(i).filled)
                 get_data().at(i).ready = val;
         }
         return get_ready();
     }

References tim::component::gotcha< Nt, BundleT, DiffT >::get_ready().

◆ set_ready() [2/2]

template<size_t Nt, typename BundleT , typename DiffT >

static auto tim::component::gotcha< Nt, BundleT, DiffT >::set_ready ( const std::array< bool, Nt > & values )

inlinestatic

set filled wrappers to array of ready values

Definition at line 291 of file components.hpp.

     {
         for(size_t i = 0; i < Nt; ++i)
         {
             if(get_data().at(i).filled)
                 get_data().at(i).ready = values.at(i);
         }
         return get_ready();
     }

References tim::component::gotcha< Nt, BundleT, DiffT >::get_ready().

◆ start()

template<size_t Nt, typename BundleT , typename DiffT >

void tim::component::gotcha< Nt, BundleT, DiffT >::start ( )

inline

Definition at line 512 of file components.hpp.

     {
         if(storage_type::is_finalizing())
             return;
  
         auto _n = get_started()++;
         auto _t = get_thread_started()++;
  
 #if defined(DEBUG)
         if(settings::debug())
         {
             static std::atomic<int64_t> _tcount(0);
             static thread_local int64_t _tid = _tcount++;
             std::stringstream           ss;
             ss << "[T" << _tid << "]> n = " << _n << ", t = " << _t << "...\n";
             std::cout << ss.str() << std::flush;
         }
 #endif
  
         // this ensures that if started from multiple threads, all threads synchronize
         // before
         if(_t == 0 && !is_configured())
             configure();
  
         if(_n == 0)
         {
             configure();
             for(auto& itr : get_data())
             {
                 if(!itr.is_finalized)
                     itr.constructor();
             }
         }
  
         if(_t == 0)
         {
             auto& _data = get_data();
             for(size_t i = 0; i < Nt; ++i)
                 _data[i].ready = _data[i].filled;
         }
     }

References tim::component::gotcha< Nt, BundleT, DiffT >::configure(), tim::debug, and tim::component::gotcha< Nt, BundleT, DiffT >::is_configured().

◆ stop()

template<size_t Nt, typename BundleT , typename DiffT >

void tim::component::gotcha< Nt, BundleT, DiffT >::stop ( )

inline

Definition at line 554 of file components.hpp.

     {
         auto _n = --get_started();
         auto _t = --get_thread_started();
  
 #if defined(DEBUG)
         if(settings::debug())
         {
             static std::atomic<int64_t> _tcount(0);
             static thread_local int64_t _tid = _tcount++;
             std::stringstream           ss;
             ss << "[T" << _tid << "]> n = " << _n << ", t = " << _t << "...\n";
             std::cout << ss.str() << std::flush;
         }
 #endif
  
         if(_t == 0)
         {
             auto& _data = get_data();
             for(size_t i = 0; i < Nt; ++i)
                 _data[i].ready = false;
         }
  
         if(_n == 0)
         {
             for(auto& itr : get_data())
             {
                 if(!itr.is_finalized)
                     itr.destructor();
             }
         }
     }

References tim::debug.

◆ thread_init()

template<size_t Nt, typename BundleT , typename DiffT >

static void tim::component::gotcha< Nt, BundleT, DiffT >::thread_init ( )

inlinestatic

Definition at line 502 of file components.hpp.

     {
         auto& _data = get_data();
         for(size_t i = 0; i < Nt; ++i)
             _data[i].ready = (_data[i].filled && get_default_ready());
     }

References tim::component::gotcha< Nt, BundleT, DiffT >::get_default_ready().

Friends And Related Function Documentation

◆ operation::record< this_type >

template<size_t Nt, typename BundleT , typename DiffT >

friend struct operation::record< this_type >

friend

Definition at line 179 of file components.hpp.

◆ operation::set_started< this_type >

template<size_t Nt, typename BundleT , typename DiffT >

friend struct operation::set_started< this_type >

friend

Definition at line 179 of file components.hpp.

◆ operation::set_stopped< this_type >

template<size_t Nt, typename BundleT , typename DiffT >

friend struct operation::set_stopped< this_type >

friend

Definition at line 179 of file components.hpp.

◆ operation::start< this_type >

template<size_t Nt, typename BundleT , typename DiffT >

friend struct operation::start< this_type >

friend

Definition at line 179 of file components.hpp.

◆ operation::stop< this_type >

template<size_t Nt, typename BundleT , typename DiffT >

friend struct operation::stop< this_type >

friend

Definition at line 179 of file components.hpp.

Member Data Documentation

◆ components_size

template<size_t Nt, typename BundleT , typename DiffT >

constexpr size_t tim::component::gotcha< Nt, BundleT, DiffT >::components_size = mpl::get_tuple_size<tuple_type>::value

staticconstexpr

Definition at line 213 of file components.hpp.

◆ differ_is_component

template<size_t Nt, typename BundleT , typename DiffT >

constexpr bool tim::component::gotcha< Nt, BundleT, DiffT >::differ_is_component

staticconstexpr

Initial value:

=
        (is_one_of<DiffT, tuple_type>::value ||
         (components_size == 0 && concepts::is_component<DiffT>::value))

Definition at line 214 of file components.hpp.

◆ differentiator_is_component

template<size_t Nt, typename BundleT , typename DiffT >

constexpr bool tim::component::gotcha< Nt, BundleT, DiffT >::differentiator_is_component = differ_is_component

staticconstexpr

Definition at line 218 of file components.hpp.

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

timemory/components/gotcha/components.hpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Friends

Detailed Description

template<size_t Nt, typename BundleT, typename DiffT> struct tim::component::gotcha< Nt, BundleT, DiffT >

Member Typedef Documentation

◆ array_t

◆ atomic_bool_t

◆ base_type

◆ binding_t

◆ bundle_type

◆ config_t

◆ constructor_t

◆ destructor_t

◆ error_t

◆ get_initializer_t

◆ get_select_list_t

◆ operator_type

◆ select_list_t

◆ storage_type

◆ this_type

◆ tuple_type

◆ value_type

◆ wrappee_t

◆ wrappid_t

Member Function Documentation

◆ add_global_suppression()

◆ configure() [1/3]

◆ configure() [2/3]

◆ configure() [3/3]

◆ construct()

◆ description()

◆ disable()

◆ enable()

◆ get_default_ready()

◆ get_info()

◆ get_initializer()

◆ get_mutex()

◆ get_permit_list()

◆ get_ready()

◆ get_reject_list()

◆ global_finalize()

◆ gotcha_factory()

◆ is_configured()

◆ label()

◆ record()

◆ revert()

◆ set_ready() [1/2]

◆ set_ready() [2/2]

◆ start()

◆ stop()

◆ thread_init()

Friends And Related Function Documentation

◆ operation::record< this_type >

◆ operation::set_started< this_type >

◆ operation::set_stopped< this_type >

◆ operation::start< this_type >

◆ operation::stop< this_type >

Member Data Documentation

◆ components_size

◆ differ_is_component

◆ differentiator_is_component

template<size_t Nt, typename BundleT, typename DiffT>
struct tim::component::gotcha< Nt, BundleT, DiffT >