timemory 3.3.0
Modular C++ Toolkit for Performance Analysis and Logging. Profiling API and Tools for C, C++, CUDA, Fortran, and Python. The C++ template API is essentially a framework to creating tools: it is designed to provide a unifying interface for recording various performance measurements alongside data logging and interfaces to other tools.
Functions
std Namespace Reference

STL namespace. More...

Functions

template<typename Tp >
::tim::statistics< Tp > max (::tim::statistics< Tp > lhs, const Tp &rhs)
 
template<typename Tp >
::tim::statistics< Tp > min (::tim::statistics< Tp > lhs, const Tp &rhs)
 
template<typename Tp >
::tim::statistics< tuple<> > & operator+= (::tim::statistics< tuple<> > &_lhs, const Tp &)
 
template<typename Tp >
tuple & operator+= (tuple<> &_lhs, const Tp &)
 
template<std::size_t N, typename Tag , typename... Types>
std::tuple_element< N, std::tuple< Types... > >::type & get (tim::auto_bundle< Tag, Types... > &obj)
 
template<std::size_t N, typename Tag , typename... Types>
const std::tuple_element< N, std::tuple< Types... > >::type & get (const tim::auto_bundle< Tag, Types... > &obj)
 
template<std::size_t N, typename Tag , typename... Types>
auto get (tim::auto_bundle< Tag, Types... > &&obj) -> decltype(get< N >(std::forward< tim::auto_bundle< Tag, Types... > >(obj).data()))
 
template<std::size_t N, typename... Types>
auto get (tim::auto_list< Types... > &obj) -> decltype(get< N >(obj.data()))
 
template<std::size_t N, typename... Types>
auto get (const tim::auto_list< Types... > &obj) -> decltype(get< N >(obj.data()))
 
template<std::size_t N, typename... Types>
auto get (tim::auto_list< Types... > &&obj) -> decltype(get< N >(std::forward< tim::auto_list< Types... > >(obj).data()))
 
template<std::size_t N, typename... Types>
std::tuple_element< N, std::tuple< Types... > >::type & get (tim::auto_tuple< Types... > &obj)
 
template<std::size_t N, typename... Types>
const std::tuple_element< N, std::tuple< Types... > >::type & get (const tim::auto_tuple< Types... > &obj)
 
template<std::size_t N, typename... Types>
auto get (tim::auto_tuple< Types... > &&obj) -> decltype(get< N >(std::forward< tim::auto_tuple< Types... > >(obj).data()))
 
template<std::size_t N, typename Tag , typename... Types>
std::tuple_element< N, std::tuple< Types... > >::type & get (::tim::component_bundle< Tag, Types... > &obj)
 
template<std::size_t N, typename Tag , typename... Types>
const std::tuple_element< N, std::tuple< Types... > >::type & get (const ::tim::component_bundle< Tag, Types... > &obj)
 
template<std::size_t N, typename Tag , typename... Types>
auto get (::tim::component_bundle< Tag, Types... > &&obj) -> decltype(get< N >(std::forward<::tim::component_bundle< Tag, Types... > >(obj).data()))
 
template<std::size_t N, typename... Types>
std::tuple_element< N, std::tuple< Types... > >::type & get (tim::component_list< Types... > &obj)
 
template<std::size_t N, typename... Types>
const std::tuple_element< N, std::tuple< Types... > >::type & get (const tim::component_list< Types... > &obj)
 
template<std::size_t N, typename... Types>
auto get (tim::component_list< Types... > &&obj) -> decltype(get< N >(std::forward< tim::component_list< Types... > >(obj).data()))
 
template<std::size_t N, typename... Types>
std::tuple_element< N, std::tuple< Types... > >::type & get (::tim::component_tuple< Types... > &obj)
 
template<std::size_t N, typename... Types>
const std::tuple_element< N, std::tuple< Types... > >::type & get (const ::tim::component_tuple< Types... > &obj)
 
template<std::size_t N, typename... Types>
auto get (::tim::component_tuple< Types... > &&obj) -> decltype(get< N >(std::forward<::tim::component_tuple< Types... > >(obj).data()))
 
template<std::size_t N, typename... Types>
std::tuple_element< N, std::tuple< Types... > >::type & get (::tim::lightweight_tuple< Types... > &obj)
 
template<std::size_t N, typename... Types>
const std::tuple_element< N, std::tuple< Types... > >::type & get (const ::tim::lightweight_tuple< Types... > &obj)
 
template<std::size_t N, typename... Types>
auto get (::tim::lightweight_tuple< Types... > &&obj) -> decltype(get< N >(std::forward<::tim::lightweight_tuple< Types... > >(obj).data()))
 

Detailed Description

STL namespace.

Function Documentation

◆ get() [1/21]

template<std::size_t N, typename Tag , typename... Types>
auto std::get ( ::tim::component_bundle< Tag, Types... > &&  obj) -> decltype(get<N>(std::forward<::tim::component_bundle<Tag, Types...>>(obj).data()))

Definition at line 159 of file component_bundle.hpp.

