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.
Public Types | Static Public Member Functions | List of all members
tim::mpl::apply< void > Struct Reference

#include "timemory/mpl/apply.hpp"

+ Collaboration diagram for tim::mpl::apply< void >:

Public Types

using Ret = void
 
template<size_t I, typename A >
using Access_t = typename std::tuple_element< I, A >::type
 

Static Public Member Functions

template<typename Fn , typename... Args, size_t N = sizeof...(Args)>
static Ret invoke (Fn &&__f, Args &&... __args) noexcept
 
template<typename Fn , template< typename... > class Tuple, typename... Args, size_t N = sizeof...(Args)>
static Ret invoke (Fn &&__f, Tuple< Args... > &&__t) noexcept
 
template<typename Tuple , size_t N = std::tuple_size<Tuple>::value>
static void plus (Tuple &_lhs, const Tuple &_rhs) noexcept
 
template<typename Tuple , size_t N = std::tuple_size<Tuple>::value>
static void minus (Tuple &_lhs, const Tuple &_rhs) noexcept
 
template<size_t N, typename Device , typename Func , typename... Args, enable_if_t< std::is_same< Device, device::gpu >::value, char > = 0>
static void unroll (Func &&__func, Args &&... __args) noexcept
 
template<size_t N, typename Device , typename Func , typename... Args, enable_if_t< std::is_same< Device, device::cpu >::value, char > = 0>
static void unroll (Func &&__func, Args &&... __args) noexcept
 
template<typename Tp , typename Value >
static auto set_value_fold (Tp &&_t, int, Value &&_v) noexcept -> decltype(std::forward< Tp >(_t)=std::forward< Value >(_v), void())
 
template<typename Tp , typename Value >
static void set_value_fold (Tp &&, long, Value &&) noexcept
 
template<typename Tuple , typename Value , size_t... Idx>
static void set_value_fold (Tuple &&_t, Value &&_v, index_sequence< Idx... >) noexcept
 
template<typename Tuple , typename Value >
static void set_value (Tuple &&_t, Value &&_v) noexcept
 
template<typename Access , typename Tuple , size_t... Idx, typename... Args>
static void access_fold (Tuple &&_t, index_sequence< Idx... >, Args &&... _args)
 
template<typename Access , typename Tuple , typename... Args>
static void access (Tuple &&__t, Args &&... __args) noexcept
 
template<typename Access , size_t... Idx, typename... Args>
static auto get_fold (index_sequence< Idx... >, Args &&... _args)
 
template<typename Access , typename... Args>
static auto get (Args &&... __args)
 
template<typename Access , typename Tuple , typename... Args>
static void access_with_indices (Tuple &&__t, Args &&... __args) noexcept
 
template<typename Access , typename TupleA , typename TupleB , typename... Args>
static void access2 (TupleA &&__ta, TupleB &&__tb, Args &&... __args) noexcept
 
template<template< typename > class Access, typename Tuple , typename... Args>
static void unroll_access (Tuple &&__t, Args &&... __args) noexcept
 
template<template< typename > class Access, typename Tuple , typename... Args>
static void type_access (Args &&... __args) noexcept
 

Detailed Description

Definition at line 486 of file apply.hpp.

Member Typedef Documentation

◆ Access_t

template<size_t I, typename A >
using tim::mpl::apply< void >::Access_t = typename std::tuple_element<I, A>::type

Definition at line 493 of file apply.hpp.

◆ Ret

using tim::mpl::apply< void >::Ret = void

Definition at line 488 of file apply.hpp.

Member Function Documentation

◆ access()

template<typename Access , typename Tuple , typename... Args>
static void tim::mpl::apply< void >::access ( Tuple &&  __t,
Args &&...  __args 
)
inlinestaticnoexcept

Definition at line 602 of file apply.hpp.

603 {
604 constexpr auto N = std::tuple_size<decay_t<Access>>::value;
605 constexpr auto Nt = std::tuple_size<decay_t<Tuple>>::value;
606 static_assert(N == Nt, "Cannot fold Access from Tuple because sizes differ");
607 access_fold<Access>(std::forward<Tuple>(__t), std::make_index_sequence<N>{},
608 std::forward<Args>(__args)...);
609 }

◆ access2()

template<typename Access , typename TupleA , typename TupleB , typename... Args>
static void tim::mpl::apply< void >::access2 ( TupleA &&  __ta,
TupleB &&  __tb,
Args &&...  __args 
)
inlinestaticnoexcept

Definition at line 645 of file apply.hpp.

