tim Namespace Reference

Namespaces
	alias
	api
	argparse
	audit
	base
	cereal
	component
	concepts
	config
	crtp
	cupti
	data
	data_storage
	device
	env
	ert
	filepath
	func
	invoke
	kokkosp
	lifetime
	math
	mpl
	node
	ompt
	openmp
	operation
	plotting
	policy
	popen
	quirk
	runtime
	sampling
	scope
	socket
	stl
	the namespace is provided to hide stl overload from global namespace but provide a method of using the namespace without a "using namespace tim;"
	trace
	trait
	units
	utility
	variadic

Classes
struct	statistics
	A generic class for statistical accumulation. It uses the timemory math overloads to enable statistics for containers such as std::vector<double>, etc. More...
class	env_settings
class	source_location
	Provides source location information and variadic joining of source location tags. More...
class	manager
class	lightweight_tuple
	This is a variadic component wrapper which provides the least amount of runtime and compilation overhead. More...
struct	get_index_sequence
struct	get_index_sequence< Tuple< Types... > >
struct	storage_initializer
	This provides an object that can initialize the storage opaquely, e.g. More...
struct	remove_pointers
struct	remove_pointers< Tuple< Tp... > >
struct	basic_tree
	Basic hierarchical tree implementation. Expects population from tim::graph. More...
struct	settings
struct	tsettings
	Implements a specific setting. More...
struct	vsettings
	Virtual base class for storing settings. More...
class	storage
class	storage< Tp, type_list<> >
class	tgraph_node
	A node in the graph, combining links to other nodes as well as the actual data. More...
class	graph
	Arbitrary Graph / Tree (i.e. binary-tree but not binary). It is unlikely that this class will interacted with directly. More...
class	graph_data
	tim::graph instance + current node + head note + sea-level. Sea-level is defined as the node depth after a fork from another graph instance and is only relevant for worker-threads) More...
class	graph_allocator
struct	complete_types
struct	available_types
class	signal_settings
class	singleton
	Thread-safe singleton management. More...
class	singleton< void, void, void >
struct	identity
struct	null_type
	this is a placeholder type for optional type-traits. It is used as the default type for the type-traits to signify there is no specialization. More...
struct	type_list
	lightweight tuple-alternative for meta-programming logic More...
struct	hasher
class	auto_base_bundle< Tag, CompT, BundleT >
	Example: auto_base_bundle<Tag, component_bundle<Tag>, auto_bundle<Tag, Types...>> will use Tag + trait::is_available<Tag> or trait::runtime_available<Tag> to disable this bundle at compile-time or run-time, respectively. It will wrap auto-start/stop around component_bundle<Tag, Types...> and use auto_bundle<Tag, Types...> for function signatures. More...
class	auto_bundle< Tag, Types... >
class	auto_hybrid< TupleT< TupleTypes... >, ListT< ListTypes... > >
class	auto_list
	This is a variadic component wrapper where all components are optional at runtime. Accept unlimited number of parameters. The constructor starts the components, the destructor stops the components. The default behavior is to query the TIMEMORY_AUTO_LIST_INIT environment variable once (the first time the bundle is used) and use that list of components (if any) to initialize the components which are part of it's template parameters. This behavior can be modified by assigning a new lambda/functor to the reference which is returned from tim::auto_list<Types...>::get_initializer(). Assignment is not thread-safe since this is relatively unnecessary... if a different set of components are required on a particular thread, just create a different type with those particular components or pass the initialization functor to the constructor. More...
class	auto_tuple
	This is a variadic component wrapper where all components are allocated on the stack and cannot be disabled at runtime. This bundler has the lowest overhead. Accepts unlimited number of template parameters. The constructor starts the components, the destructor stops the components. More...
struct	stack_bundle
struct	stack_bundle< type_list< Types... > >
struct	api_bundle
struct	api_bundle< ApiT, type_list< Types... > >
class	bundle
	Static polymorphic base class for component bundlers. More...
class	bundle< Tag, BundleT, TupleT >
	Example: bundle<Tag, component_bundle<Foo>, mixed_wrapper_types<concat<Bar, Baz>>> will use Tag + trait::is_available<Tag> or trait::runtime_available<Tag> to disable this bundle at compile-time or run-time, respectively. It will covert component_bundle<Foo> to component_bundle<Foo, Bar, Baz> for purposes of function signatures and it will instantiate std::tuple<...> depending on the compile-time availability of Bar and Baz. mixed_wrapper_types is a dummy type with the appropriate aliases to perform these conversions. Here is a theoretical implementation of mixed_wrapper_types (which supports allocating components on the stack and the heap): More...
class	component_bundle< Tag, Types... >
class	component_hybrid< TupleT< TupleTypes... >, ListT< ListTypes... > >
class	component_list
	This is a variadic component wrapper where all components are optional at runtime. Accept unlimited number of parameters. The default behavior is to query the TIMEMORY_COMPONENT_LIST_INIT environment variable once (the first time the bundle is used) and use that list of components (if any) to initialize the components which are part of it's template parameters. This behavior can be modified by assigning a new lambda/functor to the reference which is returned from tim::component_list<Types...>::get_initializer(). Assignment is not thread-safe since this is relatively unnecessary... if a different set of components are required on a particular thread, just create a different type with those particular components or pass the initialization functor to the constructor. More...
class	component_tuple
	This is a variadic component wrapper where all components are allocated on the stack and cannot be disabled at runtime. This bundler has the lowest overhead. Accepts unlimited number of template parameters. This bundler is used by tim::auto_tuple whose constructor and destructor invoke the start() and stop() member functions respectively. More...
class	component_bundle
	This is a variadic component wrapper which combines the features of tim::component_tuple<T...> and tim::component_list<U..>. The "T" types (compile-time fixed, allocated on stack) should be specified as usual, the "U" types (runtime-time optional, allocated on the heap) should be specified as a pointer. Initialization of the optional types is similar to tim::auto_list<U...> but no environment variable is built-in since, ideally, this environment variable should be customized based on the Tag template parameter. More...
class	auto_base_bundle
	Static polymorphic base class for automatic start/stop bundlers. More...
class	auto_bundle
	This is a variadic component wrapper which combines the features of tim::auto_tuple<T...> and tim::auto_list<U..>. The "T" types (compile-time fixed, allocated on stack) should be specified as usual, the "U" types (runtime-time optional, allocated on the heap) should be specified as a pointer. Initialization of the optional types is similar to tim::auto_list<U...> but no environment variable is built-in since, ideally, this environment variable should be customized based on the Tag template parameter. More...
class	component_hybrid
class	auto_hybrid

Typedefs
using	parser_t = argparse::argument_parser
using	parser_err_t = typename parser_t::result_type
using	minimal_auto_tuple_t = auto_bundle< TIMEMORY_API, TIMEMORY_MINIMAL_TUPLE_TYPES >
using	minimal_auto_list_t = auto_bundle< TIMEMORY_API, TIMEMORY_MINIMAL_LIST_TYPES >
using	minimal_auto_timer_t = auto_bundle< TIMEMORY_API, TIMEMORY_MINIMAL_TUPLE_TYPES, TIMEMORY_MINIMAL_LIST_TYPES >
using	full_auto_tuple_t = auto_bundle< TIMEMORY_API, TIMEMORY_FULL_TUPLE_TYPES >
using	full_auto_list_t = auto_bundle< TIMEMORY_API, TIMEMORY_FULL_LIST_TYPES >
using	full_auto_timer_t = auto_bundle< TIMEMORY_API, TIMEMORY_FULL_TUPLE_TYPES, TIMEMORY_FULL_LIST_TYPES >
using	auto_timer_tuple_t = minimal_auto_tuple_t
using	auto_timer_list_t = minimal_auto_list_t
using	auto_timer = minimal_auto_timer_t
using	auto_timer_t = auto_timer
using	auto_user_bundle_t = auto_bundle< TIMEMORY_API, component::user_global_bundle >
using	hash_value_t = size_t
using	hash_map_t = std::unordered_map< hash_value_t, std::string >
using	hash_alias_map_t = std::unordered_map< hash_value_t, hash_value_t >
using	hash_map_ptr_t = std::shared_ptr< hash_map_t >
using	hash_map_ptr_pair_t = std::pair< hash_map_ptr_t, hash_map_ptr_t >
using	hash_alias_ptr_t = std::shared_ptr< hash_alias_map_t >
using	hash_resolver_t = std::function< bool(hash_value_t, std::string &)>
using	hash_resolver_vec_t = std::vector< hash_resolver_t >
using	string_view_t = std::string
template<typename... T>
using	stl_tuple_t = convert_t< mpl::available_t< concat< T... > >, std::tuple<> >
template<typename... T>
using	type_list_t = convert_t< mpl::available_t< concat< T... > >, type_list<> >
template<typename Tag , typename... T>
using	component_bundle_t = convert_t< mpl::available_t< type_list< T... > >, component_bundle< Tag > >
template<typename... T>
using	component_tuple_t = convert_t< mpl::available_t< concat< T... > >, component_tuple<> >
template<typename... T>
using	component_list_t = convert_t< mpl::available_t< concat< T... > >, component_list<> >
template<typename... T>
using	auto_tuple_t = convert_t< mpl::available_t< concat< T... > >, auto_tuple<> >
template<typename... T>
using	auto_list_t = convert_t< mpl::available_t< concat< T... > >, auto_list<> >
template<typename Tag , typename... T>
using	auto_bundle_t = convert_t< mpl::available_t< type_list< T... > >, auto_bundle< Tag > >
template<typename... T>
using	lightweight_tuple_t = convert_t< mpl::available_t< concat< T... > >, lightweight_tuple<> >
template<typename T >
using	is_empty_t = typename concepts::is_empty< T >::type
template<typename T >
using	is_variadic_t = typename concepts::is_variadic< T >::type
template<typename T >
using	is_wrapper_t = typename concepts::is_wrapper< T >::type
template<typename T >
using	is_stack_wrapper_t = typename concepts::is_stack_wrapper< T >::type
template<typename T >
using	is_heap_wrapper_t = typename concepts::is_heap_wrapper< T >::type
template<typename... Ts>
using	tuple_concat_t = typename impl::tuple_concat< Ts... >::type
template<typename... Ts>
using	type_concat_t = typename impl::type_concat< Ts... >::type
template<typename U >
using	remove_pointer_t = typename std::remove_pointer< U >::type
template<typename U >
using	add_pointer_t = conditional_t<(std::is_pointer< U >::value), U, U * >
template<typename Tp , typename Type >
using	index_of = impl::index_of< Tp, Type >
template<typename Tp , typename Types >
using	is_one_of = typename impl::is_one_of< Tp, Types >
	check if type is in expansion More...
template<template< typename > class Predicate, typename Types >
using	contains_one_of = typename impl::contains_one_of< Predicate, Types >
	check if type is in expansion More...
template<template< typename > class Predicate, typename Types >
using	contains_one_of_t = typename contains_one_of< Predicate, Types >::type
template<typename Tp >
using	get_index_sequence_t = typename get_index_sequence< decay_t< Tp > >::type
template<typename T , typename U >
using	convert_t = typename impl::convert< T, U >::type
template<template< typename... > class T, typename... U>
using	convert_each_t = typename impl::convert_each< T, U... >::type
template<typename T >
using	unwrap_t = typename impl::unwrapper< T >::type
template<template< typename > class CheckT, bool CheckV, template< typename > class TransformT, typename T , typename U >
using	apply_transform_t = typename impl::apply_transform< CheckT, CheckV, TransformT, T, U >::type
template<typename Tuple , typename T >
using	push_back_t = typename mpl::push_back< Tuple, T >::type
template<typename Tp >
using	remove_pointers_t = typename remove_pointers< Tp >::type
template<typename Tp >
using	storage_singleton = singleton< Tp, std::unique_ptr< Tp, impl::storage_deleter< Tp > >, TIMEMORY_API >
using	complete_types_t = typename complete_types< std::make_index_sequence< TIMEMORY_COMPONENTS_END > >::type
using	available_types_t = typename available_types< std::make_index_sequence< TIMEMORY_COMPONENTS_END > >::type
using	complete_tuple_t = convert_t< complete_types_t, std::tuple<> >
using	complete_component_list_t = convert_t< complete_types_t, component_list<> >
using	complete_component_tuple_t = convert_t< complete_types_t, component_tuple<> >
using	complete_auto_list_t = convert_t< complete_types_t, auto_list<> >
using	complete_auto_tuple_t = convert_t< complete_types_t, auto_tuple<> >
using	available_tuple_t = convert_t< available_types_t, std::tuple<> >
using	available_component_list_t = convert_t< available_types_t, component_list<> >
using	available_component_tuple_t = convert_t< available_types_t, component_tuple<> >
using	available_auto_list_t = convert_t< available_types_t, auto_list<> >
using	available_auto_tuple_t = convert_t< available_types_t, auto_tuple<> >
using	complete_list_t = complete_component_list_t
using	available_list_t = available_component_list_t
using	global_bundle_t = component_tuple< component::user_global_bundle >
using	ompt_bundle_t = component_tuple< component::user_ompt_bundle >
using	mpip_bundle_t = component_tuple< component::user_mpip_bundle >
using	ncclp_bundle_t = component_tuple< component::user_ncclp_bundle >
using	common_singleton = singleton< void, void, void >
template<typename Tp , Tp Num>
using	make_integer_sequence = std::make_integer_sequence< Tp, Num >
	Alias template make_integer_sequence. More...
template<size_t... Idx>
using	index_sequence = std::integer_sequence< size_t, Idx... >
	Alias template index_sequence. More...
template<size_t Num>
using	make_index_sequence = std::make_integer_sequence< size_t, Num >
	Alias template make_index_sequence. More...
template<typename... Types>
using	index_sequence_for = std::make_index_sequence< sizeof...(Types)>
	Alias template index_sequence_for. More...
template<bool B, typename T = int>
using	enable_if_t = typename std::enable_if< B, T >::type
	Alias template for enable_if. More...
template<typename T >
using	decay_t = typename std::decay< T >::type
	Alias template for decay. More...
template<bool B, typename Lhs , typename Rhs >
using	conditional_t = typename std::conditional< B, Lhs, Rhs >::type
template<typename T >
using	remove_cv_t = typename std::remove_cv< T >::type
template<typename T >
using	remove_const_t = typename std::remove_const< T >::type
template<int N>
using	priority_constant = std::integral_constant< int, N >
template<typename T >
using	identity_t = typename identity< T >::type
template<size_t Idx, typename Tp >
using	type_list_element_t = typename type_list_element< Idx, Tp >::type
using	string_t = std::string
using	mutex_t = std::recursive_mutex
	Recursive mutex is used for convenience since the performance penalty vs. a regular mutex is not really an issue since there are not many locks in general. More...
using	auto_lock_t = std::unique_lock< mutex_t >
	Unique lock type around mutex_t. More...
template<typename... T>
using	component_hybrid_t = typename component_hybrid< T... >::type
using	string = tim::mpl::apply< std::string >
template<typename... Types>
using	concat = typename impl::concat< Types... >::type

Enumerations
enum class	sys_signal : int {   Hangup = SIGHUP ,   Interrupt = SIGINT ,   Quit = SIGQUIT ,   Illegal = SIGILL ,   Trap = SIGTRAP ,   Abort = SIGABRT ,   Emulate = SIGEMT ,   FPE = SIGFPE ,   Kill = SIGKILL ,   Bus = SIGBUS ,   SegFault = SIGSEGV ,   System = SIGSYS ,   Pipe = SIGPIPE ,   Alarm = SIGALRM ,   Terminate = SIGTERM ,   Urgent = SIGURG ,   Stop = SIGTSTP ,   CPUtime = SIGXCPU ,   FileSize = SIGXFSZ ,   VirtualAlarm = SIGVTALRM ,   ProfileAlarm = SIGPROF ,   User1 = SIGUSR1 ,   User2 = SIGUSR2 }

