Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 1234]

Ckamping::measurements::AggregatedTree< DataType >	Class representing an aggregated measurement tree, i.e., a measurement tree for which the global aggregation has been performed
Ckamping::AllocContainerOfT< T >	Buffer allocation tag used for indicating that a buffer of type T should be allocated by KaMPIng
Ckamping::internal::AllocNewDataBufferBuilder< AllocType, ValueType, parameter_type_param, modifiability, buffer_type, buffer_resize_policy >	Parameter object representing a data buffer to be allocated by KaMPIng. This is a specialization of DataBufferBuilder for buffer allocation tags, such as alloc_new, alloc_new_using and alloc_container_of. This is an intermediate object not holding any data. The actual buffer is constructed by calling the construct_buffer_or_rebind() method
Ckamping::AllocNewT< Container >	Buffer allocation tag used for indicating that a buffer should be allocated by KaMPIng
Ckamping::AllocNewUsingT< Container >	Buffer allocation tag used for indicating that a buffer should be allocated by KaMPIng
Ckamping::internal::any_tag_t	Tag struct for message tag
Ckamping::internal::buffered_mode_t	Tag for buffered send mode
Ckamping::internal::CallableWrapper< F >	A wrapper around a functor F that makes it callable using the call method
Ckamping::CommunicationGraphLocalView	Local view of a a distributed communication graph from the perspective of the current rank. Each vertex is a rank and the edges define possible communication links between the vertices. This view provides access to the (potentially weighted) in- and outgoing edges which are represented as a sequence of neighboring ranks. Note that MPI allows this to be a multi-graph. process' rank
Ckamping::ops::internal::commutative_tag	Tag for a commutative reduce operation
►Cstd::conjunction
Ckamping::internal::all_unique< std::tuple< T, Ts... > >	Recursive wrapper (std::integral_constant) to test if all types of a tuple are unique. This is done by checking for each type whether the type occurs in the types of the tuple to the right. If this is true for any type/position, the types in the tuple are not unique
►Ckamping::contiguous_type< T, N >	Constructs an contiguous type of size N from type T using MPI_Type_contiguous
►Ckamping::byte_serialized< std::pair< First, Second > >
Ckamping::mpi_type_traits< std::pair< First, Second >, std::enable_if_t< has_static_type_v< First > &&has_static_type_v< Second > > >	Specialization of the mpi_type_traits type trait for std::pair, which represents the pair as a sequence of bytes
►Ckamping::byte_serialized< std::tuple< Ts... > >
Ckamping::mpi_type_traits< std::tuple< Ts... >, std::enable_if_t<(has_static_type_v< Ts > &&...)> >	Specialization of the mpi_type_traits type trait for std::tuple, which represents the tuple as MPI struct type
Ckamping::contiguous_type< std::byte, sizeof(std::pair< First, Second >)>
Ckamping::contiguous_type< std::byte, sizeof(std::tuple< Ts... >)>
►Ckamping::contiguous_type< std::byte, sizeof(T)>
Ckamping::byte_serialized< T >	Constructs a type that is serialized as a sequence of sizeof(T) bytes using MPI_BYTE. Note that you must ensure that this conversion is valid
►Ckamping::internal::CopyMoveEnabler< bool >	Class optionally containing a copy constructor while supporting move assignment/construction
Ckamping::internal::RankDataBuffer< RankType::any, type >	Encapsulates the rank of a PE. This is needed for p2p communication and rooted MPI collectives like MPI_Gather
Ckamping::internal::RankDataBuffer< RankType::null, type >	Encapsulates the rank of a PE. This is needed for p2p communication and rooted MPI collectives like MPI_Gather
Ckamping::internal::SendModeParameter< SendModeTag >	Parameter object for send_mode encapsulating the send mode compile-time tag
Ckamping::internal::TagParam< TagType::any >	Encapsulates a message tag. Specialization if the value is MPI_ANY_TAG
Ckamping::internal::TagParam< TagType::value >	Encapsulates a message tag. Specialization if an explicit tag value is provided
►Ckamping::internal::CopyMoveEnabler< enable_copy_construction_v< ownership > >
►Ckamping::internal::DataBuffer< size_t, ParameterType, type, BufferModifiability::modifiable, BufferOwnership::owning, BufferType::in_buffer, BufferResizePolicy::no_resize, BufferAllocation::user_allocated >
Ckamping::internal::RankDataBuffer< RankType::value, type >	Encapsulates the rank of a PE. This is needed for p2p communication and rooted MPI collectives like MPI_Gather
Ckamping::internal::DataBuffer< MemberType, TParameterType, parameter_type_param, modifiability, ownership, buffer_type_param, buffer_resize_policy_param, allocation, ValueType >	Data buffer used for named parameters
Ckamping::internal::GenericDataBuffer< MemberType, TParameterType, parameter_type_param, modifiability, ownership, buffer_type_param >	A more generic version of a DataBuffer which stores an object of type
Ckamping::internal::CopyMoveEnabler< true >	Specialisation of ParameterObjectBase which possesses a copy constructor
Ckamping::measurements::Counter< CommunicatorType >	Distributed counter object
Ckamping::internal::DataBufferBuilder< Data, parameter_type_param, modifiability, buffer_type, buffer_resize_policy, ValueType >	Parameter object representing a data buffer. This is an intermediate object which only holds the data and parameters. The actual buffer is created by calling the construct_buffer_or_rebind() method
Ckamping::internal::default_value_type_tag	Tag type to indicate that the value_type should be inferred from the container
Ckamping::plugin::grid_plugin_helpers::Destination	Mixin for MessageEnvelope to store a destination PE
Ckamping::internal::DiscardSerializationBuffers	Predicate to check whether a buffer provided to make_mpi_result() shall be discard or returned in the result object, including a hotfix for serialization
Ckamping::DistributedCommunicationGraph< DefaultContainer >	A (vertex-centric) distributed communication graph. Each vertex of the graph corresponds to a rank and each edge (i,j) connect two ranks i and j which can communicate with each other. The distributed communication graph is vertex-centric in the sense that on each rank the local graph only contains the corresponding vertex and its in and out neighborhood. Note that MPI allow multiple edges between the same ranks i and j, i.e. the distributed communication graph can be a multi-graph
Ckamping::internal::EmptyDataBuffer< Data, type, buffer_type_param >	Empty buffer that can be used as default argument for optional buffer parameters
Ckamping::Environment< init_finalize_mode >	Wrapper for MPI functions that don't require a communicator. If the template parameter init_finalize_mode is set to InitMPIMode::InitFinalize (default), MPI_Init is called in the constructor, and MPI_Finalize is called in the destructor
►Cstd::exception	STL class
►Ckamping::MPIFailureDetected	Base class for all exceptions thrown by the FaultTolerance plugin. Means, that either a process failed or the communicator was revoked
Ckamping::MPIProcFailedError	Thrown when a process failure prevented the completetion of the MPI operation
Ckamping::MPIProcFailedPendingError	Thrown when a potential sender matching a non-blocking wildcard source receive has failed
Ckamping::MPIRevokedError	Thrown when the communicator was revoked
Ckamping::MpiErrorException	The exception type used when an MPI call did not return MPI_SUCCESS
►Ckamping::internal::Extractable	Base class containing logic to verify whether a buffer's data has already been extracted. This only has effects if an appropiate assertion level is set
Ckamping::internal::DataBuffer< size_t, ParameterType, type, BufferModifiability::modifiable, BufferOwnership::owning, BufferType::in_buffer, BufferResizePolicy::no_resize, BufferAllocation::user_allocated >
Ckamping::internal::DataBuffer< MemberType, TParameterType, parameter_type_param, modifiability, ownership, buffer_type_param, buffer_resize_policy_param, allocation, ValueType >	Data buffer used for named parameters
Ckamping::internal::GenericDataBuffer< MemberType, TParameterType, parameter_type_param, modifiability, ownership, buffer_type_param >	A more generic version of a DataBuffer which stores an object of type
►Cstd::false_type
Ckamping::builtin_type< T >	Checks if the type T is a builtin MPI type
Ckamping::has_static_type< typename, Enable >	Check if the type has a static type definition, i.e. mpi_type_traits is defined
Ckamping::internal::has_data_member< typename, typename >	Helper to decide if data type has .data() method
Ckamping::internal::is_specialization< T, Template >	Type trait to check if a type is an instance of a templated type
Ckamping::internal::is_std_array< A >	Helper to check if a type is a std::array
Ckamping::internal::is_std_pair< T >	Helper to check if a type is a std::pair
Ckamping::internal::is_std_tuple< T >	Helper to check if a type is a std::tuple
Ckamping::internal::FilterOut<... >	Base template used to filter a list of types and only keep those whose types meet specified criteria. See the following specialisations for more information
Ckamping::internal::FilterOut< Predicate >	Specialisation of template class used to filter a list of types and only keep the those whose types meet the specified criteria
Ckamping::internal::FilterOut< Predicate, Head, Tail... >	Specialization of template class used to filter a list of (buffer-)types and discard those for which The template is recursively instantiated to check one type after the other and "insert" it into a std::tuple if it meets the criteria . based on https://stackoverflow.com/a/18366475
Ckamping::internal::FilterOut< Predicate, std::tuple< Types... > >	Specialisation of template class for types stored in a std::tuple<...> that is used to filter these types and only keep those which meet certain criteria (see above)
Ckamping::internal::FlatContainer< T, Enable >	Maps a container to is underlying nested container
Ckamping::internal::FlatContainer< T, std::enable_if_t< is_nested_send_buffer_v< T > > >	Maps a container to is underlying nested container
Ckamping::internal::FlatContainer< T, std::enable_if_t< is_sparse_send_buffer_v< T > > >	Maps a container to is underlying nested container
Ckamping::measurements::FlatPrinter	Printer class that prints an evaluated TimerTree in a flat format in which the timer hierarchy is collapsed into a dot separated identifier per measurement
Ckamping::measurements::internal::Gather	Object encapsulating a gather operation on a given range of objects
Ckamping::plugin::grid::GridCommunicator< DefaultContainerType >	Object returned by plugin::GridCommunicator::make_grid_communicator() representing a grid communicator which enables alltoall communication with a latency in sqrt(p) where p is the size of the original communicator
Ckamping::plugin::grid_plugin_helpers::GridPosition	Class representing a position within a logical two-dimensional processor grid
Ckamping::Group	A group of MPI processes
Ckamping::internal::has_no_unused_parameters< RequiredParametersTuple, OptionalParametersTuple, Args >	Struct wrapping a check that verifies that no unused parameters are part of the arguments
Ckamping::internal::has_parameter_helper< typename >	Helper struct needed to retrieve the types stored in a std::tuple for the has_parameter_type check
Ckamping::internal::ignore_t< T >	Tag type for parameters that can be omitted on some PEs (e.g., root PE, or non-root PEs)
Ckamping::is_contiguous_sized_range< T >	A type trait that checks if a type T is a contiguous and sized range, i.e., it is a range and has std::size and std::data defined
Ckamping::is_pair_like< T >	A type trait that checks if a type T is a pair-like type, i.e., it may be destructured using std::get<0> and std::get<1> and has a size of 2
Ckamping::is_range< T >	A type trait that checks if a type T is a range, i.e., it has std::begin and std::end defined
Ckamping::kabool	Wrapper around bool to allow handling containers of boolean values
Ckamping::kamping_tag	Tag used for indicating that a struct is reflectable
Ckamping::internal::logical_xor_impl< T >	Wrapper struct for logical xor, as the standard library does not provided a function object for it
Ckamping::internal::logical_xor_impl< void >	Template specialization for kamping::internal::logical_xor_impl without type parameter, which leaves to operand type to be deduced. The actual implementation is used in case that the operation is a builtin operation for the given datatype
Ckamping::measurements::internal::Max	Object encapsulating a maximum operation on a given range of objects
Ckamping::internal::max_impl< T >	Wrapper struct for std::max
Ckamping::internal::max_impl< void >	Template specialization for kamping::internal::max_impl without type parameter, which leaves the operand type to be deduced
Ckamping::plugin::reproducible_reduce::MessageBuffer< T, Communicator >	Responsible for storing and communicating intermediate results between PEs
Ckamping::plugin::reproducible_reduce::MessageBuffer< T, kamping::Communicator >
Ckamping::plugin::reproducible_reduce::MessageBufferEntry< T >	Encapsulates a single intermediate result (value) and its index
Ckamping::measurements::internal::Min	Object encapsulating a minimum operation on a given range of objects
Ckamping::internal::min_impl< T >	Wrapper struct for std::min
Ckamping::internal::min_impl< void >	Template specialization for kamping::internal::min_impl without type parameter, which leaves the operand type to be deduced. The actual implementation is used in case that the operation is a builtin operation for the given datatype
Ckamping::internal::mpi_operation_traits< Op, Datatype >	Type trait for checking whether a functor is a builtin MPI reduction operation and query corresponding MPI_Op
Ckamping::mpi_type_traits< T, Enable >	The type trait that maps a C++ type T to a type trait that can be used to construct an MPI_Datatype
Ckamping::mpi_type_traits< T, std::enable_if_t<!std::is_same_v< decltype(type_dispatcher< T >()), no_matching_type > > >	The type trait that maps a C++ type T to a type trait that can be used to construct an MPI_Datatype
Ckamping::MPIAllocator< T >	STL-compatible allocator for requesting memory using the builtin MPI allocator
Ckamping::MPIResult< Args >	MPIResult contains the result of a MPI call wrapped by KaMPIng
Ckamping::no_matching_type	Type tag for indicating that no static type definition exists for a type
Ckamping::measurements::internal::NodeMeasurements< T, default_global_aggregation_mode >	Class to store measurement data points associated with a node in a measurement tree, e.g., a timer-tree
►Ckamping::measurements::internal::NodeMeasurements< DataType, GlobalAggregationMode::sum >
Ckamping::measurements::internal::CounterTreeNode< DataType >	Class representing a node in the counter tree. Each node represents a measurement (or multiple with the same key). A node can have multiple children which represent nested measurements. The measurements associated with a node's children are executed while the node's measurement is still active
►Ckamping::measurements::internal::NodeMeasurements< Duration, GlobalAggregationMode::max >
Ckamping::measurements::internal::TimerTreeNode< double, Duration >
Ckamping::measurements::internal::TimerTreeNode< TimePoint, Duration >	Class representing a node in the timer tree. Each node represents a time measurement (or multiple with the same key). A node can have multiple children which represent nested time measurements. The measurements associated with a node's children are executed while the node's measurement is still active
Ckamping::ops::internal::non_commutative_tag	Tag for a non-commutative reduce operation
Ckamping::NonBlockingResult< CallerProvidedArgs, RequestDataBuffer, Buffers >	NonBlockingResult contains the result of a non-blocking MPI call wrapped by KaMPIng. It encapsulates a kamping::Request and stores the buffers associated with the non-blocking call. Upon completion the owning out-buffers among all associated buffers are returned wrappend in an MPIResult object
Ckamping::ops::null< T >	Builtin null operation (aka MPI_OP_NULL)
Ckamping::internal::OperationBuilder< Op, Commutative >	Parameter wrapping an operation passed to reduce-like MPI collectives. This wraps an MPI operation without the argument of the operation specified. This enables the user to construct such wrapper using the parameter factory kamping::op without passing the type of the operation. The library developer may then construct the actual operation wrapper with a given type later
Ckamping::internal::parameter_type_to_integral_constant< T >	Wrapper to get an std::integral_constant for a kamping::internal::ParameterType
Ckamping::internal::parameter_types_to_integral_constants< ParameterTypes >	Wrapper to get a tuple of std::integral_constant for each kamping::internal::ParameterType passed as template parameter that are extracted as tuple of std::integral_constant
Ckamping::internal::parameters_to_integral_constant< Parameters >	Wrapper to get a tuple of std::integral_constant for each kamping::internal::ParameterType of the parameters
Ckamping::internal::ParameterTypeEntry< ptype >	Wrapper class to store an enum entry (kamping::internal::ParameterType) in a separate type (so that it can be used in a compile time list)
Ckamping::internal::ParameterTypeUnwrapping< Arg >	Trait struct used to determine the underlying type and value of the parameter type of an object with a parameter type. (This is a building block to enable plugins to have their own named parameters)
Ckamping::internal::ParameterTypeUnwrapping< std::integral_constant< T, v > >	Trait struct used to determine the underlying type and value of the parameter type of an std::integral_constant wrapping a parameter type. (This is a building block to enable plugins to have their own named parameters)
Ckamping::plugin::PluginBase< CommunicatorClass, DefaultContainerType, PluginClass >	Helper class for using CRTP for mixins. Which are used to implement kamping plugins
►Ckamping::plugin::PluginBase< Comm, DefaultContainerType, DispatchAlltoall >
Ckamping::plugin::DispatchAlltoall< Comm, DefaultContainerType >	Plugin providing an alltoallv exchange method which calls one of multiple underlying alltoallv exchange algorithms depending on the communication volume
►Ckamping::plugin::PluginBase< Comm, DefaultContainerType, GridCommunicator >
Ckamping::plugin::GridCommunicator< Comm, DefaultContainerType >	Plugin adding a two dimensional communication grid to the communicator
►Ckamping::plugin::PluginBase< Comm, DefaultContainerType, ReproducibleReducePlugin >
Ckamping::plugin::ReproducibleReducePlugin< Comm, DefaultContainerType >	Reproducible reduction of distributed arrays
►Ckamping::plugin::PluginBase< Comm, DefaultContainerType, SampleSort >
Ckamping::plugin::SampleSort< Comm, DefaultContainerType >	Plugin that adds a canonical sample sort to the communicator
►Ckamping::plugin::PluginBase< Comm, DefaultContainerType, SparseAlltoall >
Ckamping::plugin::SparseAlltoall< Comm, DefaultContainerType >	Plugin providing a sparse alltoall exchange method
►Ckamping::plugin::PluginBase< Comm, DefaultContainerType, UserLevelFailureMitigation >
Ckamping::plugin::UserLevelFailureMitigation< Comm, DefaultContainerType >	A plugin implementing a wrapper around the User-Level Failure-Mitigation (ULFM) feature of the upcoming MPI 4 standard. This plugin and the accompanying example is tested with OpenMPI 5.0.2
►CPlugins
Ckamping::Communicator< std::vector >
Ckamping::Communicator<>
Ckamping::Communicator< DefaultContainerType >
Ckamping::TopologyCommunicator< std::vector >
►Ckamping::Communicator< DefaultContainerType, Plugins >	Wrapper for MPI communicator providing access to rank() and size() of the communicator. The Communicator is also access point to all MPI communications provided by KaMPIng
Ckamping::TopologyCommunicator< std::vector >
►Ckamping::TopologyCommunicator< DefaultContainerType, Plugins >	A Communicator which possesses an additional virtual topology and supports neighborhood collectives (on the topology). A virtual topology can be defined by a communication graph: each MPI rank corresponds to a vertex in the graph and an edge (i,j) defines a (directed) communication link from rank i to rank j. Such a topolgy can be used to model frequent (sparse) communication patterns and there are specialized (neighborhood) collective operations, e.g., MPI_Neighbor_alltoall etc., exploiting this structure
Ckamping::DistributedGraphCommunicator< DefaultContainerType, Plugins >	A Communicator which possesses an additional virtual topology and supports neighborhood collectives (on the topology). The virtual topology is specified via a distributed communication graph (see DistributedCommunicationGraph)
Ckamping::DistributedGraphCommunicator< DefaultContainerType, Plugins >	A Communicator which possesses an additional virtual topology and supports neighborhood collectives (on the topology). The virtual topology is specified via a distributed communication graph (see DistributedCommunicationGraph)
Ckamping::TopologyCommunicator< DefaultContainerType, Plugins >	A Communicator which possesses an additional virtual topology and supports neighborhood collectives (on the topology). A virtual topology can be defined by a communication graph: each MPI rank corresponds to a vertex in the graph and an edge (i,j) defines a (directed) communication link from rank i to rank j. Such a topolgy can be used to model frequent (sparse) communication patterns and there are specialized (neighborhood) collective operations, e.g., MPI_Neighbor_alltoall etc., exploiting this structure
Ckamping::PoolAnyResult< IndexType, StatusType >	Result returned by RequestPool::wait_any()
Ckamping::plugin::dispatch_alltoall::internal::PredicateDispatchAlltoall	Predicate to check whether an argument provided to alltoallv_dispatch shall be discarded in the internal calls
Ckamping::internal::PredicateForResultObject	Predicate to check whether a buffer provided to make_mpi_result() shall be discard or returned in the result object
Ckamping::plugin::sparse_alltoall::internal::PredicateForSparseAlltoall	Predicate to check whether an argument provided to sparse_alltoall shall be discarded in the internal calls to Communicator::issend()
Ckamping::internal::PrependParameterType< ptype, Tuple >	Template class to prepend the ParameterTypeEntry<ParameterType::ptype> type to a given std::tuple
Ckamping::internal::PrependType< typename, typename >	Base template used to concatenate a type to a given std::tuple. based on https://stackoverflow.com/a/18366475
Ckamping::internal::PrependType< Head, std::tuple< Tail... > >	Specialization of a class template used to preprend a type to a given std::tuple
Ckamping::plugin::sparse_alltoall::ProbedMessage< T, Communicator >	Class encapsulating a probed message that is ready to be received in a sparse alltoall exchange
Ckamping::internal::rank_any_t	Tag struct for MPI_ANY_SOURCE
Ckamping::internal::rank_null_t	Tag struct for MPI_PROC_NULL
Ckamping::internal::RankDataBuffer< rank_type, parameter_type >	Encapsulates the rank of a PE. This is needed for p2p communication and rooted MPI collectives like MPI_Gather
Ckamping::RankRange	Struct encapsulating a MPI rank range triplet as used in functions like MPI_Group_range_incl/excl
Ckamping::RankRanges	RankRanges encapsulate multiple rank ranges which are used in functions like MPI_Group_range_incl/excl
Ckamping::internal::ready_mode_t	Tag for ready send mode
Ckamping::internal::ReduceOperation< T, Op, Commutative >	Wraps an operation and translates it to a builtin MPI_Op or constructs a custom operation
Ckamping::plugin::reproducible_reduce::ReproducibleCommunicator< T, Communicator >	Communicator that can reproducibly reduce an array of a fixed size according to a binary tree scheme
Ckamping::RequestBase< RequestType >	Base class for request wrappers
►Ckamping::RequestBase< PooledRequest< IndexType > >
Ckamping::PooledRequest< IndexType >	Wrapper for MPI requests owned by a RequestPool
►Ckamping::RequestBase< Request >
Ckamping::Request	Wrapper for MPI request handles (aka. MPI_Request)
Ckamping::RequestPool< DefaultContainerType >	A pool for storing multiple Request s and checking them for completion
Ckamping::internal::ResultCategoryNotUsed	Use this type if one of the template parameters of MPIResult is not used for a specific wrapped MPI call
Ckamping::measurements::internal::ScalarOrVectorPrinter< T >	Able to print either a single value or a vector of value to the given outstream
Ckamping::measurements::internal::ScalarOrVectorPrinter< double >
Ckamping::ScopedDatatype	A scoped MPI_Datatype that commits the type on construction and frees it on destruction. This is useful for RAII-style management of MPI_Datatype objects
Ckamping::internal::serialization_support_tag	Tag type to identify serialization support
Ckamping::measurements::SimpleJsonPrinter< Duration >	Printer class that prints an evaluated TimerTree in Json format
Ckamping::plugin::grid_plugin_helpers::Source	Mixin for MessageEnvelope to store a source PE
Ckamping::Span< T >	A span modeled after C++20's std::span
Ckamping::Span< int const >
Ckamping::internal::standard_mode_t	Tag for standard send mode
Ckamping::Status	Wrapper for MPI_Status
Ckamping::struct_type< T >	Constructs a MPI_Datatype for a struct-like type
►Ckamping::struct_type< std::pair< First, Second > >
Ckamping::mpi_type_traits< std::pair< First, Second >, std::enable_if_t< has_static_type_v< First > &&has_static_type_v< Second > > >	Specialization of the mpi_type_traits type trait for std::pair, which represents the pair as a sequence of bytes
►Ckamping::struct_type< std::tuple< Ts... > >
Ckamping::mpi_type_traits< std::tuple< Ts... >, std::enable_if_t<(has_static_type_v< Ts > &&...)> >	Specialization of the mpi_type_traits type trait for std::tuple, which represents the tuple as MPI struct type
Ckamping::measurements::internal::Sum	Object encapsulating a summation operation on a given range of objects
Ckamping::internal::synchronous_mode_t	Tag for synchronous send mode
Ckamping::internal::TagParam< tag_type >	Encapsulates a message tag
Ckamping::measurements::Timer< CommunicatorType >	Distributed timer object
Ckamping::measurements::internal::Tree< NodeType >	Tree consisting of objects of type NodeType. The tree constitutes a hierarchy of measurements such that each node correspond to one (or multiple) measurement(s) with the same name. For timer tree, the measurements corresponding to the node's children are all started and stopped while the node's current time measurement is running
Ckamping::measurements::internal::Tree< kamping::measurements::internal::CounterTreeNode< DataType > >
Ckamping::measurements::internal::Tree< kamping::measurements::internal::TimerTreeNode< double, Duration > >
►Ckamping::measurements::internal::TreeNode< DerivedNode >	Object representing a node in a tree. The class is not meant to be used on its own but to encapsulate the basic "tree-node behaviour" (e.g. management of children nodes etc.) for other specialised node classes like TimerTreeNode via CRTP paradigm
Ckamping::measurements::internal::TimerTreeNode< double, Duration >
►Ckamping::measurements::internal::TreeNode< AggregatedTreeNode< DataType > >
Ckamping::measurements::AggregatedTreeNode< DataType >	Class representing a node in an (globally) aggregated tree, i.e., a node of a timer (or counter) tree where the global aggregation operations has been performed and which can be printed
►Ckamping::measurements::internal::TreeNode< CounterTreeNode< DataType > >
Ckamping::measurements::internal::CounterTreeNode< DataType >	Class representing a node in the counter tree. Each node represents a measurement (or multiple with the same key). A node can have multiple children which represent nested measurements. The measurements associated with a node's children are executed while the node's measurement is still active
Ckamping::measurements::internal::TreeNode< TimerTreeNode< double, Duration > >
►Ckamping::measurements::internal::TreeNode< TimerTreeNode< TimePoint, Duration > >
Ckamping::measurements::internal::TimerTreeNode< TimePoint, Duration >	Class representing a node in the timer tree. Each node represents a time measurement (or multiple with the same key). A node can have multiple children which represent nested time measurements. The measurements associated with a node's children are executed while the node's measurement is still active
►Cstd::true_type
Ckamping::builtin_type< bool >	Specialization of builtin_type for bool
Ckamping::builtin_type< char >	Specialization of builtin_type for char
Ckamping::builtin_type< double >	Specialization of builtin_type for double
Ckamping::builtin_type< float >	Specialization of builtin_type for float
Ckamping::builtin_type< int >	Specialization of builtin_type for int
Ckamping::builtin_type< kabool >	Specialization of builtin_type for kabool
Ckamping::builtin_type< long double >	Specialization of builtin_type for long double
Ckamping::builtin_type< long int >	Specialization of builtin_type for long int
Ckamping::builtin_type< long long int >	Specialization of builtin_type for long long int
Ckamping::builtin_type< short int >	Specialization of builtin_type for short int
Ckamping::builtin_type< signed char >	Specialization of builtin_type for signed char
Ckamping::builtin_type< std::complex< double > >	Specialization of builtin_type for std::complex<double>
Ckamping::builtin_type< std::complex< float > >	Specialization of builtin_type for std::complex<float>
Ckamping::builtin_type< std::complex< long double > >	Specialization of builtin_type for std::complex<long double>
Ckamping::builtin_type< unsigned char >	Specialization of builtin_type for unsigned char
Ckamping::builtin_type< unsigned int >	Specialization of builtin_type for unsigned int
Ckamping::builtin_type< unsigned long int >	Specialization of builtin_type for unsigned long int
Ckamping::builtin_type< unsigned long long int >	Specialization of builtin_type for unsigned long long int
Ckamping::builtin_type< unsigned short int >	Specialization of builtin_type for unsigned short int
Ckamping::builtin_type< wchar_t >	Specialization of builtin_type for wchar_t
Ckamping::has_static_type< T, std::void_t< decltype(mpi_type_traits< T >::data_type())> >	Check if the type has a static type definition, i.e. mpi_type_traits is defined
Ckamping::internal::all_unique< Tuple >	Base wrapper (std::integral_constant) to test if all types of a tuple are unique
Ckamping::internal::has_data_member< T, std::void_t< decltype(std::declval< T >().data())> >	Helper to decide if data type has .data() method
Ckamping::internal::is_specialization< Template< Args... >, Template >	Type trait to check if a type is an instance of a templated type
Ckamping::internal::is_std_array< std::array< T, N > >	Helper to check if a type is a std::array
Ckamping::internal::is_std_pair< std::pair< T1, T2 > >	Helper to check if a type is a std::pair
Ckamping::internal::is_std_tuple< std::tuple< Ts... > >	Helper to check if a type is a std::tuple
Cstd::tuple_element< index, kamping::MPIResult< Args... > >	Specialization of the std::tuple_element for kamping::MPIResult. Part of the structured binding machinery
Cstd::tuple_size< kamping::MPIResult< Args... > >	Specialization of the std::tuple_size for kamping::MPIResult. Part of the structured binding machinery
Ckamping::internal::type_list< Args >	Helper type for representing a type list
Ckamping::ops::internal::undefined_commutative_tag	Tag for a reduce operation without manually declared commutativity (this is only used internally for builtin reduce operations)
Ckamping::internal::unused_tparam	An unused template parameter
Ckamping::internal::UnusedRebindContainer< typename >	Dummy template for representing the absence of a container to rebind to
Ckamping::internal::UserOperationPtrWrapper< is_commutative >	Wrapper for a user defined reduction operation based on a function pointer
Ckamping::internal::UserOperationWrapper< is_commutative, T, Op >	Wrapper for a user defined reduction operation based on a functor object
Ckamping::internal::ValueTypeWrapper< has_value_type_member, T >	Wrapper to get the value type of a non-container type (aka the type itself)
Ckamping::internal::ValueTypeWrapper< true, T >	Wrapper to get the value type of a container type
►Ckamping::plugin::grid_plugin_helpers::Attributes
Ckamping::plugin::grid_plugin_helpers::MessageEnvelope< PayloadType, Attributes >	Augments a plain message with additional information via