647 {
648 constexpr size_t N = std::tuple_size<decay_t<Access>>::value;
649 constexpr size_t Na = std::tuple_size<decay_t<TupleA>>::value;
650 constexpr size_t Nb = std::tuple_size<decay_t<TupleB>>::value;
651 static_assert(Na == Nb, "tuple A size must match tuple B size");
652 internal::apply<void>::template apply_access2<Access, TupleA, TupleB, Args...>(
653 std::forward<TupleA>(__ta), std::forward<TupleB>(__tb),
654 make_index_sequence<N>{}, std::forward<Args>(__args)...);
655 }

◆ access_fold()

template<typename Access , typename Tuple , size_t... Idx, typename... Args>
static void tim::mpl::apply< void >::access_fold ( Tuple &&  _t,
index_sequence< Idx... >  ,
Args &&...  _args 
)
inlinestatic

Definition at line 592 of file apply.hpp.

594 {
595 TIMEMORY_FOLD_EXPRESSION(
596 Access_t<Idx, Access>(std::get<Idx>(_t), std::forward<Args>(_args)...));
597 }
tim::_args
std::array< char *, 4 > _args
Definition: launch_process.cpp:50
TIMEMORY_FOLD_EXPRESSION
#define TIMEMORY_FOLD_EXPRESSION(...)
Definition: types.hpp:56

References tim::_args, and TIMEMORY_FOLD_EXPRESSION.

◆ access_with_indices()

template<typename Access , typename Tuple , typename... Args>
static void tim::mpl::apply< void >::access_with_indices ( Tuple &&  __t,
Args &&...  __args 
)
inlinestaticnoexcept

Definition at line 633 of file apply.hpp.

635 {
636 constexpr auto N = std::tuple_size<decay_t<Tuple>>::value;
637 internal::apply<void>::template apply_access_with_indices<Access, Tuple, Args...>(
638 std::forward<Tuple>(__t), make_index_sequence<N>{},
639 std::forward<Args>(__args)...);
640 }

◆ get()

template<typename Access , typename... Args>
static auto tim::mpl::apply< void >::get ( Args &&...  __args)
inlinestatic

Definition at line 623 of file apply.hpp.

624 {
625 constexpr auto N = std::tuple_size<decay_t<Access>>::value;
626 return get_fold<Access>(std::make_index_sequence<N>{},
627 std::forward<Args>(__args)...);
628 }

◆ get_fold()

template<typename Access , size_t... Idx, typename... Args>
static auto tim::mpl::apply< void >::get_fold ( index_sequence< Idx... >  ,
Args &&...  _args 
)
inlinestatic

Definition at line 614 of file apply.hpp.

615 {
616 return std::make_tuple(
617 Access_t<Idx, Access>::get(std::forward<Args>(_args)...)...);
618 }
tim::get
auto get(const auto_bundle< Tag, Types... > &_obj)
Definition: auto_bundle.hpp:152

References tim::_args.

◆ invoke() [1/2]

template<typename Fn , typename... Args, size_t N = sizeof...(Args)>
static Ret tim::mpl::apply< void >::invoke ( Fn &&  __f,
Args &&...  __args 
)
inlinestaticnoexcept

Definition at line 499 of file apply.hpp.

500 {
501 __f(std::forward<Args>(__args)...);
502 }

◆ invoke() [2/2]

template<typename Fn , template< typename... > class Tuple, typename... Args, size_t N = sizeof...(Args)>
static Ret tim::mpl::apply< void >::invoke ( Fn &&  __f,
Tuple< Args... > &&  __t 
)
inlinestaticnoexcept

Definition at line 509 of file apply.hpp.

510 {
511 using Tuple_t = Tuple<Args...>;
512 internal::apply<Ret>::template invoke<Fn, Tuple_t>(
513 std::forward<Fn>(__f), std::forward<Tuple_t>(__t), make_index_sequence<N>{});
514 }

◆ minus()

template<typename Tuple , size_t N = std::tuple_size<Tuple>::value>
static void tim::mpl::apply< void >::minus ( Tuple &  _lhs,
const Tuple &  _rhs 
)
inlinestaticnoexcept

Definition at line 529 of file apply.hpp.

530 {
531 math::minus(_lhs, _rhs);
532 }
tim::math::minus
Tp & minus(Tp &, const Up &)
Definition: minus.hpp:98

References tim::math::minus().

◆ plus()

template<typename Tuple , size_t N = std::tuple_size<Tuple>::value>
static void tim::mpl::apply< void >::plus ( Tuple &  _lhs,
const Tuple &  _rhs 
)
inlinestaticnoexcept

Definition at line 520 of file apply.hpp.

521 {
522 math::plus(_lhs, _rhs);
523 }
tim::math::plus
Tp & plus(Tp &, const Up &)
Definition: plus.hpp:106