161{
162 using obj_type = ::tim::component_bundle<Tag, Types...>;
163 return get<N>(std::forward<obj_type>(obj).data());
164}
tim::component_bundle
This is a variadic component wrapper which combines the features of tim::component_tuple<T....
Definition: types.hpp:63

◆ get() [2/21]

template<std::size_t N, typename Tag , typename... Types>
std::tuple_element< N, std::tuple< Types... > >::type & std::get ( ::tim::component_bundle< Tag, Types... > &  obj)

Definition at line 141 of file component_bundle.hpp.

142{
143 return get<N>(obj.data());
144}

◆ get() [3/21]

template<std::size_t N, typename... Types>
auto std::get ( ::tim::component_tuple< Types... > &&  obj) -> decltype(get<N>(std::forward<::tim::component_tuple<Types...>>(obj).data()))

Definition at line 160 of file component_tuple.hpp.

162{
163 using obj_type = ::tim::component_tuple<Types...>;
164 return get<N>(std::forward<obj_type>(obj).data());
165}
tim::component_tuple
This is a variadic component wrapper where all components are allocated on the stack and cannot be di...
Definition: component_tuple.hpp:80

◆ get() [4/21]

template<std::size_t N, typename... Types>
std::tuple_element< N, std::tuple< Types... > >::type & std::get ( ::tim::component_tuple< Types... > &  obj)

Definition at line 142 of file component_tuple.hpp.

143{
144 return get<N>(obj.data());
145}

◆ get() [5/21]

template<std::size_t N, typename... Types>
auto std::get ( ::tim::lightweight_tuple< Types... > &&  obj) -> decltype(get<N>(std::forward<::tim::lightweight_tuple<Types...>>(obj).data()))

Definition at line 815 of file lightweight_tuple.hpp.

817{
818 using obj_type = ::tim::lightweight_tuple<Types...>;
819 return get<N>(std::forward<obj_type>(obj).data());
820}
tim::lightweight_tuple
This is a variadic component wrapper which provides the least amount of runtime and compilation overh...
Definition: lightweight_tuple.hpp:70

◆ get() [6/21]

template<std::size_t N, typename... Types>
std::tuple_element< N, std::tuple< Types... > >::type & std::get ( ::tim::lightweight_tuple< Types... > &  obj)

Definition at line 797 of file lightweight_tuple.hpp.

798{
799 return get<N>(obj.data());
800}
tim::lightweight_tuple::data
data_type & data()
get tuple
Definition: lightweight_tuple.cpp:434

References tim::lightweight_tuple< Types >::data().

◆ get() [7/21]

template<std::size_t N, typename Tag , typename... Types>
const std::tuple_element< N, std::tuple< Types... > >::type & std::get ( const ::tim::component_bundle< Tag, Types... > &  obj)

Definition at line 150 of file component_bundle.hpp.

151{
152 return get<N>(obj.data());
153}

◆ get() [8/21]

template<std::size_t N, typename... Types>
const std::tuple_element< N, std::tuple< Types... > >::type & std::get ( const ::tim::component_tuple< Types... > &  obj)

Definition at line 151 of file component_tuple.hpp.

152{
153 return get<N>(obj.data());
154}

◆ get() [9/21]

template<std::size_t N, typename... Types>
const std::tuple_element< N, std::tuple< Types... > >::type & std::get ( const ::tim::lightweight_tuple< Types... > &  obj)

Definition at line 806 of file lightweight_tuple.hpp.

807{
808 return get<N>(obj.data());
809}

◆ get() [10/21]

template<std::size_t N, typename Tag , typename... Types>
const std::tuple_element< N, std::tuple< Types... > >::type & std::get ( const tim::auto_bundle< Tag, Types... > &  obj)

Definition at line 212 of file auto_bundle.hpp.

213{
214 return get<N>(obj.data());
215}

◆ get() [11/21]

template<std::size_t N, typename... Types>
auto std::get ( const tim::auto_list< Types... > &  obj) -> decltype(get<N>(obj.data()))

Definition at line 197 of file auto_list.hpp.

198{
199 return get<N>(obj.data());
200}

◆ get() [12/21]

template<std::size_t N, typename... Types>
const std::tuple_element< N, std::tuple< Types... > >::type & std::get ( const tim::auto_tuple< Types... > &  obj)

Definition at line 175 of file auto_tuple.hpp.

176{
177 return get<N>(obj.data());
178}

◆ get() [13/21]

template<std::size_t N, typename... Types>
const std::tuple_element< N, std::tuple< Types... > >::type & std::get ( const tim::component_list< Types... > &  obj)

Definition at line 169 of file component_list.hpp.

170{
171 return get<N>(obj.data());
172}

◆ get() [14/21]

template<std::size_t N, typename Tag , typename... Types>
auto std::get ( tim::auto_bundle< Tag, Types... > &&  obj) -> decltype(get<N>(std::forward<tim::auto_bundle<Tag, Types...>>(obj).data()))

Definition at line 221 of file auto_bundle.hpp.

223{
224 using obj_type = tim::auto_bundle<Tag, Types...>;
225 return get<N>(std::forward<obj_type>(obj).data());
226}
tim::auto_bundle
This is a variadic component wrapper which combines the features of tim::auto_tuple<T....
Definition: types.hpp:75

◆ get() [15/21]

template<std::size_t N, typename Tag , typename... Types>
std::tuple_element< N, std::tuple< Types... > >::type & std::get ( tim::auto_bundle< Tag, Types... > &  obj)

Definition at line 203 of file auto_bundle.hpp.

204{
205 return get<N>(obj.data());
206}

Referenced by tim::invoke::invoke(), and tim::operation::common_utils::is_empty().

◆ get() [16/21]

template<std::size_t N, typename... Types>
auto std::get ( tim::auto_list< Types... > &&  obj) -> decltype(get<N>(std::forward<tim::auto_list<Types...>>(obj).data()))

Definition at line 206 of file auto_list.hpp.

208{
209 using obj_type = tim::auto_list<Types...>;
210 return get<N>(std::forward<obj_type>(obj).data());
211}
tim::auto_list
This is a variadic component wrapper where all components are optional at runtime....
Definition: auto_list.hpp:91

◆ get() [17/21]

template<std::size_t N, typename... Types>
auto std::get ( tim::auto_list< Types... > &  obj) -> decltype(get<N>(obj.data()))

Definition at line 188 of file auto_list.hpp.

189{
190 return get<N>(obj.data());
191}

◆ get() [18/21]

template<std::size_t N, typename... Types>
auto std::get ( tim::auto_tuple< Types... > &&  obj) -> decltype(get<N>(std::forward<tim::auto_tuple<Types...>>(obj).data()))

Definition at line 184 of file auto_tuple.hpp.

186{
187 using obj_type = tim::auto_tuple<Types...>;
188 return get<N>(std::forward<obj_type>(obj).data());
189}
tim::auto_tuple
This is a variadic component wrapper where all components are allocated on the stack and cannot be di...
Definition: auto_tuple.hpp:65

◆ get() [19/21]

template<std::size_t N, typename... Types>
std::tuple_element< N, std::tuple< Types... > >::type & std::get ( tim::auto_tuple< Types... > &  obj)

Definition at line 166 of file auto_tuple.hpp.

167{
168 return get<N>(obj.data());
169}

◆ get() [20/21]

template<std::size_t N, typename... Types>
auto std::get ( tim::component_list< Types... > &&  obj) -> decltype(get<N>(std::forward<tim::component_list<Types...>>(obj).data()))

Definition at line 178 of file component_list.hpp.

180{
181 using obj_type = tim::component_list<Types...>;
182 return get<N>(std::forward<obj_type>(obj).data());
183}
tim::component_list
This is a variadic component wrapper where all components are optional at runtime....
Definition: component_list.hpp:98

◆ get() [21/21]

template<std::size_t N, typename... Types>
std::tuple_element< N, std::tuple< Types... > >::type & std::get ( tim::component_list< Types... > &  obj)

Definition at line 160 of file component_list.hpp.

161{
162 return get<N>(obj.data());
163}

◆ max()

template<typename Tp >
::tim::statistics< Tp > std::max ( ::tim::statistics< Tp >  lhs,
const Tp &  rhs 
)

Definition at line 320 of file statistics.hpp.

321{
322 return lhs.get_max(rhs);
323}
tim::statistics::get_max
const value_type & get_max() const
Definition: statistics.hpp:129

References tim::statistics< Tp >::get_max().

Referenced by tim::trace::lock< Tp, true >::acquire(), tim::trace::lock< Tp, false >::acquire(), kokkosp_begin_fence(), kokkosp_begin_parallel_for(), kokkosp_begin_parallel_reduce(), kokkosp_begin_parallel_scan(), tim::graph< T, AllocatorT >::max_depth(), tim::operation::finalize::get< Type, true >::operator()(), tim::popen::pclose(), tim::component::current_peak_rss::stop(), tim::component::peak_rss::stop(), 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(), timemory_pop_trace(), and timemory_push_trace().

◆ min()

template<typename Tp >
::tim::statistics< Tp > std::min ( ::tim::statistics< Tp >  lhs,
const Tp &  rhs 
)

Definition at line 329 of file statistics.hpp.

330{
331 return lhs.get_min(rhs);
332}
tim::statistics::get_min
const value_type & get_min() const
Definition: statistics.hpp:128

References tim::statistics< Tp >::get_min().

Referenced by tim::operation::compose< RetType, LhsType, RhsType >::generate(), and tim::component::craypat_counters::record().

◆ operator+=() [1/2]

template<typename Tp >
::tim::statistics< tuple<> > & std::operator+= ( ::tim::statistics< tuple<> > &  _lhs,
const Tp &   
)

Definition at line 338 of file statistics.hpp.

339{
340 return _lhs;
341}

Referenced by tim::api_bundle< ApiT, type_list< Types... > >::operator+=(), and tim::bundle< Tag, BundleT, TupleT >::operator+=().

◆ operator+=() [2/2]

template<typename Tp >
tuple & std::operator+= ( tuple<> &  _lhs,
const Tp &   
)

Definition at line 516 of file stl.hpp.

517{
518 return _lhs;
519}