| ▼Nkamping | |
| ►Ninternal | Internal namespace marking the code that is not user-facing |
| Call_unique | Base wrapper (std::integral_constant) to test if all types of a tuple are unique |
| Call_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 |
| CAllocNewDataBufferBuilder | 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 |
| Cany_tag_t | Tag struct for message tag |
| Cbuffered_mode_t | Tag for buffered send mode |
| CCallableWrapper | A wrapper around a functor F that makes it callable using the call method |
| CCopyMoveEnabler | Class optionally containing a copy constructor while supporting move assignment/construction |
| CCopyMoveEnabler< true > | Specialisation of ParameterObjectBase which possesses a copy constructor |
| CDataBuffer | Data buffer used for named parameters |
| CDataBufferBuilder | 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 |
| Cdefault_value_type_tag | Tag type to indicate that the value_type should be inferred from the container |
| CDiscardSerializationBuffers | 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 |
| CEmptyDataBuffer | Empty buffer that can be used as default argument for optional buffer parameters |
| CExtractable | 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 |
| CFilterOut | 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 |
| CFilterOut< Predicate > | Specialisation of template class used to filter a list of types and only keep the those whose types meet the specified criteria |
| CFilterOut< 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 |
| CFilterOut< 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) |
| CFlatContainer | Maps a container to is underlying nested container |
| CFlatContainer< T, std::enable_if_t< is_nested_send_buffer_v< T > > > | Maps a container to is underlying nested container |
| CFlatContainer< T, std::enable_if_t< is_sparse_send_buffer_v< T > > > | Maps a container to is underlying nested container |
| CGenericDataBuffer | A more generic version of a DataBuffer which stores an object of type |
| Chas_data_member | Helper to decide if data type has |
| Chas_data_member< T, std::void_t< decltype(std::declval< T >().data())> > | Helper to decide if data type has |
| Chas_no_unused_parameters | Struct wrapping a check that verifies that no unused parameters are part of the arguments |
| Chas_parameter_helper | Helper struct needed to retrieve the types stored in a std::tuple for the has_parameter_type check |
| Cignore_t | Tag type for parameters that can be omitted on some PEs (e.g., root PE, or non-root PEs) |
| Cis_specialization | Type trait to check if a type is an instance of a templated type |
| Cis_specialization< Template< Args... >, Template > | Type trait to check if a type is an instance of a templated type |
| Cis_std_array | Helper to check if a type is a std::array |
| Cis_std_array< std::array< T, N > > | Helper to check if a type is a std::array |
| Cis_std_pair | Helper to check if a type is a std::pair |
| Cis_std_pair< std::pair< T1, T2 > > | Helper to check if a type is a std::pair |
| Cis_std_tuple | Helper to check if a type is a std::tuple |
| Cis_std_tuple< std::tuple< Ts... > > | Helper to check if a type is a std::tuple |
| Clogical_xor_impl | Wrapper struct for logical xor, as the standard library does not provide a function object for it |
| Clogical_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 |
| Cmax_impl | Wrapper struct for std::max |
| Cmax_impl< void > | Template specialization for kamping::internal::max_impl without type parameter, which leaves the operand type to be deduced |
| Cmin_impl | Wrapper struct for std::min |
| Cmin_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 |
| Cmpi_operation_traits | Type trait for checking whether a functor is a builtin MPI reduction operation and query the corresponding MPI_Op |
| Cno_matching_type | Type tag for indicating that no static type definition exists for a type |
| COperationBuilder | 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 |
| Cparameter_type_to_integral_constant | Wrapper to get an std::integral_constant for a kamping::internal::ParameterType |
| Cparameter_types_to_integral_constants | 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 |
| Cparameters_to_integral_constant | Wrapper to get a tuple of std::integral_constant for each kamping::internal::ParameterType of the parameters |
| CParameterTypeEntry | 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) |
| CParameterTypeUnwrapping | 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) |
| CParameterTypeUnwrapping< 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) |
| CPredicateForResultObject | Predicate to check whether a buffer provided to make_mpi_result() shall be discard or returned in the result object |
| CPrependParameterType | Template class to prepend the ParameterTypeEntry<ParameterType::ptype> type to a given std::tuple |
| CPrependType | Base template used to concatenate a type to a given std::tuple. based on https://stackoverflow.com/a/18366475 |
| CPrependType< Head, std::tuple< Tail... > > | Specialization of a class template used to preprend a type to a given std::tuple |
| Crank_any_t | Tag struct for MPI_ANY_SOURCE |
| Crank_null_t | Tag struct for MPI_PROC_NULL |
| CRankDataBuffer | Encapsulates the rank of a PE. This is needed for p2p communication and rooted MPI collectives like MPI_Gather |
| CRankDataBuffer< RankType::any, type > | Encapsulates the rank of a PE. This is needed for p2p communication and rooted MPI collectives like MPI_Gather |
| CRankDataBuffer< RankType::null, type > | Encapsulates the rank of a PE. This is needed for p2p communication and rooted MPI collectives like MPI_Gather |
| CRankDataBuffer< RankType::value, type > | Encapsulates the rank of a PE. This is needed for p2p communication and rooted MPI collectives like MPI_Gather |
| Cready_mode_t | Tag for ready send mode |
| CReduceOperation | Wraps an operation and translates it to a builtin MPI_Op or constructs a custom operation |
| CResultCategoryNotUsed | Use this type if one of the template parameters of MPIResult is not used for a specific wrapped MPI call |
| CSendModeParameter | Parameter object for send_mode encapsulating the send mode compile-time tag |
| Cserialization_support_tag | Tag type to identify serialization support |
| Cstandard_mode_t | Tag for standard send mode |
| Csynchronous_mode_t | Tag for synchronous send mode |
| CTagParam | Encapsulates a message tag |
| CTagParam< TagType::any, parameter_type_ > | Encapsulates a message tag. Specialization if the value is MPI_ANY_TAG |
| CTagParam< TagType::value, parameter_type_ > | Encapsulates a message tag. Specialization if an explicit tag value is provided |
| Ctype_list | Helper type for representing a type list |
| Cunused_tparam | An unused template parameter |
| CUnusedRebindContainer | Dummy template for representing the absence of a container to rebind to |
| CUserOperationPtrWrapper | Wrapper for a user defined reduction operation based on a function pointer |
| CUserOperationWrapper | Wrapper for a user defined reduction operation based on a functor object |
| CValueTypeWrapper | Wrapper to get the value type of a non-container type (aka the type itself) |
| CValueTypeWrapper< true, T > | Wrapper to get the value type of a container type |
| ►Nmeasurements | |
| ►Ninternal | |
| CCounterTreeNode | 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 |
| CGather | Object encapsulating a gather operation on a given range of objects |
| CMax | Object encapsulating a maximum operation on a given range of objects |
| CMin | Object encapsulating a minimum operation on a given range of objects |
| CNodeMeasurements | Class to store measurement data points associated with a node in a measurement tree, e.g., a timer-tree |
| CScalarOrVectorPrinter | Able to print either a single value or a vector of value to the given outstream |
| CSum | Object encapsulating a summation operation on a given range of objects |
| CTimerTreeNode | 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 |
| CTree | 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 |
| CTreeNode | 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 |
| CAggregatedTree | Class representing an aggregated measurement tree, i.e., a measurement tree for which the global aggregation has been performed |
| CAggregatedTreeNode | 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 |
| CCounter | Distributed counter object |
| CFlatPrinter | 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 |
| CSimpleJsonPrinter | Printer class that prints an evaluated TimerTree in Json format |
| CTimer | Distributed timer object |
| ►Nops | This namespace contains all builtin operations supported by MPI |
| ►Ninternal | |
| Ccommutative_tag | Tag for a commutative reduce operation |
| Cnon_commutative_tag | Tag for a non-commutative reduce operation |
| Cundefined_commutative_tag | Tag for a reduce operation without manually declared commutativity (this is only used internally for builtin reduce operations) |
| Cnull | Builtin null operation (aka MPI_OP_NULL) |
| ►Nplugin | |
| ►Ndispatch_alltoall | |
| ►Ninternal | |
| CPredicateDispatchAlltoall | Predicate to check whether an argument provided to alltoallv_dispatch shall be discarded in the internal calls |
| ►Ngrid | |
| CGridCommunicator | 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 |
| ►Ngrid_plugin_helpers | |
| CDestination | Mixin for MessageEnvelope to store a destination PE |
| CGridPosition | Class representing a position within a logical two-dimensional processor grid |
| CMessageEnvelope | Augments a plain message with additional information via |
| CSource | Mixin for MessageEnvelope to store a source PE |
| ►Nreproducible_reduce | |
| CMessageBuffer | Responsible for storing and communicating intermediate results between PEs |
| CMessageBufferEntry | Encapsulates a single intermediate result (value) and its index |
| CReproducibleCommunicator | Communicator that can reproducibly reduce an array of a fixed size according to a binary tree scheme |
| ►Nsparse_alltoall | |
| ►Ninternal | |
| CPredicateForSparseAlltoall | Predicate to check whether an argument provided to sparse_alltoall shall be discarded in the internal calls to Communicator::issend() |
| CProbedMessage | Class encapsulating a probed message that is ready to be received in a sparse alltoall exchange |
| CDispatchAlltoall | Plugin providing an alltoallv exchange method which calls one of multiple underlying alltoallv exchange algorithms depending on the communication volume |
| CGridCommunicator | Plugin adding a two dimensional communication grid to the communicator |
| CPluginBase | Helper class for using CRTP for mixins. Which are used to implement kamping plugins |
| CReproducibleReducePlugin | Reproducible reduction of distributed arrays |
| CSampleSort | Plugin that adds a canonical sample sort to the communicator |
| CSparseAlltoall | Plugin providing a sparse alltoall exchange method |
| CUserLevelFailureMitigation | 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 |
| ►Ntypes | |
| Cbuiltin_type | Checks if the type T is a builtin MPI type |
| Cbuiltin_type< bool > | Specialization of builtin_type for bool |
| Cbuiltin_type< char > | Specialization of builtin_type for char |
| Cbuiltin_type< double > | Specialization of builtin_type for double |
| Cbuiltin_type< float > | Specialization of builtin_type for float |
| Cbuiltin_type< int > | Specialization of builtin_type for int |
| Cbuiltin_type< kabool > | Specialization of builtin_type for kabool |
| Cbuiltin_type< long double > | Specialization of builtin_type for long double |
| Cbuiltin_type< long int > | Specialization of builtin_type for long int |
| Cbuiltin_type< long long int > | Specialization of builtin_type for long long int |
| Cbuiltin_type< short int > | Specialization of builtin_type for short int |
| Cbuiltin_type< signed char > | Specialization of builtin_type for signed char |
| Cbuiltin_type< std::byte > | Specialization of builtin_type for std::byte |
| Cbuiltin_type< std::complex< double > > | Specialization of builtin_type for std::complex<double> |
| Cbuiltin_type< std::complex< float > > | Specialization of builtin_type for std::complex<float> |
| Cbuiltin_type< std::complex< long double > > | Specialization of builtin_type for std::complex<long double> |
| Cbuiltin_type< unsigned char > | Specialization of builtin_type for unsigned char |
| Cbuiltin_type< unsigned int > | Specialization of builtin_type for unsigned int |
| Cbuiltin_type< unsigned long int > | Specialization of builtin_type for unsigned long int |
| Cbuiltin_type< unsigned long long int > | Specialization of builtin_type for unsigned long long int |
| Cbuiltin_type< unsigned short int > | Specialization of builtin_type for unsigned short int |
| Cbuiltin_type< wchar_t > | Specialization of builtin_type for wchar_t |
| Cbyte_serialized | Constructs a type serialized as a sequence of sizeof(T) bytes using MPI_BYTE |
| Ccontiguous_type | Constructs a contiguous MPI type of N elements of type T using MPI_Type_contiguous |
| Chas_static_type | Check if the type has a static type definition, i.e. kamping::types::mpi_type_traits is defined |
| Chas_static_type< T, std::void_t< decltype(mpi_type_traits< T >::data_type())> > | Check if the type has a static type definition, i.e. kamping::types::mpi_type_traits is defined |
| Ckabool | Wrapper around bool to allow handling containers of boolean values |
| Ckamping_tag | Tag used for indicating that a struct is reflectable |
| Cmpi_type_traits | The type trait that maps a C++ type T to an MPI_Datatype for the kamping-types module |
| Cmpi_type_traits< T, std::enable_if_t< has_auto_dispatched_type_v< T > > > | Partial specialization of kamping::types::mpi_type_traits for types matched by kamping::types::type_dispatcher() |
| CScopedDatatype | RAII wrapper that commits an MPI_Datatype on construction and frees it on destruction |
| Cstruct_type | Constructs an MPI_Datatype for a struct-like type |
| Ctype_dispatcher_lookup | Default lookup policy for contiguous_type and struct_type |
| CAllocContainerOfT | Buffer allocation tag used for indicating that a buffer of type T should be allocated by KaMPIng |
| CAllocNewT | Buffer allocation tag used for indicating that a buffer should be allocated by KaMPIng |
| CAllocNewUsingT | Buffer allocation tag used for indicating that a buffer should be allocated by KaMPIng |
| CCommunicationGraphLocalView | 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 |
| CCommunicator | 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 |
| CDistributedCommunicationGraph | 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 |
| CDistributedGraphCommunicator | 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) |
| CEnvironment | 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 |
| CGroup | A group of MPI processes |
| Chas_static_type | Check if the type has a static type definition, i.e. kamping::mpi_type_traits is defined |
| Chas_static_type< T, std::void_t< decltype(mpi_type_traits< T >::data_type())> > | Check if the type has a static type definition, i.e. kamping::mpi_type_traits is defined |
| Cis_contiguous_sized_range | 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 |
| Cis_pair_like | 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 |
| Cis_range | A type trait that checks if a type T is a range, i.e., it has std::begin and std::end defined |
| Ckamping_lookup | Lookup policy for KaMPIng that resolves MPI_Datatypes via kamping::mpi_type_traits |
| Cmpi_type_traits | The type trait that maps a C++ type T to an MPI_Datatype for full KaMPIng |
| Cmpi_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 |
| Cmpi_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 |
| Cmpi_type_traits< T, std::enable_if_t< has_auto_dispatched_type_v< T > > > | Partial specialization of mpi_type_traits for types handled by type_dispatcher |
| CMPIAllocator | STL-compatible allocator for requesting memory using the builtin MPI allocator |
| CMpiErrorException | The exception type used when an MPI call did not return MPI_SUCCESS |
| CMPIFailureDetected | Base class for all exceptions thrown by the FaultTolerance plugin. Means, that either a process failed or the communicator was revoked |
| CMPIProcFailedError | Thrown when a process failure prevented the completetion of the MPI operation |
| CMPIProcFailedPendingError | Thrown when a potential sender matching a non-blocking wildcard source receive has failed |
| CMPIResult | MPIResult contains the result of a MPI call wrapped by KaMPIng |
| CMPIRevokedError | Thrown when the communicator was revoked |
| CNonBlockingResult | 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 |
| CPoolAnyResult | Result returned by RequestPool::wait_any() |
| CPooledRequest | Wrapper for MPI requests owned by a RequestPool |
| CRankRange | Struct encapsulating a MPI rank range triplet as used in functions like MPI_Group_range_incl/excl |
| CRankRanges | RankRanges encapsulate multiple rank ranges which are used in functions like MPI_Group_range_incl/excl |
| CRequest | Wrapper for MPI request handles (aka. MPI_Request) |
| CRequestBase | Base class for request wrappers |
| CRequestPool | A pool for storing multiple Request s and checking them for completion |
| CSpan | A span modeled after C++20's std::span |
| CStatus | Wrapper for MPI_Status |
| CTopologyCommunicator | 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 |
| ▼Nstd | STL namespace |
| Ctuple_element< index, kamping::MPIResult< Args... > > | Specialization of the std::tuple_element for kamping::MPIResult. Part of the structured binding machinery |
| Ctuple_size< kamping::MPIResult< Args... > > | Specialization of the std::tuple_size for kamping::MPIResult. Part of the structured binding machinery |
1.10.0