References tim::math::plus().

◆ set_value()

template<typename Tuple , typename Value >
static void tim::mpl::apply< void >::set_value ( Tuple &&  _t,
Value &&  _v 
)
inlinestaticnoexcept

Definition at line 582 of file apply.hpp.

583 {
584 constexpr auto N = std::tuple_size<decay_t<Tuple>>::value;
585 set_value_fold(std::forward<Tuple>(_t), std::forward<Value>(_v),
586 make_index_sequence<N>{});
587 }
tim::mpl::apply< void >::set_value_fold
static auto set_value_fold(Tp &&_t, int, Value &&_v) noexcept -> decltype(std::forward< Tp >(_t)=std::forward< Value >(_v), void())
Definition: apply.hpp:561

◆ set_value_fold() [1/3]

template<typename Tp , typename Value >
static void tim::mpl::apply< void >::set_value_fold ( Tp &&  ,
long  ,
Value &&   
)
inlinestaticnoexcept

Definition at line 568 of file apply.hpp.

569 {}

◆ set_value_fold() [2/3]

template<typename Tp , typename Value >
static auto tim::mpl::apply< void >::set_value_fold ( Tp &&  _t,
int  ,
Value &&  _v 
) -> decltype(std::forward<Tp>(_t) = std::forward<Value>(_v), void())
inlinestaticnoexcept

Definition at line 561 of file apply.hpp.

563 {
564 std::forward<Tp>(_t) = std::forward<Value>(_v);
565 }

◆ set_value_fold() [3/3]

template<typename Tuple , typename Value , size_t... Idx>
static void tim::mpl::apply< void >::set_value_fold ( Tuple &&  _t,
Value &&  _v,
index_sequence< Idx... >   
)
inlinestaticnoexcept

Definition at line 572 of file apply.hpp.

574 {
575 TIMEMORY_FOLD_EXPRESSION(
576 set_value_fold(std::get<Idx>(_t), 0, std::forward<Value>(_v)));
577 }

References TIMEMORY_FOLD_EXPRESSION.

◆ type_access()

template<template< typename > class Access, typename Tuple , typename... Args>
static void tim::mpl::apply< void >::type_access ( Args &&...  __args)
inlinestaticnoexcept

Definition at line 671 of file apply.hpp.

672 {
673 constexpr size_t N = std::tuple_size<decay_t<Tuple>>::value;
674 internal::apply<void>::template type_access<Access, Tuple, Args...>(
675 make_index_sequence<N>{}, std::forward<Args>(__args)...);
676 }
tim::mpl::apply< void >::type_access
static void type_access(Args &&... __args) noexcept
Definition: apply.hpp:671

◆ unroll() [1/2]

template<size_t N, typename Device , typename Func , typename... Args, enable_if_t< std::is_same< Device, device::gpu >::value, char > = 0>
static void tim::mpl::apply< void >::unroll ( Func &&  __func,
Args &&...  __args 
)
inlinestaticnoexcept

Definition at line 538 of file apply.hpp.

539 {
540 internal::apply<void>::template unroll<N, Device, Func, Args...>(
541 std::forward<Func>(__func), std::forward<Args>(__args)...);
542 }
tim::mpl::apply< void >::unroll
static void unroll(Func &&__func, Args &&... __args) noexcept
Definition: apply.hpp:538

◆ unroll() [2/2]

template<size_t N, typename Device , typename Func , typename... Args, enable_if_t< std::is_same< Device, device::cpu >::value, char > = 0>
static void tim::mpl::apply< void >::unroll ( Func &&  __func,
Args &&...  __args 
)
inlinestaticnoexcept

Definition at line 548 of file apply.hpp.

549 {
550 internal::apply<void>::template unroll<N, Device, Func, Args...>(
551 std::forward<Func>(__func), std::forward<Args>(__args)...);
552 }

◆ unroll_access()

template<template< typename > class Access, typename Tuple , typename... Args>
static void tim::mpl::apply< void >::unroll_access ( Tuple &&  __t,
Args &&...  __args 
)
inlinestaticnoexcept

Definition at line 660 of file apply.hpp.

661 {
662 constexpr size_t N = std::tuple_size<decay_t<Tuple>>::value;
663 internal::apply<void>::template unroll_access<Access, Tuple, Args...>(
664 std::forward<Tuple>(__t), make_index_sequence<N>{},
665 std::forward<Args>(__args)...);
666 }
tim::mpl::apply< void >::unroll_access
static void unroll_access(Tuple &&__t, Args &&... __args) noexcept
Definition: apply.hpp:660
The documentation for this struct was generated from the following file: