#include "timemory/compat/macros.h"
#include "timemory/hash/types.hpp"
#include "timemory/macros/attributes.hpp"
#include "timemory/macros/os.hpp"
#include "timemory/mpl/concepts.hpp"
#include "timemory/utility/macros.hpp"
#include <array>
#include <bitset>
#include <functional>
#include <initializer_list>
#include <memory>
#include <ostream>
#include <sstream>
#include <string>
#include <type_traits>

Include dependency graph for types.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	tim::identity< T >

struct	tim::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	tim::type_list< Tp >
	lightweight tuple-alternative for meta-programming logic More...

struct	tim::crtp::base
	a generic type for prioritizing a function call to the base class over derived functions, e.g. void start(crtp::base, Args&&... args) { start(args...); } More...

struct	tim::mpl::lightweight
	a generic type for indicating that function call or constructor should be as lightweight as possible. More...

struct	tim::mpl::piecewise_select< Tp >

struct	tim::mpl::piecewise_ignore< Tp >

struct	tim::scope::tree
	Dummy struct to designates tree (hierarchical) storage. This scope (default) maintains nesting in the call-graph storage. In this scoping mode, the results will be separated from each other based on the identifier AND the current number of component instances in a "start" region. E.g. for two components with the same identifiers where the first calls start, then the second calls start then the second will be at a depth of +1 relative to the first (i.e. a child of the first). More...

struct	tim::scope::flat
	Dummy struct to designates flat (no hierarchy) storage. When flat scoping is globally enabled, all entries to the call-graph storage at entered at a depth of zero. Thus, if you want a report of all the function calls and their total values for each identifier, flat scoping should be globally enabled. This can be combined with timeline scoping to produce results where every measurement is its own call-graph entry at a depth of zero (produces a large amount of data). Flat-scoping can be enabled at the component bundler level also, there are two ways to do this: (1) to enable flat-scoping for all instances of the bundle, add tim::quirk::flat_scope to the template parameters of the bundler; (2) to enable flat-scoping for specific bundler instances, pass. More...

struct	tim::scope::timeline
	Dummy struct to designates timeline (hierarchical, non-duplicated) storage. It is meaningless by itself and should be combined with tim::scope::tree or tim::scope::flat. A tree timeline has all the hierarchy properties of the tree scope but entries at the same depth with the same identifiers are separated entries in the resuls. Timeline-scoping can be enabled at the component bundler level also, there are two ways to do this: (1) to enable timeline-scoping for all instances of the bundle, add tim::quirk::timeline_scope to the template parameters of the bundler; (2) to enable timeline-scoping for specific bundler instances, pass. More...

struct	tim::scope::config
	this data type encodes the options of storage scope. The default is hierarchical (tree) scope. Specification of flat scope overrides the hierarchy scope, e.g. you cannot have a hierarchical flat scope. The timeline scope is meaningless should a specification of tree or flat, thus the valid combinations are: tree, flat, tree + timeline, flat + timeline. More...

struct	tim::scope::destructor
	provides an object which can be returned from functions that will execute the lambda provided during construction when it is destroyed More...

struct	tim::lifetime::scoped
	Dummy struct for meta-programming to designate that a component activates it's features at the first start() invocation and deactivates it's features when all instances that called start() have called stop(). Thus, the component's features are dependent on at least one component instance existing in memory (excluding the instances in the call-graph, which never call start/stop) More...

struct	tim::lifetime::persistent
	Dummy struct for meta-programming to designate that a component activates its features in {global,thread}_init and deactivates it's features in {global,thead}_finalize. More...

struct	tim::audit::incoming
	Used by component audit member function to designate the parameters being passed are incoming (e.g. before a gotcha wrappee is invoked) More...

struct	tim::audit::outgoing
	Used by component audit member function to designate the parameters being passed are outgoing (e.g. the return value from a gotcha wrappee) More...

Namespaces
namespace	tim

namespace	tim::cupti

namespace	tim::crtp

namespace	tim::mpl

namespace	tim::scope

namespace	tim::lifetime

namespace	tim::audit

namespace	std
	STL namespace.

namespace	tim::cereal

namespace	tim::cereal::detail

Macros
#define	TIMEMORY_FOLD_EXPRESSION(...) ::tim::consume_parameters(::std::initializer_list<int>{ (__VA_ARGS__, 0)... })

#define	TIMEMORY_FOLD_EXPANSION(TYPE, SIZE, ...) std::array<TYPE, SIZE>({ (::tim::consume_parameters(), __VA_ARGS__)... });

#define	TIMEMORY_RETURN_FOLD_EXPRESSION(...) ::std::make_tuple((::tim::consume_parameters(), __VA_ARGS__)...)

#define	TIMEMORY_DECLARE_EXTERN_TEMPLATE(...) extern template __VA_ARGS__;

#define	TIMEMORY_INSTANTIATE_EXTERN_TEMPLATE(...) template __VA_ARGS__;

#define	TIMEMORY_ESC(...) __VA_ARGS__

#define	TIMEMORY_DELETED_OBJECT(NAME)

