tim::scope::config Struct Reference

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...

#include "timemory/utility/types.hpp"

Collaboration diagram for tim::scope::config:

Public Member Functions
	config ()
	config (const data_type &obj)
	config (data_type &&obj) noexcept
	config (bool _flat)
	config (bool _flat, bool _timeline)
	config (bool _flat, bool _timeline, bool _tree)
	config (tree)
	config (flat)
	config (timeline)
template<typename Arg , typename... Args, std::enable_if_t<(std::is_same< Arg, tree >::value||std::is_same< Arg, flat >::value||std::is_same< Arg, timeline >::value), int > = 0>
	config (Arg &&arg, Args &&... args)
	~config ()=default
	config (const config &)=default
	config (config &&) noexcept=default
config &	operator= (const config &)=default
config &	operator= (config &&) noexcept=default
config &	operator= (const data_type &rhs)
config &	operator= (data_type &&rhs) noexcept
template<typename T , std::enable_if_t<(std::is_same< T, tree >::value||std::is_same< T, flat >::value||std::is_same< T, timeline >::value), int > = 0>
config &	operator+= (T)
template<typename T , std::enable_if_t<(std::is_same< T, tree >::value||std::is_same< T, flat >::value||std::is_same< T, timeline >::value), int > = 0>
config &	set (bool val=true)
bool	is_flat () const
bool	is_timeline () const
bool	is_tree () const
bool	is_flat_timeline () const
bool	is_tree_timeline () const
template<bool ForceFlatT>
bool	is_flat () const
template<bool ForceTreeT, bool ForceTimeT>
bool	is_tree () const
template<typename ForceTreeT = false_type, typename ForceFlatT = false_type, typename ForceTimeT = false_type>
uint64_t	compute_depth (uint64_t _current)
template<typename ForceTreeT = false_type, typename ForceFlatT = false_type, typename ForceTimeT = false_type>
uint64_t	compute_hash (uint64_t _id, uint64_t _depth, uint64_t &_counter)

Friends
std::ostream &	operator<< (std::ostream &os, const config &obj)

Detailed Description

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.

Definition at line 445 of file types.hpp.

Constructor & Destructor Documentation

config() [1/12]

tim::scope::config::config ( )

inline

Definition at line 447 of file types.hpp.

    : data_type(get_default_bitset())
    {}

config() [2/12]

tim::scope::config::config ( const data_type &  obj )

inlineexplicit

Definition at line 451 of file types.hpp.

    : data_type(obj)
    {}

config() [3/12]

tim::scope::config::config ( data_type &&  obj )

inlineexplicitnoexcept

Definition at line 455 of file types.hpp.

    : data_type(std::forward<data_type>(obj))
    {}

config() [4/12]

tim::scope::config::config ( bool  _flat )

inlineexplicit

Definition at line 459 of file types.hpp.

    : data_type(generate(input_type{ { _flat, false, false } },
                         make_index_sequence<scope_count>{}))
    {}

config() [5/12]

tim::scope::config::config ( bool  _flat, bool  _timeline  )

inlineexplicit

Definition at line 464 of file types.hpp.

    : data_type(generate(input_type{ { _flat, _timeline, false } },
                         make_index_sequence<scope_count>{}))
    {}

config() [6/12]

tim::scope::config::config ( bool  _flat, bool  _timeline, bool  _tree  )

inlineexplicit

Definition at line 469 of file types.hpp.

    : data_type(generate(input_type{ { _flat, _timeline, _tree } },
                         make_index_sequence<scope_count>{}))
    {}

config() [7/12]

tim::scope::config::config ( tree  )

inline

Definition at line 474 of file types.hpp.

    : config(false, false, false)
    {}

config() [8/12]

tim::scope::config::config ( flat  )

inline

Definition at line 478 of file types.hpp.

    : config(true, false, false)
    {}

config() [9/12]

tim::scope::config::config ( timeline  )

inline

Definition at line 482 of file types.hpp.

    : config(false, true, false)
    {}

config() [10/12]

template<typename Arg , typename... Args, std::enable_if_t<(std::is_same< Arg, tree >::value||std::is_same< Arg, flat >::value||std::is_same< Arg, timeline >::value), int > = 0>

tim::scope::config::config ( Arg &&  arg, Args &&...  args  )

inlineexplicit

Definition at line 491 of file types.hpp.

    {
        *this += std::forward<Arg>(arg);
        TIMEMORY_FOLD_EXPRESSION(*this += std::forward<Args>(args));
    }

References TIMEMORY_FOLD_EXPRESSION.

~config()

tim::scope::config::~config ( )

default

config() [11/12]

tim::scope::config::config ( const config &  )

default

config() [12/12]

tim::scope::config::config ( config &&  )

defaultnoexcept

Member Function Documentation

compute_depth()

template<typename ForceTreeT = false_type, typename ForceFlatT = false_type, typename ForceTimeT = false_type>

uint64_t tim::scope::config::compute_depth ( uint64_t  _current )

inline

Definition at line 586 of file types.hpp.

    {
        static_assert(!(ForceTreeT::value && ForceFlatT::value),
                      "Error! Type cannot enforce tree-based call-stack depth storage "
                      "and flat call-stack depth storage simulatenously");
        // flat:     always at depth of 1
        // tree:     features nesting
        // timeline: features nesting if not flat and depth of 1 if flat
        if(ForceFlatT::value || is_flat())
        {
            // flat + timeline will be differentiated via compute_hash
            // flat + tree is invalid and flat takes precedence
            // printf("compute_depth is flat at %i\n", (int) _current);
            return 1;
        }
        // if not flat, return the nested depth and compute_hash will account
        // for whether the entry is a duplicate or not
        // printf("compute_depth is tree or timeline at %i\n", (int) _current);
        return _current + 1;
    }

compute_hash()

template<typename ForceTreeT = false_type, typename ForceFlatT = false_type, typename ForceTimeT = false_type>

uint64_t tim::scope::config::compute_hash ( uint64_t  _id, uint64_t  _depth, uint64_t &  _counter  )

inline

Definition at line 609 of file types.hpp.

    {
        // flat/tree:  always compute the same hash for a given depth and key
        // timeline:   uses a counter to differentiate idential hashes occurring at diff
        //             time points.
        // below is a fall-through (i.e. not an if-else) bc either tree or flat can be
        // combined with timeline but in the case of tree + flat, flat will take
        // precedence.
        if(is_tree<ForceTreeT::value, ForceTimeT::value>() ||
           is_flat<ForceFlatT::value>())
        {
            // printf("compute_hash is tree or flat at %i\n", (int) _depth);
            _id = get_combined_hash_id(_id, _depth);
            // _id ^= _depth;
        }
        if(ForceTimeT::value || is_timeline())
        {
            // printf("compute_hash is timeline at %i\n", (int) _depth);
            _id = get_combined_hash_id(_id, _counter++);
            // _id ^= _counter++;
        }
        // printf("compute_hash is %i at depth %i (counter = %i)\n", (int) _id, (int)
        // _depth,
        //       (int) _counter);
        return _id;
    }

References tim::get_combined_hash_id().

is_flat() [1/2]

bool tim::scope::config::is_flat ( ) const

inline

Definition at line 539 of file types.hpp.

{ return this->test(flat::value); }

is_flat() [2/2]

template<bool ForceFlatT>

bool tim::scope::config::is_flat ( ) const

inline

Definition at line 557 of file types.hpp.

    {
        return (ForceFlatT) ? true : this->test(flat::value);
    }

is_flat_timeline()

bool tim::scope::config::is_flat_timeline ( ) const

inline

Definition at line 547 of file types.hpp.

    {
        return (is_flat() && is_timeline());
    }

is_timeline()

bool tim::scope::config::is_timeline ( ) const

inline

Definition at line 540 of file types.hpp.

{ return this->test(timeline::value); }

is_tree() [1/2]

bool tim::scope::config::is_tree ( ) const

inline

Definition at line 543 of file types.hpp.

    {
        return this->none() || (this->test(tree::value) && !this->test(flat::value));
    }

is_tree() [2/2]

template<bool ForceTreeT, bool ForceTimeT>

bool tim::scope::config::is_tree ( ) const

inline

Definition at line 563 of file types.hpp.

    {
        return (ForceTreeT)
                   ? true
                   : ((ForceTimeT) ? false
                                   : (this->none() || (this->test(tree::value) &&
                                                       !this->test(flat::value))));
    }

is_tree_timeline()

bool tim::scope::config::is_tree_timeline ( ) const

inline

Definition at line 551 of file types.hpp.

    {
        return (is_tree() && is_timeline());
    }

operator+=()

template<typename T , std::enable_if_t<(std::is_same< T, tree >::value||std::is_same< T, flat >::value||std::is_same< T, timeline >::value), int > = 0>

config& tim::scope::config::operator+= ( T  )

inline

Definition at line 521 of file types.hpp.

    {
        this->data_type::set(T::value, true);
        return *this;
    }

operator=() [1/4]

config& tim::scope::config::operator= ( config &&  )

defaultnoexcept

operator=() [2/4]

config& tim::scope::config::operator= ( const config &  )

default

operator=() [3/4]

config& tim::scope::config::operator= ( const data_type &  rhs )

inline

Definition at line 503 of file types.hpp.

    {
        if(this != &rhs)
            data_type::operator=(rhs);
        return *this;
    }

operator=() [4/4]

config& tim::scope::config::operator= ( data_type &&  rhs )

inlinenoexcept

Definition at line 510 of file types.hpp.

    {
        if(this != &rhs)
            data_type::operator=(std::forward<data_type>(rhs));
        return *this;
    }

set()

template<typename T , std::enable_if_t<(std::is_same< T, tree >::value||std::is_same< T, flat >::value||std::is_same< T, timeline >::value), int > = 0>

config& tim::scope::config::set ( bool  val = true )

inline

Definition at line 533 of file types.hpp.

    {
        this->data_type::set(T::value, val);
        return *this;
    }

Referenced by tim::scope::operator+().

Friends And Related Function Documentation

operator<<

std::ostream& operator<< ( std::ostream &  os, const config &  obj  )

friend

Definition at line 572 of file types.hpp.

    {
        std::stringstream ss;
        ss << std::boolalpha << "tree: " << obj.is_tree() << ", flat: " << obj.is_flat()
           << ", timeline: " << obj.is_timeline()
           << ". Values: flat::value = " << obj.test(flat::value)
           << ", timeline::value = " << obj.test(timeline::value)
           << ", tree::value = " << obj.test(tree::value);
        os << ss.str();
        return os;
    }

---

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

• timemory/utility/types.hpp