Functions
template<>
auto	invoke_preinit< kokkosp::memory_tracker > (long)
template<typename... Types, typename... Args, enable_if_t<(sizeof...(Types) > 0 &&sizeof...(Args) >=2), int > >
void	timemory_init (Args &&... _args)
	TIMEMORY_CONFIG_LINKAGE (void) timemory_init(int argc
	if (_settings)
	while (exe_name.find('\\') !=std::string::npos) exe_name
	while (exe_name.find('/') !=std::string::npos) exe_name
	for (const auto &ext :_exe_suffixes)
	for (auto &itr :exe_name)
	while ((pos=exe_name.find("--")) !=std::string::npos) exe_name.erase(pos
	if (exe_name.empty()) exe_name
	if (_manager)
	timemory_argparse (argc, argv)
	timemory_argparse (argc, argv, &parser)
	if (_cleanup_parser) parser
	if (_cleanup_settings &&!_shared_settings) return
	if (_cleanup_settings) _settings
parser	enable_help ()
parser	on_error ([=](parser_t &p, const parser_err_t &_err) { err_action(_err);if(dmp::rank()==0 &&_settings->get_verbose() > 0) p.print_help("-- <NON_TIMEMORY_ARGS>");})
	for (const auto &itr :_settings->ordering())
parser	add_argument () .names(
	description ("A generic option for any setting. Each argument MUST be passed in " "form: 'NAME=VALUE'. E.g. --timemory-args " "\"papi_events=PAPI_TOT_INS,PAPI_TOT_CYC\" text_output=off") .action([&](parser_t &p)
	err_action (parser->parse_known_args(argc, argv, "--", settings::verbose()))
	if (parser->exists("help")) help_action(*parser)
void	timemory_init (int argc, char **argv, const std::string &_prefix="timemory-", const std::string &_suffix="-output")
	initialization (creates manager and configures output path) More...
void	timemory_init (const std::string &exe_name, const std::string &_prefix="timemory-", const std::string &_suffix="-output")
	initialization (creates manager and configures output path) More...
void	timemory_init (int *argc, char ***argv, const std::string &_prefix="timemory-", const std::string &_suffix="-output")
	initialization (creates manager, configures output path, mpi_init) More...
void	timemory_init (int *argc, char ***argv, argparse::argument_parser &parser, const std::string &_prefix="timemory-", const std::string &_suffix="-output")
void	timemory_init (std::vector< std::string > &, argparse::argument_parser &parser, const std::string &_prefix="timemory-", const std::string &_suffix="-output")
void	timemory_finalize ()
	finalization of the specified types More...
void	timemory_argparse (int *argc, char ***argv, argparse::argument_parser *parser=nullptr, settings *_settings=nullptr)
void	timemory_argparse (std::vector< std::string > &, argparse::argument_parser *parser=nullptr, settings *_settings=nullptr)
template<typename... Args>
void	init (Args &&... args)
void	finalize ()
template<typename Tp >
Tp	get_env (const std::string &env_id, Tp _default)
template<typename Tp >
Tp	load_env (const std::string &env_id, Tp _default)
template<typename Tp >
void	set_env (const std::string &env_var, const Tp &_val, int override)
	TIMEMORY_ENVIRONMENT_LINKAGE (env_settings::~env_settings())
	TIMEMORY_ENVIRONMENT_LINKAGE (env_settings::env_map_t) env_settings
template<>
	TIMEMORY_ENVIRONMENT_LINKAGE (std::string) get_env(const std
template<>
	TIMEMORY_ENVIRONMENT_LINKAGE (bool) get_env(const std
	TIMEMORY_ENVIRONMENT_LINKAGE (void) print_env(std
	TIMEMORY_ENVIRONMENT_LINKAGE (tim::env_settings *) env_settings
template<>
std::string	get_env (const std::string &env_id, std::string _default)
template<>
bool	get_env (const std::string &env_id, bool _default)
template<>
std::string	load_env (const std::string &env_id, std::string _default)
template<>
bool	load_env (const std::string &env_id, bool _default)
void	print_env (std::ostream &os=std::cout)
template<typename Tp , typename FuncT >
void	generic_serialization (const std::string &fname, const Tp &obj, const std::string &_main_name="timemory", const std::string &_data_name="data", FuncT &&_func=[](typename policy::output_archive_t< decay_t< Tp >>::type &) {})
template<typename ArchiveT , typename ApiT = TIMEMORY_API, typename Tp , typename FuncT >
void	generic_serialization (const std::string &fname, const Tp &obj, const std::string &_main_name="timemory", const std::string &_data_name="data", FuncT &&_func=[](typename policy::output_archive_t< decay_t< Tp >>::type &) {})
template<typename ArchiveT , typename ApiT = TIMEMORY_API, typename Tp , typename FuncT >
void	generic_serialization (std::ostream &ofs, const Tp &obj, const std::string &_main_name="timemory", const std::string &_data_name="data", FuncT &&_func=[](typename policy::output_archive_t< decay_t< Tp >>::type &) {})
template<typename Tp , typename Tag , typename PtrT , typename PairT >
PairT &	get_shared_ptr_pair ()
template<typename Tp , typename Tag , typename PtrT , typename PairT >
PtrT	get_shared_ptr_pair_instance ()
template<typename Tp , typename Tag , typename PtrT , typename PairT >
PtrT	get_shared_ptr_pair_main_instance ()
template<typename Tp , typename Tag , typename PtrT >
PtrT	get_shared_ptr_lone_instance ()
	TIMEMORY_HASH_LINKAGE (hash_map_ptr_t &) get_hash_ids()
	TIMEMORY_HASH_LINKAGE (hash_alias_ptr_t &) get_hash_aliases()
	TIMEMORY_HASH_LINKAGE (std::shared_ptr< hash_resolver_vec_t > &) get_hash_resolvers()
	TIMEMORY_HASH_LINKAGE (hash_value_t) get_hash_id(const hash_alias_ptr_t &_hash_alias
	if (_alias_itr !=_hash_alias->end()) return _alias_itr -> second
	TIMEMORY_HASH_LINKAGE (void) add_hash_id(const hash_map_ptr_t &_hash_map
hash_map_ptr_t &	get_hash_ids ()
hash_alias_ptr_t &	get_hash_aliases ()
std::shared_ptr< hash_resolver_vec_t > &	get_hash_resolvers ()
template<typename Tp , std::enable_if_t< concepts::is_string_type< std::decay_t< Tp >>::value, int > = 0>
hash_value_t	get_hash_id (Tp &&_prefix)
hash_value_t	get_combined_hash_id (hash_value_t _lhs, hash_value_t _rhs)
template<typename Tp , std::enable_if_t<!std::is_integral< std::decay_t< Tp >>::value, int > = 0>
hash_value_t	get_combined_hash_id (hash_value_t _lhs, Tp &&_rhs)
hash_value_t	get_hash_id (const hash_alias_ptr_t &_hash_alias, hash_value_t _hash_id)
hash_value_t	add_hash_id (hash_map_ptr_t &_hash_map, const string_view_t &_prefix)
	add an string to the given hash-map (if it doesn't already exist) and return the hash More...
hash_value_t	add_hash_id (const string_view_t &_prefix)
	add an string to the default hash-map (if it doesn't already exist) and return the hash More...
void	add_hash_id (const hash_map_ptr_t &_hash_map, const hash_alias_ptr_t &_hash_alias, hash_value_t _hash_id, hash_value_t _alias_hash_id)
void	add_hash_id (hash_value_t _hash_id, hash_value_t _alias_hash_id)
string_view_t	get_hash_identifier_fast (hash_value_t _hash)
	this does not check other threads or aliases. Only call this function when you know that the hash exists on the thread and is not an alias More...
std::string	get_hash_identifier (const hash_map_ptr_t &_hash_map, const hash_alias_ptr_t &_hash_alias, hash_value_t _hash_id)
std::string	get_hash_identifier (hash_value_t _hash_id)
template<typename FuncT >
size_t	add_hash_resolver (FuncT &&_func)
std::string	demangle_hash_identifier (std::string, char bdelim='[', char edelim=']')
template<typename... Args>
auto	get_demangled_hash_identifier (Args &&... _args)
manager *	timemory_manager_master_instance ()
void	timemory_library_constructor ()
template<typename T >
auto	invoke_preinit (int) -> decltype(std::declval< T >().preinit(), void())
template<typename T >
auto	invoke_preinit (long)
template<typename Bundle , typename EnumT , typename... Args>
void	configure (std::initializer_list< EnumT > components, Args &&... args)
template<typename Bundle , typename... Args>
void	configure (const std::initializer_list< std::string > &components, Args &&... args)
template<typename Bundle , typename... ExtraArgs, template< typename, typename... > class Container, typename... Args>
void	configure (const Container< std::string, ExtraArgs... > &components, Args &&... args)
	this is for initializing with a container of string More...
template<typename Bundle , typename... Args>
void	configure (const std::string &components, Args &&... args)
	this is for initializing with a string More...
template<typename Bundle , template< typename, typename... > class Container, typename Intp , typename... ExtraArgs, typename... Args, typename std::enable_if< std::is_integral< Intp >::value||std::is_same< Intp, TIMEMORY_NATIVE_COMPONENT >::value, int >::type >
void	configure (const Container< Intp, ExtraArgs... > &components, Args &&... args)
template<typename Bundle , template< typename, typename... > class Container, typename... ExtraArgs, typename... Args>
void	configure (const Container< const char *, ExtraArgs... > &components, Args &&... args)
template<typename Bundle , typename... Args>
void	configure (const int ncomponents, const int *components, Args &&... args)
template<typename StringT , typename... ExtraArgs, template< typename, typename... > class Container>
std::vector< TIMEMORY_COMPONENT >	enumerate_components (const Container< StringT, ExtraArgs... > &component_names)
	description: use this function to generate an array of enumerations from a list of string that can be subsequently used to initialize an auto_list or a component_list More...
std::set< TIMEMORY_COMPONENT >	enumerate_components (const std::initializer_list< std::string > &component_names)
template<typename StringT = std::string>
std::vector< TIMEMORY_COMPONENT >	enumerate_components (const std::string &names, const StringT &env_id="")
template<typename... ExtraArgs>
std::set< TIMEMORY_COMPONENT >	enumerate_components (const std::set< std::string, ExtraArgs... > &component_names)
template<template< typename... > class CompList, typename... CompTypes, typename EnumT = int>
void	initialize (CompList< CompTypes... > &obj, std::initializer_list< EnumT > components)
template<template< typename... > class CompList, typename... CompTypes>
void	initialize (CompList< CompTypes... > &obj, std::initializer_list< std::string > components)
template<template< typename... > class CompList, typename... CompTypes, typename... ExtraArgs, template< typename, typename... > class Container>
void	initialize (CompList< CompTypes... > &obj, const Container< std::string, ExtraArgs... > &components)
template<template< typename... > class CompList, typename... CompTypes>
void	initialize (CompList< CompTypes... > &obj, const std::string &components)
	this is for initializing with a string More...
template<template< typename... > class CompList, typename... CompTypes, template< typename, typename... > class Container, typename Intp , typename... ExtraArgs, typename std::enable_if< std::is_integral< Intp >::value||std::is_same< Intp, TIMEMORY_NATIVE_COMPONENT >::value, int >::type >
void	initialize (CompList< CompTypes... > &obj, const Container< Intp, ExtraArgs... > &components)
	description: use this function to initialize a auto_list or component_list from a list of enumerations More...
template<template< typename... > class CompList, typename... CompTypes, template< typename, typename... > class Container, typename... ExtraArgs>
void	initialize (CompList< CompTypes... > &obj, const Container< const char *, ExtraArgs... > &components)
template<template< typename... > class CompList, typename... CompTypes>
void	initialize (CompList< CompTypes... > &obj, const int ncomponents, const int *components)
template<size_t Idx, typename Type , template< size_t, typename > class Bundle, typename EnumT = int>
void	insert (Bundle< Idx, Type > &obj, std::initializer_list< EnumT > components)
template<size_t Idx, typename Type , template< size_t, typename > class Bundle>
void	insert (Bundle< Idx, Type > &obj, const std::initializer_list< std::string > &components)
template<size_t Idx, typename Type , template< size_t, typename > class Bundle, typename... ExtraArgs, template< typename, typename... > class Container>
void	insert (Bundle< Idx, Type > &obj, const Container< std::string, ExtraArgs... > &components)
	this is for initializing with a container of string More...
template<size_t Idx, typename Type , template< size_t, typename > class Bundle>
void	insert (Bundle< Idx, Type > &obj, const std::string &components)
	this is for initializing with a string More...
template<size_t Idx, typename Type , template< size_t, typename > class Bundle, template< typename, typename... > class Container, typename Intp , typename... ExtraArgs, typename std::enable_if< std::is_integral< Intp >::value||std::is_same< Intp, TIMEMORY_NATIVE_COMPONENT >::value, int >::type >
void	insert (Bundle< Idx, Type > &obj, const Container< Intp, ExtraArgs... > &components)
	description: use this function to insert tools into a bundle More...
template<size_t Idx, typename Type , template< size_t, typename > class Bundle, template< typename, typename... > class Container, typename... ExtraArgs>
void	insert (Bundle< Idx, Type > &obj, const Container< const char *, ExtraArgs... > &components)
template<size_t Idx, typename Type , template< size_t, typename > class Bundle>
void	insert (Bundle< Idx, Type > &obj, const int ncomponents, const int *components)
template<typename T , typename... Args>
void	initialize (T *obj, Args &&... args)
template<typename T , typename... Args>
void	insert (T *obj, Args &&... args)
template<typename Bundle_t , template< typename, typename... > class Container, typename Intp , typename... ExtraArgs, typename... Args, typename std::enable_if< std::is_integral< Intp >::value||std::is_same< Intp, TIMEMORY_NATIVE_COMPONENT >::value, int >::type = 0>
void	configure (const Container< Intp, ExtraArgs... > &components, Args &&...)
	description: use this function to insert tools into a bundle More...
TIMEMORY_SETTINGS_INLINE std::string	get_local_datetime (const char *dt_format, std::time_t *dt_curr)
	TIMEMORY_SETTINGS_MEMBER_DEF (string_t, config_file, TIMEMORY_SETTINGS_KEY("CONFIG_FILE")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("SUPPRESS_PARSING")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("SUPPRESS_CONFIG")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("ENABLED")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("AUTO_OUTPUT")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("COUT_OUTPUT")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("FILE_OUTPUT")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("TEXT_OUTPUT")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("JSON_OUTPUT")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("TREE_OUTPUT")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("DART_OUTPUT")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("TIME_OUTPUT")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("PLOT_OUTPUT")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("DIFF_OUTPUT")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("FLAMEGRAPH_OUTPUT")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("CTEST_NOTES")) TIMEMORY_SETTINGS_MEMBER_DEF(int
	TIMEMORY_SETTINGS_KEY ("VERBOSE")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("DEBUG")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("BANNER")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("COLLAPSE_THREADS")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("COLLAPSE_PROCESSES")) TIMEMORY_SETTINGS_MEMBER_DEF(uint16_t
	TIMEMORY_SETTINGS_KEY ("MAX_DEPTH")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("TIME_FORMAT")) TIMEMORY_SETTINGS_MEMBER_DEF(int16_t
	TIMEMORY_SETTINGS_KEY ("PRECISION")) TIMEMORY_SETTINGS_MEMBER_DEF(int16_t
	TIMEMORY_SETTINGS_KEY ("WIDTH")) TIMEMORY_SETTINGS_MEMBER_DEF(int32_t
	TIMEMORY_SETTINGS_KEY ("MAX_WIDTH")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("SCIENTIFIC")) TIMEMORY_SETTINGS_MEMBER_DEF(int16_t
	TIMEMORY_SETTINGS_KEY ("TIMING_PRECISION")) TIMEMORY_SETTINGS_MEMBER_DEF(int16_t
	TIMEMORY_SETTINGS_KEY ("TIMING_WIDTH")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("TIMING_UNITS")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("TIMING_SCIENTIFIC")) TIMEMORY_SETTINGS_MEMBER_DEF(int16_t
	TIMEMORY_SETTINGS_KEY ("MEMORY_PRECISION")) TIMEMORY_SETTINGS_MEMBER_DEF(int16_t
	TIMEMORY_SETTINGS_KEY ("MEMORY_WIDTH")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("MEMORY_UNITS")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("MEMORY_SCIENTIFIC")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("OUTPUT_PATH")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("OUTPUT_PREFIX")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("INPUT_PATH")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("INPUT_PREFIX")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("INPUT_EXTENSIONS")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("DART_TYPE")) TIMEMORY_SETTINGS_MEMBER_DEF(uint64_t
	TIMEMORY_SETTINGS_KEY ("DART_COUNT")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("DART_LABEL")) TIMEMORY_SETTINGS_MEMBER_DEF(size_t
	TIMEMORY_SETTINGS_KEY ("MAX_THREAD_BOOKMARKS")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("CPU_AFFINITY")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("STACK_CLEARING")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("ADD_SECONDARY")) TIMEMORY_SETTINGS_MEMBER_DEF(size_t
	TIMEMORY_SETTINGS_KEY ("THROTTLE_COUNT")) TIMEMORY_SETTINGS_MEMBER_DEF(size_t
	TIMEMORY_SETTINGS_KEY ("THROTTLE_VALUE")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("GLOBAL_COMPONENTS")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("TUPLE_COMPONENTS")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("LIST_COMPONENTS")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("OMPT_COMPONENTS")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("MPIP_COMPONENTS")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("NCCLP_COMPONENTS")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("TRACE_COMPONENTS")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("PROFILER_COMPONENTS")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("KOKKOS_COMPONENTS")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("COMPONENTS")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("MPI_INIT")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("MPI_FINALIZE")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("MPI_THREAD")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("MPI_THREAD_TYPE")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("UPCXX_INIT")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("UPCXX_FINALIZE")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("PAPI_THREADING")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("PAPI_MULTIPLEXING")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("PAPI_FAIL_ON_ERROR")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("PAPI_QUIET")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("PAPI_EVENTS")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("PAPI_ATTACH")) TIMEMORY_SETTINGS_MEMBER_DEF(int
	TIMEMORY_SETTINGS_KEY ("PAPI_OVERFLOW")) TIMEMORY_SETTINGS_MEMBER_DEF(uint64_t
	TIMEMORY_SETTINGS_KEY ("CUDA_EVENT_BATCH_SIZE")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("NVTX_MARKER_DEVICE_SYNC")) TIMEMORY_SETTINGS_MEMBER_DEF(int32_t
	TIMEMORY_SETTINGS_KEY ("CUPTI_ACTIVITY_LEVEL")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("CUPTI_ACTIVITY_KINDS")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("CUPTI_EVENTS")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("CUPTI_METRICS")) TIMEMORY_SETTINGS_MEMBER_DEF(int
	TIMEMORY_SETTINGS_KEY ("CUPTI_DEVICE")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("ROOFLINE_MODE")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("ROOFLINE_MODE_CPU")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("ROOFLINE_MODE_GPU")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("ROOFLINE_EVENTS_CPU")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("ROOFLINE_EVENTS_GPU")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("ROOFLINE_TYPE_LABELS")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("ROOFLINE_TYPE_LABELS_CPU")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("ROOFLINE_TYPE_LABELS_GPU")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("INSTRUCTION_ROOFLINE")) TIMEMORY_SETTINGS_MEMBER_DEF(uint64_t
	TIMEMORY_SETTINGS_KEY ("ERT_NUM_THREADS")) TIMEMORY_SETTINGS_MEMBER_DEF(uint64_t
	TIMEMORY_SETTINGS_KEY ("ERT_NUM_THREADS_CPU")) TIMEMORY_SETTINGS_MEMBER_DEF(uint64_t
	TIMEMORY_SETTINGS_KEY ("ERT_NUM_THREADS_GPU")) TIMEMORY_SETTINGS_MEMBER_DEF(uint64_t
	TIMEMORY_SETTINGS_KEY ("ERT_NUM_STREAMS")) TIMEMORY_SETTINGS_MEMBER_DEF(uint64_t
	TIMEMORY_SETTINGS_KEY ("ERT_GRID_SIZE")) TIMEMORY_SETTINGS_MEMBER_DEF(uint64_t
	TIMEMORY_SETTINGS_KEY ("ERT_BLOCK_SIZE")) TIMEMORY_SETTINGS_MEMBER_DEF(uint64_t
	TIMEMORY_SETTINGS_KEY ("ERT_ALIGNMENT")) TIMEMORY_SETTINGS_MEMBER_DEF(uint64_t
	TIMEMORY_SETTINGS_KEY ("ERT_MIN_WORKING_SIZE")) TIMEMORY_SETTINGS_MEMBER_DEF(uint64_t
	TIMEMORY_SETTINGS_KEY ("ERT_MIN_WORKING_SIZE_CPU")) TIMEMORY_SETTINGS_MEMBER_DEF(uint64_t
	TIMEMORY_SETTINGS_KEY ("ERT_MIN_WORKING_SIZE_GPU")) TIMEMORY_SETTINGS_MEMBER_DEF(uint64_t
	TIMEMORY_SETTINGS_KEY ("ERT_MAX_DATA_SIZE")) TIMEMORY_SETTINGS_MEMBER_DEF(uint64_t
	TIMEMORY_SETTINGS_KEY ("ERT_MAX_DATA_SIZE_CPU")) TIMEMORY_SETTINGS_MEMBER_DEF(uint64_t
	TIMEMORY_SETTINGS_KEY ("ERT_MAX_DATA_SIZE_GPU")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("ERT_SKIP_OPS")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("CRAYPAT")) TIMEMORY_SETTINGS_MEMBER_DEF(int32_t
	TIMEMORY_SETTINGS_KEY ("NODE_COUNT")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("DESTRUCTOR_REPORT")) TIMEMORY_SETTINGS_MEMBER_DEF(string_t
	TIMEMORY_SETTINGS_KEY ("PYTHON_EXE")) TIMEMORY_SETTINGS_MEMBER_DEF(int64_t
	TIMEMORY_SETTINGS_KEY ("SEPARATOR_FREQ")) TIMEMORY_SETTINGS_MEMBER_DEF(bool
	TIMEMORY_SETTINGS_KEY ("ENABLE_SIGNAL_HANDLER")) TIMEMORY_SETTINGS_REFERENCE_DEF(bool
	TIMEMORY_SETTINGS_KEY ("ALLOW_SIGNAL_HANDLER")) TIMEMORY_SETTINGS_REFERENCE_DEF(bool
	TIMEMORY_SETTINGS_KEY ("ENABLE_ALL_SIGNALS")) TIMEMORY_SETTINGS_REFERENCE_DEF(bool
	TIMEMORY_SETTINGS_KEY ("DISABLE_ALL_SIGNALS")) TIMEMORY_SETTINGS_REFERENCE_DEF(bool
	TIMEMORY_SETTINGS_KEY ("FLAT_PROFILE")) TIMEMORY_SETTINGS_REFERENCE_DEF(bool
	TIMEMORY_SETTINGS_LINKAGE (vsettings::display_map_t) vsettings
	TIMEMORY_SETTINGS_LINKAGE (bool) vsettings
template<typename Tp >
TIMEMORY_NOCLONE storage_singleton< Tp > *	get_storage_singleton ()
template<typename Tp >
storage_singleton< Tp > *	get_storage_singleton ()
template<typename T >
void	print_graph_bracketed (const graph< T > &t, std::ostream &os=std::cout)
template<typename T >
void	print_subgraph_bracketed (const graph< T > &t, typename graph< T >::iterator root, std::ostream &os=std::cout)
template<typename T , typename Formatter = std::function<std::string(const T&)>>
void	print_graph (const tim::graph< T > &t, Formatter format, std::ostream &str=std::cout)
template<typename T , typename Formatter = std::function<std::string(const T&)>>
void	print_subgraph (const tim::graph< T > &t, Formatter format, typename tim::graph< T >::iterator root, std::ostream &str=std::cout)
template<typename T >
void	print_graph (const tim::graph< T > &t, std::ostream &str)
template<typename T , typename Formatter = std::function<std::string(const T&)>>
void	print_graph_hierarchy (const tim::graph< T > &t, Formatter format, std::ostream &str=std::cout)
template<typename T , typename Formatter = std::function<std::string(const T&)>>
void	print_subgraph_hierarchy (const tim::graph< T > &t, Formatter format, typename tim::graph< T >::iterator root, std::ostream &str=std::cout)
void	insert_and_remove (const sys_signal &_type, signal_settings::signal_set_t *_ins, signal_settings::signal_set_t *_rem)
template<typename FuncT , typename TraitsT = mpl::function_traits<FuncT>>
std::string	mangle (const std::string &func)
bool	launch_process (const char *cmd, const std::string &extra, std::ostream *os)
bool	enable_signal_detection (signal_settings::signal_set_t=signal_settings::get_default())
template<typename Tp , enable_if_t<!std::is_enum< Tp >::value &&std::is_integral< Tp >::value > = 0>
bool	enable_signal_detection (std::initializer_list< Tp > &&)
void	disable_signal_detection ()
void	update_signal_detection (const signal_settings::signal_set_t &_signals)
template<typename... ArgsT>
void	consume_parameters (ArgsT &&...) TIMEMORY_HIDDEN
std::string	dirname (std::string _fname)
int	makedir (std::string _dir, int umask)
bool	get_bool (const std::string &strbool, bool _default) noexcept
std::vector< std::string >	read_command_line (pid_t _pid)
template<typename Tp >
bool	isfinite (const Tp &arg)
template<typename Tp , typename ApiT = TIMEMORY_API, size_t N = 4>
mutex_t &	type_mutex (uint64_t _n=0)
	A simple way to get a mutex for a class or common behavior, e.g. type_mutex<decltype(std::cout)>() provides a mutex for synchronizing output streams. Recommend using in conjunction with auto-lock: tim::auto_lock_t _lk{ type_mutex<Foo>() }. More...
std::string	demangle (const char *_mangled_name, int *_status=nullptr)
std::string	demangle (const std::string &_str, int *_status=nullptr)
template<typename Tp >
auto	try_demangle ()
template<typename Tp >
auto	demangle ()
template<typename Tp >
auto	typeid_hash ()
template<typename T >
T	from_string (const std::string &str)
template<typename T >
T	from_string (const char *cstr)
template<typename ContainerT = std::vector<std::string>, typename PredicateT = std::function<std::string(const std::string&)>>
ContainerT	delimit (const std::string &line, const std::string &delimiters="\"',;: ", PredicateT &&predicate=[](const std::string &s) -> std::string { return s;})
template<typename PredicateT = std::function<std::string(const std::string&)>>
std::string	str_transform (const std::string &input, const std::string &_begin, const std::string &_end, PredicateT &&predicate)
	apply a string transformation to substring inbetween a common delimiter. e.g. More...
template<typename T >
size_t	get_hash (T &&obj)
size_t	get_hash (const string_view_t &str)
size_t	get_hash (const char *cstr)
template<typename Tag , typename... Types>
auto	get (const auto_bundle< Tag, Types... > &_obj)
template<typename Tag , typename... Types>
auto	get_labeled (const auto_bundle< Tag, Types... > &_obj)
template<typename... Types>
auto	get (const auto_list< Types... > &_obj)
template<typename... Types>
auto	get_labeled (const auto_list< Types... > &_obj)
template<typename... Types>
auto	get (const auto_tuple< Types... > &_obj)
template<typename... Types>
auto	get_labeled (const auto_tuple< Types... > &_obj)
template<typename... Types>
auto	get (const component_bundle< Types... > &_obj) -> decltype(std::declval< component_bundle< Types... >>().get())
template<typename... Types>
auto	get_labeled (const component_bundle< Types... > &_obj) -> decltype(std::declval< component_bundle< Types... >>().get_labeled())
template<typename... Types>
auto	get (const component_list< Types... > &_obj) -> decltype(std::declval< component_list< Types... >>().get())
template<typename... Types>
auto	get_labeled (const component_list< Types... > &_obj) -> decltype(std::declval< component_list< Types... >>().get_labeled())
template<typename... Types>
auto	get (const component_tuple< Types... > &_obj) -> decltype(std::declval< component_tuple< Types... >>().get())
template<typename... Types>
auto	get_labeled (const component_tuple< Types... > &_obj) -> decltype(std::declval< component_tuple< Types... >>().get_labeled())
template<typename... Types>
auto	get (const lightweight_tuple< Types... > &_obj) -> decltype(std::declval< lightweight_tuple< Types... >>().get())
template<typename... Types>
auto	get_labeled (const lightweight_tuple< Types... > &_obj) -> decltype(std::declval< lightweight_tuple< Types... >>().get_labeled())

Variables
char **	argv
char const std::string &	_prefix
char const std::string const std::string &	_suffix
std::string	exe_name = (argc > 0) ? argv[0] : ""
size_t	pos = std::string::npos
char argparse::argument_parser &	parser
char argparse::argument_parser tim::settings *	_settings
if argc	return
auto	help_action
auto	err_action
bool	_cleanup_parser = parser == nullptr
bool	_cleanup_settings = _settings == nullptr
hash_value_t	_hash_id
const hash_alias_ptr_t &	_hash_alias
	suppress_parsing
	suppress_config
	enabled
	auto_output
	cout_output
	file_output
	text_output
	json_output
	tree_output
	dart_output
	time_output
	plot_output
	diff_output
	flamegraph_output
	ctest_notes
	verbose
	debug
	banner
	collapse_threads
	collapse_processes
	max_depth
	time_format
	precision
	width
	max_width
	scientific
	timing_precision
	timing_width
	timing_units
	timing_scientific
	memory_precision
	memory_width
	memory_units
	memory_scientific
	output_path
	output_prefix
	input_path
	input_prefix
	input_extensions
	dart_type
	dart_count
	dart_label
	max_thread_bookmarks
	cpu_affinity
	stack_clearing
	add_secondary
	throttle_count
	throttle_value
	global_components
	tuple_components
	list_components
	ompt_components
	mpip_components
	ncclp_components
	trace_components
	profiler_components
	kokkos_components
	components
	mpi_init
	mpi_finalize
	mpi_thread
	mpi_thread_type
	upcxx_init
	upcxx_finalize
	papi_threading
	papi_multiplexing
	papi_fail_on_error
	papi_quiet
	papi_events
	papi_attach
	papi_overflow
	cuda_event_batch_size
	nvtx_marker_device_sync
	cupti_activity_level
	cupti_activity_kinds
	cupti_events
	cupti_metrics
	cupti_device
	roofline_mode
	cpu_roofline_mode
	gpu_roofline_mode
	cpu_roofline_events
	gpu_roofline_events
	roofline_type_labels
	roofline_type_labels_cpu
	roofline_type_labels_gpu
	instruction_roofline
	ert_num_threads
	ert_num_threads_cpu
	ert_num_threads_gpu
	ert_num_streams
	ert_grid_size
	ert_block_size
	ert_alignment
	ert_min_working_size
	ert_min_working_size_cpu
	ert_min_working_size_gpu
	ert_max_data_size
	ert_max_data_size_cpu
	ert_max_data_size_gpu
	ert_skip_ops
	craypat_categories
	node_count
	destructor_report
	python_exe
	separator_frequency
	enable_signal_handler
	allow_signal_handler
	enable_all_signals
	disable_all_signals
	flat_profile
	timeline_profile

Detailed Description

Extern template declarations

---

Class Documentation

tim::remove_pointers

struct tim::remove_pointers

template<typename Tp>
struct tim::remove_pointers< Tp >

Definition at line 69 of file types.hpp.

Collaboration diagram for tim::remove_pointers< Tp >:

tim::remove_pointers< Tuple< Tp... > >

struct tim::remove_pointers< Tuple< Tp... > >

template<template< typename... > class Tuple, typename... Tp>
struct tim::remove_pointers< Tuple< Tp... > >

Definition at line 72 of file types.hpp.

Collaboration diagram for tim::remove_pointers< Tuple< Tp... > >:

Class Members
	type

tim::graph_allocator

class tim::graph_allocator

template<typename Tp>
class tim::graph_allocator< Tp >

Definition at line 187 of file types.hpp.

Collaboration diagram for tim::graph_allocator< Tp >:

tim::complete_types

struct tim::complete_types

template<typename Tp>
struct tim::complete_types< Tp >

Definition at line 201 of file types.hpp.

Collaboration diagram for tim::complete_types< Tp >:

tim::available_types

struct tim::available_types

template<typename Tp>
struct tim::available_types< Tp >

Definition at line 214 of file types.hpp.

Collaboration diagram for tim::available_types< Tp >:

tim::identity

struct tim::identity

template<typename T>
struct tim::identity< T >

Definition at line 211 of file types.hpp.

Collaboration diagram for tim::identity< T >:

Class Members
typedef T	type

tim::type_list

struct tim::type_list

template<typename... Tp>
struct tim::type_list< Tp >

lightweight tuple-alternative for meta-programming logic

Definition at line 232 of file types.hpp.

Collaboration diagram for tim::type_list< Tp >:

tim::bundle

class tim::bundle

template<typename...>
class tim::bundle<... >

Static polymorphic base class for component bundlers.

Definition at line 51 of file bundle.hpp.

Collaboration diagram for tim::bundle<... >:

tim::component_bundle

class tim::component_bundle

template<typename... Types>
class tim::component_bundle< Types >

This is a variadic component wrapper which combines the features of tim::component_tuple<T...> and tim::component_list<U..>. The "T" types (compile-time fixed, allocated on stack) should be specified as usual, the "U" types (runtime-time optional, allocated on the heap) should be specified as a pointer. Initialization of the optional types is similar to tim::auto_list<U...> but no environment variable is built-in since, ideally, this environment variable should be customized based on the Tag template parameter.

Template Parameters

Tag	unique identifying type for the bundle which when tim::trait::is_available<Tag> is false at compile-time or tim::trait::runtime_enabled<Tag>() is false at runtime, then none of the components will be collected
Types	Specification of the component types to bundle together

See also: tim::auto_bundle. The primary difference b/t the "component_*" and "auto_*" is that the latter used the constructor/destructor to call start and stop and is thus easier to just copy-and-paste into different places. However, the former is better suited for special configuration, data-access, etc.

Definition at line 63 of file types.hpp.

Collaboration diagram for tim::component_bundle< Types >:

tim::auto_base_bundle

class tim::auto_base_bundle

template<typename... Types>
class tim::auto_base_bundle< Types >

Static polymorphic base class for automatic start/stop bundlers.

Definition at line 72 of file types.hpp.

Collaboration diagram for tim::auto_base_bundle< Types >:

tim::auto_bundle

class tim::auto_bundle

template<typename... Types>
class tim::auto_bundle< Types >

This is a variadic component wrapper which combines the features of tim::auto_tuple<T...> and tim::auto_list<U..>. The "T" types (compile-time fixed, allocated on stack) should be specified as usual, the "U" types (runtime-time optional, allocated on the heap) should be specified as a pointer. Initialization of the optional types is similar to tim::auto_list<U...> but no environment variable is built-in since, ideally, this environment variable should be customized based on the Tag template parameter.

Template Parameters

Tag	unique identifying type for the bundle which when tim::trait::is_available<Tag> is false at compile-time or tim::trait::runtime_enabled<Tag>() is false at runtime, then none of the components will be collected
Types	Specification of the component types to bundle together

// dummy type identifying the context
struct FooApi {};
 
using bundle_t = tim::auto_bundle<FooApi, wall_clock, cpu_clock*>;
 
void foo_init() // user initialization routine
{
    bundle_t::get_initializer() = [](bundle_t& b)
    {
        static auto env_enum = tim::enumerate_components(
            tim::delimit(tim::get_env<string_t>("FOO_COMPONENTS", "wall_clock")));
 
        :im::initialize(b, env_enum);
    };
}
void bar()
{
    // will record whichever components are specified by "FOO_COMPONENT" in
    // environment, which "wall_clock" as the default
 
    auto bar = bundle_t("foo");
    // ...
}
 
int main(int argc, char** argv)
{
    tim::timemory_init(argc, argv);
 
    foo_init();
 
    bar();
 
    tim::timemory_finalize();
}

The above code will record wall-clock, cpu-clock, and peak-rss. The intermediate storage will happen on the stack and when the destructor is called, it will add itself to the call-graph

Definition at line 75 of file types.hpp.

Collaboration diagram for tim::auto_bundle< Types >:

tim::component_hybrid

class tim::component_hybrid

template<typename TupleT, typename ListT>
class tim::component_hybrid< TupleT, ListT >

Definition at line 84 of file types.hpp.

Collaboration diagram for tim::component_hybrid< TupleT, ListT >:

tim::auto_hybrid

class tim::auto_hybrid

template<typename TupleT, typename ListT>
class tim::auto_hybrid< TupleT, ListT >

Definition at line 87 of file types.hpp.

Collaboration diagram for tim::auto_hybrid< TupleT, ListT >:

Typedef Documentation

add_pointer_t

template<typename U >

using tim::add_pointer_t = typedef conditional_t<(std::is_pointer<U>::value), U, U*>

Definition at line 533 of file types.hpp.

apply_transform_t

template<template< typename > class CheckT, bool CheckV, template< typename > class TransformT, typename T , typename U >

using tim::apply_transform_t = typedef typename impl::apply_transform<CheckT, CheckV, TransformT, T, U>::type

Definition at line 826 of file types.hpp.

auto_bundle_t

template<typename Tag , typename... T>

using tim::auto_bundle_t = typedef convert_t<mpl::available_t<type_list<T...> >, auto_bundle<Tag> >

Definition at line 352 of file available.hpp.

auto_list_t

template<typename... T>

using tim::auto_list_t = typedef convert_t<mpl::available_t<concat<T...> >, auto_list<> >

Definition at line 349 of file available.hpp.

auto_lock_t

std::unique_lock< std::recursive_mutex > tim::auto_lock_t

Unique lock type around mutex_t.

Definition at line 115 of file utility.hpp.

auto_timer

using tim::auto_timer = typedef minimal_auto_timer_t

Definition at line 65 of file auto_timer.hpp.

auto_timer_list_t

using tim::auto_timer_list_t = typedef minimal_auto_list_t

Definition at line 64 of file auto_timer.hpp.

auto_timer_t

using tim::auto_timer_t = typedef auto_timer

Definition at line 71 of file auto_timer.hpp.

auto_timer_tuple_t

using tim::auto_timer_tuple_t = typedef minimal_auto_tuple_t

Definition at line 63 of file auto_timer.hpp.

auto_tuple_t

template<typename... T>

using tim::auto_tuple_t = typedef convert_t<mpl::available_t<concat<T...> >, auto_tuple<> >

Definition at line 346 of file available.hpp.

auto_user_bundle_t

using tim::auto_user_bundle_t = typedef auto_bundle<TIMEMORY_API, component::user_global_bundle>

Definition at line 36 of file auto_user_bundle.hpp.

available_auto_list_t

using tim::available_auto_list_t = typedef convert_t<available_types_t, auto_list<> >

Definition at line 246 of file types.hpp.

available_auto_tuple_t

using tim::available_auto_tuple_t = typedef convert_t<available_types_t, auto_tuple<> >

Definition at line 247 of file types.hpp.

available_component_list_t

using tim::available_component_list_t = typedef convert_t<available_types_t, component_list<> >

Definition at line 244 of file types.hpp.

available_component_tuple_t

using tim::available_component_tuple_t = typedef convert_t<available_types_t, component_tuple<> >

Definition at line 245 of file types.hpp.

available_list_t

using tim::available_list_t = typedef available_component_list_t

Definition at line 254 of file types.hpp.

available_tuple_t

using tim::available_tuple_t = typedef convert_t<available_types_t, std::tuple<> >

Definition at line 243 of file types.hpp.

available_types_t

using tim::available_types_t = typedef typename available_types<std::make_index_sequence<TIMEMORY_COMPONENTS_END> >::type

Definition at line 230 of file types.hpp.

common_singleton

using tim::common_singleton = typedef singleton<void, void, void>

Definition at line 103 of file singleton.hpp.

complete_auto_list_t

using tim::complete_auto_list_t = typedef convert_t<complete_types_t, auto_list<> >

Definition at line 238 of file types.hpp.

complete_auto_tuple_t

using tim::complete_auto_tuple_t = typedef convert_t<complete_types_t, auto_tuple<> >

Definition at line 239 of file types.hpp.

complete_component_list_t

using tim::complete_component_list_t = typedef convert_t<complete_types_t, component_list<> >

Definition at line 236 of file types.hpp.

complete_component_tuple_t

using tim::complete_component_tuple_t = typedef convert_t<complete_types_t, component_tuple<> >

Definition at line 237 of file types.hpp.

complete_list_t

using tim::complete_list_t = typedef complete_component_list_t

Definition at line 253 of file types.hpp.

complete_tuple_t

using tim::complete_tuple_t = typedef convert_t<complete_types_t, std::tuple<> >

Definition at line 235 of file types.hpp.

complete_types_t

using tim::complete_types_t = typedef typename complete_types<std::make_index_sequence<TIMEMORY_COMPONENTS_END> >::type

Definition at line 227 of file types.hpp.

component_bundle_t

template<typename Tag , typename... T>

using tim::component_bundle_t = typedef convert_t<mpl::available_t<type_list<T...> >, component_bundle<Tag> >

Definition at line 336 of file available.hpp.

component_hybrid_t

template<typename... T>

using tim::component_hybrid_t = typedef typename component_hybrid<T...>::type

Definition at line 99 of file component_hybrid.hpp.

component_list_t

template<typename... T>

using tim::component_list_t = typedef convert_t<mpl::available_t<concat<T...> >, component_list<> >

Definition at line 343 of file available.hpp.

component_tuple_t

template<typename... T>

using tim::component_tuple_t = typedef convert_t<mpl::available_t<concat<T...> >, component_tuple<> >

Definition at line 340 of file available.hpp.

concat

template<typename... Types>

using tim::concat = typedef typename impl::concat<Types...>::type

Definition at line 707 of file types.hpp.

conditional_t

template<bool B, typename Lhs , typename Rhs >

using tim::conditional_t = typedef typename std::conditional<B, Lhs, Rhs>::type

Definition at line 197 of file types.hpp.

contains_one_of

template<template< typename > class Predicate, typename Types >

using tim::contains_one_of = typedef typename impl::contains_one_of<Predicate, Types>

check if type is in expansion

Definition at line 744 of file types.hpp.

contains_one_of_t

template<template< typename > class Predicate, typename Types >

using tim::contains_one_of_t = typedef typename contains_one_of<Predicate, Types>::type

Definition at line 747 of file types.hpp.

convert_each_t

template<template< typename... > class T, typename... U>

using tim::convert_each_t = typedef typename impl::convert_each<T, U...>::type

Definition at line 819 of file types.hpp.

convert_t

template<typename T , typename U >

using tim::convert_t = typedef typename impl::convert<T, U>::type

Definition at line 816 of file types.hpp.

decay_t

template<typename T >

using tim::decay_t = typedef typename std::decay<T>::type

Alias template for decay.

Definition at line 194 of file types.hpp.

enable_if_t

template<bool B, typename T = int>

using tim::enable_if_t = typedef typename std::enable_if<B, T>::type

Alias template for enable_if.

Definition at line 190 of file types.hpp.

full_auto_list_t

using tim::full_auto_list_t = typedef auto_bundle<TIMEMORY_API, TIMEMORY_FULL_LIST_TYPES>

Definition at line 49 of file auto_timer.hpp.

full_auto_timer_t

using tim::full_auto_timer_t = typedef auto_bundle<TIMEMORY_API, TIMEMORY_FULL_TUPLE_TYPES, TIMEMORY_FULL_LIST_TYPES>

Definition at line 50 of file auto_timer.hpp.

full_auto_tuple_t

using tim::full_auto_tuple_t = typedef auto_bundle<TIMEMORY_API, TIMEMORY_FULL_TUPLE_TYPES>

Definition at line 48 of file auto_timer.hpp.

get_index_sequence_t

template<typename Tp >

using tim::get_index_sequence_t = typedef typename get_index_sequence<decay_t<Tp> >::type

Definition at line 811 of file types.hpp.

global_bundle_t

using tim::global_bundle_t = typedef component_tuple<component::user_global_bundle>

Definition at line 258 of file types.hpp.

hash_alias_map_t

using tim::hash_alias_map_t = typedef std::unordered_map<hash_value_t, hash_value_t>

Definition at line 83 of file types.hpp.

hash_alias_ptr_t

using tim::hash_alias_ptr_t = typedef std::shared_ptr<hash_alias_map_t>

Definition at line 86 of file types.hpp.

hash_map_ptr_pair_t

using tim::hash_map_ptr_pair_t = typedef std::pair<hash_map_ptr_t, hash_map_ptr_t>

Definition at line 85 of file types.hpp.

hash_map_ptr_t

using tim::hash_map_ptr_t = typedef std::shared_ptr<hash_map_t>

Definition at line 84 of file types.hpp.

hash_map_t

using tim::hash_map_t = typedef std::unordered_map<hash_value_t, std::string>

Definition at line 82 of file types.hpp.

hash_resolver_t

using tim::hash_resolver_t = typedef std::function<bool(hash_value_t, std::string&)>

Definition at line 87 of file types.hpp.

hash_resolver_vec_t

using tim::hash_resolver_vec_t = typedef std::vector<hash_resolver_t>

Definition at line 88 of file types.hpp.

hash_value_t

using tim::hash_value_t = typedef size_t

Definition at line 81 of file types.hpp.

identity_t

template<typename T >

using tim::identity_t = typedef typename identity<T>::type

Definition at line 217 of file types.hpp.

index_of

template<typename Tp , typename Type >

using tim::index_of = typedef impl::index_of<Tp, Type>

Definition at line 536 of file types.hpp.

index_sequence

template<size_t... Idx>

using tim::index_sequence = typedef std::integer_sequence<size_t, Idx...>

Alias template index_sequence.

Definition at line 178 of file types.hpp.

index_sequence_for

template<typename... Types>

using tim::index_sequence_for = typedef std::make_index_sequence<sizeof...(Types)>

Alias template index_sequence_for.

Definition at line 186 of file types.hpp.

is_empty_t

template<typename T >

using tim::is_empty_t = typedef typename concepts::is_empty<T>::type

Definition at line 521 of file concepts.hpp.

is_heap_wrapper_t

template<typename T >

using tim::is_heap_wrapper_t = typedef typename concepts::is_heap_wrapper<T>::type

Definition at line 533 of file concepts.hpp.

is_one_of

template<typename Tp , typename Types >

using tim::is_one_of = typedef typename impl::is_one_of<Tp, Types>

check if type is in expansion

Definition at line 738 of file types.hpp.

is_stack_wrapper_t

template<typename T >

using tim::is_stack_wrapper_t = typedef typename concepts::is_stack_wrapper<T>::type

Definition at line 530 of file concepts.hpp.

is_variadic_t

template<typename T >

using tim::is_variadic_t = typedef typename concepts::is_variadic<T>::type

Definition at line 524 of file concepts.hpp.

is_wrapper_t

template<typename T >

using tim::is_wrapper_t = typedef typename concepts::is_wrapper<T>::type

Definition at line 527 of file concepts.hpp.

lightweight_tuple_t

template<typename... T>

using tim::lightweight_tuple_t = typedef convert_t<mpl::available_t<concat<T...> >, lightweight_tuple<> >

Definition at line 355 of file available.hpp.

make_index_sequence

template<size_t Num>

using tim::make_index_sequence = typedef std::make_integer_sequence<size_t, Num>

Alias template make_index_sequence.

Definition at line 182 of file types.hpp.

make_integer_sequence

template<typename Tp , Tp Num>

using tim::make_integer_sequence = typedef std::make_integer_sequence<Tp, Num>

Alias template make_integer_sequence.

Definition at line 174 of file types.hpp.

minimal_auto_list_t

using tim::minimal_auto_list_t = typedef auto_bundle<TIMEMORY_API, TIMEMORY_MINIMAL_LIST_TYPES>

Definition at line 42 of file auto_timer.hpp.

minimal_auto_timer_t

using tim::minimal_auto_timer_t = typedef auto_bundle<TIMEMORY_API, TIMEMORY_MINIMAL_TUPLE_TYPES, TIMEMORY_MINIMAL_LIST_TYPES>

Definition at line 43 of file auto_timer.hpp.

minimal_auto_tuple_t

using tim::minimal_auto_tuple_t = typedef auto_bundle<TIMEMORY_API, TIMEMORY_MINIMAL_TUPLE_TYPES>

Definition at line 41 of file auto_timer.hpp.

mpip_bundle_t

using tim::mpip_bundle_t = typedef component_tuple<component::user_mpip_bundle>

Definition at line 260 of file types.hpp.

mutex_t

std::recursive_mutex tim::mutex_t

Recursive mutex is used for convenience since the performance penalty vs. a regular mutex is not really an issue since there are not many locks in general.

Definition at line 111 of file utility.hpp.

ncclp_bundle_t

using tim::ncclp_bundle_t = typedef component_tuple<component::user_ncclp_bundle>

Definition at line 261 of file types.hpp.

ompt_bundle_t

using tim::ompt_bundle_t = typedef component_tuple<component::user_ompt_bundle>

Definition at line 259 of file types.hpp.

parser_err_t

using tim::parser_err_t = typedef typename parser_t::result_type

Definition at line 287 of file definition.hpp.

parser_t

using tim::parser_t = typedef argparse::argument_parser

Definition at line 286 of file definition.hpp.

priority_constant

template<int N>

using tim::priority_constant = typedef std::integral_constant<int, N>

Definition at line 206 of file types.hpp.

push_back_t

template<typename Tuple , typename T >

using tim::push_back_t = typedef typename mpl::push_back<Tuple, T>::type

Definition at line 1048 of file types.hpp.

remove_const_t

template<typename T >

using tim::remove_const_t = typedef typename std::remove_const<T>::type

Definition at line 203 of file types.hpp.

remove_cv_t

template<typename T >

using tim::remove_cv_t = typedef typename std::remove_cv<T>::type

Definition at line 200 of file types.hpp.

remove_pointer_t

template<typename U >

using tim::remove_pointer_t = typedef typename std::remove_pointer<U>::type

Definition at line 530 of file types.hpp.

remove_pointers_t

template<typename Tp >

using tim::remove_pointers_t = typedef typename remove_pointers<Tp>::type

Definition at line 78 of file types.hpp.

stl_tuple_t

template<typename... T>

using tim::stl_tuple_t = typedef convert_t<mpl::available_t<concat<T...> >, std::tuple<> >

Definition at line 330 of file available.hpp.

storage_singleton

template<typename Tp >

using tim::storage_singleton = typedef singleton<Tp, std::unique_ptr<Tp, impl::storage_deleter<Tp> >, TIMEMORY_API>

Definition at line 177 of file types.hpp.

string

using tim::string = typedef tim::mpl::apply<std::string>

Definition at line 52 of file macros.hpp.

string_t

using tim::string_t = typedef std::string

Definition at line 105 of file utility.hpp.

string_view_t

using tim::string_view_t = typedef std::string

Definition at line 100 of file language.hpp.

tuple_concat_t

template<typename... Ts>

using tim::tuple_concat_t = typedef typename impl::tuple_concat<Ts...>::type

Definition at line 524 of file types.hpp.

type_concat_t

template<typename... Ts>

using tim::type_concat_t = typedef typename impl::type_concat<Ts...>::type

Definition at line 527 of file types.hpp.

type_list_element_t

template<size_t Idx, typename Tp >

using tim::type_list_element_t = typedef typename type_list_element<Idx, Tp>::type

Definition at line 273 of file types.hpp.

type_list_t

template<typename... T>

using tim::type_list_t = typedef convert_t<mpl::available_t<concat<T...> >, type_list<> >

Definition at line 333 of file available.hpp.

unwrap_t

template<typename T >

using tim::unwrap_t = typedef typename impl::unwrapper<T>::type

Definition at line 822 of file types.hpp.

Enumeration Type Documentation

sys_signal

enum tim::sys_signal : int

strong

Enumerator
Hangup
Interrupt
Quit
Illegal
Trap
Abort
Emulate
FPE
Kill
Bus
SegFault
System
Pipe
Alarm
Terminate
Urgent
Stop
CPUtime
FileSize
VirtualAlarm
ProfileAlarm
User1
User2

Definition at line 69 of file declaration.hpp.

{
    Hangup       = SIGHUP,   // 1
    Interrupt    = SIGINT,   // 2
    Quit         = SIGQUIT,  // 3
    Illegal      = SIGILL,
    Trap         = SIGTRAP,
    Abort        = SIGABRT,
    Emulate      = SIGEMT,
    FPE          = SIGFPE,
    Kill         = SIGKILL,
    Bus          = SIGBUS,
    SegFault     = SIGSEGV,
    System       = SIGSYS,
    Pipe         = SIGPIPE,
    Alarm        = SIGALRM,
    Terminate    = SIGTERM,
    Urgent       = SIGURG,
    Stop         = SIGTSTP,
    CPUtime      = SIGXCPU,
    FileSize     = SIGXFSZ,
    VirtualAlarm = SIGVTALRM,
    ProfileAlarm = SIGPROF,
    User1        = SIGUSR1,
    User2        = SIGUSR2
};

Function Documentation

add_argument()

parser tim::add_argument

(

)

Definition at line 332 of file definition.hpp.

               { "--timemory-args" })

add_hash_id() [1/4]

void tim::add_hash_id	(	const hash_map_ptr_t &	_hash_map,
		const hash_alias_ptr_t &	_hash_alias,
		hash_value_t	_hash_id,
		hash_value_t	_alias_hash_id
	)

add_hash_id() [2/4]

hash_value_t tim::add_hash_id ( const string_view_t &  _prefix )

inline

add an string to the default hash-map (if it doesn't already exist) and return the hash

Definition at line 207 of file types.hpp.

{
    return add_hash_id(get_hash_ids(), _prefix);
}

References _prefix, add_hash_id(), and get_hash_ids().

add_hash_id() [3/4]

hash_value_t tim::add_hash_id ( hash_map_ptr_t &  _hash_map, const string_view_t &  _prefix  )

inline

add an string to the given hash-map (if it doesn't already exist) and return the hash

Definition at line 187 of file types.hpp.

{
    hash_value_t _hash_id = get_hash_id(_prefix);
    if(_hash_map && _hash_map->find(_hash_id) == _hash_map->end())
    {
        (*_hash_map)[_hash_id] = std::string{ _prefix };
    }
    return _hash_id;
}

References _hash_id, _prefix, and get_hash_id().

Referenced by tim::source_location::source_location(), add_hash_id(), tim::base::storage::add_hash_id(), tim::cereal::load(), tim::bundle< Tag, BundleT, TupleT >::rekey(), tim::lightweight_tuple< Types >::rekey(), tim::bundle< Tag, BundleT, TupleT >::serialize(), tim::lightweight_tuple< Types >::serialize(), timemory_add_hash_id(), and timemory_push_trace().

add_hash_id() [4/4]

void tim::add_hash_id	(	hash_value_t	_hash_id,
		hash_value_t	_alias_hash_id
	)

add_hash_resolver()

template<typename FuncT >

size_t tim::add_hash_resolver

(

FuncT &&

_func

)

Definition at line 261 of file types.hpp.

{
    auto _resolvers = get_hash_resolvers();
    if(!_resolvers)
        return 0;
    _resolvers->emplace_back(std::forward<FuncT>(_func));
    return _resolvers->size();
}

References get_hash_resolvers().

configure() [1/8]

template<typename Bundle , template< typename, typename... > class Container, typename... ExtraArgs, typename... Args>

void tim::configure	(	const Container< const char *, ExtraArgs... > &	components,
		Args &&...	args
	)

Definition at line 108 of file configure.hpp.

{
    std::unordered_set<std::string> _components;
    for(auto itr : components)
        _components.insert(std::string(itr));
    configure<Bundle>(_components, std::forward<Args>(args)...);
}

References components.

configure() [2/8]

template<typename Bundle , template< typename, typename... > class Container, typename Intp , typename... ExtraArgs, typename... Args, typename std::enable_if< std::is_integral< Intp >::value||std::is_same< Intp, TIMEMORY_NATIVE_COMPONENT >::value, int >::type >

void tim::configure	(	const Container< Intp, ExtraArgs... > &	components,
		Args &&...	args
	)

Definition at line 97 of file configure.hpp.

{
    for(auto itr : components)
        runtime::configure<Bundle>(itr, std::forward<Args>(args)...);
}

References components.

configure() [3/8]

template<typename Bundle_t , template< typename, typename... > class Container, typename Intp , typename... ExtraArgs, typename... Args, typename std::enable_if< std::is_integral< Intp >::value||std::is_same< Intp, TIMEMORY_NATIVE_COMPONENT >::value, int >::type = 0>

void tim::configure	(	const Container< Intp, ExtraArgs... > &	components,
		Args &&	...
	)

description: use this function to insert tools into a bundle

usage: using namespace tim::component; using optional_t = tim::auto_tuple<user_global_bundle>;

tim::configure<user_global_bundle>({ CPU_CLOCK, CPU_UTIL });

auto obj = new optional_t(FUNCTION, LINE); typename... ExtraArgs required because of extra "hidden" template parameters in STL containers

configure() [4/8]

template<typename Bundle , typename... ExtraArgs, template< typename, typename... > class Container, typename... Args>

void tim::configure	(	const Container< std::string, ExtraArgs... > &	components,
		Args &&...	args
	)

this is for initializing with a container of string

Definition at line 71 of file configure.hpp.

{
    configure<Bundle>(enumerate_components(components), std::forward<Args>(args)...);
}

References components, and enumerate_components().

configure() [5/8]

template<typename Bundle , typename... Args>

void tim::configure	(	const int	ncomponents,
		const int *	components,
		Args &&...	args
	)

Definition at line 120 of file configure.hpp.

{
    for(int i = 0; i < ncomponents; ++i)
        runtime::configure<Bundle>(components[i], std::forward<Args>(args)...);
}

References components.

configure() [6/8]

template<typename Bundle , typename... Args>

void tim::configure	(	const std::initializer_list< std::string > &	components,
		Args &&...	args
	)

Definition at line 59 of file configure.hpp.

{
    configure<Bundle>(enumerate_components(components), std::forward<Args>(args)...);
}

References components, and enumerate_components().

configure() [7/8]

template<typename Bundle , typename... Args>

void tim::configure	(	const std::string &	components,
		Args &&...	args
	)

this is for initializing with a string

Definition at line 82 of file configure.hpp.

{
    configure<Bundle>(enumerate_components(tim::delimit(components)),
                      std::forward<Args>(args)...);
}

References components, delimit(), and enumerate_components().

configure() [8/8]

template<typename Bundle , typename EnumT , typename... Args>

void tim::configure	(	std::initializer_list< EnumT >	components,
		Args &&...	args
	)

Definition at line 50 of file configure.hpp.

{
    configure<Bundle>(std::vector<EnumT>(components), std::forward<Args>(args)...);
}

References components.

Referenced by tim::sampling::sampler< CompT< Types... >, N, SigIds... >::configure(), and tim::sampling::sampler< CompT< Types... >, N, SigIds... >::start().

consume_parameters()

template<typename... ArgsT>

void tim::consume_parameters

(

ArgsT &&

...

)

Definition at line 285 of file types.hpp.

{}

Referenced by tim::operation::finalize::mpi_get< Type, true >::mpi_get(), tim::component::cuda_profiler::configure(), tim::kokkosp::get_static(), get_storage_singleton(), tim::kokkosp::get_tl_static(), tim::component::caliper_common::init(), tim::operation::init_storage< Tp >::init(), tim::bundle< Tag, BundleT, TupleT >::init_storage(), tim::lightweight_tuple< Types >::init_storage(), tim::env_settings::insert(), tim::plotting::operation::join(), kokkosp_init_library(), tim::settings::load(), makedir(), tim::openmp::ompt_suppress_unused_variable_warnings(), tim::component::papi_common::overflow_handler(), tim::component::ompt_handle< Api >::preinit(), tim::component::ompt_data_tracker< Api >::preinit(), tim::settings::push(), tim::config::read_command_line(), read_command_line(), tim::settings::save(), set_env(), tim::component::ompt_data_tracker< Api >::store(), and timemory_push_trace_hash().

delimit()

template<typename ContainerT = std::vector<std::string>, typename PredicateT = std::function<std::string(const std::string&)>>

ContainerT tim::delimit ( const std::string &  line, const std::string &  delimiters = "\"',;: ", PredicateT &&  predicate = [](const std::string& s) -> std::string { return s; }  )

inline

Definition at line 666 of file utility.hpp.

                                                                   : ",
        PredicateT&& predicate = [](const std::string& s) -> std::string { return s; })
{
    ContainerT _result{};
    size_t     _beginp = 0;  // position that is the beginning of the new string
    size_t     _delimp = 0;  // position of the delimiter in the string
    while(_beginp < line.length() && _delimp < line.length())
    {
        // find the first character (starting at _delimp) that is not a delimiter
        _beginp = line.find_first_not_of(delimiters, _delimp);
        // if no a character after or at _end that is not a delimiter is not found
        // then we are done
        if(_beginp == std::string::npos)
            break;
        // starting at the position of the new string, find the next delimiter
        _delimp = line.find_first_of(delimiters, _beginp);
        std::string _tmp{};
        try
        {
            // starting at the position of the new string, get the characters
            // between this position and the next delimiter
            _tmp = line.substr(_beginp, _delimp - _beginp);
        } catch(std::exception& e)
        {
            // print the exception but don't fail, unless maybe it should?
            fprintf(stderr, "%s\n", e.what());
        }
        // don't add empty strings
        if(!_tmp.empty())
        {
            _result.insert(_result.end(), predicate(_tmp));
        }
    }
    return _result;
}

Referenced by configure(), tim::env::configure(), description(), enumerate_components(), tim::env::get_bundle_components(), tim::component::cupti_counters::get_event_initializer(), tim::component::cupti_activity::get_initializer(), tim::component::papi_common::get_initializer(), tim::component::network_stats::get_interfaces(), tim::component::cupti_counters::get_metric_initializer(), tim::ert::configuration< DeviceT, Tp, CounterT >::get_skip_ops(), if(), initialize(), tim::env::initialize(), insert(), tim::env::insert(), launch_process(), tim::settings::read(), tim::popen::read_fork(), tim::operation::finalize::print< Tp, true >::setup(), and tim::data::stream::write_banner().

demangle() [1/3]

template<typename Tp >

auto tim::demangle ( )

inline

Definition at line 271 of file utility.hpp.

{
    // static because a type demangle will always be the same
    static auto _val = demangle(typeid(Tp).name());
    return _val;
}

References demangle().

Referenced by try_demangle().

demangle() [2/3]

std::string tim::demangle ( const char *  _mangled_name, int *  _status = nullptr  )

inline

Definition at line 166 of file utility.hpp.

{
#if defined(TIMEMORY_ENABLE_DEMANGLE)
    // return the mangled since there is no buffer
    if(!_mangled_name)
        return std::string{};
 
    int         _ret = 0;
    std::string _demangled_name{ _mangled_name };
    if(!_status)
        _status = &_ret;
 
    // PARAMETERS to __cxa_demangle
    //  mangled_name:
    //      A NULL-terminated character string containing the name to be demangled.
    //  buffer:
    //      A region of memory, allocated with malloc, of *length bytes, into which the
    //      demangled name is stored. If output_buffer is not long enough, it is expanded
    //      using realloc. output_buffer may instead be NULL; in that case, the demangled
    //      name is placed in a region of memory allocated with malloc.
    //  _buflen:
    //      If length is non-NULL, the length of the buffer containing the demangled name
    //      is placed in *length.
    //  status:
    //      *status is set to one of the following values
    char* _demang = abi::__cxa_demangle(_mangled_name, nullptr, nullptr, _status);
    switch(*_status)
    {
        //  0 : The demangling operation succeeded.
        // -1 : A memory allocation failiure occurred.
        // -2 : mangled_name is not a valid name under the C++ ABI mangling rules.
        // -3 : One of the arguments is invalid.
        case 0:
        {
            if(_demang)
                _demangled_name = std::string{ _demang };
            break;
        }
        case -1:
        {
            char _msg[1024];
            ::memset(_msg, '\0', 1024 * sizeof(char));
            ::snprintf(_msg, 1024, "memory allocation failure occurred demangling %s",
                       _mangled_name);
            ::perror(_msg);
            break;
        }
        case -2: break;
        case -3:
        {
            char _msg[1024];
            ::memset(_msg, '\0', 1024 * sizeof(char));
            ::snprintf(_msg, 1024, "Invalid argument in: (\"%s\", nullptr, nullptr, %p)",
                       _mangled_name, (void*) _status);
            ::perror(_msg);
            break;
        }
        default: break;
    };
 
    // free allocated buffer
    ::free(_demang);
    return _demangled_name;
#else
    (void) _status;
    return _mangled_name;
#endif
}

Referenced by tim::operation::finalize::mpi_get< Type, true >::mpi_get(), tim::component::gotcha< Nt, BundleT, DiffT >::construct(), demangle(), tim::ert::configuration< DeviceT, Tp, CounterT >::get_executor(), tim::component::cpu_roofline< Types >::get_type_string(), tim::component::gpu_roofline< Types >::get_type_string(), tim::operation::finalize::mpi_get< Type, true >::operator()(), tim::operation::finalize::upc_get< Type, true >::operator()(), and tim::operation::finalize::get< Type, true >::operator()().

demangle() [3/3]

std::string tim::demangle ( const std::string &  _str, int *  _status = nullptr  )

inline

Definition at line 238 of file utility.hpp.

{
    return demangle(_str.c_str(), _status);
}

References demangle().

demangle_hash_identifier()

std::string tim::demangle_hash_identifier	(	std::string	,
		char	bdelim = '[',
		char	edelim = ']'
	)

Referenced by get_demangled_hash_identifier(), and tim::operation::decode< ApiT >::operator()().

description()

tim::description

(

"A generic option for any setting. Each argument MUST be passed in " "form: '

NAME = VALUE'. E.g. --timemory-args " "\"papi_events=PAPI_TOT_INS,PAPI_TOT_CYC\" text_output=off"

)

&

Definition at line 334 of file definition.hpp.

                          : 'NAME=VALUE'. E.g. --timemory-args "
                     "\"papi_events=PAPI_TOT_INS,PAPI_TOT_CYC\" text_output=off")
        .action([&](parser_t& p) {
            // get the options
            auto vopt = p.get<std::vector<std::string>>("timemory-args");
            for(auto& str : vopt)
            {
                // get the args
                auto vec = tim::delimit(str, " \t;:");
                for(const auto& itr : vec)
                {
                    DEBUG_PRINT_HERE("Processing: %s", itr.c_str());
                    auto _pos = itr.find('=');
                    auto _key = itr.substr(0, _pos);
                    auto _val = (_pos == std::string::npos) ? "" : itr.substr(_pos + 1);
                    if(!_settings->update(_key, _val, false))
                    {
                        std::cerr << "[timemory_argparse]> Warning! For "
                                     "--timemory-args, key \""
                                  << _key << "\" is not a recognized setting. \"" << _val
                                  << "\" was not applied." << std::endl;
                    }
                }
            }
        });

References _settings, DEBUG_PRINT_HERE, delimit(), and tim::argparse::argument_parser::get().

Referenced by tim::operation::finalize::print< Tp, true >::print(), tim::argparse::argument_parser::enable_help(), tim::operation::finalize::print< Tp, true >::setup(), and tim::operation::finalize::print< Tp, true >::update_data().

dirname()

TIMEMORY_UTILITY_INLINE std::string tim::dirname

(

std::string

_fname

)

Definition at line 39 of file utility.cpp.

{
#if defined(TIMEMORY_UNIX)
    char* _cfname = realpath(_fname.c_str(), nullptr);
    _fname        = std::string(_cfname);
    free(_cfname);
 
    while(_fname.find("\\\\") != std::string::npos)
        _fname.replace(_fname.find("\\\\"), 2, "/");
    while(_fname.find('\\') != std::string::npos)
        _fname.replace(_fname.find('\\'), 1, "/");
 
    return _fname.substr(0, _fname.find_last_of('/'));
#elif defined(TIMEMORY_WINDOWS)
    while(_fname.find('/') != std::string::npos)
        _fname.replace(_fname.find('/'), 1, "\\");
 
    _fname = _fname.substr(0, _fname.find_last_of('\\'));
    return (_fname.at(_fname.length() - 1) == '\\')
               ? _fname.substr(0, _fname.length() - 1)
               : _fname;
#endif
}

disable_signal_detection()

void tim::disable_signal_detection ( )

inline

Definition at line 379 of file signals.hpp.

{}

Referenced by update_signal_detection().

enable_help()

parser tim::enable_help

(

)

enable_signal_detection() [1/2]

bool tim::enable_signal_detection ( signal_settings::signal_set_t  = signal_settings::get_default() )

inline

Definition at line 368 of file signals.hpp.

{ return false; }

Referenced by if(), and update_signal_detection().

enable_signal_detection() [2/2]

template<typename Tp , enable_if_t<!std::is_enum< Tp >::value &&std::is_integral< Tp >::value > = 0>

bool tim::enable_signal_detection ( std::initializer_list< Tp > &&  )

inline

Definition at line 373 of file signals.hpp.

{
    return false;
}

enumerate_components() [1/4]

template<typename StringT , typename... ExtraArgs, template< typename, typename... > class Container>

std::vector< TIMEMORY_COMPONENT > tim::enumerate_components

(

const Container< StringT, ExtraArgs... > &

component_names

)

description: use this function to generate an array of enumerations from a list of string that can be subsequently used to initialize an auto_list or a component_list

usage: using namespace tim::component; using optional_t = tim::auto_list<wall_clock, cpu_clock, cpu_util, cuda_event>;

auto obj = new optional_t(FUNCTION, LINE); tim::initialize(*obj, tim::enumerate_components({ "cpu_clock", "cpu_util"}));

Definition at line 62 of file enumerate.hpp.

{
    std::set<TIMEMORY_COMPONENT> _set;
    for(const auto& itr : component_names)
        _set.insert(runtime::enumerate(std::string(itr)));
    std::vector<TIMEMORY_COMPONENT> _vec;
    _vec.reserve(_set.size());
    for(auto&& itr : _set)
        _vec.emplace_back(itr);
    return _vec;
}

References tim::runtime::enumerate().

Referenced by configure(), tim::env::configure(), enumerate_components(), tim::env::get_bundle_components(), tim::env::initialize(), initialize(), insert(), tim::env::insert(), timemory_add_components(), timemory_begin_record_types(), timemory_get_begin_record_types(), and timemory_remove_components().

enumerate_components() [2/4]

std::set< TIMEMORY_COMPONENT > tim::enumerate_components ( const std::initializer_list< std::string > &  component_names )

inline

Definition at line 77 of file enumerate.hpp.

{
    return enumerate_components(std::set<std::string>(component_names));
}

References enumerate_components().

enumerate_components() [3/4]

template<typename... ExtraArgs>

std::set< TIMEMORY_COMPONENT > tim::enumerate_components

(

const std::set< std::string, ExtraArgs... > &

component_names

)

Definition at line 101 of file enumerate.hpp.

{
    std::set<TIMEMORY_COMPONENT> vec;
    for(const auto& itr : component_names)
        vec.insert(runtime::enumerate(itr));
    return vec;
}

References tim::runtime::enumerate().

enumerate_components() [4/4]

template<typename StringT = std::string>

std::vector<TIMEMORY_COMPONENT> tim::enumerate_components	(	const std::string &	names,
		const StringT &	env_id = ""
	)

Definition at line 86 of file enumerate.hpp.

{
    if(std::string(env_id).length() > 0)
    {
        return enumerate_components(tim::delimit(get_env<std::string>(env_id, names)));
    }
    {
        return enumerate_components(tim::delimit(names));
    }
}

References delimit(), and enumerate_components().

err_action()

tim::err_action

(

parser->

parse_known_argsargc, argv, "--", settings::verbose()

)

finalize()

void tim::finalize ( )

inline

Definition at line 119 of file types.hpp.

{
    timemory_finalize();
}

References timemory_finalize().

for() [1/3]

tim::for

(

auto &itr :exe_name

)

Definition at line 123 of file definition.hpp.

                  : exe_name)
    {
        if(itr == '_')
            itr = '-';
    }

for() [2/3]

tim::for

(

const auto &ext :_exe_suffixes

)

Definition at line 116 of file definition.hpp.

                        : _exe_suffixes)
    {
        if(exe_name.find(ext) != std::string::npos)
            exe_name.erase(exe_name.find(ext), ext.length() + 1);
    }

References exe_name.

for() [3/3]

tim::for

(

const auto &itr :_settings->

ordering()

)

Definition at line 323 of file definition.hpp.

                        : _settings->ordering())
    {
        auto sitr = _settings->find(itr);
        if(sitr != _settings->end() && sitr->second)
        {
            sitr->second->add_argument(*parser);
        }
    }

References _settings, tim::argparse::argument_parser::add_argument(), and parser.

from_string() [1/2]

template<typename T >

T tim::from_string ( const char *  cstr )

inline

Definition at line 321 of file utility.hpp.

{
    std::stringstream ss;
    ss << cstr;
    T val{};
    ss >> val;
    return val;
}

from_string() [2/2]

template<typename T >

T tim::from_string ( const std::string &  str )

inline

Definition at line 308 of file utility.hpp.

{
    std::stringstream ss;
    ss << str;
    T val{};
    ss >> val;
    return val;
}

generic_serialization() [1/3]

template<typename Tp , typename FuncT >

void tim::generic_serialization	(	const std::string &	fname,
		const Tp &	obj,
		const std::string &	_main_name = "timemory",
		const std::string &	_data_name = "data",
		FuncT &&	_func = [](typename policy::output_archive_t<decay_t<Tp>>::type&) {}
	)

Definition at line 65 of file serialization.hpp.

                                                                                {})
{
    std::ofstream ofs(fname.c_str());
    if(ofs)
    {
        // ensure json write final block during destruction before the file is closed
        using policy_type = policy::output_archive_t<decay_t<Tp>>;
        auto oa           = policy_type::get(ofs);
        oa->setNextName(_main_name.c_str());
        oa->startNode();
        _func(*oa);
        (*oa)(cereal::make_nvp(_data_name.c_str(), obj));
        oa->finishNode();
    }
    if(ofs)
        ofs << std::endl;
    ofs.close();
}

generic_serialization() [2/3]

template<typename ArchiveT , typename ApiT = TIMEMORY_API, typename Tp , typename FuncT >

void tim::generic_serialization	(	const std::string &	fname,
		const Tp &	obj,
		const std::string &	_main_name = "timemory",
		const std::string &	_data_name = "data",
		FuncT &&	_func = [](typename policy::output_archive_t<decay_t<Tp>>::type&) {}
	)

Definition at line 103 of file serialization.hpp.

                                                                                {})
{
    static_assert(concepts::is_output_archive<ArchiveT>::value,
                  "Error! Not an output archive type");
    std::ofstream ofs(fname.c_str());
    if(ofs)
    {
        // ensure json write final block during destruction before the file is closed
        using policy_type = policy::output_archive<ArchiveT, ApiT>;
        auto oa           = policy_type::get(ofs);
        oa->setNextName(_main_name.c_str());
        oa->startNode();
        _func(*oa);
        (*oa)(cereal::make_nvp(_data_name.c_str(), obj));
        oa->finishNode();
    }
    if(ofs)
        ofs << std::endl;
    ofs.close();
}

generic_serialization() [3/3]

template<typename ArchiveT , typename ApiT = TIMEMORY_API, typename Tp , typename FuncT >

void tim::generic_serialization	(	std::ostream &	ofs,
		const Tp &	obj,
		const std::string &	_main_name = "timemory",
		const std::string &	_data_name = "data",
		FuncT &&	_func = [](typename policy::output_archive_t<decay_t<Tp>>::type&) {}
	)

Definition at line 143 of file serialization.hpp.

                                                                                {})
{
    // ensure json write final block during destruction before the file is closed
    using policy_type = policy::output_archive<ArchiveT, ApiT>;
    auto oa           = policy_type::get(ofs);
 
    if(!_main_name.empty())
    {
        oa->setNextName(_main_name.c_str());
        oa->startNode();
    }
 
    // execute the function with extra data
    _func(*oa);
 
    (*oa)(cereal::make_nvp(_data_name, obj));
 
    if(!_main_name.empty())
    {
        oa->finishNode();
    }
}

get() [1/7]

template<typename Tag , typename... Types>

auto tim::get

(

const auto_bundle< Tag, Types... > &

_obj

)

Definition at line 152 of file auto_bundle.hpp.

{
    return get(_obj.get_component());
}

Referenced by tim::operation::finalize::flamegraph< Type >::flamegraph(), tim::operation::finalize::mpi_get< Type, true >::mpi_get(), tim::policy::record_statistics< CompT, Tp >::apply(), tim::component::gotcha< Nt, BundleT, DiffT >::construct(), tim::trait::apply< TraitT, CommonT >::get(), get(), tim::component::factory::get_typeids(), tim::operation::init_storage< Tp >::init(), tim::singleton< Type, PointerT, TagT >::instance(), tim::operation::common_utils::is_empty(), tim::operation::finalize::mpi_get< Type, true >::operator()(), tim::operation::finalize::upc_get< Type, true >::operator()(), tim::trait::apply< TraitT, CommonT >::operator()(), tim::operation::finalize::print< Tp, true >::print_json(), tim::operation::finalize::print< Tp, true >::print_tree(), tim::settings::read(), tim::operation::finalize::print< Tp, true >::read_json(), tim::singleton< Type, PointerT, TagT >::reset(), tim::component::gotcha< Nt, BundleT, DiffT >::revert(), tim::ert::serialize(), tim::bundle< Tag, BundleT, TupleT >::start(), tim::component::mpip_handle< Toolset, Tag >::stop(), tim::bundle< Tag, BundleT, TupleT >::stop(), and tim::operation::finalize::print< Tp, true >::write_stream().

get() [2/7]

template<typename... Types>

auto tim::get

(

const auto_list< Types... > &

_obj

)

Definition at line 143 of file auto_list.hpp.

{
    return get(_obj.get_component());
}

References get().

get() [3/7]

template<typename... Types>

auto tim::get

(

const auto_tuple< Types... > &

_obj

)

Definition at line 117 of file auto_tuple.hpp.

{
    return get(_obj.get_component());
}

References get().

get() [4/7]

template<typename... Types>

auto tim::get

(

const component_bundle< Types... > &

_obj

)

-> decltype(std::declval<component_bundle<Types...>>().get())

Definition at line 111 of file component_bundle.hpp.

{
    return _obj.get();
}

get() [5/7]

template<typename... Types>

auto tim::get

(

const component_list< Types... > &

_obj

)

-> decltype(std::declval<component_list<Types...>>().get())

Definition at line 130 of file component_list.hpp.

{
    return _obj.get();
}

get() [6/7]

template<typename... Types>

auto tim::get

(

const component_tuple< Types... > &

_obj

)

-> decltype(std::declval<component_tuple<Types...>>().get())

Definition at line 112 of file component_tuple.hpp.

{
    return _obj.get();
}

get() [7/7]

template<typename... Types>

auto tim::get

(

const lightweight_tuple< Types... > &

_obj

)

-> decltype(std::declval<lightweight_tuple<Types...>>().get())

Definition at line 622 of file lightweight_tuple.hpp.

{
    return _obj.get();
}

get_bool()

TIMEMORY_UTILITY_INLINE bool tim::get_bool ( const std::string &  strbool, bool  _default  )

noexcept

Definition at line 117 of file utility.cpp.

{
    // empty string returns default
    if(strbool.empty())
        return _default;
 
    // check if numeric
    if(strbool.find_first_not_of("0123456789") == std::string::npos)
    {
        if(strbool.length() > 1 || strbool[0] != '0')
            return true;
        return false;
    }
 
    // convert to lowercase
    auto _val = std::string{ strbool };
    for(auto& itr : _val)
        itr = tolower(itr);
 
    // check for matches to acceptable forms of false
    for(const auto& itr : { "off", "false", "no", "n", "f" })
    {
        if(_val == itr)
            return false;
    }
 
    // check for matches to acceptable forms of true
    for(const auto& itr : { "on", "true", "yes", "y", "t" })
    {
        if(_val == itr)
            return true;
    }
 
    return _default;
}

Referenced by tim::argparse::argument_parser::argument::get().

get_combined_hash_id() [1/2]

hash_value_t tim::get_combined_hash_id	(	hash_value_t	_lhs,
		hash_value_t	_rhs
	)

Definition at line 158 of file types.hpp.

{
    return (_lhs ^= _rhs + 0x9e3779b9 + (_lhs << 6) + (_lhs >> 2));
}

Referenced by get_combined_hash_id().

get_combined_hash_id() [2/2]

template<typename Tp , std::enable_if_t<!std::is_integral< std::decay_t< Tp >>::value, int > = 0>

hash_value_t tim::get_combined_hash_id	(	hash_value_t	_lhs,
		Tp &&	_rhs
	)

Definition at line 167 of file types.hpp.

{
    return get_combined_hash_id(_lhs, get_hash_id(std::forward<Tp>(_rhs)));
}

References get_combined_hash_id(), and get_hash_id().

Referenced by tim::scope::config::compute_hash().

get_demangled_hash_identifier()

template<typename... Args>

auto tim::get_demangled_hash_identifier

(

Args &&...

_args

)

Definition at line 283 of file types.hpp.

{
    return demangle_hash_identifier(get_hash_identifier(std::forward<Args>(_args)...));
}

References demangle_hash_identifier(), and get_hash_identifier().

get_env() [1/3]

template<>

bool tim::get_env	(	const std::string &	env_id,
		bool	_default
	)

get_env() [2/3]

template<>

std::string tim::get_env	(	const std::string &	env_id,
		std::string	_default
	)

get_env() [3/3]

template<typename Tp >

Tp tim::get_env	(	const std::string &	env_id,
		Tp	_default
	)

Definition at line 171 of file declaration.hpp.

{
    if(env_id.empty())
        return _default;
 
    auto* _env_settings = env_settings::instance();
    char* env_var       = std::getenv(env_id.c_str());
    if(env_var)
    {
        std::string       str_var = std::string(env_var);
        std::stringstream iss{ str_var };
        auto              var = Tp{};
        iss >> var;
        if(_env_settings)
            _env_settings->insert<Tp>(env_id, var);
        return var;
    }
    // record default value
    if(_env_settings)
        _env_settings->insert<Tp>(env_id, _default);
 
    // return default if not specified in environment
    return _default;
}

References tim::env_settings::instance().

Referenced by tim::signal_settings::check_environment(), tim::env::configure(), tim::vsettings::get_debug(), tim::env::initialize(), tim::env::insert(), and timemory_enable_pthread_gotcha_wrapper().

get_hash() [1/3]

size_t tim::get_hash

(

const char *

cstr

)

Definition at line 809 of file utility.hpp.

{
    return std::hash<string_view_t>{}(cstr);
}

get_hash() [2/3]

size_t tim::get_hash

(

const string_view_t &

str

)

Definition at line 801 of file utility.hpp.

{
    return std::hash<string_view_t>{}(str);
}

get_hash() [3/3]

template<typename T >

size_t tim::get_hash

(

T &&

obj

)

Definition at line 793 of file utility.hpp.

{
    return std::hash<decay_t<T>>()(std::forward<T>(obj));
}

Referenced by tim::hasher< T >::operator()().

get_hash_aliases()

hash_alias_ptr_t& tim::get_hash_aliases

(

)

get_hash_id() [1/2]

hash_value_t tim::get_hash_id	(	const hash_alias_ptr_t &	_hash_alias,
		hash_value_t	_hash_id
	)

get_hash_id() [2/2]

template<typename Tp , std::enable_if_t< concepts::is_string_type< std::decay_t< Tp >>::value, int > = 0>

hash_value_t tim::get_hash_id

(

Tp &&

_prefix

)

Definition at line 140 of file types.hpp.

{
    return std::hash<string_view_t>{}(std::forward<Tp>(_prefix));
}

References _prefix.

Referenced by add_hash_id(), get_combined_hash_id(), tim::operation::push_node< Tp >::operator()(), timemory_is_throttled(), timemory_pop_trace(), and timemory_reset_throttle().

get_hash_identifier() [1/2]

std::string tim::get_hash_identifier	(	const hash_map_ptr_t &	_hash_map,
		const hash_alias_ptr_t &	_hash_alias,
		hash_value_t	_hash_id
	)

Referenced by get_demangled_hash_identifier(), tim::operation::decode< ApiT >::operator()(), and tim::cereal::save().

get_hash_identifier() [2/2]

std::string tim::get_hash_identifier

(

hash_value_t

_hash_id

)

get_hash_identifier_fast()

string_view_t tim::get_hash_identifier_fast ( hash_value_t  _hash )

inline

this does not check other threads or aliases. Only call this function when you know that the hash exists on the thread and is not an alias

Definition at line 237 of file types.hpp.

{
    auto& _hash_ids = get_hash_ids();
    auto  itr       = _hash_ids->find(_hash);
    if(itr != _hash_ids->end())
        return itr->second;
    return "";
}

References get_hash_ids().

Referenced by tim::bundle< Tag, BundleT, TupleT >::set_prefix().

get_hash_ids()

hash_map_ptr_t& tim::get_hash_ids

(

)

Referenced by add_hash_id(), get_hash_identifier_fast(), tim::bundle< Tag, BundleT, TupleT >::serialize(), tim::lightweight_tuple< Types >::serialize(), tim::bundle< Tag, BundleT, TupleT >::set_prefix(), and tim::lightweight_tuple< Types >::set_prefix().

get_hash_resolvers()

std::shared_ptr<hash_resolver_vec_t>& tim::get_hash_resolvers

(

)

Referenced by add_hash_resolver(), and tim::operation::decode< ApiT >::operator()().

get_labeled() [1/7]

template<typename Tag , typename... Types>

auto tim::get_labeled

(

const auto_bundle< Tag, Types... > &

_obj

)

Definition at line 161 of file auto_bundle.hpp.

{
    return get_labeled(_obj.get_component());
}

Referenced by get_labeled().

get_labeled() [2/7]

template<typename... Types>

auto tim::get_labeled

(

const auto_list< Types... > &

_obj

)

Definition at line 150 of file auto_list.hpp.

{
    return get_labeled(_obj.get_component());
}

References get_labeled().

get_labeled() [3/7]

template<typename... Types>

auto tim::get_labeled

(

const auto_tuple< Types... > &

_obj

)

Definition at line 124 of file auto_tuple.hpp.

{
    return get_labeled(_obj.get_component());
}

References get_labeled().

get_labeled() [4/7]

template<typename... Types>

auto tim::get_labeled

(

const component_bundle< Types... > &

_obj

)

-> decltype(std::declval<component_bundle<Types...>>().get_labeled())

Definition at line 121 of file component_bundle.hpp.

{
    return _obj.get_labeled();
}

get_labeled() [5/7]

template<typename... Types>

auto tim::get_labeled

(

const component_list< Types... > &

_obj

)

-> decltype(std::declval<component_list<Types...>>().get_labeled())

Definition at line 140 of file component_list.hpp.

{
    return _obj.get_labeled();
}

get_labeled() [6/7]

template<typename... Types>

auto tim::get_labeled

(

const component_tuple< Types... > &

_obj

)

-> decltype(std::declval<component_tuple<Types...>>().get_labeled())

Definition at line 122 of file component_tuple.hpp.

{
    return _obj.get_labeled();
}

get_labeled() [7/7]

template<typename... Types>

auto tim::get_labeled

(

const lightweight_tuple< Types... > &

_obj

)

-> decltype(std::declval<lightweight_tuple<Types...>>().get_labeled())

Definition at line 632 of file lightweight_tuple.hpp.

{
    return _obj.get_labeled();
}

get_local_datetime()

std::string tim::get_local_datetime	(	const char *	dt_format,
		std::time_t *	dt_curr
	)

Definition at line 132 of file settings.cpp.

{
    char mbstr[100];
    if(!dt_curr)
        dt_curr = settings::get_launch_time(TIMEMORY_API{});
 
    if(std::strftime(mbstr, sizeof(mbstr), dt_format, std::localtime(dt_curr)))
        return std::string{ mbstr };
    return std::string{};
}

References tim::settings::get_launch_time(), and TIMEMORY_API.

Referenced by tim::settings::get_global_output_prefix().

get_shared_ptr_lone_instance()

template<typename Tp , typename Tag , typename PtrT >

PtrT tim::get_shared_ptr_lone_instance

(

)

Definition at line 77 of file declaration.hpp.

{
    static auto _instance = std::make_shared<Tp>();
    return _instance;
}

get_shared_ptr_pair()

template<typename Tp , typename Tag , typename PtrT , typename PairT >

PairT & tim::get_shared_ptr_pair

(

)

Definition at line 42 of file declaration.hpp.

{
    static auto                 _master = std::make_shared<Tp>();
    static std::atomic<int64_t> _count{ 0 };
    static thread_local auto    _inst =
        PairT{ _master, PtrT{ (_count++ == 0) ? nullptr : new Tp{} } };
    return _inst;
}

get_shared_ptr_pair_instance()

template<typename Tp , typename Tag , typename PtrT , typename PairT >

PtrT tim::get_shared_ptr_pair_instance

(

)

Definition at line 55 of file declaration.hpp.

{
    static thread_local auto& _pinst = get_shared_ptr_pair<Tp, Tag>();
    static thread_local auto& _inst  = _pinst.second ? _pinst.second : _pinst.first;
    return _inst;
}

get_shared_ptr_pair_main_instance()

template<typename Tp , typename Tag , typename PtrT , typename PairT >

PtrT tim::get_shared_ptr_pair_main_instance

(

)

Definition at line 66 of file declaration.hpp.

{
    static auto& _pinst = get_shared_ptr_pair<Tp, Tag>();
    static auto  _inst  = _pinst.first;
    return _inst;
}

get_storage_singleton() [1/2]

template<typename Tp >

TIMEMORY_NOCLONE storage_singleton<Tp>* tim::get_storage_singleton

(

)

Definition at line 74 of file declaration.hpp.

{
    using singleton_type  = tim::storage_singleton<Tp>;
    using component_type  = typename Tp::component_type;
    static auto _instance = std::unique_ptr<singleton_type>(
        (trait::runtime_enabled<component_type>::get()) ? new singleton_type{} : nullptr);
    static auto _dtor = scope::destructor{ []() { _instance.reset(); } };
    return _instance.get();
    consume_parameters(_dtor);
}

References consume_parameters().

get_storage_singleton() [2/2]

template<typename Tp >

storage_singleton<Tp>* tim::get_storage_singleton

(

)

Definition at line 74 of file declaration.hpp.

{
    using singleton_type  = tim::storage_singleton<Tp>;
    using component_type  = typename Tp::component_type;
    static auto _instance = std::unique_ptr<singleton_type>(
        (trait::runtime_enabled<component_type>::get()) ? new singleton_type{} : nullptr);
    static auto _dtor = scope::destructor{ []() { _instance.reset(); } };
    return _instance.get();
    consume_parameters(_dtor);
}

References consume_parameters().

if() [1/8]

tim::if

(

_alias_itr !

= _hash_alias->end()

)

-> second

if() [2/8]

tim::if

(

_cleanup_parser

)

if() [3/8]

tim::if

(

_cleanup_settings &&!

_shared_settings

)

if() [4/8]

tim::if

(

_cleanup_settings

)

if() [5/8]

tim::if

(

_manager

)

Definition at line 162 of file definition.hpp.

    {
        _manager->update_metadata_prefix();
    }

if() [6/8]

tim::if

(

_settings

)

Definition at line 63 of file definition.hpp.

    {
        if(_settings->get_debug() || _settings->get_verbose() > 3)
            PRINT_HERE("%s", "");
 
        if(_settings->get_enable_signal_handler())
        {
            auto default_signals = signal_settings::get_default();
            for(const auto& itr : default_signals)
                signal_settings::enable(itr);
            // should return default and any modifications from environment
            auto enabled_signals = signal_settings::get_enabled();
            enable_signal_detection(enabled_signals);
        }
 
        auto _ncfg = _settings->get_suppress_config();
        if(!_ncfg)
        {
            // default configuration files
            std::set<std::string> _dcfg = {
                get_env<string_t>("HOME") + std::string("/.timemory.cfg"),
                get_env<string_t>("HOME") + std::string("/.timemory.json"),
                get_env<string_t>("HOME") + std::string("/.config/timemory.cfg"),
                get_env<string_t>("HOME") + std::string("/.config/timemory.json")
            };
 
            auto _cfg   = _settings->get_config_file();
            auto _files = tim::delimit(_cfg, ",;");
            for(const auto& citr : _files)
            {
                std::ifstream ifs(citr);
                if(ifs)
                {
                    _settings->read(ifs, citr);
                }
                else if(_dcfg.find(citr) == _dcfg.end())
                {
                    TIMEMORY_EXCEPTION(std::string("Error reading configuration file: ") +
                                       citr);
                }
            }
        }
    }

References _settings, delimit(), tim::signal_settings::enable(), enable_signal_detection(), tim::signal_settings::get_default(), tim::signal_settings::get_enabled(), PRINT_HERE, and TIMEMORY_EXCEPTION.

if() [7/8]

tim::if

(

exe_name.

empty()

)

References _settings, argv, exe_name, tim::manager::master_instance(), tim::settings::parse(), tim::signal_settings::set_exit_action(), tim::settings::store_command_line(), and tim::signal_settings::str().

if() [8/8]

tim::if

(

parser->

exists"help"

)

init()

template<typename... Args>

void tim::init

(

Args &&...

args

)

Definition at line 111 of file types.hpp.

{
    timemory_init(std::forward<Args>(args)...);
}

References timemory_init().

Referenced by tim::bundle< Tag, BundleT, TupleT >::bundle(), tim::lightweight_tuple< Types >::lightweight_tuple(), and tim::component::papi_common::initialize_papi().

initialize() [1/8]

template<template< typename... > class CompList, typename... CompTypes, template< typename, typename... > class Container, typename... ExtraArgs>

void tim::initialize	(	CompList< CompTypes... > &	obj,
		const Container< const char *, ExtraArgs... > &	components
	)

Definition at line 110 of file initialize.hpp.

{
    std::vector<std::string> _components;
    _components.reserve(components.size());
    for(auto itr : components)
        _components.emplace_back(std::string(itr));
    initialize(obj, _components);
}

References components, and initialize().

initialize() [2/8]

template<template< typename... > class CompList, typename... CompTypes, template< typename, typename... > class Container, typename Intp , typename... ExtraArgs, typename std::enable_if< std::is_integral< Intp >::value||std::is_same< Intp, TIMEMORY_NATIVE_COMPONENT >::value, int >::type >

void tim::initialize	(	CompList< CompTypes... > &	obj,
		const Container< Intp, ExtraArgs... > &	components
	)

description: use this function to initialize a auto_list or component_list from a list of enumerations

usage: using namespace tim::component; using optional_t = tim::auto_list<wall_clock, cpu_clock, cpu_util, cuda_event>; auto obj = new optional_t(FUNCTION, LINE); tim::initialize(*obj, { CPU_CLOCK, CPU_UTIL }); typename... ExtraArgs required because of extra "hidden" template parameters in STL containers

Definition at line 99 of file initialize.hpp.

{
    for(auto itr : components)
        runtime::initialize(obj, itr);
}

References components, and tim::runtime::initialize().

initialize() [3/8]

template<template< typename... > class CompList, typename... CompTypes, typename... ExtraArgs, template< typename, typename... > class Container>

void tim::initialize ( CompList< CompTypes... > &  obj, const Container< std::string, ExtraArgs... > &  components  )

inline

Definition at line 72 of file initialize.hpp.

{
    initialize(obj, enumerate_components(components));
}

References components, enumerate_components(), and initialize().

initialize() [4/8]

template<template< typename... > class CompList, typename... CompTypes>

void tim::initialize	(	CompList< CompTypes... > &	obj,
		const int	ncomponents,
		const int *	components
	)

Definition at line 124 of file initialize.hpp.

{
    for(int i = 0; i < ncomponents; ++i)
        runtime::initialize(obj, components[i]);
}

References components, and tim::runtime::initialize().

initialize() [5/8]

template<template< typename... > class CompList, typename... CompTypes>

void tim::initialize ( CompList< CompTypes... > &  obj, const std::string &  components  )

inline

this is for initializing with a string

Definition at line 84 of file initialize.hpp.

{
    initialize(obj, enumerate_components(tim::delimit(components)));
}

References components, delimit(), enumerate_components(), and initialize().

initialize() [6/8]

template<template< typename... > class CompList, typename... CompTypes, typename EnumT = int>

void tim::initialize ( CompList< CompTypes... > &  obj, std::initializer_list< EnumT >  components  )

inline

Definition at line 53 of file initialize.hpp.

{
    initialize(obj, std::vector<EnumT>(components));
}

References components.

Referenced by tim::singleton< Type, PointerT, TagT >::singleton(), tim::auto_base_bundle< Tag, CompT, BundleT >::initialize(), tim::env::initialize(), and initialize().

initialize() [7/8]

template<template< typename... > class CompList, typename... CompTypes>

void tim::initialize ( CompList< CompTypes... > &  obj, std::initializer_list< std::string >  components  )

inline

Definition at line 62 of file initialize.hpp.

{
    initialize(obj, enumerate_components(components));
}

References components, enumerate_components(), and initialize().

initialize() [8/8]

template<typename T , typename... Args>

void tim::initialize	(	T *	obj,
		Args &&...	args
	)

Definition at line 96 of file types.hpp.

{
    if(obj)
        initialize(*obj, std::forward<Args>(args)...);
}

References initialize().

insert() [1/8]

template<size_t Idx, typename Type , template< size_t, typename > class Bundle, template< typename, typename... > class Container, typename... ExtraArgs>

void tim::insert	(	Bundle< Idx, Type > &	obj,
		const Container< const char *, ExtraArgs... > &	components
	)

Definition at line 105 of file insert.hpp.

{
    std::vector<std::string> _components;
    _components.reserve(components.size());
    for(auto itr : components)
        _components.emplace_back(std::string(itr));
    insert(obj, _components);
}

References components, and insert().

insert() [2/8]

template<size_t Idx, typename Type , template< size_t, typename > class Bundle, template< typename, typename... > class Container, typename Intp , typename... ExtraArgs, typename std::enable_if< std::is_integral< Intp >::value||std::is_same< Intp, TIMEMORY_NATIVE_COMPONENT >::value, int >::type >

void tim::insert	(	Bundle< Idx, Type > &	obj,
		const Container< Intp, ExtraArgs... > &	components
	)

description: use this function to insert tools into a bundle

usage: using namespace tim::component; using optional_t = tim::auto_tuple<user_global_bundle>; auto obj = new optional_t(FUNCTION, LINE); tim::insert(obj.get<user_global_bundle>(), { CPU_CLOCK, CPU_UTIL }); typename... ExtraArgs required because of extra "hidden" template parameters in STL containers

Definition at line 94 of file insert.hpp.

{
    for(auto itr : components)
        runtime::insert(obj, itr);
}

References components, and tim::runtime::insert().

insert() [3/8]

template<size_t Idx, typename Type , template< size_t, typename > class Bundle, typename... ExtraArgs, template< typename, typename... > class Container>

void tim::insert ( Bundle< Idx, Type > &  obj, const Container< std::string, ExtraArgs... > &  components  )

inline

this is for initializing with a container of string

Definition at line 68 of file insert.hpp.

{
    insert(obj, enumerate_components(components));
}

References components, enumerate_components(), and insert().

insert() [4/8]

template<size_t Idx, typename Type , template< size_t, typename > class Bundle>

void tim::insert	(	Bundle< Idx, Type > &	obj,
		const int	ncomponents,
		const int *	components
	)

Definition at line 118 of file insert.hpp.

{
    for(int i = 0; i < ncomponents; ++i)
        runtime::insert(obj, components[i]);
}

References components, and tim::runtime::insert().

insert() [5/8]

template<size_t Idx, typename Type , template< size_t, typename > class Bundle>

void tim::insert ( Bundle< Idx, Type > &  obj, const std::initializer_list< std::string > &  components  )

inline

Definition at line 56 of file insert.hpp.

{
    insert(obj, enumerate_components(components));
}

References components, enumerate_components(), and insert().

insert() [6/8]

template<size_t Idx, typename Type , template< size_t, typename > class Bundle>

void tim::insert ( Bundle< Idx, Type > &  obj, const std::string &  components  )

inline

this is for initializing with a string

Definition at line 79 of file insert.hpp.

{
    insert(obj, enumerate_components(tim::delimit(components)));
}

References components, delimit(), enumerate_components(), and insert().

insert() [7/8]

template<size_t Idx, typename Type , template< size_t, typename > class Bundle, typename EnumT = int>

void tim::insert ( Bundle< Idx, Type > &  obj, std::initializer_list< EnumT >  components  )

inline

Definition at line 47 of file insert.hpp.

{
    insert(obj, std::vector<EnumT>(components));
}

References components.

Referenced by tim::kokkosp::create_profiler(), tim::env::insert(), tim::utility::path::insert(), insert(), tim::singleton< Type, PointerT, TagT >::instance(), and tim::component::cupti_counters::label_array().

insert() [8/8]

template<typename T , typename... Args>

void tim::insert	(	T *	obj,
		Args &&...	args
	)

Definition at line 129 of file types.hpp.

{
    if(obj)
        insert(*obj, std::forward<Args>(args)...);
}

References insert().

insert_and_remove()

void tim::insert_and_remove ( const sys_signal &  _type, signal_settings::signal_set_t *  _ins, signal_settings::signal_set_t *  _rem  )

inline

Definition at line 58 of file signals.hpp.

{
    if(!_ins || !_rem)
        return;
    _ins->insert(_type);
    auto itr = _rem->find(_type);
    if(itr != _rem->end())
        _rem->erase(itr);
}

Referenced by tim::signal_settings::disable(), and tim::signal_settings::enable().

invoke_preinit() [1/2]

template<typename T >

auto tim::invoke_preinit

(

int

)

-> decltype(std::declval<T>().preinit(), void())

Definition at line 51 of file storage_initializer.hpp.

{
    T::preinit();
}

invoke_preinit() [2/2]

template<typename T >

auto tim::invoke_preinit

(

long

)

Definition at line 60 of file storage_initializer.hpp.

{}

invoke_preinit< kokkosp::memory_tracker >()

template<>

auto tim::invoke_preinit< kokkosp::memory_tracker > ( long  )

inline

Definition at line 40 of file kokkosp.cpp.

{
    kokkosp::memory_tracker::label()       = "kokkos_memory";
    kokkosp::memory_tracker::description() = "Kokkos Memory tracker";
}

References tim::component::data_tracker< InpT, Tag >::description(), and tim::component::data_tracker< InpT, Tag >::label().

isfinite()

template<typename Tp >

bool tim::isfinite ( const Tp &  arg )

inline

Definition at line 127 of file utility.hpp.

{
#if defined(TIMEMORY_WINDOWS)
    // Windows seems to be missing std::isfinite
    return (arg == arg && arg != std::numeric_limits<Tp>::infinity() &&
            arg != -std::numeric_limits<Tp>::infinity())
               ? true
               : false;
#else
    return std::isfinite(arg);
#endif
}

Referenced by tim::component::read_char::get(), tim::component::written_char::get(), tim::component::read_bytes::get(), tim::component::written_bytes::get(), and tim::math::is_finite().

launch_process()

bool tim::launch_process ( const char *  cmd, const std::string &  extra, std::ostream *  os  )

inline

Definition at line 172 of file popen.hpp.

{
#if !defined(TIMEMORY_WINDOWS)
    auto                       delim = tim::delimit(cmd, " \t");
    tim::popen::TIMEMORY_PIPE* fp    = nullptr;
    if(delim.size() < 2)
    {
        fp = tim::popen::popen(cmd, nullptr, nullptr);
    }
    else
    {
        static std::string   _c = "-c";
        std::array<char*, 4> _args;
        _args.fill(nullptr);
        char*       _cshell = getenv("SHELL");
        char*       _ushell = getusershell();
        std::string _shell = (_cshell) ? _cshell : (_ushell) ? getusershell() : "/bin/sh";
        _args.at(0)        = (char*) _shell.c_str();
        _args.at(1)        = (char*) _c.c_str();
        _args.at(2)        = (char*) cmd;
        fp                 = tim::popen::popen(_args.at(0), _args.data());
    }
 
    if(fp == nullptr)
    {
        std::stringstream ss;
        ss << "[timemory]> Error launching command: '" << cmd << "'... " << extra;
        perror(ss.str().c_str());
        return false;
    }
    if(os)
    {
        popen::flush_output(*os, fp);
    }
 
    auto ec = tim::popen::pclose(fp);
    if(ec != 0)
    {
        std::stringstream ss;
        ss << "[timemory]> Command: '" << cmd << "' returned a non-zero exit code: " << ec
           << "... " << extra;
        perror(ss.str().c_str());
        return false;
    }
#else
    if(std::system(nullptr) != 0)
    {
        int ec = std::system(cmd);
 
        if(ec != 0)
        {
            fprintf(stderr,
                    "[timemory]> Command: '%s' returned a non-zero exit code: %i... %s\n",
                    cmd, ec, extra.c_str());
            return false;
        }
    }
    else
    {
        fprintf(stderr, "std::system unavailable for command: '%s'... %s\n", cmd,
                extra.c_str());
        return false;
    }
    (void) os;
#endif
 
    return true;
}

References tim::plotting::cmd, delimit(), tim::popen::flush_output(), tim::popen::pclose(), and tim::popen::popen().

Referenced by makedir().

load_env() [1/3]

template<>

bool tim::load_env	(	const std::string &	env_id,
		bool	_default
	)

load_env() [2/3]

template<>

std::string tim::load_env	(	const std::string &	env_id,
		std::string	_default
	)

load_env() [3/3]

template<typename Tp >

Tp tim::load_env	(	const std::string &	env_id,
		Tp	_default
	)

Definition at line 200 of file declaration.hpp.

{
    if(env_id.empty())
        return _default;
 
    auto* _env_settings = env_settings::instance();
    if(!_env_settings)
        return _default;
 
    auto itr = _env_settings->get(env_id);
    if(itr != _env_settings->end())
    {
        std::stringstream iss{ itr->second };
        auto              var = Tp{};
        iss >> var;
        return var;
    }
 
    // return default if not specified in environment
    return _default;
}

References tim::env_settings::instance().

makedir()

TIMEMORY_UTILITY_INLINE int tim::makedir	(	std::string	_dir,
		int	umask
	)

Definition at line 66 of file utility.cpp.

{
#if defined(TIMEMORY_UNIX)
    while(_dir.find("\\\\") != std::string::npos)
        _dir.replace(_dir.find("\\\\"), 2, "/");
    while(_dir.find('\\') != std::string::npos)
        _dir.replace(_dir.find('\\'), 1, "/");
 
    if(_dir.length() == 0)
        return 0;
 
    int ret = mkdir(_dir.c_str(), umask);
    if(ret != 0)
    {
        int err = errno;
        if(err != EEXIST)
        {
            std::cerr << "mkdir(" << _dir.c_str() << ", " << umask
                      << ") returned: " << ret << std::endl;
            std::stringstream _sdir;
            _sdir << "/bin/mkdir -p " << _dir;
            return (launch_process(_sdir.str().c_str())) ? 0 : 1;
        }
    }
#elif defined(TIMEMORY_WINDOWS)
    consume_parameters(umask);
    while(_dir.find('/') != std::string::npos)
        _dir.replace(_dir.find('/'), 1, "\\");
 
    if(_dir.length() == 0)
        return 0;
 
    int ret = _mkdir(_dir.c_str());
    if(ret != 0)
    {
        int err = errno;
        if(err != EEXIST)
        {
            std::cerr << "_mkdir(" << _dir.c_str() << ") returned: " << ret << std::endl;
            std::stringstream _sdir;
            _sdir << "mkdir " << _dir;
            return (launch_process(_sdir.str().c_str())) ? 0 : 1;
        }
    }
#endif
    return 0;
}

References tim::plotting::_dir, consume_parameters(), and launch_process().

Referenced by tim::settings::compose_output_filename(), and tim::settings::get_global_output_prefix().

mangle()

template<typename FuncT , typename TraitsT = mpl::function_traits<FuncT>>

std::string tim::mangle

(

const std::string &

func

)

Definition at line 106 of file mangler.hpp.

{
    using _Tuple             = typename TraitsT::args_type;
    constexpr bool is_memfun = TraitsT::is_memfun;
    constexpr bool is_const  = TraitsT::is_const;
    return impl::mangler<_Tuple>::mangle(func, is_memfun, is_const);
}

on_error()

parser tim::on_error

(

[=] (parser_t &p, const parser_err_t &_err) { err_action(_err);if(dmp::rank()==0 &&_settings->get_verbose() > 0) p.print_help("-- <NON_TIMEMORY_ARGS>");}

)

References _settings, err_action, and tim::argparse::argument_parser::print_help().

print_env()

void tim::print_env

(

std::ostream &

os = std::cout

)

print_graph() [1/2]

template<typename T , typename Formatter = std::function<std::string(const T&)>>

void tim::print_graph	(	const tim::graph< T > &	t,
		Formatter	format,
		std::ostream &	str = std::cout
	)

Definition at line 3269 of file graph.hpp.

{
    int head_count = t.number_of_siblings(t.begin());
    int nhead      = 0;
    for(typename tim::graph<T>::sibling_iterator ritr = t.begin(); ritr != t.end();
        ++ritr, ++nhead)
    {
        print_subgraph(t, format, ritr, str);
        if(nhead != head_count)
        {
            str << std::endl;
        }
    }
}

References tim::graph< T, AllocatorT >::begin(), tim::graph< T, AllocatorT >::end(), tim::graph< T, AllocatorT >::number_of_siblings(), and print_subgraph().

print_graph() [2/2]

template<typename T >

void tim::print_graph	(	const tim::graph< T > &	t,
		std::ostream &	str
	)

Definition at line 3288 of file graph.hpp.

{
    auto _formatter = [](const T& obj) {
        std::stringstream ss;
        ss << obj;
        return ss.str();
    };
    int head_count = t.number_of_siblings(t.begin());
    int nhead      = 0;
    for(typename tim::graph<T>::sibling_iterator ritr = t.begin(); ritr != t.end();
        ++ritr, ++nhead)
    {
        print_subgraph(t, _formatter, ritr, str);
        if(nhead != head_count)
        {
            str << std::endl;
        }
    }
}

References tim::graph< T, AllocatorT >::begin(), tim::graph< T, AllocatorT >::end(), tim::graph< T, AllocatorT >::number_of_siblings(), and print_subgraph().

print_graph_bracketed()

template<typename T >

void tim::print_graph_bracketed	(	const graph< T > &	t,
		std::ostream &	os = std::cout
	)

Definition at line 3190 of file graph.hpp.

{
    int head_count = t.number_of_siblings(t.begin());
    int nhead      = 0;
    for(typename graph<T>::sibling_iterator ritr = t.begin(); ritr != t.end();
        ++ritr, ++nhead)
    {
        print_subgraph_bracketed(t, ritr, os);
        if(nhead != head_count)
        {
            os << std::endl;
        }
    }
}

References tim::graph< T, AllocatorT >::begin(), tim::graph< T, AllocatorT >::end(), tim::graph< T, AllocatorT >::number_of_siblings(), and print_subgraph_bracketed().

print_graph_hierarchy()

template<typename T , typename Formatter = std::function<std::string(const T&)>>

void tim::print_graph_hierarchy	(	const tim::graph< T > &	t,
		Formatter	format,
		std::ostream &	str = std::cout
	)

Definition at line 3364 of file graph.hpp.

{
    int head_count = t.number_of_siblings(t.begin());
    int nhead      = 0;
    for(typename tim::graph<T>::sibling_iterator ritr = t.begin(); ritr != t.end();
        ++ritr, ++nhead)
    {
        print_subgraph_hierarchy(t, format, ritr, str);
        if(nhead != head_count)
        {
            str << std::endl;
        }
    }
}

References tim::graph< T, AllocatorT >::begin(), tim::graph< T, AllocatorT >::end(), tim::graph< T, AllocatorT >::number_of_siblings(), and print_subgraph_hierarchy().

print_subgraph()

template<typename T , typename Formatter = std::function<std::string(const T&)>>

void tim::print_subgraph	(	const tim::graph< T > &	t,
		Formatter	format,
		typename tim::graph< T >::iterator	root,
		std::ostream &	str = std::cout
	)

Definition at line 3312 of file graph.hpp.

{
    if(t.empty())
        return;
    if(t.number_of_children(root) == 0)
    {
        os << format(*root);
    }
    else
    {
        // parent
        std::string str = format(*root);
        if(str.length() > 0)
            os << str << "\n";
        // child1, ..., childn
        int sibling_count = t.number_of_siblings(t.begin(root));
        int nsiblings;
        typename tim::graph<T>::sibling_iterator children;
        for(children = t.begin(root), nsiblings = 0; children != t.end(root);
            ++children, ++nsiblings)
        {
            // recursively print child
            print_subgraph(t, format, children, os);
            // comma after every child except the last one
            if(nsiblings != sibling_count)
            {
                os << "\n";
            }
        }
    }
}

References tim::graph< T, AllocatorT >::begin(), tim::graph< T, AllocatorT >::empty(), tim::graph< T, AllocatorT >::end(), tim::graph< T, AllocatorT >::number_of_children(), and tim::graph< T, AllocatorT >::number_of_siblings().

Referenced by print_graph().

print_subgraph_bracketed()

template<typename T >

void tim::print_subgraph_bracketed	(	const graph< T > &	t,
		typename graph< T >::iterator	root,
		std::ostream &	os = std::cout
	)

Definition at line 3211 of file graph.hpp.

{
    static int _depth = 0;
    if(t.empty())
        return;
 
    auto        m_depth = _depth++;
    std::string indent  = {};
    for(int i = 0; i < m_depth; ++i)
        indent += "  ";
 
    if(t.number_of_children(root) == 0)
    {
        os << "\n" << indent << *root;
    }
    else
    {
        // parent
        os << "\n" << indent << *root;
        os << "(";
        // child1, ..., childn
        int sibling_count = t.number_of_siblings(t.begin(root));
        int nsiblings;
        typename graph<T>::sibling_iterator children;
        for(children = t.begin(root), nsiblings = 0; children != t.end(root);
            ++children, ++nsiblings)
        {
            // recursively print child
            print_subgraph_bracketed(t, children, os);
            // comma after every child except the last one
            if(nsiblings != sibling_count)
            {
                os << ", ";
            }
        }
        os << ")";
    }
    --_depth;
}

References tim::graph< T, AllocatorT >::begin(), tim::graph< T, AllocatorT >::empty(), tim::graph< T, AllocatorT >::end(), tim::graph< T, AllocatorT >::number_of_children(), and tim::graph< T, AllocatorT >::number_of_siblings().

Referenced by print_graph_bracketed().

print_subgraph_hierarchy()

template<typename T , typename Formatter = std::function<std::string(const T&)>>

void tim::print_subgraph_hierarchy	(	const tim::graph< T > &	t,
		Formatter	format,
		typename tim::graph< T >::iterator	root,
		std::ostream &	str = std::cout
	)

Definition at line 3383 of file graph.hpp.

{
    if(t.empty())
        return;
    if(t.number_of_children(root) == 0)
    {
        os << format(*root);
    }
    else
    {
        // parent
        std::string str = format(*root);
        if(str.length() > 0)
            os << str << "\n" << std::setw(2 * (t.depth(root) + 1)) << "|_";
        // child1, ..., childn
        int sibling_count = t.number_of_siblings(t.begin(root));
        int nsiblings;
        typename tim::graph<T>::sibling_iterator children;
        for(children = t.begin(root), nsiblings = 0; children != t.end(root);
            ++children, ++nsiblings)
        {
            // recursively print child
            print_subgraph_hierarchy(t, format, children, os);
            // comma after every child except the last one
            if(nsiblings != sibling_count)
            {
                os << "\n" << std::setw(2 * (t.depth(root) + 1)) << "|_";
            }
        }
    }
}

References tim::graph< T, AllocatorT >::begin(), tim::graph< T, AllocatorT >::depth(), tim::graph< T, AllocatorT >::empty(), tim::graph< T, AllocatorT >::end(), tim::graph< T, AllocatorT >::number_of_children(), and tim::graph< T, AllocatorT >::number_of_siblings().

Referenced by print_graph_hierarchy().

read_command_line()

TIMEMORY_UTILITY_INLINE std::vector< std::string > tim::read_command_line

(

pid_t

_pid

)

Definition at line 285 of file utility.cpp.

{
    std::vector<std::string> _cmdline;
#if defined(TIMEMORY_LINUX)
    std::stringstream fcmdline;
    fcmdline << "/proc/" << _pid << "/cmdline";
    std::ifstream ifs(fcmdline.str().c_str());
    if(ifs)
    {
        char        cstr;
        std::string sarg;
        while(!ifs.eof())
        {
            ifs >> cstr;
            if(!ifs.eof())
            {
                if(cstr != '\0')
                {
                    sarg += cstr;
                }
                else
                {
                    _cmdline.push_back(sarg);
                    sarg = "";
                }
            }
        }
        ifs.close();
    }
 
#else
    consume_parameters(_pid);
#endif
    return _cmdline;
}

References consume_parameters().

Referenced by tim::config::read_command_line(), and timemory_trace_init().

set_env()

template<typename Tp >

void tim::set_env	(	const std::string &	env_var,
		const Tp &	_val,
		int	override
	)

Definition at line 226 of file declaration.hpp.

{
    std::stringstream ss_val;
    ss_val << _val;
#if defined(TIMEMORY_MACOS) || (defined(TIMEMORY_LINUX) && (_POSIX_C_SOURCE >= 200112L))
    setenv(env_var.c_str(), ss_val.str().c_str(), override);
#elif defined(TIMEMORY_WINDOWS)
    auto _curr = get_env<std::string>(env_var, "");
    if(_curr.empty() || override > 0)
        _putenv_s(env_var.c_str(), ss_val.str().c_str());
#else
    consume_parameters(env_var, _val, override, ss_val);
#endif
}

References consume_parameters().

Referenced by tim::settings::insert(), kokkosp_init_library(), and timemory_set_environ().

str_transform()

template<typename PredicateT = std::function<std::string(const std::string&)>>

std::string tim::str_transform ( const std::string &  input, const std::string &  _begin, const std::string &  _end, PredicateT &&  predicate  )

inline

apply a string transformation to substring inbetween a common delimiter. e.g.

Definition at line 708 of file utility.hpp.

{
    size_t      _beg_pos = 0;  // position that is the beginning of the new string
    size_t      _end_pos = 0;  // position of the delimiter in the string
    std::string _result  = input;
    while(_beg_pos < _result.length() && _end_pos < _result.length())
    {
        // find the first sequence of characters after the end-position
        _beg_pos = _result.find(_begin, _end_pos);
 
        // if sequence wasn't found, we are done
        if(_beg_pos == std::string::npos)
            break;
 
        // starting after the position of the first delimiter, find the end sequence
        if(!_end.empty())
            _end_pos = _result.find(_end, _beg_pos + 1);
        else
            _end_pos = _beg_pos + _begin.length();
 
        // break if not found
        if(_end_pos == std::string::npos)
            break;
 
        // length of the substr being operated on
        auto _len = _end_pos - _beg_pos;
 
        // get the substring between the two delimiters (including first delimiter)
        auto _sub = _result.substr(_beg_pos, _len);
 
        // apply the transform
        auto _transformed = predicate(_sub);
 
        // only replace if necessary
        if(_sub != _transformed)
        {
            _result = _result.replace(_beg_pos, _len, _transformed);
            // move end to the end of transformed string
            _end_pos = _beg_pos + _transformed.length();
        }
    }
    return _result;
}

Referenced by tim::operation::decode< ApiT >::tokenized_demangle().

timemory_argparse() [1/4]

tim::timemory_argparse	(	argc	,
		argv
	)

Referenced by kokkosp_parse_args(), and kokkosp_print_help().

timemory_argparse() [2/4]

tim::timemory_argparse	(	argc	,
		argv	,
		&	parser
	)

timemory_argparse() [3/4]

void tim::timemory_argparse	(	int *	argc,
		char ***	argv,
		argparse::argument_parser *	parser = nullptr,
		settings *	_settings = nullptr
	)

timemory_argparse() [4/4]

void tim::timemory_argparse	(	std::vector< std::string > &	,
		argparse::argument_parser *	parser = nullptr,
		settings *	_settings = nullptr
	)

TIMEMORY_CONFIG_LINKAGE()

tim::TIMEMORY_CONFIG_LINKAGE

(

void

)

Definition at line 170 of file definition.hpp.

{
    auto* cstr  = const_cast<char*>(exe_name.c_str());
    auto  _argc = 1;
    auto* _argv = &cstr;
    timemory_init(_argc, _argv, _prefix, _suffix);
}

References _prefix, _suffix, exe_name, and timemory_init().

TIMEMORY_ENVIRONMENT_LINKAGE() [1/6]

template<>

tim::TIMEMORY_ENVIRONMENT_LINKAGE

(

bool

)

const

Definition at line 227 of file definition.hpp.

{
    if(env_id.empty())
        return _default;
 
    auto* _env_settings = env_settings::instance();
    char* env_var       = std::getenv(env_id.c_str());
    if(env_var)
    {
        std::string var = std::string(env_var);
        bool        val = true;
        if(var.find_first_not_of("0123456789") == std::string::npos)
        {
            val = (bool) atoi(var.c_str());
        }
        else
        {
            for(auto& itr : var)
                itr = tolower(itr);
            for(const auto& itr : { "off", "false", "no", "n", "f", "0" })
            {
                if(var == itr)
                {
                    if(_env_settings)
                        _env_settings->insert<bool>(env_id, false);
                    return false;
                }
            }
        }
        if(_env_settings)
            _env_settings->insert<bool>(env_id, val);
        return val;
    }
    // record default value
    if(_env_settings)
        _env_settings->insert<bool>(env_id, _default);
 
    // return default if not specified in environment
    return _default;
}

References tim::env_settings::instance().

TIMEMORY_ENVIRONMENT_LINKAGE() [2/6]

tim::TIMEMORY_ENVIRONMENT_LINKAGE

(

env_settings::env_map_t

)

Definition at line 96 of file definition.hpp.

{
    auto_lock_t lk(type_mutex<env_settings>(), std::defer_lock);
    lock_flag().store(true);
    if(!lk.owns_lock())
        lk.lock();
 
    auto      _tmp = *m_env;
    env_map_t _ret;
    for(const auto& itr : _tmp)
        _ret[itr.first] = itr.second;
 
    lock_flag().store(false);
    return _ret;
}
//
//--------------------------------------------------------------------------------------//
//
TIMEMORY_ENVIRONMENT_LINKAGE(void)
env_settings::print(std::ostream& os) const
{
    if(m_id == 0)
        const_cast<env_settings&>(*this).collapse();
 
    auto _data = get();
 
    size_t _w = 35;
    for(const auto& itr : _data)
        _w = std::max<size_t>(itr.first.length(), _w);
 
    std::stringstream filler;
    filler.fill('-');
    filler << '#';
    filler << std::setw(88) << "";
    filler << '#';
 
    std::stringstream ss;
    ss << filler.str() << '\n';
    ss << "# Environment settings:\n";
    for(const auto& itr : _data)
    {
        ss << "# " << std::setw(_w) << std::right << itr.first << "\t = \t" << std::left
           << itr.second << '\n';
    }
    ss << filler.str();
    os << ss.str() << '\n';
}
//
//--------------------------------------------------------------------------------------//
//
// NOLINTNEXTLINE
TIMEMORY_ENVIRONMENT_LINKAGE(void)
env_settings::collapse()
{
    if(m_id != 0)
        return;
 
    auto_lock_t lk(type_mutex<env_settings>(), std::defer_lock);
    if(!lk.owns_lock())
        lk.lock();
 
    lock_flag().store(true);
 
    // insert all the other maps into this map
    for(size_t i = 0; i < m_env_other.size(); ++i)
    {
        // get the map instance
        auto* itr = m_env_other[i];
        if(itr)
        {
            // loop over entries
            for(const auto& mitr : *m_env_other[i])
            {
                auto key = mitr.first;
                if(m_env->find(key) != m_env->end())
                {
                    // if the key already exists and if the entries differ,
                    // create a new unique entry for the index
                    if(m_env->find(key)->second != mitr.second)
                    {
                        key += string_t("[@") + std::to_string(i + 1) + string_t("]");
                        (*m_env)[key] = mitr.second;
                    }
                }
                else
                {
                    // if a new entry, insert without unique tag to avoid duplication
                    // when thread count is very high
                    (*m_env)[key] = mitr.second;
                }
            }
        }
    }
    lock_flag().store(false);
}

TIMEMORY_ENVIRONMENT_LINKAGE() [3/6]

tim::TIMEMORY_ENVIRONMENT_LINKAGE

(

env_settings::~

env_settings()

)

Definition at line 84 of file definition.hpp.

{
    if(m_id == 0)
    {
        delete m_env;
        for(auto& itr : m_env_other)
            delete itr;
    }
}

TIMEMORY_ENVIRONMENT_LINKAGE() [4/6]

template<>

tim::TIMEMORY_ENVIRONMENT_LINKAGE

(

std::string

)

const

Definition at line 198 of file definition.hpp.

{
    if(env_id.empty())
        return _default;
 
    auto* _env_settings = env_settings::instance();
    char* env_var       = std::getenv(env_id.c_str());
    if(env_var)
    {
        std::stringstream ss;
        ss << env_var;
        if(_env_settings)
            _env_settings->insert(env_id, ss.str());
        return ss.str();
    }
    // record default value
    if(_env_settings)
        _env_settings->insert(env_id, _default);
 
    // return default if not specified in environment
    return _default;
}

References tim::env_settings::instance().

TIMEMORY_ENVIRONMENT_LINKAGE() [5/6]

tim::TIMEMORY_ENVIRONMENT_LINKAGE

(

tim::env_settings *

)

Definition at line 338 of file definition.hpp.

{
    static std::atomic<int>           _count{ 0 };
    static env_settings               _instance{};
    static thread_local int           _id = _count++;
    static thread_local env_settings* _local =
        (_id == 0) ? (&_instance) : new env_settings{ &_instance, _id };
    static thread_local auto _ldtor = scope::destructor{ []() {
        if(_local == &_instance || _id == 0)
            return;
        delete _local;
        _local                      = nullptr;
    } };
    return _local;
    (void) _ldtor;
}

TIMEMORY_ENVIRONMENT_LINKAGE() [6/6]

tim::TIMEMORY_ENVIRONMENT_LINKAGE

(

void

)

Definition at line 333 of file definition.hpp.

                          { os << (*env_settings::instance()); }

References tim::env_settings::instance().

timemory_finalize()

void tim::timemory_finalize

(

)

finalization of the specified types

Referenced by finalize(), and kokkosp_finalize_library().

TIMEMORY_HASH_LINKAGE() [1/5]

tim::TIMEMORY_HASH_LINKAGE

(

hash_alias_ptr_t &

)

Definition at line 57 of file definition.hpp.

{
    static thread_local auto _inst =
        get_shared_ptr_pair_instance<hash_alias_map_t, TIMEMORY_API>();
    return _inst;
}

TIMEMORY_HASH_LINKAGE() [2/5]

tim::TIMEMORY_HASH_LINKAGE

(

hash_map_ptr_t &

)

Definition at line 47 of file definition.hpp.

{
    static thread_local auto _inst =
        get_shared_ptr_pair_instance<hash_map_t, TIMEMORY_API>();
    return _inst;
}

TIMEMORY_HASH_LINKAGE() [3/5]

tim::TIMEMORY_HASH_LINKAGE

(

hash_value_t

)

const &

TIMEMORY_HASH_LINKAGE() [4/5]

tim::TIMEMORY_HASH_LINKAGE

(

std::shared_ptr< hash_resolver_vec_t > &

)

Definition at line 67 of file definition.hpp.

{
    static auto _inst = []() {
        auto _subinst = get_shared_ptr_lone_instance<hash_resolver_vec_t, TIMEMORY_API>();
        if(_subinst && _subinst->empty())
            _subinst->reserve(10);
        return _subinst;
    }();
    return _inst;
}

TIMEMORY_HASH_LINKAGE() [5/5]

tim::TIMEMORY_HASH_LINKAGE

(

void

)

const &

timemory_init() [1/6]

template<typename... Types, typename... Args, enable_if_t<(sizeof...(Types) > 0 &&sizeof...(Args) >=2), int > >

void tim::timemory_init ( Args &&...  _args )

inline

Definition at line 49 of file declaration.hpp.

{
    using types_type = tim::convert_t<tuple_concat_t<Types...>, tim::type_list<>>;
    manager::get_storage<types_type>::initialize();
    timemory_init(std::forward<Args>(_args)...);
}

Referenced by init(), kokkosp_init_library(), kokkosp_parse_args(), and TIMEMORY_CONFIG_LINKAGE().

timemory_init() [2/6]

void tim::timemory_init	(	const std::string &	exe_name,
		const std::string &	_prefix = "timemory-",
		const std::string &	_suffix = "-output"
	)

initialization (creates manager and configures output path)

timemory_init() [3/6]

void tim::timemory_init	(	int *	argc,
		char ***	argv,
		argparse::argument_parser &	parser,
		const std::string &	_prefix = "timemory-",
		const std::string &	_suffix = "-output"
	)

timemory_init() [4/6]

void tim::timemory_init	(	int *	argc,
		char ***	argv,
		const std::string &	_prefix = "timemory-",
		const std::string &	_suffix = "-output"
	)

initialization (creates manager, configures output path, mpi_init)

timemory_init() [5/6]

void tim::timemory_init	(	int	argc,
		char **	argv,
		const std::string &	_prefix = "timemory-",
		const std::string &	_suffix = "-output"
	)

initialization (creates manager and configures output path)

timemory_init() [6/6]

void tim::timemory_init	(	std::vector< std::string > &	,
		argparse::argument_parser &	parser,
		const std::string &	_prefix = "timemory-",
		const std::string &	_suffix = "-output"
	)

timemory_library_constructor()

void tim::timemory_library_constructor

(

)

timemory_manager_master_instance()

manager* tim::timemory_manager_master_instance

(

)

TIMEMORY_SETTINGS_KEY() [1/111]

tim::TIMEMORY_SETTINGS_KEY

(

"ADD_SECONDARY"

)

TIMEMORY_SETTINGS_KEY() [2/111]

tim::TIMEMORY_SETTINGS_KEY

(

"ALLOW_SIGNAL_HANDLER"

)

TIMEMORY_SETTINGS_KEY() [3/111]

tim::TIMEMORY_SETTINGS_KEY

(

"AUTO_OUTPUT"

)

TIMEMORY_SETTINGS_KEY() [4/111]

tim::TIMEMORY_SETTINGS_KEY

(

"BANNER"

)

TIMEMORY_SETTINGS_KEY() [5/111]

tim::TIMEMORY_SETTINGS_KEY

(

"COLLAPSE_PROCESSES"

)

TIMEMORY_SETTINGS_KEY() [6/111]

tim::TIMEMORY_SETTINGS_KEY

(

"COLLAPSE_THREADS"

)

TIMEMORY_SETTINGS_KEY() [7/111]

tim::TIMEMORY_SETTINGS_KEY

(

"COMPONENTS"

)

TIMEMORY_SETTINGS_KEY() [8/111]

tim::TIMEMORY_SETTINGS_KEY

(

"COUT_OUTPUT"

)

TIMEMORY_SETTINGS_KEY() [9/111]

tim::TIMEMORY_SETTINGS_KEY

(

"CPU_AFFINITY"

)

TIMEMORY_SETTINGS_KEY() [10/111]

tim::TIMEMORY_SETTINGS_KEY

(

"CRAYPAT"

)

TIMEMORY_SETTINGS_KEY() [11/111]

tim::TIMEMORY_SETTINGS_KEY

(

"CTEST_NOTES"

)

TIMEMORY_SETTINGS_KEY() [12/111]

tim::TIMEMORY_SETTINGS_KEY

(

"CUDA_EVENT_BATCH_SIZE"

)

TIMEMORY_SETTINGS_KEY() [13/111]

tim::TIMEMORY_SETTINGS_KEY

(

"CUPTI_ACTIVITY_KINDS"

)

TIMEMORY_SETTINGS_KEY() [14/111]

tim::TIMEMORY_SETTINGS_KEY

(

"CUPTI_ACTIVITY_LEVEL"

)

TIMEMORY_SETTINGS_KEY() [15/111]

tim::TIMEMORY_SETTINGS_KEY

(

"CUPTI_DEVICE"

)

TIMEMORY_SETTINGS_KEY() [16/111]

tim::TIMEMORY_SETTINGS_KEY

(

"CUPTI_EVENTS"

)

TIMEMORY_SETTINGS_KEY() [17/111]

tim::TIMEMORY_SETTINGS_KEY

(

"CUPTI_METRICS"

)

TIMEMORY_SETTINGS_KEY() [18/111]

tim::TIMEMORY_SETTINGS_KEY

(

"DART_COUNT"

)

TIMEMORY_SETTINGS_KEY() [19/111]

tim::TIMEMORY_SETTINGS_KEY

(

"DART_LABEL"

)

TIMEMORY_SETTINGS_KEY() [20/111]

tim::TIMEMORY_SETTINGS_KEY

(

"DART_OUTPUT"

)

TIMEMORY_SETTINGS_KEY() [21/111]

tim::TIMEMORY_SETTINGS_KEY

(

"DART_TYPE"

)

TIMEMORY_SETTINGS_KEY() [22/111]

tim::TIMEMORY_SETTINGS_KEY

(

"DEBUG"

)

TIMEMORY_SETTINGS_KEY() [23/111]

tim::TIMEMORY_SETTINGS_KEY

(

"DESTRUCTOR_REPORT"

)

TIMEMORY_SETTINGS_KEY() [24/111]

tim::TIMEMORY_SETTINGS_KEY

(

"DIFF_OUTPUT"

)

TIMEMORY_SETTINGS_KEY() [25/111]

tim::TIMEMORY_SETTINGS_KEY

(

"DISABLE_ALL_SIGNALS"

)

TIMEMORY_SETTINGS_KEY() [26/111]

tim::TIMEMORY_SETTINGS_KEY

(

"ENABLE_ALL_SIGNALS"

)

TIMEMORY_SETTINGS_KEY() [27/111]

tim::TIMEMORY_SETTINGS_KEY

(

"ENABLE_SIGNAL_HANDLER"

)

TIMEMORY_SETTINGS_KEY() [28/111]

tim::TIMEMORY_SETTINGS_KEY

(

"ENABLED"

)

TIMEMORY_SETTINGS_KEY() [29/111]

tim::TIMEMORY_SETTINGS_KEY

(

"ERT_ALIGNMENT"

)

TIMEMORY_SETTINGS_KEY() [30/111]

tim::TIMEMORY_SETTINGS_KEY

(

"ERT_BLOCK_SIZE"

)

TIMEMORY_SETTINGS_KEY() [31/111]

tim::TIMEMORY_SETTINGS_KEY

(

"ERT_GRID_SIZE"

)

TIMEMORY_SETTINGS_KEY() [32/111]

tim::TIMEMORY_SETTINGS_KEY

(

"ERT_MAX_DATA_SIZE"

)

TIMEMORY_SETTINGS_KEY() [33/111]

tim::TIMEMORY_SETTINGS_KEY

(

"ERT_MAX_DATA_SIZE_CPU"

)

TIMEMORY_SETTINGS_KEY() [34/111]

tim::TIMEMORY_SETTINGS_KEY

(

"ERT_MAX_DATA_SIZE_GPU"

)

TIMEMORY_SETTINGS_KEY() [35/111]

tim::TIMEMORY_SETTINGS_KEY

(

"ERT_MIN_WORKING_SIZE"

)

TIMEMORY_SETTINGS_KEY() [36/111]

tim::TIMEMORY_SETTINGS_KEY

(

"ERT_MIN_WORKING_SIZE_CPU"

)

TIMEMORY_SETTINGS_KEY() [37/111]

tim::TIMEMORY_SETTINGS_KEY

(

"ERT_MIN_WORKING_SIZE_GPU"

)

TIMEMORY_SETTINGS_KEY() [38/111]

tim::TIMEMORY_SETTINGS_KEY

(

"ERT_NUM_STREAMS"

)

TIMEMORY_SETTINGS_KEY() [39/111]

tim::TIMEMORY_SETTINGS_KEY

(

"ERT_NUM_THREADS"

)

TIMEMORY_SETTINGS_KEY() [40/111]

tim::TIMEMORY_SETTINGS_KEY

(

"ERT_NUM_THREADS_CPU"

)

TIMEMORY_SETTINGS_KEY() [41/111]

tim::TIMEMORY_SETTINGS_KEY

(

"ERT_NUM_THREADS_GPU"

)

TIMEMORY_SETTINGS_KEY() [42/111]

tim::TIMEMORY_SETTINGS_KEY

(

"ERT_SKIP_OPS"

)

TIMEMORY_SETTINGS_KEY() [43/111]

tim::TIMEMORY_SETTINGS_KEY

(

"FILE_OUTPUT"

)

TIMEMORY_SETTINGS_KEY() [44/111]

tim::TIMEMORY_SETTINGS_KEY

(

"FLAMEGRAPH_OUTPUT"

)

TIMEMORY_SETTINGS_KEY() [45/111]

tim::TIMEMORY_SETTINGS_KEY

(

"FLAT_PROFILE"

)

TIMEMORY_SETTINGS_KEY() [46/111]

tim::TIMEMORY_SETTINGS_KEY

(

"GLOBAL_COMPONENTS"

)

TIMEMORY_SETTINGS_KEY() [47/111]

tim::TIMEMORY_SETTINGS_KEY

(

"INPUT_EXTENSIONS"

)

TIMEMORY_SETTINGS_KEY() [48/111]

tim::TIMEMORY_SETTINGS_KEY

(

"INPUT_PATH"

)

TIMEMORY_SETTINGS_KEY() [49/111]

tim::TIMEMORY_SETTINGS_KEY

(

"INPUT_PREFIX"

)

TIMEMORY_SETTINGS_KEY() [50/111]

tim::TIMEMORY_SETTINGS_KEY

(

"INSTRUCTION_ROOFLINE"

)

TIMEMORY_SETTINGS_KEY() [51/111]

tim::TIMEMORY_SETTINGS_KEY

(

"JSON_OUTPUT"

)

TIMEMORY_SETTINGS_KEY() [52/111]

tim::TIMEMORY_SETTINGS_KEY

(

"KOKKOS_COMPONENTS"

)

TIMEMORY_SETTINGS_KEY() [53/111]

tim::TIMEMORY_SETTINGS_KEY

(

"LIST_COMPONENTS"

)

TIMEMORY_SETTINGS_KEY() [54/111]

tim::TIMEMORY_SETTINGS_KEY

(

"MAX_DEPTH"

)

TIMEMORY_SETTINGS_KEY() [55/111]

tim::TIMEMORY_SETTINGS_KEY

(

"MAX_THREAD_BOOKMARKS"

)

TIMEMORY_SETTINGS_KEY() [56/111]

tim::TIMEMORY_SETTINGS_KEY

(

"MAX_WIDTH"

)

TIMEMORY_SETTINGS_KEY() [57/111]

tim::TIMEMORY_SETTINGS_KEY

(

"MEMORY_PRECISION"

)

TIMEMORY_SETTINGS_KEY() [58/111]

tim::TIMEMORY_SETTINGS_KEY

(

"MEMORY_SCIENTIFIC"

)

TIMEMORY_SETTINGS_KEY() [59/111]

tim::TIMEMORY_SETTINGS_KEY

(

"MEMORY_UNITS"

)

TIMEMORY_SETTINGS_KEY() [60/111]

tim::TIMEMORY_SETTINGS_KEY

(

"MEMORY_WIDTH"

)

TIMEMORY_SETTINGS_KEY() [61/111]

tim::TIMEMORY_SETTINGS_KEY

(

"MPI_FINALIZE"

)

TIMEMORY_SETTINGS_KEY() [62/111]

tim::TIMEMORY_SETTINGS_KEY

(

"MPI_INIT"

)

TIMEMORY_SETTINGS_KEY() [63/111]

tim::TIMEMORY_SETTINGS_KEY

(

"MPI_THREAD"

)

TIMEMORY_SETTINGS_KEY() [64/111]

tim::TIMEMORY_SETTINGS_KEY

(

"MPI_THREAD_TYPE"

)

TIMEMORY_SETTINGS_KEY() [65/111]

tim::TIMEMORY_SETTINGS_KEY

(

"MPIP_COMPONENTS"

)

TIMEMORY_SETTINGS_KEY() [66/111]

tim::TIMEMORY_SETTINGS_KEY

(

"NCCLP_COMPONENTS"

)

TIMEMORY_SETTINGS_KEY() [67/111]

tim::TIMEMORY_SETTINGS_KEY

(

"NODE_COUNT"

)

TIMEMORY_SETTINGS_KEY() [68/111]

tim::TIMEMORY_SETTINGS_KEY

(

"NVTX_MARKER_DEVICE_SYNC"

)

TIMEMORY_SETTINGS_KEY() [69/111]

tim::TIMEMORY_SETTINGS_KEY

(

"OMPT_COMPONENTS"

)

TIMEMORY_SETTINGS_KEY() [70/111]

tim::TIMEMORY_SETTINGS_KEY

(

"OUTPUT_PATH"

)

TIMEMORY_SETTINGS_KEY() [71/111]

tim::TIMEMORY_SETTINGS_KEY

(

"OUTPUT_PREFIX"

)

TIMEMORY_SETTINGS_KEY() [72/111]

tim::TIMEMORY_SETTINGS_KEY

(

"PAPI_ATTACH"

)

TIMEMORY_SETTINGS_KEY() [73/111]

tim::TIMEMORY_SETTINGS_KEY

(

"PAPI_EVENTS"

)

TIMEMORY_SETTINGS_KEY() [74/111]

tim::TIMEMORY_SETTINGS_KEY

(

"PAPI_FAIL_ON_ERROR"

)

TIMEMORY_SETTINGS_KEY() [75/111]

tim::TIMEMORY_SETTINGS_KEY

(

"PAPI_MULTIPLEXING"

)

TIMEMORY_SETTINGS_KEY() [76/111]

tim::TIMEMORY_SETTINGS_KEY

(

"PAPI_OVERFLOW"

)

TIMEMORY_SETTINGS_KEY() [77/111]

tim::TIMEMORY_SETTINGS_KEY

(

"PAPI_QUIET"

)

TIMEMORY_SETTINGS_KEY() [78/111]

tim::TIMEMORY_SETTINGS_KEY

(

"PAPI_THREADING"

)

TIMEMORY_SETTINGS_KEY() [79/111]

tim::TIMEMORY_SETTINGS_KEY

(

"PLOT_OUTPUT"

)

TIMEMORY_SETTINGS_KEY() [80/111]

tim::TIMEMORY_SETTINGS_KEY

(

"PRECISION"

)

TIMEMORY_SETTINGS_KEY() [81/111]

tim::TIMEMORY_SETTINGS_KEY

(

"PROFILER_COMPONENTS"

)

TIMEMORY_SETTINGS_KEY() [82/111]

tim::TIMEMORY_SETTINGS_KEY

(

"PYTHON_EXE"

)

TIMEMORY_SETTINGS_KEY() [83/111]

tim::TIMEMORY_SETTINGS_KEY

(

"ROOFLINE_EVENTS_CPU"

)

TIMEMORY_SETTINGS_KEY() [84/111]

tim::TIMEMORY_SETTINGS_KEY

(

"ROOFLINE_EVENTS_GPU"

)

TIMEMORY_SETTINGS_KEY() [85/111]

tim::TIMEMORY_SETTINGS_KEY

(

"ROOFLINE_MODE"

)

TIMEMORY_SETTINGS_KEY() [86/111]

tim::TIMEMORY_SETTINGS_KEY

(

"ROOFLINE_MODE_CPU"

)

TIMEMORY_SETTINGS_KEY() [87/111]

tim::TIMEMORY_SETTINGS_KEY

(

"ROOFLINE_MODE_GPU"

)

TIMEMORY_SETTINGS_KEY() [88/111]

tim::TIMEMORY_SETTINGS_KEY

(

"ROOFLINE_TYPE_LABELS"

)

TIMEMORY_SETTINGS_KEY() [89/111]

tim::TIMEMORY_SETTINGS_KEY

(

"ROOFLINE_TYPE_LABELS_CPU"

)

TIMEMORY_SETTINGS_KEY() [90/111]

tim::TIMEMORY_SETTINGS_KEY

(

"ROOFLINE_TYPE_LABELS_GPU"

)

TIMEMORY_SETTINGS_KEY() [91/111]

tim::TIMEMORY_SETTINGS_KEY

(

"SCIENTIFIC"

)

TIMEMORY_SETTINGS_KEY() [92/111]

tim::TIMEMORY_SETTINGS_KEY

(

"SEPARATOR_FREQ"

)

TIMEMORY_SETTINGS_KEY() [93/111]

tim::TIMEMORY_SETTINGS_KEY

(

"STACK_CLEARING"

)

TIMEMORY_SETTINGS_KEY() [94/111]

tim::TIMEMORY_SETTINGS_KEY

(

"SUPPRESS_CONFIG"

)

TIMEMORY_SETTINGS_KEY() [95/111]

tim::TIMEMORY_SETTINGS_KEY

(

"SUPPRESS_PARSING"

)

Referenced by tim::settings::get_global_output_prefix(), and tim::component::network_stats::get_interfaces().

TIMEMORY_SETTINGS_KEY() [96/111]

tim::TIMEMORY_SETTINGS_KEY

(

"TEXT_OUTPUT"

)

TIMEMORY_SETTINGS_KEY() [97/111]

tim::TIMEMORY_SETTINGS_KEY

(

"THROTTLE_COUNT"

)

TIMEMORY_SETTINGS_KEY() [98/111]

tim::TIMEMORY_SETTINGS_KEY

(

"THROTTLE_VALUE"

)

TIMEMORY_SETTINGS_KEY() [99/111]

tim::TIMEMORY_SETTINGS_KEY

(

"TIME_FORMAT"

)

TIMEMORY_SETTINGS_KEY() [100/111]

tim::TIMEMORY_SETTINGS_KEY

(

"TIME_OUTPUT"

)

TIMEMORY_SETTINGS_KEY() [101/111]

tim::TIMEMORY_SETTINGS_KEY

(

"TIMING_PRECISION"

)

TIMEMORY_SETTINGS_KEY() [102/111]

tim::TIMEMORY_SETTINGS_KEY

(

"TIMING_SCIENTIFIC"

)

TIMEMORY_SETTINGS_KEY() [103/111]

tim::TIMEMORY_SETTINGS_KEY

(

"TIMING_UNITS"

)

TIMEMORY_SETTINGS_KEY() [104/111]

tim::TIMEMORY_SETTINGS_KEY

(

"TIMING_WIDTH"

)

TIMEMORY_SETTINGS_KEY() [105/111]

tim::TIMEMORY_SETTINGS_KEY

(

"TRACE_COMPONENTS"

)

TIMEMORY_SETTINGS_KEY() [106/111]

tim::TIMEMORY_SETTINGS_KEY

(

"TREE_OUTPUT"

)

TIMEMORY_SETTINGS_KEY() [107/111]

tim::TIMEMORY_SETTINGS_KEY

(

"TUPLE_COMPONENTS"

)

TIMEMORY_SETTINGS_KEY() [108/111]

tim::TIMEMORY_SETTINGS_KEY

(

"UPCXX_FINALIZE"

)

TIMEMORY_SETTINGS_KEY() [109/111]

tim::TIMEMORY_SETTINGS_KEY

(

"UPCXX_INIT"

)

TIMEMORY_SETTINGS_KEY() [110/111]

tim::TIMEMORY_SETTINGS_KEY

(

"VERBOSE"

)

TIMEMORY_SETTINGS_KEY() [111/111]

tim::TIMEMORY_SETTINGS_KEY

(

"WIDTH"

)

TIMEMORY_SETTINGS_LINKAGE() [1/2]

tim::TIMEMORY_SETTINGS_LINKAGE

(

bool

)

Definition at line 89 of file vsettings.cpp.

{
    // an exact match to name or env-name should always be checked
    if(inp == m_env_name || inp == m_name)
        return true;
 
    if(exact)
    {
        // match the command-line option w/ or w/o leading dashes
        auto _cmd_line_exact = [&](const std::string& itr) {
            // don't match short-options
            if(itr.length() == 2)
                return false;
            auto _with_dash = (itr == inp);
            auto _pos       = itr.find_first_not_of('-');
            if(_with_dash || _pos == std::string::npos)
                return _with_dash;
            return (itr.substr(_pos) == inp);
        };
 
        return std::any_of(m_cmdline.begin(), m_cmdline.end(), _cmd_line_exact);
    }
    else
    {
        const auto       cre = std::regex_constants::icase;
        const std::regex re(inp, cre);
 
        if(std::regex_search(m_env_name, re) || std::regex_search(m_name, re))
            return true;
 
        auto _cmd_line_regex = [&](const std::string& itr) {
            // don't match short-options
            if(itr.length() == 2)
                return false;
            return std::regex_search(itr, re);
        };
 
        return std::any_of(m_cmdline.begin(), m_cmdline.end(), _cmd_line_regex);
    }
}
//
//--------------------------------------------------------------------------------------//
//
TIMEMORY_SETTINGS_LINKAGE(void)
vsettings::clone(std::shared_ptr<vsettings> rhs)
{
    m_name        = rhs->m_name;
    m_env_name    = rhs->m_env_name;
    m_description = rhs->m_description;
    m_cmdline     = rhs->m_cmdline;
    m_count       = rhs->m_count;
    m_max_count   = rhs->m_max_count;
}

References tim::vsettings::m_cmdline, tim::vsettings::m_env_name, and tim::vsettings::m_name.

TIMEMORY_SETTINGS_LINKAGE() [2/2]

tim::TIMEMORY_SETTINGS_LINKAGE

(

vsettings::display_map_t

)

Definition at line 55 of file vsettings.cpp.

{
    display_map_t _data;
    auto          _as_str = [&](auto _val) {
        std::stringstream _ss;
        _ss.setf(fmt);
        if(_w > -1)
            _ss << std::setw(_w);
        if(_p > -1)
            _ss << std::setprecision(_p);
        _ss << std::boolalpha << _val;
        return _ss.str();
    };
 
    auto _arr_as_str = [&](auto _val) -> std::string {
        if(_val.empty())
            return "";
        std::stringstream _ss;
        for(size_t i = 0; i < _val.size(); ++i)
            _ss << ", " << _as_str(_val.at(i));
        return _ss.str().substr(2);
    };
 
    _data["name"]         = _as_str(m_name);
    _data["count"]        = _as_str(m_count);
    _data["max_count"]    = _as_str(m_max_count);
    _data["env_name"]     = _as_str(m_env_name);
    _data["description"]  = _as_str(m_description);
    _data["command_line"] = _arr_as_str(m_cmdline);
    _data["choices"]      = _arr_as_str(m_choices);
    return _data;
}

References tim::vsettings::m_choices, tim::vsettings::m_cmdline, tim::vsettings::m_count, tim::vsettings::m_description, tim::vsettings::m_env_name, tim::vsettings::m_max_count, and tim::vsettings::m_name.

TIMEMORY_SETTINGS_MEMBER_DEF()

tim::TIMEMORY_SETTINGS_MEMBER_DEF	(	string_t	,
		config_file	,
		TIMEMORY_SETTINGS_KEY("CONFIG_FILE")
	)

try_demangle()

template<typename Tp >

auto tim::try_demangle ( )

inline

Definition at line 247 of file utility.hpp.

{
    // static because a type demangle will always be the same
    static auto _val = []() {
        // wrap the type in type_list and then extract ... from tim::type_list<...>
        auto _tmp = ::tim::demangle(typeid(type_list<Tp>).name());
        auto _key = std::string{ "type_list" };
        auto _idx = _tmp.find(_key);
        _idx      = _tmp.find('<', _idx);
        _tmp      = _tmp.substr(_idx + 1);
        _idx      = _tmp.find_last_of('>');
        _tmp      = _tmp.substr(0, _idx);
        // strip trailing whitespaces
        while((_idx = _tmp.find_last_of(' ')) == _tmp.length() - 1)
            _tmp = _tmp.substr(0, _idx);
        return _tmp;
    }();
    return _val;
}

References demangle().

type_mutex()

template<typename Tp , typename ApiT = TIMEMORY_API, size_t N = 4>

mutex_t & tim::type_mutex

(

uint64_t

_n = 0

)

A simple way to get a mutex for a class or common behavior, e.g. type_mutex<decltype(std::cout)>() provides a mutex for synchronizing output streams. Recommend using in conjunction with auto-lock: tim::auto_lock_t _lk{ type_mutex<Foo>() }.

Template Parameters

Tp	data type for lock
ApiT	API for lock
N	max size

Definition at line 157 of file utility.hpp.

{
    static std::array<mutex_t, N> _mutexes{};
    return _mutexes.at(_n % N);
}

Referenced by tim::operation::finalize::print< Tp, true >::write_stream().

typeid_hash()

template<typename Tp >

auto tim::typeid_hash ( )

inline

Definition at line 299 of file utility.hpp.

{
    return internal::typeid_hash<Tp>(0);
}

update_signal_detection()

void tim::update_signal_detection ( const signal_settings::signal_set_t &  _signals )

inline

Definition at line 75 of file signals.hpp.

{
    if(signal_settings::allow())
    {
        disable_signal_detection();
        enable_signal_detection(_signals);
    }
}

References tim::signal_settings::allow(), disable_signal_detection(), and enable_signal_detection().

while() [1/3]

tim::while

(

(pos=exe_name.find("--")) !

= std::string::npos

)

while() [2/3]

tim::while

(

exe_name.find('/') !

= std::string::npos

)

while() [3/3]

tim::while

(

exe_name.find('\\') !

= std::string::npos

)

Variable Documentation

_cleanup_parser

bool tim::_cleanup_parser = parser == nullptr

Definition at line 302 of file definition.hpp.

_cleanup_settings

bool tim::_cleanup_settings = _settings == nullptr

Definition at line 307 of file definition.hpp.

_hash_alias

const hash_alias_ptr_t& tim::_hash_alias

Definition at line 93 of file definition.hpp.

Referenced by tim::operation::decode< ApiT >::operator()().

_hash_id

const hash_alias_ptr_t hash_value_t tim::_hash_id

Initial value:

{
    auto _alias_itr = _hash_alias->find(_hash_id)

Definition at line 82 of file definition.hpp.

Referenced by add_hash_id(), and tim::operation::decode< ApiT >::operator()().

_prefix

char argparse::argument_parser const std::string & tim::_prefix

Definition at line 59 of file definition.hpp.

Referenced by tim::operation::finalize::flamegraph< Type >::flamegraph(), tim::operation::print< Tp >::print(), tim::operation::set_prefix< Tp >::set_prefix(), tim::base::storage::add_hash_id(), add_hash_id(), tim::settings::compose_input_filename(), tim::settings::compose_output_filename(), tim::operation::echo_measurement< Tp, true >::generate_name(), tim::settings::get_global_input_prefix(), tim::settings::get_global_output_prefix(), get_hash_id(), tim::component::factory::hidden::get_opaque(), tim::cereal::load(), tim::operation::finalize::get< Type, true >::operator()(), tim::operation::set_prefix< Tp >::operator()(), tim::component::opaque::push(), tim::cereal::save(), tim::component::caliper_marker::set_prefix(), tim::component::caliper_loop_marker::set_prefix(), tim::component::nvtx_marker::set_prefix(), tim::component::malloc_gotcha::set_prefix(), tim::component::likwid_marker::set_prefix(), tim::component::likwid_nvmarker::set_prefix(), tim::component::user_bundle< Idx, Tag >::set_prefix(), tim::component::gperftools_heap_profiler::set_prefix(), tim::component::ompt_handle< Api >::set_prefix(), tim::component::vtune_event::set_prefix(), tim::component::vtune_frame::set_prefix(), tim::component::opaque::setup(), and TIMEMORY_CONFIG_LINKAGE().

_settings

char argparse::argument_parser tim::settings* tim::_settings

Initial value:

{
    
    if(!argc || !argv)
        return

Definition at line 276 of file definition.hpp.

Referenced by tim::operation::finalize::merge< Type, true >::merge(), c_timemory_init(), description(), for(), tim::settings::get_global_output_prefix(), tim::component::network_stats::get_interfaces(), if(), on_error(), tim::operation::finalize::ctest_notes_deleter::operator()(), tim::settings::parse(), tim::manager::swap_settings(), timemory_finalize_library(), and tim::manager::update_settings().

_suffix

char argparse::argument_parser const std::string const std::string & tim::_suffix

Initial value:

{
    static auto _settings = settings::shared_instance()

Definition at line 60 of file definition.hpp.

Referenced by tim::operation::print< Tp >::print(), and TIMEMORY_CONFIG_LINKAGE().

add_secondary

tim::add_secondary

Definition at line 1371 of file settings.cpp.

allow_signal_handler

tim::allow_signal_handler

Definition at line 1484 of file settings.cpp.

argv

char *** tim::argv

Definition at line 59 of file definition.hpp.

Referenced by tim::argparse::argument_vector::argument_vector(), c_timemory_init(), if(), kokkosp_parse_args(), kokkosp_print_help(), tim::argparse::argument_parser::parse(), tim::argparse::argument_parser::parse_known_args(), tim::settings::store_command_line(), timemory_init_library(), and timemory_init_library_().

auto_output

tim::auto_output

Definition at line 1315 of file settings.cpp.

banner

tim::banner

Definition at line 1330 of file settings.cpp.

collapse_processes

tim::collapse_processes

Definition at line 1333 of file settings.cpp.

Referenced by tim::operation::finalize::mpi_get< Type, true >::mpi_get(), tim::operation::finalize::mpi_get< Type, true >::operator()(), tim::operation::finalize::upc_get< Type, true >::operator()(), and tim::operation::finalize::get< Type, true >::operator()().

collapse_threads

tim::collapse_threads

Definition at line 1331 of file settings.cpp.

Referenced by tim::operation::finalize::get< Type, true >::operator()().

components

tim::components

Definition at line 1394 of file settings.cpp.

Referenced by c_timemory_create_auto_tuple(), configure(), tim::env::get_user_bundle_variables(), initialize(), insert(), timemory_push_components_(), and timemory_set_default_().

cout_output

tim::cout_output

Definition at line 1316 of file settings.cpp.

Referenced by tim::operation::finalize::print< Tp, true >::execute(), and tim::operation::finalize::print< Tp, true >::setup().

cpu_affinity

tim::cpu_affinity

Definition at line 1368 of file settings.cpp.

cpu_roofline_events

tim::cpu_roofline_events

Definition at line 1432 of file settings.cpp.

cpu_roofline_mode

tim::cpu_roofline_mode

Definition at line 1428 of file settings.cpp.

Referenced by tim::component::cpu_roofline< Types >::event_mode().

craypat_categories

tim::craypat_categories

Definition at line 1472 of file settings.cpp.

ctest_notes

tim::ctest_notes

Definition at line 1327 of file settings.cpp.

cuda_event_batch_size

tim::cuda_event_batch_size

Definition at line 1413 of file settings.cpp.

Referenced by tim::component::cuda_event::get_batched_marker_size().

cupti_activity_kinds

tim::cupti_activity_kinds

Definition at line 1419 of file settings.cpp.

Referenced by tim::component::cupti_activity::get_initializer().

cupti_activity_level

tim::cupti_activity_level

Definition at line 1417 of file settings.cpp.

Referenced by tim::component::cupti_activity::get_initializer().

cupti_device

tim::cupti_device

Definition at line 1425 of file settings.cpp.

Referenced by tim::component::cupti_counters::get_device_initializer().

cupti_events

tim::cupti_events

Definition at line 1421 of file settings.cpp.

Referenced by tim::component::cupti_counters::get_event_initializer().

cupti_metrics

tim::cupti_metrics

Definition at line 1423 of file settings.cpp.

Referenced by tim::component::cupti_counters::get_metric_initializer().

dart_count

tim::dart_count

Definition at line 1364 of file settings.cpp.

dart_label

tim::dart_label

Definition at line 1365 of file settings.cpp.

Referenced by tim::operation::echo_measurement< Tp, true >::generate_name(), and tim::operation::echo_measurement< Tp, true >::generate_prefix().

dart_output

tim::dart_output

Definition at line 1321 of file settings.cpp.

Referenced by tim::operation::finalize::print< Tp, true >::execute().

dart_type

tim::dart_type

Definition at line 1363 of file settings.cpp.

debug

tim::debug

Definition at line 1329 of file settings.cpp.

Referenced by tim::operation::finalize::mpi_get< Type, true >::mpi_get(), tim::bundle< Tag, BundleT, TupleT >::~bundle(), tim::component::caliper_common::_init(), tim::component::malloc_gotcha::audit(), tim::component::cpu_roofline< Types >::configure(), tim::component::user_bundle< Idx, Tag >::configure(), tim::component::gotcha< Nt, BundleT, DiffT >::construct(), tim::component::data_tracker< InpT, Tag >::description(), tim::base::ring_buffer::destroy(), tim::component::cpu_roofline< Types >::event_mode(), tim::sampling::sampler< CompT< Types... >, N, SigIds... >::execute(), tim::ert::counter< DeviceT, Tp, Counter >::get_buffer(), tim::component::papi_common::get_initializer(), tim::component::cpu_roofline< Types >::global_finalize(), tim::component::gpu_roofline< Types >::global_finalize(), tim::component::cpu_roofline< Types >::global_init(), tim::component::user_bundle< Idx, Tag >::global_init(), tim::bundle< Tag, BundleT, TupleT >::init(), tim::component::papi_common::initialize(), tim::component::papi_common::initialize_papi(), tim::data::stream::insert(), tim::component::user_bundle< Idx, Tag >::insert(), tim::operation::finalize::mpi_get< Type, true >::operator()(), tim::operation::finalize::upc_get< Type, true >::operator()(), tim::operation::finalize::get< Type, true >::operator()(), tim::operation::finalize::ctest_notes_deleter::operator()(), tim::ert::ops_main(), tim::plotting::operation::plot(), tim::config::read_command_line(), tim::component::user_bundle< Idx, Tag >::reset(), tim::sampling::sampler< CompT< Types... >, N, SigIds... >::set_delay(), tim::sampling::sampler< CompT< Types... >, N, SigIds... >::set_frequency(), tim::component::gotcha< Nt, BundleT, DiffT >::start(), tim::component::gotcha< Nt, BundleT, DiffT >::stop(), tim::component::cpu_roofline< Types >::thread_init(), timemory_add_hash_id(), timemory_add_hash_ids(), timemory_copy_hash_ids(), timemory_push_trace(), and timemory_push_trace_hash().

destructor_report

tim::destructor_report

Definition at line 1475 of file settings.cpp.

diff_output

tim::diff_output

Definition at line 1324 of file settings.cpp.

Referenced by tim::operation::finalize::print< Tp, true >::execute().

disable_all_signals

tim::disable_all_signals

Definition at line 1488 of file settings.cpp.

enable_all_signals

tim::enable_all_signals

Definition at line 1486 of file settings.cpp.

enable_signal_handler

tim::enable_signal_handler

Definition at line 1482 of file settings.cpp.

enabled

tim::enabled

Definition at line 1314 of file settings.cpp.

Referenced by timemory_begin_record(), timemory_begin_record_enum(), timemory_begin_record_types(), timemory_get_begin_record(), timemory_get_begin_record_enum(), timemory_get_begin_record_types(), timemory_pause(), timemory_push_trace(), timemory_push_trace_hash(), and timemory_resume().

err_action

auto tim::err_action

Initial value:

= [=](const parser_err_t& _err) {
        if(dmp::rank() == 0 && _err)
            std::cerr << "[timemory_argparse]> Error! " << _err << std::endl;
    }

Definition at line 296 of file definition.hpp.

Referenced by on_error().

ert_alignment

tim::ert_alignment

Definition at line 1456 of file settings.cpp.

Referenced by tim::ert::configuration< DeviceT, Tp, CounterT >::get_alignment().

ert_block_size

tim::ert_block_size

Definition at line 1454 of file settings.cpp.

Referenced by tim::ert::configuration< DeviceT, Tp, CounterT >::get_block_size().

ert_grid_size

tim::ert_grid_size

Definition at line 1452 of file settings.cpp.

Referenced by tim::ert::configuration< DeviceT, Tp, CounterT >::get_grid_size().

ert_max_data_size

tim::ert_max_data_size

Definition at line 1464 of file settings.cpp.

Referenced by tim::ert::configuration< DeviceT, Tp, CounterT >::get_max_data_size().

ert_max_data_size_cpu

tim::ert_max_data_size_cpu

Definition at line 1466 of file settings.cpp.

ert_max_data_size_gpu

tim::ert_max_data_size_gpu

Definition at line 1468 of file settings.cpp.

Referenced by tim::ert::configuration< DeviceT, Tp, CounterT >::get_max_data_size().

ert_min_working_size

tim::ert_min_working_size

Definition at line 1458 of file settings.cpp.

Referenced by tim::ert::configuration< DeviceT, Tp, CounterT >::get_min_working_size().

ert_min_working_size_cpu

tim::ert_min_working_size_cpu

Definition at line 1460 of file settings.cpp.

Referenced by tim::ert::configuration< DeviceT, Tp, CounterT >::get_min_working_size().

ert_min_working_size_gpu

tim::ert_min_working_size_gpu

Definition at line 1462 of file settings.cpp.

Referenced by tim::ert::configuration< DeviceT, Tp, CounterT >::get_min_working_size().

ert_num_streams

tim::ert_num_streams

Definition at line 1450 of file settings.cpp.

Referenced by tim::ert::configuration< DeviceT, Tp, CounterT >::get_num_streams().

ert_num_threads

tim::ert_num_threads

Definition at line 1444 of file settings.cpp.

Referenced by tim::ert::configuration< DeviceT, Tp, CounterT >::get_num_threads().

ert_num_threads_cpu

tim::ert_num_threads_cpu

Definition at line 1446 of file settings.cpp.

Referenced by tim::ert::configuration< DeviceT, Tp, CounterT >::get_num_threads().

ert_num_threads_gpu

tim::ert_num_threads_gpu

Definition at line 1448 of file settings.cpp.

Referenced by tim::ert::configuration< DeviceT, Tp, CounterT >::get_num_threads().

ert_skip_ops

tim::ert_skip_ops

Definition at line 1470 of file settings.cpp.

Referenced by tim::ert::configuration< DeviceT, Tp, CounterT >::get_skip_ops().

exe_name

tim::exe_name = (argc > 0) ? argv[0] : ""

Definition at line 107 of file definition.hpp.

Referenced by for(), if(), TIMEMORY_CONFIG_LINKAGE(), and timemory_trace_init().

file_output

tim::file_output

Definition at line 1317 of file settings.cpp.

Referenced by tim::operation::finalize::print< Tp, true >::execute(), and tim::operation::finalize::print< Tp, true >::setup().

flamegraph_output

tim::flamegraph_output

Definition at line 1325 of file settings.cpp.

flat_profile

tim::flat_profile

Definition at line 1491 of file settings.cpp.

Referenced by tim::component::caliper_common::get_nested().

global_components

tim::global_components

Definition at line 1376 of file settings.cpp.

Referenced by tim::env::get_user_bundle_variables().

gpu_roofline_events

tim::gpu_roofline_events

Definition at line 1434 of file settings.cpp.

gpu_roofline_mode

tim::gpu_roofline_mode

Definition at line 1430 of file settings.cpp.

Referenced by tim::component::gpu_roofline< Types >::event_mode().

help_action

auto tim::help_action

Initial value:

= [](parser_t& p) {
        if(dmp::rank() == 0)
            p.print_help("-- <NON_TIMEMORY_ARGS>");
        exit(EXIT_SUCCESS);
    }

Definition at line 290 of file definition.hpp.

input_extensions

tim::input_extensions

Definition at line 1361 of file settings.cpp.

input_path

tim::input_path

Definition at line 1358 of file settings.cpp.

Referenced by tim::settings::compose_input_filename(), and tim::settings::get_global_input_prefix().

input_prefix

tim::input_prefix

Definition at line 1359 of file settings.cpp.

Referenced by tim::settings::compose_input_filename(), and tim::settings::get_global_input_prefix().

instruction_roofline

tim::instruction_roofline

Definition at line 1442 of file settings.cpp.

Referenced by tim::component::gpu_roofline< Types >::configure().

json_output

tim::json_output

Definition at line 1319 of file settings.cpp.

Referenced by tim::operation::finalize::print< Tp, true >::execute(), and tim::plotting::operation::plot().

kokkos_components

tim::kokkos_components

Definition at line 1392 of file settings.cpp.

Referenced by tim::env::get_user_bundle_variables().

list_components

tim::list_components

Definition at line 1380 of file settings.cpp.

max_depth

tim::max_depth

Definition at line 1335 of file settings.cpp.

Referenced by tim::operation::finalize::flamegraph< Type >::flamegraph(), tim::operation::finalize::print< Tp, true >::print(), tim::operation::finalize::print< Tp, true >::print_dart(), tim::operation::finalize::print< Tp, true >::setup(), and tim::operation::finalize::print< Tp, true >::write_stream().

max_thread_bookmarks

tim::max_thread_bookmarks

Definition at line 1366 of file settings.cpp.

max_width

tim::max_width

Definition at line 1339 of file settings.cpp.

Referenced by tim::data::base::stream_entry::construct().

memory_precision

tim::memory_precision

Definition at line 1348 of file settings.cpp.

memory_scientific

tim::memory_scientific

Definition at line 1353 of file settings.cpp.

memory_units

tim::memory_units

Definition at line 1351 of file settings.cpp.

Referenced by tim::component::read_char::get_display_unit(), tim::component::written_char::get_display_unit(), tim::component::read_bytes::get_display_unit(), tim::component::written_bytes::get_display_unit(), tim::component::current_peak_rss::get_display_unit(), tim::component::read_char::get_unit(), tim::component::written_char::get_unit(), tim::component::read_bytes::get_unit(), tim::component::written_bytes::get_unit(), and tim::component::current_peak_rss::get_unit().

memory_width

tim::memory_width

Definition at line 1350 of file settings.cpp.

mpi_finalize

tim::mpi_finalize

Definition at line 1396 of file settings.cpp.

mpi_init

tim::mpi_init

Definition at line 1395 of file settings.cpp.

mpi_thread

tim::mpi_thread

Definition at line 1397 of file settings.cpp.

mpi_thread_type

tim::mpi_thread_type

Definition at line 1398 of file settings.cpp.

mpip_components

tim::mpip_components

Definition at line 1384 of file settings.cpp.

Referenced by tim::env::get_user_bundle_variables().

ncclp_components

tim::ncclp_components

Definition at line 1386 of file settings.cpp.

Referenced by tim::env::get_user_bundle_variables().

node_count

tim::node_count

Definition at line 1474 of file settings.cpp.

Referenced by tim::operation::finalize::mpi_get< Type, true >::mpi_get(), tim::operation::finalize::mpi_get< Type, true >::operator()(), tim::operation::finalize::upc_get< Type, true >::operator()(), and tim::operation::finalize::get< Type, true >::operator()().

nvtx_marker_device_sync

tim::nvtx_marker_device_sync

Definition at line 1415 of file settings.cpp.

Referenced by tim::component::nvtx_marker::use_device_sync().

ompt_components

tim::ompt_components

Definition at line 1382 of file settings.cpp.

Referenced by tim::env::get_user_bundle_variables().

output_path

tim::output_path

Definition at line 1355 of file settings.cpp.

Referenced by tim::settings::compose_input_filename(), kokkosp_init_library(), and timemory_trace_init().

output_prefix

tim::output_prefix

Definition at line 1356 of file settings.cpp.

Referenced by tim::settings::compose_input_filename(), and tim::operation::finalize::ctest_notes_deleter::operator()().

papi_attach

tim::papi_attach

Definition at line 1411 of file settings.cpp.

Referenced by tim::component::papi_common::initialize().

papi_events

tim::papi_events

Definition at line 1410 of file settings.cpp.

Referenced by tim::component::papi_common::get_initializer().

papi_fail_on_error

tim::papi_fail_on_error

Definition at line 1407 of file settings.cpp.

Referenced by tim::component::papi_common::get_initializer().

papi_multiplexing

tim::papi_multiplexing

Definition at line 1405 of file settings.cpp.

Referenced by tim::component::papi_common::initialize().

papi_overflow

tim::papi_overflow

Definition at line 1412 of file settings.cpp.

Referenced by tim::component::papi_common::initialize().

papi_quiet

tim::papi_quiet

Definition at line 1409 of file settings.cpp.

papi_threading

tim::papi_threading

Definition at line 1403 of file settings.cpp.

parser

char argparse::argument_parser * tim::parser

Definition at line 209 of file definition.hpp.

Referenced by for().

plot_output

tim::plot_output

Definition at line 1323 of file settings.cpp.

Referenced by tim::operation::finalize::print< Tp, true >::execute().

pos

size_t tim::pos = std::string::npos

Definition at line 129 of file definition.hpp.

Referenced by tim::operation::finalize::merge< Type, true >::merge(), tim::graph< T, AllocatorT >::begin(), tim::settings::compose_output_filename(), tim::graph< T, AllocatorT >::depth(), tim::graph< T, AllocatorT >::end(), tim::graph< T, AllocatorT >::max_depth(), tim::graph< T, AllocatorT >::iterator_base::number_of_children(), tim::graph< T, AllocatorT >::number_of_children(), tim::graph< T, AllocatorT >::number_of_siblings(), tim::operation::finalize::ctest_notes_deleter::operator()(), and tim::graph< T, AllocatorT >::reparent().

precision

tim::precision

Definition at line 1337 of file settings.cpp.

Referenced by tim::policy::output_archive< cereal::PrettyJSONOutputArchive, Api >::get(), and tim::policy::output_archive< cereal::MinimalJSONOutputArchive, Api >::get().

profiler_components

tim::profiler_components

Definition at line 1390 of file settings.cpp.

Referenced by tim::env::get_user_bundle_variables().

python_exe

tim::python_exe

Definition at line 1477 of file settings.cpp.

return

if argc tim::return

Definition at line 284 of file definition.hpp.

roofline_mode

tim::roofline_mode

Definition at line 1426 of file settings.cpp.

Referenced by tim::component::cpu_roofline< Types >::event_mode(), and tim::component::gpu_roofline< Types >::event_mode().

roofline_type_labels

tim::roofline_type_labels

Definition at line 1436 of file settings.cpp.

Referenced by tim::component::cpu_roofline< Types >::label(), and tim::component::gpu_roofline< Types >::label().

roofline_type_labels_cpu

tim::roofline_type_labels_cpu

Definition at line 1438 of file settings.cpp.

Referenced by tim::component::cpu_roofline< Types >::label().

roofline_type_labels_gpu

tim::roofline_type_labels_gpu

Definition at line 1440 of file settings.cpp.

Referenced by tim::component::gpu_roofline< Types >::label().

scientific

tim::scientific

Definition at line 1340 of file settings.cpp.

separator_frequency

tim::separator_frequency

Definition at line 1479 of file settings.cpp.

Referenced by tim::data::stream::separator_frequency().

stack_clearing

tim::stack_clearing

Definition at line 1369 of file settings.cpp.

suppress_config

tim::suppress_config

Definition at line 1312 of file settings.cpp.

suppress_parsing

tim::suppress_parsing

Definition at line 1310 of file settings.cpp.

text_output

tim::text_output

Definition at line 1318 of file settings.cpp.

Referenced by tim::operation::finalize::print< Tp, true >::execute(), and tim::operation::finalize::print< Tp, true >::setup().

throttle_count

tim::throttle_count

Definition at line 1372 of file settings.cpp.

throttle_value

tim::throttle_value

Definition at line 1374 of file settings.cpp.

time_format

tim::time_format

Definition at line 1336 of file settings.cpp.

time_output

tim::time_output

Definition at line 1322 of file settings.cpp.

timeline_profile

tim::timeline_profile

Definition at line 1492 of file settings.cpp.

timing_precision

tim::timing_precision

Definition at line 1341 of file settings.cpp.

timing_scientific

tim::timing_scientific

Definition at line 1346 of file settings.cpp.

timing_units

tim::timing_units

Definition at line 1344 of file settings.cpp.

Referenced by tim::component::read_char::get_display_unit(), tim::component::written_char::get_display_unit(), tim::component::read_bytes::get_display_unit(), tim::component::written_bytes::get_display_unit(), tim::component::read_char::get_timing_unit(), tim::component::written_char::get_timing_unit(), tim::component::read_bytes::get_timing_unit(), tim::component::written_bytes::get_timing_unit(), tim::component::read_char::get_unit(), tim::component::written_char::get_unit(), tim::component::read_bytes::get_unit(), and tim::component::written_bytes::get_unit().

timing_width

tim::timing_width

Definition at line 1343 of file settings.cpp.

trace_components

tim::trace_components

Definition at line 1388 of file settings.cpp.

Referenced by tim::env::get_user_bundle_variables(), and timemory_trace_init().

tree_output

tim::tree_output

Definition at line 1320 of file settings.cpp.

Referenced by tim::operation::finalize::print< Tp, true >::print(), tim::operation::finalize::print< Tp, true >::execute(), and tim::operation::finalize::print< Tp, true >::update_data().

tuple_components

tim::tuple_components

Definition at line 1378 of file settings.cpp.

upcxx_finalize

tim::upcxx_finalize

Definition at line 1401 of file settings.cpp.

upcxx_init

tim::upcxx_init

Definition at line 1400 of file settings.cpp.

verbose

tim::verbose

Definition at line 1328 of file settings.cpp.

Referenced by tim::operation::finalize::mpi_get< Type, true >::mpi_get(), tim::bundle< Tag, BundleT, TupleT >::~bundle(), tim::component::caliper_common::_init(), tim::component::malloc_gotcha::audit(), tim::component::cpu_roofline< Types >::configure(), tim::component::user_bundle< Idx, Tag >::configure(), tim::component::data_tracker< InpT, Tag >::description(), tim::base::ring_buffer::destroy(), tim::component::cpu_roofline< Types >::event_mode(), tim::component::papi_common::get_initializer(), tim::component::cpu_roofline< Types >::global_finalize(), tim::component::gpu_roofline< Types >::global_finalize(), tim::component::cpu_roofline< Types >::global_init(), tim::component::user_bundle< Idx, Tag >::global_init(), tim::bundle< Tag, BundleT, TupleT >::init(), tim::component::papi_common::initialize(), tim::component::papi_common::initialize_papi(), tim::component::user_bundle< Idx, Tag >::insert(), tim::operation::finalize::mpi_get< Type, true >::operator()(), tim::operation::finalize::upc_get< Type, true >::operator()(), tim::operation::finalize::ctest_notes_deleter::operator()(), tim::ert::ops_main(), tim::plotting::operation::plot(), tim::config::read_command_line(), tim::component::user_bundle< Idx, Tag >::reset(), tim::sampling::sampler< CompT< Types... >, N, SigIds... >::set_delay(), tim::sampling::sampler< CompT< Types... >, N, SigIds... >::set_frequency(), tim::component::cpu_roofline< Types >::thread_init(), timemory_begin_record(), timemory_begin_record_enum(), timemory_begin_record_types(), timemory_end_record(), timemory_get_begin_record(), timemory_get_begin_record_enum(), timemory_get_begin_record_types(), and timemory_init_library().

width

tim::width

Definition at line 1338 of file settings.cpp.

Referenced by tim::operation::finalize::get< Type, true >::operator()().