#define	TIMEMORY_DELETE_COPY_MOVE_OBJECT(NAME)

#define	TIMEMORY_DEFAULT_MOVE_ONLY_OBJECT(NAME)

#define	TIMEMORY_EXCEPTION(...)

#define	TIMEMORY_TESTING_EXCEPTION(...) {}

#define	TIMEMORY_TUPLE_ACCESSOR(INDEX, TUPLE, NAME)

#define	TIMEMORY_SET_CLASS_VERSION(VERSION_NUMBER, ...)

#define	TIMEMORY_GET_CLASS_VERSION(...) ::tim::cereal::detail::StaticVersion<__VA_ARGS__>::version

Typedefs
template<typename Tp , Tp Num>
using	tim::make_integer_sequence = std::make_integer_sequence< Tp, Num >
	Alias template make_integer_sequence. More...

template<size_t... Idx>
using	tim::index_sequence = std::integer_sequence< size_t, Idx... >
	Alias template index_sequence. More...

template<size_t Num>
using	tim::make_index_sequence = std::make_integer_sequence< size_t, Num >
	Alias template make_index_sequence. More...

template<typename... Types>
using	tim::index_sequence_for = std::make_index_sequence< sizeof...(Types)>
	Alias template index_sequence_for. More...

template<bool B, typename T = int>
using	tim::enable_if_t = typename std::enable_if< B, T >::type
	Alias template for enable_if. More...

template<typename T >
using	tim::decay_t = typename std::decay< T >::type
	Alias template for decay. More...

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

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

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

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

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

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

using	tim::scope::data_type = std::bitset< scope_count >

using	tim::scope::input_type = std::array< bool, scope_count >

Functions
template<typename... ArgsT>
void	tim::consume_parameters (ArgsT &&...)

input_type &	tim::scope::get_fields ()

config	tim::scope::operator+ (config _lhs, tree)

config	tim::scope::operator+ (config _lhs, flat)

config	tim::scope::operator+ (config _lhs, timeline)

config	tim::scope::operator+ (config _lhs, config _rhs)

Detailed Description

Declaration of types for utility directory

Definition in file types.hpp.

Class Documentation

◆ 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::crtp::base

struct tim::crtp::base

a generic type for prioritizing a function call to the base class over derived functions, e.g. void start(crtp::base, Args&&... args) { start(args...); }

Definition at line 310 of file types.hpp.

Collaboration diagram for tim::crtp::base:

◆ tim::mpl::lightweight

struct tim::mpl::lightweight

a generic type for indicating that function call or constructor should be as lightweight as possible.

Definition at line 327 of file types.hpp.

Collaboration diagram for tim::mpl::lightweight:

◆ tim::mpl::piecewise_select

struct tim::mpl::piecewise_select

template<typename... Tp>
struct tim::mpl::piecewise_select< Tp >

Definition at line 333 of file types.hpp.

Collaboration diagram for tim::mpl::piecewise_select< Tp >:

◆ tim::mpl::piecewise_ignore

struct tim::mpl::piecewise_ignore

template<typename... Tp>
struct tim::mpl::piecewise_ignore< Tp >

Definition at line 337 of file types.hpp.

Collaboration diagram for tim::mpl::piecewise_ignore< Tp >:

◆ tim::lifetime::scoped

struct tim::lifetime::scoped

Dummy struct for meta-programming to designate that a component activates it's features at the first start() invocation and deactivates it's features when all instances that called start() have called stop(). Thus, the component's features are dependent on at least one component instance existing in memory (excluding the instances in the call-graph, which never call start/stop)

Definition at line 751 of file types.hpp.

Collaboration diagram for tim::lifetime::scoped:

◆ tim::lifetime::persistent

struct tim::lifetime::persistent

Dummy struct for meta-programming to designate that a component activates its features in {global,thread}_init and deactivates it's features in {global,thead}_finalize.

Definition at line 761 of file types.hpp.

Collaboration diagram for tim::lifetime::persistent:

Macro Definition Documentation

◆ TIMEMORY_DECLARE_EXTERN_TEMPLATE

#define TIMEMORY_DECLARE_EXTERN_TEMPLATE ( ... ) extern template __VA_ARGS__;

Definition at line 78 of file types.hpp.

◆ TIMEMORY_DEFAULT_MOVE_ONLY_OBJECT

#define TIMEMORY_DEFAULT_MOVE_ONLY_OBJECT ( NAME )

Value:

        NAME(const NAME&)     = delete;                                                  \
        NAME(NAME&&) noexcept = default;                                                 \
        NAME& operator=(const NAME&) = delete;                                           \
        NAME& operator=(NAME&&) noexcept = default;

Definition at line 117 of file types.hpp.

◆ TIMEMORY_DELETE_COPY_MOVE_OBJECT

#define TIMEMORY_DELETE_COPY_MOVE_OBJECT ( NAME )

Value:

        NAME(const NAME&) = delete;                                                      \
        NAME(NAME&&)      = delete;                                                      \
        NAME& operator=(const NAME&) = delete;                                           \
        NAME& operator=(NAME&&) = delete;

Definition at line 107 of file types.hpp.

◆ TIMEMORY_DELETED_OBJECT

#define TIMEMORY_DELETED_OBJECT ( NAME )

Value:

        NAME()            = delete;                                                      \
        NAME(const NAME&) = delete;                                                      \
        NAME(NAME&&)      = delete;                                                      \
        NAME& operator=(const NAME&) = delete;                                           \
        NAME& operator=(NAME&&) = delete;

Definition at line 96 of file types.hpp.

◆ TIMEMORY_ESC

#define TIMEMORY_ESC ( ... ) __VA_ARGS__

Definition at line 90 of file types.hpp.

◆ TIMEMORY_EXCEPTION

#define TIMEMORY_EXCEPTION ( ... )

Value:

        {                                                                                \
            std::stringstream _errmsg;                                                   \
            _errmsg << __VA_ARGS__;                                                      \
            perror(_errmsg.str().c_str());                                               \
            std::cerr << _errmsg.str() << std::endl;                                     \
            std::exit(EXIT_FAILURE);                                                     \
        }

Definition at line 138 of file types.hpp.

◆ TIMEMORY_FOLD_EXPANSION

#define TIMEMORY_FOLD_EXPANSION	(	TYPE,
		SIZE,
		...
	)	std::array<TYPE, SIZE>({ (::tim::consume_parameters(), __VA_ARGS__)... });

Definition at line 64 of file types.hpp.

◆ TIMEMORY_FOLD_EXPRESSION

#define TIMEMORY_FOLD_EXPRESSION ( ... ) ::tim::consume_parameters(::std::initializer_list<int>{ (__VA_ARGS__, 0)... })

Definition at line 56 of file types.hpp.

◆ TIMEMORY_GET_CLASS_VERSION

#define TIMEMORY_GET_CLASS_VERSION ( ... ) ::tim::cereal::detail::StaticVersion<__VA_ARGS__>::version

Definition at line 844 of file types.hpp.

◆ TIMEMORY_INSTANTIATE_EXTERN_TEMPLATE

#define TIMEMORY_INSTANTIATE_EXTERN_TEMPLATE ( ... ) template __VA_ARGS__;

Definition at line 84 of file types.hpp.

◆ TIMEMORY_RETURN_FOLD_EXPRESSION

#define TIMEMORY_RETURN_FOLD_EXPRESSION ( ... ) ::std::make_tuple((::tim::consume_parameters(), __VA_ARGS__)...)

Definition at line 71 of file types.hpp.

◆ TIMEMORY_SET_CLASS_VERSION

#define TIMEMORY_SET_CLASS_VERSION	(	VERSION_NUMBER,
		...
	)

Value:

        namespace tim                                                                    \
        {                                                                                \
        namespace cereal                                                                 \
        {                                                                                \
        namespace detail                                                                 \
        {                                                                                \
        template <>                                                                      \
        struct StaticVersion<__VA_ARGS__>                                                \
        {                                                                                \
            static constexpr std::uint32_t version = VERSION_NUMBER;                     \
        };                                                                               \
        }                                                                                \
        }                                                                                \
        }

Definition at line 826 of file types.hpp.

◆ TIMEMORY_TESTING_EXCEPTION

#define TIMEMORY_TESTING_EXCEPTION ( ... ) {}

Definition at line 156 of file types.hpp.

◆ TIMEMORY_TUPLE_ACCESSOR

#define TIMEMORY_TUPLE_ACCESSOR	(	INDEX,
		TUPLE,
		NAME
	)

Value:

auto& NAME() { return std::get<INDEX>(TUPLE); } \

const auto& NAME() const { return std::get<INDEX>(TUPLE); }

Definition at line 163 of file types.hpp.

Classes

Namespaces

Macros

Typedefs

Functions

Detailed Description

Class Documentation

◆ tim::identity

◆ tim::type_list

◆ tim::crtp::base

◆ tim::mpl::lightweight

◆ tim::mpl::piecewise_select

◆ tim::mpl::piecewise_ignore

◆ tim::lifetime::scoped

◆ tim::lifetime::persistent

Macro Definition Documentation

◆ TIMEMORY_DECLARE_EXTERN_TEMPLATE

◆ TIMEMORY_DEFAULT_MOVE_ONLY_OBJECT

◆ TIMEMORY_DELETE_COPY_MOVE_OBJECT

◆ TIMEMORY_DELETED_OBJECT

◆ TIMEMORY_ESC

◆ TIMEMORY_EXCEPTION

◆ TIMEMORY_FOLD_EXPANSION

◆ TIMEMORY_FOLD_EXPRESSION

◆ TIMEMORY_GET_CLASS_VERSION

◆ TIMEMORY_INSTANTIATE_EXTERN_TEMPLATE

◆ TIMEMORY_RETURN_FOLD_EXPRESSION

◆ TIMEMORY_SET_CLASS_VERSION

◆ TIMEMORY_TESTING_EXCEPTION

◆ TIMEMORY_TUPLE_ACCESSOR