#include <communicator.h>

Inheritance diagram for libMesh::Parallel::Communicator:

Public Types
enum	SendMode { DEFAULT =0, SYNCHRONOUS }
	Whether to use default or synchronous sends? More...

enum	SyncType { NBX, ALLTOALL_COUNTS, SENDRECEIVE }
	What algorithm to use for parallel synchronization? More...

Public Member Functions
	Communicator ()=default

	Communicator (const TIMPI::communicator &comm)

	Communicator (const Communicator &)=delete

Communicator &	operator= (const Communicator &)=delete

	Communicator (Communicator &&)=default

Communicator &	operator= (Communicator &&)=default

	~Communicator ()=default

void	split (int color, int key, Communicator &target) const

void	split_by_type (int split_type, int key, info i, Communicator &target) const

void	duplicate (const Communicator &comm)

void	duplicate (const communicator &comm)

communicator &	get ()

const communicator &	get () const

MessageTag	get_unique_tag (int tagvalue=MessageTag::invalid_tag) const
	Get a tag that is unique to this Communicator. More...

void	reference_unique_tag (int tagvalue) const
	Reference an already-acquired tag, so that we know it will be dereferenced multiple times before we can re-release it. More...

void	dereference_unique_tag (int tagvalue) const
	Dereference an already-acquired tag, and see if we can re-release it. More...

void	clear ()
	Free and reset this communicator. More...

processor_id_type	rank () const

processor_id_type	size () const

constexpr processor_id_type	size () const

void	send_mode (const SendMode sm)
	Explicitly sets the `SendMode` type used for send operations. More...

SendMode	send_mode () const
	Gets the user-requested SendMode. More...

void	sync_type (const SyncType st)
	Explicitly sets the `SyncType` used for sync operations. More...

void	sync_type (const std::string &st)
	Sets the sync type used for sync operations via a string. More...

SyncType	sync_type () const
	Gets the user-requested SyncType. More...

void	barrier () const
	Pause execution until all processors reach a certain point. More...

void	nonblocking_barrier (Request &req) const
	Start a barrier that doesn't block. More...

template<typename T >
timpi_pure bool	verify (const T &r) const
	Check whether a local variable has the same value on all processors, returning true if it does or false if not. More...

template<typename T >
bool	verify (const T &r) const

template<typename T >
timpi_pure bool	semiverify (const T *r) const
	Check whether a local pointer points to the same value on all processors where it is not null, returning true if it does or false if not. More...

template<typename T >
bool	semiverify (const T *r) const

template<typename T >
void	min (const T &r, T &o, Request &req) const
	Non-blocking minimum of the local value `r` into `o` with the request `req`. More...

template<typename T >
void	min (T &r) const
	Take a local variable and replace it with the minimum of it's values on all processors. More...

template<typename A >
void	min (std::vector< bool, A > &r) const

template<typename T >
void	minloc (T &r, unsigned int &min_id) const
	Take a local variable and replace it with the minimum of it's values on all processors, returning the minimum rank of a processor which originally held the minimum value. More...

template<typename T , typename A1 , typename A2 >
void	minloc (std::vector< T, A1 > &r, std::vector< unsigned int, A2 > &min_id) const
	Take a vector of local variables and replace each entry with the minimum of it's values on all processors. More...

template<typename A1 , typename A2 >
void	minloc (std::vector< bool, A1 > &r, std::vector< unsigned int, A2 > &min_id) const

template<typename T >
void	max (const T &r, T &o, Request &req) const
	Non-blocking maximum of the local value `r` into `o` with the request `req`. More...

template<typename T >
void	max (T &r) const
	Take a local variable and replace it with the maximum of it's values on all processors. More...

template<typename A >
void	max (std::vector< bool, A > &r) const

template<typename T >
void	maxloc (T &r, unsigned int &max_id) const
	Take a local variable and replace it with the maximum of it's values on all processors, returning the minimum rank of a processor which originally held the maximum value. More...

template<typename T , typename A1 , typename A2 >
void	maxloc (std::vector< T, A1 > &r, std::vector< unsigned int, A2 > &max_id) const
	Take a vector of local variables and replace each entry with the maximum of it's values on all processors. More...

template<typename A1 , typename A2 >
void	maxloc (std::vector< bool, A1 > &r, std::vector< unsigned int, A2 > &max_id) const

template<typename T >
void	product (T &r) const
	Take a local variable and replace it with the product of its values on all processors. More...

template<typename T >
void	product (const T &r, T &o, Request &req) const
	Non-blocking product of the local value `r` into `o` with the request `req`. More...

template<typename T >
void	logical_and (T &r) const
	Take a local variable and replace it with the logical_and of its values on all processors. More...

template<typename T >
void	logical_and (const T &r, T &o, Request &req) const
	Non-blocking logical_and of the local value `r` into `o` with the request `req`. More...

template<typename T >
void	bitwise_and (T &r) const
	Take a local variable and replace it with the bitwise_and of its values on all processors. More...

template<typename T >
void	bitwise_and (const T &r, T &o, Request &req) const
	Non-blocking bitwise_and of the local value `r` into `o` with the request `req`. More...

template<typename T >
void	logical_or (T &r) const
	Take a local variable and replace it with the logical_or of its values on all processors. More...

template<typename T >
void	logical_or (const T &r, T &o, Request &req) const
	Non-blocking logical_or of the local value `r` into `o` with the request `req`. More...

template<typename T >
void	bitwise_or (T &r) const
	Take a local variable and replace it with the bitwise_or of its values on all processors. More...

template<typename T >
void	bitwise_or (const T &r, T &o, Request &req) const
	Non-blocking bitwise_or of the local value `r` into `o` with the request `req`. More...

template<typename T >
void	logical_xor (T &r) const
	Take a local variable and replace it with the logical_xor of its values on all processors. More...

template<typename T >
void	logical_xor (const T &r, T &o, Request &req) const
	Non-blocking logical_xor of the local value `r` into `o` with the request `req`. More...

template<typename T >
void	bitwise_xor (T &r) const
	Take a local variable and replace it with the bitwise_xor of its values on all processors. More...

template<typename T >
void	bitwise_xor (const T &r, T &o, Request &req) const
	Non-blocking bitwise_xor of the local value `r` into `o` with the request `req`. More...

template<typename T >
void	sum (T &r) const
	Take a local variable and replace it with the sum of it's values on all processors. More...

template<typename T >
void	sum (const T &r, T &o, Request &req) const
	Non-blocking sum of the local value `r` into `o` with the request `req`. More...

template<typename T >
void	set_union (T &data, const unsigned int root_id) const
	Take a container (set, map, unordered_set, multimap, etc) of local variables on each processor, and collect their union over all processors, replacing the original on the processor with rank `root_id`. More...

template<typename T >
void	set_union (T &data) const
	Take a container of local variables on each processor, and replace it with their union over all processors, replacing the original on all processors. More...

status	probe (const unsigned int src_processor_id, const MessageTag &tag=any_tag) const
	Blocking message probe. More...

template<typename T >
Status	packed_range_probe (const unsigned int src_processor_id, const MessageTag &tag, bool &flag) const
	Non-Blocking message probe for a packed range message. More...

template<typename T >
void	send (const unsigned int dest_processor_id, const T &buf, const MessageTag &tag=no_tag) const
	Blocking-send to one processor with data-defined type. More...

template<typename T >
void	send (const unsigned int dest_processor_id, const T &buf, Request &req, const MessageTag &tag=no_tag) const
	Nonblocking-send to one processor with data-defined type. More...

template<typename T >
void	send (const unsigned int dest_processor_id, const T &buf, const DataType &type, const MessageTag &tag=no_tag) const
	Blocking-send to one processor with user-defined type. More...

template<typename T >
void	send (const unsigned int dest_processor_id, const T &buf, const DataType &type, Request &req, const MessageTag &tag=no_tag) const
	Nonblocking-send to one processor with user-defined type. More...

template<typename T >
void	send (const unsigned int dest_processor_id, const T &buf, const NotADataType &type, Request &req, const MessageTag &tag=no_tag) const
	Nonblocking-send to one processor with user-defined packable type. More...

template<typename T >
void	send (const unsigned int dest_processor_id, const std::basic_string< T > &buf, const MessageTag &tag) const

template<typename T >
void	send (const unsigned int dest_processor_id, const std::basic_string< T > &buf, Request &req, const MessageTag &tag) const

template<typename T >
Status	receive (const unsigned int dest_processor_id, T &buf, const MessageTag &tag=any_tag) const
	Blocking-receive from one processor with data-defined type. More...

template<typename T >
void	receive (const unsigned int dest_processor_id, T &buf, Request &req, const MessageTag &tag=any_tag) const
	Nonblocking-receive from one processor with data-defined type. More...

template<typename T >
Status	receive (const unsigned int dest_processor_id, T &buf, const DataType &type, const MessageTag &tag=any_tag) const
	Blocking-receive from one processor with user-defined type. More...

template<typename T >
void	receive (const unsigned int dest_processor_id, T &buf, const DataType &type, Request &req, const MessageTag &tag=any_tag) const
	Nonblocking-receive from one processor with user-defined type. More...

template<typename T >
Status	receive (const unsigned int src_processor_id, std::basic_string< T > &buf, const MessageTag &tag) const

template<typename T >
void	receive (const unsigned int src_processor_id, std::basic_string< T > &buf, Request &req, const MessageTag &tag) const

template<typename T , typename A , typename std::enable_if< std::is_base_of< DataType, StandardType< T >>::value, int >::type = 0>
bool	possibly_receive (unsigned int &src_processor_id, std::vector< T, A > &buf, Request &req, const MessageTag &tag) const
	Nonblocking-receive from one processor with user-defined type. More...

template<typename T , typename A , typename std::enable_if< Has_buffer_type< Packing< T >>::value, int >::type = 0>
bool	possibly_receive (unsigned int &src_processor_id, std::vector< T, A > &buf, Request &req, const MessageTag &tag) const
	dispatches to `possibly_receive_packed_range` More...

template<typename T , typename A , typename std::enable_if< std::is_base_of< DataType, StandardType< T >>::value, int >::type = 0>
bool	possibly_receive (unsigned int &src_processor_id, std::vector< T, A > &buf, const DataType &type, Request &req, const MessageTag &tag) const
	Nonblocking-receive from one processor with user-defined type. More...

template<typename T , typename A , typename std::enable_if< Has_buffer_type< Packing< T >>::value, int >::type = 0>
bool	possibly_receive (unsigned int &src_processor_id, std::vector< T, A > &buf, const NotADataType &type, Request &req, const MessageTag &tag) const
	Nonblocking-receive from one processor with user-defined type. More...

template<typename T , typename A1 , typename A2 >
bool	possibly_receive (unsigned int &src_processor_id, std::vector< std::vector< T, A1 >, A2 > &buf, const DataType &type, Request &req, const MessageTag &tag) const

template<typename Context , typename OutputIter , typename T >
bool	possibly_receive_packed_range (unsigned int &src_processor_id, Context context, OutputIter out, const T output_type, Request &req, const MessageTag &tag) const
	Nonblocking packed range receive from one processor with user-defined type. More...

template<typename Context , typename Iter >
void	send_packed_range (const unsigned int dest_processor_id, const Context *context, Iter range_begin, const Iter range_end, const MessageTag &tag=no_tag, std::size_t approx_buffer_size=1000000) const
	Blocking-send range-of-pointers to one processor. More...

template<typename Context , typename Iter >
void	send_packed_range (const unsigned int dest_processor_id, const Context *context, Iter range_begin, const Iter range_end, Request &req, const MessageTag &tag=no_tag, std::size_t approx_buffer_size=1000000) const
	Nonblocking-send range-of-pointers to one processor. More...

template<typename Context , typename Iter >
void	nonblocking_send_packed_range (const unsigned int dest_processor_id, const Context *context, Iter range_begin, const Iter range_end, Request &req, const MessageTag &tag=no_tag) const
	Similar to the above Nonblocking send_packed_range with a few important differences: More...

template<typename Context , typename Iter >
void	nonblocking_send_packed_range (const unsigned int dest_processor_id, const Context *context, Iter range_begin, const Iter range_end, Request &req, std::shared_ptr< std::vector< typename TIMPI::Packing< typename std::iterator_traits< Iter >::value_type >::buffer_type >> &buffer, const MessageTag &tag=no_tag) const
	Similar to the above Nonblocking send_packed_range with a few important differences: More...

template<typename Context , typename Iter >
void	nonblocking_send_packed_range (const unsigned int dest_processor_id, const Context *context, Iter range_begin, const Iter range_end, Request &req, std::shared_ptr< std::vector< typename Packing< typename std::iterator_traits< Iter >::value_type >::buffer_type >> &buffer, const MessageTag &tag) const

template<typename Context , typename OutputIter , typename T >
void	receive_packed_range (const unsigned int dest_processor_id, Context context, OutputIter out, const T output_type, const MessageTag &tag=any_tag) const
	Blocking-receive range-of-pointers from one processor. More...

template<typename Context , typename OutputIter , typename T >
void	nonblocking_receive_packed_range (const unsigned int src_processor_id, Context context, OutputIter out, const T output_type, Request &req, Status &stat, const MessageTag &tag=any_tag) const
	Non-Blocking-receive range-of-pointers from one processor. More...

template<typename Context , typename OutputIter , typename T >
void	nonblocking_receive_packed_range (const unsigned int src_processor_id, Context context, OutputIter out, const T output_type, Request &req, Status &stat, std::shared_ptr< std::vector< typename TIMPI::Packing< T >::buffer_type >> &buffer, const MessageTag &tag=any_tag) const
	Non-Blocking-receive range-of-pointers from one processor. More...

template<typename Context , typename OutputIter , typename T >
void	nonblocking_receive_packed_range (const unsigned int src_processor_id, Context context, OutputIter out, const T , Request &req, Status &stat, std::shared_ptr< std::vector< typename Packing< T >::buffer_type >> &buffer, const MessageTag &tag) const

template<typename T1 , typename T2 , typename std::enable_if< std::is_base_of< DataType, StandardType< T1 >>::value &&std::is_base_of< DataType, StandardType< T2 >>::value, int >::type = 0>
void	send_receive (const unsigned int dest_processor_id, const T1 &send_data, const unsigned int source_processor_id, T2 &recv_data, const MessageTag &send_tag=no_tag, const MessageTag &recv_tag=any_tag) const
	Send data `send` to one processor while simultaneously receiving other data `recv` from a (potentially different) processor. More...

template<typename T1 , typename T2 >
void	send_receive (const unsigned int dest_processor_id, const T1 &send_data, const DataType &type1, const unsigned int source_processor_id, T2 &recv_data, const DataType &type2, const MessageTag &send_tag=no_tag, const MessageTag &recv_tag=any_tag) const
	Send data `send` to one processor while simultaneously receiving other data `recv` from a (potentially different) processor, using a user-specified MPI Dataype. More...

template<typename T , typename A , typename std::enable_if< Has_buffer_type< Packing< T >>::value, int >::type >
void	send_receive (const unsigned int dest_processor_id, const std::vector< T, A > &send_data, const unsigned int source_processor_id, std::vector< T, A > &recv_data, const MessageTag &send_tag, const MessageTag &recv_tag) const

template<typename T , typename A1 , typename A2 >
void	send_receive (const unsigned int dest_processor_id, const std::vector< std::vector< T, A1 >, A2 > &sendvec, const unsigned int source_processor_id, std::vector< std::vector< T, A1 >, A2 > &recv, const MessageTag &send_tag, const MessageTag &recv_tag) const

template<typename T1 , typename T2 , typename std::enable_if< std::is_base_of< DataType, StandardType< T1 >>::value &&std::is_base_of< DataType, StandardType< T2 >>::value, int >::type >
void	send_receive (const unsigned int timpi_dbg_var(send_tgt), const T1 &send_val, const unsigned int timpi_dbg_var(recv_source), T2 &recv_val, const MessageTag &, const MessageTag &) const
	Send-receive data from one processor. More...

template<typename T , typename A , typename std::enable_if< std::is_base_of< DataType, StandardType< T >>::value, int >::type >
void	send_receive (const unsigned int timpi_dbg_var(dest_processor_id), const std::vector< T, A > &send, const unsigned int timpi_dbg_var(source_processor_id), std::vector< T, A > &recv, const MessageTag &, const MessageTag &) const

template<typename T , typename A1 , typename A2 >
void	send_receive (const unsigned int timpi_dbg_var(dest_processor_id), const std::vector< std::vector< T, A1 >, A2 > &send, const unsigned int timpi_dbg_var(source_processor_id), std::vector< std::vector< T, A1 >, A2 > &recv, const MessageTag &, const MessageTag &) const

template<typename Context1 , typename RangeIter , typename Context2 , typename OutputIter , typename T >
void	send_receive_packed_range (const unsigned int dest_processor_id, const Context1 context1, RangeIter send_begin, const RangeIter send_end, const unsigned int source_processor_id, Context2 context2, OutputIter out, const T *output_type, const MessageTag &send_tag=no_tag, const MessageTag &recv_tag=any_tag, std::size_t approx_buffer_size=1000000) const
	Send a range-of-pointers to one processor while simultaneously receiving another range from a (potentially different) processor. More...

template<typename Context1 , typename RangeIter , typename Context2 , typename OutputIter , typename T >
void	send_receive_packed_range (const unsigned int timpi_dbg_var(dest_processor_id), const Context1 context1, RangeIter send_begin, const RangeIter send_end, const unsigned int timpi_dbg_var(source_processor_id), Context2 context2, OutputIter out_iter, const T *output_type, const MessageTag &, const MessageTag &, std::size_t) const
	Send-receive range-of-pointers from one processor. More...

template<typename T , typename A >
void	gather (const unsigned int root_id, const T &send_data, std::vector< T, A > &recv) const
	Take a vector of length comm.size(), and on processor root_id fill in recv[processor_id] = the value of send on processor processor_id. More...

template<typename T , typename A >
void	gather (const unsigned int root_id, const std::basic_string< T > &send_data, std::vector< std::basic_string< T >, A > &recv_data, const bool identical_buffer_sizes=false) const
	The gather overload for string types has an optional identical_buffer_sizes optimization for when all strings are the same length. More...

template<typename T , typename A , typename std::enable_if< std::is_base_of< DataType, StandardType< T >>::value, int >::type = 0>
void	gather (const unsigned int root_id, std::vector< T, A > &r) const
	Take a vector of local variables and expand it on processor root_id to include values from all processors More...

template<typename T , typename A , typename std::enable_if< Has_buffer_type< Packing< T >>::value, int >::type = 0>
void	gather (const unsigned int root_id, std::vector< T, A > &r) const

template<typename T , typename A , typename std::enable_if< std::is_base_of< DataType, StandardType< T >>::value, int >::type = 0>
void	allgather (const T &send_data, std::vector< T, A > &recv_data) const
	Take a vector of length `this->size()`, and fill in `recv`[processor_id] = the value of `send` on that processor. More...

template<typename T , typename A , typename std::enable_if< Has_buffer_type< Packing< T >>::value, int >::type = 0>
void	allgather (const T &send_data, std::vector< T, A > &recv_data) const
	Take a vector of length `this->size()`, and fill in `recv`[processor_id] = the value of `send` on that processor. More...

template<typename T , typename A >
void	allgather (const std::basic_string< T > &send_data, std::vector< std::basic_string< T >, A > &recv_data, const bool identical_buffer_sizes=false) const
	The allgather overload for string types has an optional identical_buffer_sizes optimization for when all strings are the same length. More...

template<typename T , typename A , typename std::enable_if< std::is_base_of< DataType, StandardType< T >>::value, int >::type = 0>
void	allgather (std::vector< T, A > &r, const bool identical_buffer_sizes=false) const
	Take a vector of fixed size local variables and expand it to include values from all processors. More...

template<typename T , typename A1 , typename A2 , typename std::enable_if< std::is_base_of< DataType, StandardType< T >>::value, int >::type = 0>
void	allgather (const std::vector< T, A1 > &send_data, std::vector< std::vector< T, A1 >, A2 > &recv_data, const bool identical_buffer_sizes=false) const
	Take a vector of fixed size local variables and collect similar vectors from all processors. More...

template<typename T , typename A1 , typename A2 , typename std::enable_if< Has_buffer_type< Packing< T >>::value, int >::type = 0>
void	allgather (const std::vector< T, A1 > &send_data, std::vector< std::vector< T, A1 >, A2 > &recv_data, const bool identical_buffer_sizes=false) const
	Take a vector of dynamic-size local variables and collect similar vectors from all processors. More...

template<typename T , typename A , typename std::enable_if< Has_buffer_type< Packing< T >>::value, int >::type = 0>
void	allgather (std::vector< T, A > &r, const bool identical_buffer_sizes=false) const
	Take a vector of possibly dynamically sized local variables and expand it to include values from all processors. More...

template<typename T , typename A >
void	allgather (std::vector< std::basic_string< T >, A > &r, const bool identical_buffer_sizes=false) const
	AllGather overload for vectors of string types. More...

template<typename T , typename A >
void	scatter (const std::vector< T, A > &data, T &recv, const unsigned int root_id=0) const
	Take a vector of local variables and scatter the ith item to the ith processor in the communicator. More...

template<typename T , typename A >
void	scatter (const std::vector< T, A > &data, std::vector< T, A > &recv, const unsigned int root_id=0) const
	Take a vector of local variables and scatter the ith equal-sized chunk to the ith processor in the communicator. More...

template<typename T , typename A1 , typename A2 >
void	scatter (const std::vector< T, A1 > &data, const std::vector< CountType, A2 > counts, std::vector< T, A1 > &recv, const unsigned int root_id=0) const
	Take a vector of local variables and scatter the ith variable-sized chunk to the ith processor in the communicator. More...

template<typename T , typename A1 , typename A2 >
void	scatter (const std::vector< T, A1 > &data, const std::vector< int, A2 > counts, std::vector< T, A1 > &recv, const unsigned int root_id=0) const
	vector<int> based scatter, for backwards compatibility More...

template<typename T , typename A1 , typename A2 >
void	scatter (const std::vector< std::vector< T, A1 >, A2 > &data, std::vector< T, A1 > &recv, const unsigned int root_id=0, const bool identical_buffer_sizes=false) const
	Take a vector of vectors and scatter the ith inner vector to the ith processor in the communicator. More...

template<typename Context , typename Iter , typename OutputIter >
void	gather_packed_range (const unsigned int root_id, Context *context, Iter range_begin, const Iter range_end, OutputIter out, std::size_t approx_buffer_size=1000000) const
	Take a range of local variables, combine it with ranges from all processors, and write the output to the output iterator on rank root. More...

template<typename Context , typename Iter , typename OutputIter >
void	allgather_packed_range (Context *context, Iter range_begin, const Iter range_end, OutputIter out, std::size_t approx_buffer_size=1000000) const
	Take a range of local variables, combine it with ranges from all processors, and write the output to the output iterator. More...

template<typename T , typename A >
void	alltoall (std::vector< T, A > &r) const
	Effectively transposes the input vector across all processors. More...

template<typename T #ifdef TIMPI_HAVE_MPI, typename std::enable_if< std::is_base_of< DataType, StandardType< T >>::value, int >::type = 0 #endif>
void	broadcast (T &data, const unsigned int root_id=0, const bool identical_sizes=false) const
	Take a local value and broadcast it to all processors. More...

template<typename T , typename std::enable_if< Has_buffer_type< Packing< T >>::value, int >::type = 0>
void	broadcast (T &data, const unsigned int root_id=0, const bool identical_sizes=false) const
	Take a possibly dynamically-sized local value and broadcast it to all processors. More...

template<typename T >
void	broadcast (std::basic_string< T > &data, const unsigned int root_id, const bool identical_sizes) const

template<typename T , typename A >
void	broadcast (std::vector< std::basic_string< T >, A > &data, const unsigned int root_id, const bool identical_sizes) const

template<typename Context , typename OutputContext , typename Iter , typename OutputIter >
void	broadcast_packed_range (const Context context1, Iter range_begin, const Iter range_end, OutputContext context2, OutputIter out, const unsigned int root_id=0, std::size_t approx_buffer_size=1000000) const
	Blocking-broadcast range-of-pointers to one processor. More...

Detailed Description

Definition at line 1508 of file communicator.h.

Member Enumeration Documentation

◆ SendMode

enum TIMPI::Communicator::SendMode

inherited

Whether to use default or synchronous sends?

Enumerator
DEFAULT
SYNCHRONOUS

Definition at line 220 of file communicator.h.

220 { DEFAULT=0, SYNCHRONOUS };

TIMPI::Communicator::SYNCHRONOUS

Definition: communicator.h:220

TIMPI::Communicator::DEFAULT

Definition: communicator.h:220

◆ SyncType

enum TIMPI::Communicator::SyncType

inherited

What algorithm to use for parallel synchronization?

Enumerator
NBX
ALLTOALL_COUNTS
SENDRECEIVE

Definition at line 225 of file communicator.h.

225 { NBX, ALLTOALL_COUNTS, SENDRECEIVE };

TIMPI::Communicator::NBX

Definition: communicator.h:225

TIMPI::Communicator::ALLTOALL_COUNTS

Definition: communicator.h:225

TIMPI::Communicator::SENDRECEIVE

Definition: communicator.h:225

Constructor & Destructor Documentation

◆ Communicator() [1/4]

libMesh::Parallel::Communicator::Communicator ( )

default

◆ Communicator() [2/4]

libMesh::Parallel::Communicator::Communicator ( const TIMPI::communicator & comm )

inlineexplicit

Definition at line 1511 of file communicator.h.

1511 : TIMPI::Communicator(comm) {}

TIMPI::Communicator

Encapsulates the MPI_Comm object.

Definition: communicator.h:108

◆ Communicator() [3/4]

libMesh::Parallel::Communicator::Communicator ( const Communicator & )

delete

◆ Communicator() [4/4]

libMesh::Parallel::Communicator::Communicator ( Communicator && )

default

◆ ~Communicator()

libMesh::Parallel::Communicator::~Communicator ( )

default

Member Function Documentation

◆ allgather() [1/8]

template<typename T , typename A , typename std::enable_if< std::is_base_of< DataType, StandardType< T >>::value, int >::type = 0>

void TIMPI::Communicator::allgather	(	const T &	send_data,
		std::vector< T, A > &	recv_data
	)		const

inlineinherited

Take a vector of length this->size(), and fill in recv[processor_id] = the value of send on that processor.

This overload works on fixed size types

Referenced by TIMPI::Communicator::allgather(), TIMPI::Communicator::map_max(), testAllGather(), testAllGatherEmptyVectorString(), testAllGatherHalfEmptyVectorString(), testAllGatherString(), testAllGatherVectorString(), testAllGatherVectorVector(), testAllGatherVectorVectorInPlace(), testAllGatherVectorVectorPacked(), testArrayContainerAllGather(), testContainerAllGather(), testMapContainerAllGather(), testPairContainerAllGather(), testTupleContainerAllGather(), and testVectorOfContainersAllGather().

◆ allgather() [2/8]

template<typename T , typename A , typename std::enable_if< Has_buffer_type< Packing< T >>::value, int >::type = 0>

void TIMPI::Communicator::allgather	(	const T &	send_data,
		std::vector< T, A > &	recv_data
	)		const

inlineinherited

Take a vector of length this->size(), and fill in recv[processor_id] = the value of send on that processor.

This overload works on potentially dynamically sized types, and dispatches to allgather_packed_range

◆ allgather() [3/8]

template<typename T , typename A >

void TIMPI::Communicator::allgather	(	const std::basic_string< T > &	send_data,
		std::vector< std::basic_string< T >, A > &	recv_data,
		const bool	identical_buffer_sizes = `false`
	)		const

inlineinherited

The allgather overload for string types has an optional identical_buffer_sizes optimization for when all strings are the same length.

Definition at line 1629 of file parallel_implementation.h.

References TIMPI::Communicator::allgather(), and TIMPI::Communicator::size().

 {
   TIMPI_LOG_SCOPE ("allgather()","Parallel");
 
   timpi_assert(this->size());
   recv.assign(this->size(), "");
 
   // serial case
   if (this->size() < 2)
     {
       recv.resize(1);
       recv[0] = sendval;
       return;
     }
 
   std::vector<CountType>
     sendlengths  (this->size(), 0);
   std::vector<DispType>
     displacements(this->size(), 0);
 
   const CountType mysize = cast_int<CountType>(sendval.size());
 
   if (identical_buffer_sizes)
     sendlengths.assign(this->size(), mysize);
   else
     // first comm step to determine buffer sizes from all processors
     this->allgather(mysize, sendlengths);
 
   // Find the total size of the final array and
   // set up the displacement offsets for each processor
   CountType globalsize = 0;
   for (unsigned int i=0; i != this->size(); ++i)
     {
       displacements[i] = globalsize;
       globalsize += sendlengths[i];
     }
 
   // Check for quick return
   if (globalsize == 0)
     return;
 
   // monolithic receive buffer
   std::basic_string<T> r(globalsize, 0);
 
   // and get the data from the remote processors.
   timpi_call_mpi
     (TIMPI_ALLGATHERV(const_cast<T*>(mysize ? sendval.data() : nullptr),
                       mysize, StandardType<T>(),
                       &r[0], sendlengths.data(), displacements.data(),
                       StandardType<T>(), this->get()));
 
   // slice receive buffer up
   for (unsigned int i=0; i != this->size(); ++i)
     recv[i] = r.substr(displacements[i], sendlengths[i]);
 }

◆ allgather() [4/8]

template<typename T , typename A , typename std::enable_if< std::is_base_of< DataType, StandardType< T >>::value, int >::type = 0>

void TIMPI::Communicator::allgather	(	std::vector< T, A > &	r,
		const bool	identical_buffer_sizes = `false`
	)		const

inlineinherited

Take a vector of fixed size local variables and expand it to include values from all processors.

By default, each processor is allowed to have its own unique input buffer length. If it is known that all processors have the same input sizes additional communication can be avoided.

Specifically, this function transforms this:

* Processor 0: [ ... N_0 ]
* Processor 1: [ ....... N_1 ]
* ...
* Processor M: [ .. N_M]
*

into this:

* [ [ ... N_0 ] [ ....... N_1 ] ... [ .. N_M] ]
*

on each processor. This function is collective and therefore must be called by all processors in the Communicator.

◆ allgather() [5/8]

template<typename T , typename A1 , typename A2 , typename std::enable_if< std::is_base_of< DataType, StandardType< T >>::value, int >::type = 0>

void TIMPI::Communicator::allgather	(	const std::vector< T, A1 > &	send_data,
		std::vector< std::vector< T, A1 >, A2 > &	recv_data,
		const bool	identical_buffer_sizes = `false`
	)		const

inlineinherited

Take a vector of fixed size local variables and collect similar vectors from all processors.

By default, each processor is allowed to have its own unique input buffer length. If it is known that all processors have the same input sizes additional communication can be avoided.

◆ allgather() [6/8]

template<typename T , typename A1 , typename A2 , typename std::enable_if< Has_buffer_type< Packing< T >>::value, int >::type = 0>

void TIMPI::Communicator::allgather	(	const std::vector< T, A1 > &	send_data,
		std::vector< std::vector< T, A1 >, A2 > &	recv_data,
		const bool	identical_buffer_sizes = `false`
	)		const

inlineinherited

Take a vector of dynamic-size local variables and collect similar vectors from all processors.

◆ allgather() [7/8]

template<typename T , typename A , typename std::enable_if< Has_buffer_type< Packing< T >>::value, int >::type = 0>

void TIMPI::Communicator::allgather	(	std::vector< T, A > &	r,
		const bool	identical_buffer_sizes = `false`
	)		const

inlineinherited

Take a vector of possibly dynamically sized local variables and expand it to include values from all processors.

By default, each processor is allowed to have its own unique input buffer length. If it is known that all processors have the same input sizes additional communication can be avoided.

Specifically, this function transforms this:

* Processor 0: [ ... N_0 ]
* Processor 1: [ ....... N_1 ]
* ...
* Processor M: [ .. N_M]
*

into this:

* [ [ ... N_0 ] [ ....... N_1 ] ... [ .. N_M] ]
*

on each processor. This function is collective and therefore must be called by all processors in the Communicator.

◆ allgather() [8/8]

template<typename T , typename A >

void TIMPI::Communicator::allgather	(	std::vector< std::basic_string< T >, A > &	r,
		const bool	identical_buffer_sizes = `false`
	)		const

inlineinherited

AllGather overload for vectors of string types.

◆ allgather_packed_range()

template<typename Context , typename Iter , typename OutputIter >

void TIMPI::Communicator::allgather_packed_range	(	Context *	context,
		Iter	range_begin,
		const Iter	range_end,
		OutputIter	out,
		std::size_t	approx_buffer_size = `1000000`
	)		const

inlineinherited

Take a range of local variables, combine it with ranges from all processors, and write the output to the output iterator.

The approximate maximum size (in entries; number of bytes will likely be 4x or 8x larger) to use in a single data vector buffer to send can be specified for performance or memory usage reasons; if the range cannot be packed into a single buffer of this size then multiple buffers and messages will be used.

Note that the received data vector sizes will be the sum of the sent vector sizes; a smaller-than-default size may be useful for users on many processors, in cases where all-to-one communication cannot be avoided entirely.

Referenced by testGettableStringAllGather(), testNestingAllGather(), testNullAllGather(), and testTupleStringAllGather().

◆ alltoall()

template<typename T , typename A >

void TIMPI::Communicator::alltoall ( std::vector< T, A > & r ) const

inlineinherited

Effectively transposes the input vector across all processors.

The jth entry on processor i is replaced with the ith entry from processor j.

Referenced by TIMPI::detail::push_parallel_alltoall_helper().

◆ barrier()

void TIMPI::Communicator::barrier ( ) const

inherited

Pause execution until all processors reach a certain point.

Definition at line 225 of file communicator.C.

References TIMPI::Communicator::size().

Referenced by testBarrier(), and TIMPI::TIMPIInit::~TIMPIInit().

 {
   if (this->size() > 1)
     {
       TIMPI_LOG_SCOPE("barrier()", "Communicator");
       timpi_call_mpi(MPI_Barrier (this->get()));
     }
 }

◆ bitwise_and() [1/2]

template<typename T >

void TIMPI::Communicator::bitwise_and ( T & r ) const

inlineinherited

Take a local variable and replace it with the bitwise_and of its values on all processors.

Containers are replaced element-wise.

◆ bitwise_and() [2/2]

template<typename T >

void TIMPI::Communicator::bitwise_and	(	const T &	r,
		T &	o,
		Request &	req
	)		const

inlineinherited

Non-blocking bitwise_and of the local value r into o with the request req.

◆ bitwise_or() [1/2]

template<typename T >

void TIMPI::Communicator::bitwise_or ( T & r ) const

inlineinherited

Take a local variable and replace it with the bitwise_or of its values on all processors.

Containers are replaced element-wise.

◆ bitwise_or() [2/2]

template<typename T >

void TIMPI::Communicator::bitwise_or	(	const T &	r,
		T &	o,
		Request &	req
	)		const

inlineinherited

Non-blocking bitwise_or of the local value r into o with the request req.

◆ bitwise_xor() [1/2]

template<typename T >

void TIMPI::Communicator::bitwise_xor ( T & r ) const

inlineinherited

Take a local variable and replace it with the bitwise_xor of its values on all processors.

Containers are replaced element-wise.

◆ bitwise_xor() [2/2]

template<typename T >

void TIMPI::Communicator::bitwise_xor	(	const T &	r,
		T &	o,
		Request &	req
	)		const

inlineinherited

Non-blocking bitwise_xor of the local value r into o with the request req.

◆ broadcast() [1/4]

template<typename T #ifdef TIMPI_HAVE_MPI, typename std::enable_if< std::is_base_of< DataType, StandardType< T >>::value, int >::type = 0 #endif>

void TIMPI::Communicator::broadcast	(	T &	data,
		const unsigned int	root_id = `0`,
		const bool	identical_sizes = `false`
	)		const

inlineinherited

Take a local value and broadcast it to all processors.

Optionally takes the root_id processor, which specifies the processor initiating the broadcast.

If data is a container, it will be resized on target processors. When using pre-sized target containers, specify identical_sizes=true on all processors for an optimization.

Fixed variant

Referenced by TIMPI::Communicator::broadcast(), testBroadcast(), testBroadcastArrayType(), testBroadcastNestedType(), testBroadcastString(), testContainerBroadcast(), and testVectorOfContainersBroadcast().

◆ broadcast() [2/4]

template<typename T , typename std::enable_if< Has_buffer_type< Packing< T >>::value, int >::type = 0>

void TIMPI::Communicator::broadcast	(	T &	data,
		const unsigned int	root_id = `0`,
		const bool	identical_sizes = `false`
	)		const

inlineinherited

Take a possibly dynamically-sized local value and broadcast it to all processors.

Optionally takes the root_id processor, which specifies the processor initiating the broadcast.

If data is a container, it will be resized on target processors. When using pre-sized target containers, specify identical_sizes=true on all processors for an optimization.

Dynamic variant

◆ broadcast() [3/4]

template<typename T >

void TIMPI::Communicator::broadcast	(	std::basic_string< T > &	data,
		const unsigned int	root_id,
		const bool	identical_sizes
	)		const

inlineinherited

Definition at line 1720 of file parallel_implementation.h.

References TIMPI::Communicator::broadcast(), TIMPI::Communicator::rank(), TIMPI::Communicator::size(), and TIMPI::Communicator::verify().

 {
   if (this->size() == 1)
     {
       timpi_assert (!this->rank());
       timpi_assert (!root_id);
       return;
     }
 
   timpi_assert_less (root_id, this->size());
   timpi_assert (this->verify(identical_sizes));
 
   TIMPI_LOG_SCOPE("broadcast()", "Parallel");
 
   std::size_t data_size = data.size();
 
   if (identical_sizes)
     timpi_assert(this->verify(data_size));
   else
     this->broadcast(data_size, root_id);
 
   std::vector<T> data_c(data_size);
 #ifndef NDEBUG
   std::basic_string<T> orig(data);
 #endif
 
   if (this->rank() == root_id)
     for (std::size_t i=0; i<data.size(); i++)
       data_c[i] = data[i];
 
   this->broadcast (data_c, root_id, StandardType<T>::is_fixed_type);
 
   data.assign(data_c.begin(), data_c.end());
 
 #ifndef NDEBUG
   if (this->rank() == root_id)
     timpi_assert_equal_to (data, orig);
 #endif
 }

◆ broadcast() [4/4]

template<typename T , typename A >

void TIMPI::Communicator::broadcast	(	std::vector< std::basic_string< T >, A > &	data,
		const unsigned int	root_id,
		const bool	identical_sizes
	)		const

inlineinherited

The strings will be packed in one long array with the size of each string preceding the actual characters

Definition at line 1764 of file parallel_implementation.h.

References TIMPI::Communicator::broadcast(), TIMPI::Communicator::rank(), TIMPI::Communicator::size(), and TIMPI::Communicator::verify().

 {
   if (this->size() == 1)
     {
       timpi_assert (!this->rank());
       timpi_assert (!root_id);
       return;
     }
 
   timpi_assert_less (root_id, this->size());
   timpi_assert (this->verify(identical_sizes));
 
   TIMPI_LOG_SCOPE("broadcast()", "Parallel");
 
   std::size_t bufsize=0;
   if (root_id == this->rank() || identical_sizes)
     {
       for (std::size_t i=0; i<data.size(); ++i)
         bufsize += data[i].size() + 1;  // Add one for the string length word
     }
 
   if (identical_sizes)
     timpi_assert(this->verify(bufsize));
   else
     this->broadcast(bufsize, root_id);
 
   // Here we use unsigned int to store up to 32-bit characters
   std::vector<unsigned int> temp; temp.reserve(bufsize);
   // Pack the strings
   if (root_id == this->rank())
     {
       for (std::size_t i=0; i<data.size(); ++i)
         {
           temp.push_back(cast_int<unsigned int>(data[i].size()));
           for (std::size_t j=0; j != data[i].size(); ++j)
             temp.push_back(data[i][j]);
         }
     }
   else
     temp.resize(bufsize);
 
   // broad cast the packed strings
   this->broadcast(temp, root_id, true);
 
   // Unpack the strings
   if (root_id != this->rank())
     {
       data.clear();
       typename std::vector<unsigned int>::const_iterator iter = temp.begin();
       while (iter != temp.end())
         {
           std::size_t curr_len = *iter++;
           data.push_back(std::basic_string<T>(iter, iter+curr_len));
           iter += curr_len;
         }
     }
 }

◆ broadcast_packed_range()

template<typename Context , typename OutputContext , typename Iter , typename OutputIter >

void TIMPI::Communicator::broadcast_packed_range	(	const Context *	context1,
		Iter	range_begin,
		const Iter	range_end,
		OutputContext *	context2,
		OutputIter	out,
		const unsigned int	root_id = `0`,
		std::size_t	approx_buffer_size = `1000000`
	)		const

inlineinherited

Blocking-broadcast range-of-pointers to one processor.

This function does not send the raw pointers, but rather constructs new objects at the other end whose contents match the objects pointed to by the sender.

void TIMPI::pack(const T *, vector<int> & data, const Context *) is used to serialize type T onto the end of a data vector.

unsigned int TIMPI::packable_size(const T *, const Context *) is used to allow data vectors to reserve memory, and for additional error checking

unsigned int TIMPI::packed_size(const T *, vector<int>::const_iterator) is used to advance to the beginning of the next object's data.

The approximate maximum size (in entries; number of bytes will likely be 4x or 8x larger) to use in a single data vector buffer can be specified for performance or memory usage reasons; if the range cannot be packed into a single buffer of this size then multiple buffers and messages will be used.

◆ clear()

void TIMPI::Communicator::clear ( )

inherited

Free and reset this communicator.

Definition at line 162 of file communicator.C.

References TIMPI::Communicator::_communicator, and TIMPI::Communicator::_I_duped_it.

Referenced by TIMPI::Communicator::operator=(), TIMPI::Communicator::split(), TIMPI::Communicator::split_by_type(), and TIMPI::Communicator::~Communicator().

                          {
 #ifdef TIMPI_HAVE_MPI
   if (_I_duped_it)
     {
       timpi_assert (_communicator != MPI_COMM_NULL);
       timpi_call_mpi
         (MPI_Comm_free(&_communicator));
 
       _communicator = MPI_COMM_NULL;
     }
   _I_duped_it = false;
 #endif
 }

◆ dereference_unique_tag()

void TIMPI::Communicator::dereference_unique_tag ( int tagvalue ) const

inherited

Dereference an already-acquired tag, and see if we can re-release it.

Definition at line 46 of file communicator.C.

References TIMPI::Communicator::used_tag_values.

Referenced by TIMPI::MessageTag::operator=(), and TIMPI::MessageTag::~MessageTag().

 {
   // This had better be an already-acquired tag.
   timpi_assert(used_tag_values.count(tagvalue));
 
   used_tag_values[tagvalue]--;
   // If we don't have any more outstanding references, we
   // don't even need to keep this tag in our "used" set.
   if (!used_tag_values[tagvalue])
     used_tag_values.erase(tagvalue);
 }

◆ duplicate() [1/2]

void TIMPI::Communicator::duplicate ( const Communicator & comm )

inherited

Definition at line 137 of file communicator.C.

References TIMPI::Communicator::_communicator, TIMPI::Communicator::send_mode(), and TIMPI::Communicator::sync_type().

Referenced by testGetUniqueTagAuto(), and testStringSyncType().

 {
   this->duplicate(comm._communicator);
   this->send_mode(comm.send_mode());
   this->sync_type(comm.sync_type());
 }

◆ duplicate() [2/2]

void TIMPI::Communicator::duplicate ( const communicator & comm )

inherited

Definition at line 146 of file communicator.C.

References TIMPI::Communicator::_communicator, TIMPI::Communicator::_I_duped_it, and TIMPI::Communicator::assign().

 {
   if (_communicator != MPI_COMM_NULL)
     {
       timpi_call_mpi
         (MPI_Comm_dup(comm, &_communicator));
 
       _I_duped_it = true;
     }
   this->assign(_communicator);
 }

◆ gather() [1/4]

template<typename T , typename A >

void TIMPI::Communicator::gather	(	const unsigned int	root_id,
		const T &	send_data,
		std::vector< T, A > &	recv
	)		const

inlineinherited

Take a vector of length comm.size(), and on processor root_id fill in recv[processor_id] = the value of send on processor processor_id.

Referenced by testGather(), testGatherString(), and testGatherString2().

◆ gather() [2/4]

template<typename T , typename A >

void TIMPI::Communicator::gather	(	const unsigned int	root_id,
		const std::basic_string< T > &	send_data,
		std::vector< std::basic_string< T >, A > &	recv_data,
		const bool	identical_buffer_sizes = `false`
	)		const

inlineinherited

The gather overload for string types has an optional identical_buffer_sizes optimization for when all strings are the same length.

◆ gather() [3/4]

template<typename T , typename A , typename std::enable_if< std::is_base_of< DataType, StandardType< T >>::value, int >::type = 0>

void TIMPI::Communicator::gather	(	const unsigned int	root_id,
		std::vector< T, A > &	r
	)		const

inlineinherited

Take a vector of local variables and expand it on processor root_id to include values from all processors

This handles the case where the lengths of the vectors may vary. Specifically, this function transforms this:

* Processor 0: [ ... N_0 ]
* Processor 1: [ ....... N_1 ]
* ...
* Processor M: [ .. N_M]
*

into this:

* [ [ ... N_0 ] [ ....... N_1 ] ... [ .. N_M] ]
*

on processor root_id. This function is collective and therefore must be called by all processors in the Communicator.

If the type T is a standard (fixed-size) type then we use a standard MPI_Gatherv; if it is a packable variable-size type then we dispatch to gather_packed_range.

◆ gather() [4/4]

template<typename T , typename A , typename std::enable_if< Has_buffer_type< Packing< T >>::value, int >::type = 0>

void TIMPI::Communicator::gather	(	const unsigned int	root_id,
		std::vector< T, A > &	r
	)		const

inlineinherited

◆ gather_packed_range()

template<typename Context , typename Iter , typename OutputIter >

void TIMPI::Communicator::gather_packed_range	(	const unsigned int	root_id,
		Context *	context,
		Iter	range_begin,
		const Iter	range_end,
		OutputIter	out,
		std::size_t	approx_buffer_size = `1000000`
	)		const

inlineinherited

Take a range of local variables, combine it with ranges from all processors, and write the output to the output iterator on rank root.

The approximate maximum size (in entries; number of bytes will likely be 4x or 8x larger) to use in a single data vector buffer to send can be specified for performance or memory usage reasons; if the range cannot be packed into a single buffer of this size then multiple buffers and messages will be used.

Note that the received data vector sizes will be the sum of the sent vector sizes; a smaller-than-default size may be useful for users on many processors, in cases where all-to-one communication cannot be avoided entirely.

◆ get() [1/2]

communicator& TIMPI::Communicator::get ( )

inlineinherited

Definition at line 167 of file communicator.h.

References TIMPI::Communicator::_communicator.

Referenced by TIMPI::PostWaitUnpackNestedBuffer< Container >::run(), and testMPIULongMin().

167 { return _communicator; }

TIMPI::Communicator::_communicator

communicator _communicator

Definition: communicator.h:236

◆ get() [2/2]

const communicator& TIMPI::Communicator::get ( ) const

inlineinherited

Definition at line 169 of file communicator.h.

References TIMPI::Communicator::_communicator.

169 { return _communicator; }

TIMPI::Communicator::_communicator

communicator _communicator

Definition: communicator.h:236

◆ get_unique_tag()

MessageTag TIMPI::Communicator::get_unique_tag ( int tagvalue = MessageTag::invalid_tag ) const

inherited

Get a tag that is unique to this Communicator.

A requested tag value may be provided. If no request is made then an automatic unique tag value will be generated; such usage of get_unique_tag() must be done on every processor in a consistent order.

Note: If people are also using magic numbers or copying raw communicators around then we can't guarantee the tag is unique to this MPI_Comm.; Leaving tagvalue unspecified is recommended in most cases. Manually selecting tag values is dangerous, as tag values may be freed and reselected earlier than expected in asynchronous communication algorithms.

Definition at line 251 of file communicator.C.

References TIMPI::Communicator::_max_tag, TIMPI::Communicator::_next_tag, TIMPI::MessageTag::invalid_tag, TIMPI::Communicator::max(), and TIMPI::Communicator::used_tag_values.

Referenced by TIMPI::pull_parallel_vector_data(), TIMPI::detail::push_parallel_alltoall_helper(), TIMPI::detail::push_parallel_nbx_helper(), TIMPI::detail::push_parallel_roundrobin_helper(), testGetUniqueTagAuto(), testGetUniqueTagManual(), and testGetUniqueTagOverlap().

 {
   if (tagvalue == MessageTag::invalid_tag)
     {
 #ifndef NDEBUG
       // Automatic tag values have to be requested in sync
       int maxval = _next_tag;
       this->max(maxval);
       timpi_assert_equal_to(_next_tag, maxval);
 #endif
       tagvalue = _next_tag++;
     }
 
   if (used_tag_values.count(tagvalue))
     {
       // Get the largest value in the used values, and pick one
       // larger
       tagvalue = used_tag_values.rbegin()->first+1;
       timpi_assert(!used_tag_values.count(tagvalue));
     }
   if (tagvalue >= _next_tag)
     _next_tag = tagvalue+1;
 
   if (_next_tag >= _max_tag)
     _next_tag = _max_tag/2;
 
   used_tag_values[tagvalue] = 1;
 
   return MessageTag(tagvalue, this);
 }

◆ logical_and() [1/2]

template<typename T >

void TIMPI::Communicator::logical_and ( T & r ) const

inlineinherited

Take a local variable and replace it with the logical_and of its values on all processors.

Containers are replaced element-wise.

◆ logical_and() [2/2]

template<typename T >

void TIMPI::Communicator::logical_and	(	const T &	r,
		T &	o,
		Request &	req
	)		const

inlineinherited

Non-blocking logical_and of the local value r into o with the request req.

◆ logical_or() [1/2]

template<typename T >

void TIMPI::Communicator::logical_or ( T & r ) const

inlineinherited

Take a local variable and replace it with the logical_or of its values on all processors.

Containers are replaced element-wise.

◆ logical_or() [2/2]

template<typename T >

void TIMPI::Communicator::logical_or	(	const T &	r,
		T &	o,
		Request &	req
	)		const

inlineinherited

Non-blocking logical_or of the local value r into o with the request req.

◆ logical_xor() [1/2]

template<typename T >

void TIMPI::Communicator::logical_xor ( T & r ) const

inlineinherited

Take a local variable and replace it with the logical_xor of its values on all processors.

Containers are replaced element-wise.

◆ logical_xor() [2/2]

template<typename T >

void TIMPI::Communicator::logical_xor	(	const T &	r,
		T &	o,
		Request &	req
	)		const

inlineinherited

Non-blocking logical_xor of the local value r into o with the request req.

◆ max() [1/3]

template<typename T >

void TIMPI::Communicator::max	(	const T &	r,
		T &	o,
		Request &	req
	)		const

inlineinherited

Non-blocking maximum of the local value r into o with the request req.

Referenced by TIMPI::detail::empty_send_assertion(), TIMPI::Communicator::get_unique_tag(), TIMPI::detail::push_parallel_roundrobin_helper(), TIMPI::Communicator::semiverify(), testInfinityMax(), testMapMax(), testMax(), testMaxVecBool(), testNonblockingMax(), testNonFixedTypeMapMax(), and TIMPI::Communicator::verify().

◆ max() [2/3]

template<typename T >

void TIMPI::Communicator::max ( T & r ) const

inlineinherited

Take a local variable and replace it with the maximum of it's values on all processors.

Containers are replaced element-wise.

◆ max() [3/3]

template<typename A >

void TIMPI::Communicator::max ( std::vector< bool, A > & r ) const

inlineinherited

Definition at line 2303 of file parallel_implementation.h.

References TIMPI::Communicator::size(), and TIMPI::Communicator::verify().

 {
   if (this->size() > 1 && !r.empty())
     {
       TIMPI_LOG_SCOPE("max(vector<bool>)", "Parallel");
 
       timpi_assert(this->verify(r.size()));
 
       std::vector<unsigned int> ruint;
       pack_vector_bool(r, ruint);
       std::vector<unsigned int> temp(ruint.size());
       timpi_call_mpi
         (TIMPI_ALLREDUCE (ruint.data(), temp.data(),
                           cast_int<CountType>(ruint.size()),
                           StandardType<unsigned int>(), MPI_BOR,
                           this->get()));
       unpack_vector_bool(temp, r);
     }
 }

◆ maxloc() [1/3]

template<typename T >

void TIMPI::Communicator::maxloc	(	T &	r,
		unsigned int &	max_id
	)		const

inlineinherited

Take a local variable and replace it with the maximum of it's values on all processors, returning the minimum rank of a processor which originally held the maximum value.

Definition at line 2441 of file parallel_implementation.h.

References TIMPI::ignore(), TIMPI::DataPlusInt< T >::rank, TIMPI::Communicator::rank(), TIMPI::Communicator::size(), and TIMPI::DataPlusInt< T >::val.

Referenced by testMaxloc(), testMaxlocBool(), testMaxlocDouble(), and testMaxlocPair().

 {
   if (this->size() > 1)
     {
       TIMPI_LOG_SCOPE("maxloc(scalar)", "Parallel");
 
       DataPlusInt<T> data_in;
       ignore(data_in); // unused ifndef TIMPI_HAVE_MPI
       data_in.val = r;
       data_in.rank = this->rank();
 
       timpi_call_mpi
         (TIMPI_ALLREDUCE (MPI_IN_PLACE, &data_in, 1,
                           dataplusint_type_acquire<T>().first,
                           OpFunction<T>::max_location(), this->get()));
       r = data_in.val;
       max_id = data_in.rank;
     }
   else
     max_id = this->rank();
 }

◆ maxloc() [2/3]

template<typename T , typename A1 , typename A2 >

void TIMPI::Communicator::maxloc	(	std::vector< T, A1 > &	r,
		std::vector< unsigned int, A2 > &	max_id
	)		const

inlineinherited

Take a vector of local variables and replace each entry with the maximum of it's values on all processors.

Set each min_id entry to the minimum rank where a corresponding maximum was found.

Definition at line 2466 of file parallel_implementation.h.

References TIMPI::Communicator::rank(), TIMPI::Communicator::size(), and TIMPI::Communicator::verify().

 {
   if (this->size() > 1 && !r.empty())
     {
       TIMPI_LOG_SCOPE("maxloc(vector)", "Parallel");
 
       timpi_assert(this->verify(r.size()));
 
       std::vector<DataPlusInt<T>> data_in(r.size());
       for (std::size_t i=0; i != r.size(); ++i)
         {
           data_in[i].val  = r[i];
           data_in[i].rank = this->rank();
         }
       std::vector<DataPlusInt<T>> data_out(r.size());
 
       timpi_call_mpi
         (TIMPI_ALLREDUCE(data_in.data(), data_out.data(),
                          cast_int<CountType>(r.size()),
                          dataplusint_type_acquire<T>().first,
                          OpFunction<T>::max_location(),
                          this->get()));
       for (std::size_t i=0; i != r.size(); ++i)
         {
           r[i]      = data_out[i].val;
           max_id[i] = data_out[i].rank;
         }
     }
   else if (!r.empty())
     {
       for (std::size_t i=0; i != r.size(); ++i)
         max_id[i] = this->rank();
     }
 }

◆ maxloc() [3/3]

template<typename A1 , typename A2 >

void TIMPI::Communicator::maxloc	(	std::vector< bool, A1 > &	r,
		std::vector< unsigned int, A2 > &	max_id
	)		const

inlineinherited

Definition at line 2504 of file parallel_implementation.h.

References TIMPI::Communicator::rank(), TIMPI::Communicator::size(), and TIMPI::Communicator::verify().

 {
   if (this->size() > 1 && !r.empty())
     {
       TIMPI_LOG_SCOPE("maxloc(vector<bool>)", "Parallel");
 
       timpi_assert(this->verify(r.size()));
 
       std::vector<DataPlusInt<int>> data_in(r.size());
       for (std::size_t i=0; i != r.size(); ++i)
         {
           data_in[i].val  = r[i];
           data_in[i].rank = this->rank();
         }
       std::vector<DataPlusInt<int>> data_out(r.size());
       timpi_call_mpi
         (TIMPI_ALLREDUCE(data_in.data(), data_out.data(),
                          cast_int<CountType>(r.size()),
                          StandardType<int>(),
                          OpFunction<int>::max_location(),
                          this->get()));
       for (std::size_t i=0; i != r.size(); ++i)
         {
           r[i]      = data_out[i].val;
           max_id[i] = data_out[i].rank;
         }
     }
   else if (!r.empty())
     {
       for (std::size_t i=0; i != r.size(); ++i)
         max_id[i] = this->rank();
     }
 }

◆ min() [1/3]

template<typename T >

void TIMPI::Communicator::min	(	const T &	r,
		T &	o,
		Request &	req
	)		const

inlineinherited

Non-blocking minimum of the local value r into o with the request req.

Referenced by TIMPI::Communicator::semiverify(), testInfinityMin(), testMin(), testMinLarge(), testMinVecBool(), testNonblockingMin(), testNonblockingTest(), testNonblockingWaitany(), and TIMPI::Communicator::verify().

◆ min() [2/3]

template<typename T >

void TIMPI::Communicator::min ( T & r ) const

inlineinherited

Take a local variable and replace it with the minimum of it's values on all processors.

Containers are replaced element-wise.

◆ min() [3/3]

template<typename A >

void TIMPI::Communicator::min ( std::vector< bool, A > & r ) const

inlineinherited

Definition at line 2182 of file parallel_implementation.h.

References TIMPI::Communicator::size(), and TIMPI::Communicator::verify().

 {
   if (this->size() > 1 && !r.empty())
     {
       TIMPI_LOG_SCOPE("min(vector<bool>)", "Parallel");
 
       timpi_assert(this->verify(r.size()));
 
       std::vector<unsigned int> ruint;
       pack_vector_bool(r, ruint);
       std::vector<unsigned int> temp(ruint.size());
       timpi_call_mpi
         (TIMPI_ALLREDUCE
           (ruint.data(), temp.data(),
            cast_int<CountType>(ruint.size()),
            StandardType<unsigned int>(), MPI_BAND, this->get()));
       unpack_vector_bool(temp, r);
     }
 }

◆ minloc() [1/3]

template<typename T >

void TIMPI::Communicator::minloc	(	T &	r,
		unsigned int &	min_id
	)		const

inlineinherited

Take a local variable and replace it with the minimum of it's values on all processors, returning the minimum rank of a processor which originally held the minimum value.

Definition at line 2204 of file parallel_implementation.h.

References TIMPI::ignore(), TIMPI::DataPlusInt< T >::rank, TIMPI::Communicator::rank(), TIMPI::Communicator::size(), and TIMPI::DataPlusInt< T >::val.

Referenced by testMinloc(), testMinlocBool(), testMinlocDouble(), and testMinlocPair().

 {
   if (this->size() > 1)
     {
       TIMPI_LOG_SCOPE("minloc(scalar)", "Parallel");
 
       DataPlusInt<T> data_in;
       ignore(data_in); // unused ifndef TIMPI_HAVE_MPI
       data_in.val = r;
       data_in.rank = this->rank();
 
       timpi_call_mpi
         (TIMPI_ALLREDUCE (MPI_IN_PLACE, &data_in, 1,
                           dataplusint_type_acquire<T>().first,
                           OpFunction<T>::min_location(), this->get()));
       r = data_in.val;
       min_id = data_in.rank;
     }
   else
     min_id = this->rank();
 }

◆ minloc() [2/3]

template<typename T , typename A1 , typename A2 >

void TIMPI::Communicator::minloc	(	std::vector< T, A1 > &	r,
		std::vector< unsigned int, A2 > &	min_id
	)		const

inlineinherited

Take a vector of local variables and replace each entry with the minimum of it's values on all processors.

Set each min_id entry to the minimum rank where a corresponding minimum was found.

Definition at line 2229 of file parallel_implementation.h.

References TIMPI::Communicator::rank(), TIMPI::Communicator::size(), and TIMPI::Communicator::verify().

 {
   if (this->size() > 1 && !r.empty())
     {
       TIMPI_LOG_SCOPE("minloc(vector)", "Parallel");
 
       timpi_assert(this->verify(r.size()));
 
       std::vector<DataPlusInt<T>> data_in(r.size());
       for (std::size_t i=0; i != r.size(); ++i)
         {
           data_in[i].val  = r[i];
           data_in[i].rank = this->rank();
         }
       std::vector<DataPlusInt<T>> data_out(r.size());
 
       timpi_call_mpi
         (TIMPI_ALLREDUCE (data_in.data(), data_out.data(),
                           cast_int<CountType>(r.size()),
                           dataplusint_type_acquire<T>().first,
                           OpFunction<T>::min_location(), this->get()));
       for (std::size_t i=0; i != r.size(); ++i)
         {
           r[i]      = data_out[i].val;
           min_id[i] = data_out[i].rank;
         }
     }
   else if (!r.empty())
     {
       for (std::size_t i=0; i != r.size(); ++i)
         min_id[i] = this->rank();
     }
 }

◆ minloc() [3/3]

template<typename A1 , typename A2 >

void TIMPI::Communicator::minloc	(	std::vector< bool, A1 > &	r,
		std::vector< unsigned int, A2 > &	min_id
	)		const

inlineinherited

Definition at line 2266 of file parallel_implementation.h.

References TIMPI::Communicator::rank(), TIMPI::Communicator::size(), and TIMPI::Communicator::verify().

 {
   if (this->size() > 1 && !r.empty())
     {
       TIMPI_LOG_SCOPE("minloc(vector<bool>)", "Parallel");
 
       timpi_assert(this->verify(r.size()));
 
       std::vector<DataPlusInt<int>> data_in(r.size());
       for (std::size_t i=0; i != r.size(); ++i)
         {
           data_in[i].val  = r[i];
           data_in[i].rank = this->rank();
         }
       std::vector<DataPlusInt<int>> data_out(r.size());
       timpi_call_mpi
         (TIMPI_ALLREDUCE
           (data_in.data(), data_out.data(),
            cast_int<CountType>(r.size()), StandardType<int>(),
            OpFunction<int>::min_location(), this->get()));
       for (std::size_t i=0; i != r.size(); ++i)
         {
           r[i]      = data_out[i].val;
           min_id[i] = data_out[i].rank;
         }
     }
   else if (!r.empty())
     {
       for (std::size_t i=0; i != r.size(); ++i)
         min_id[i] = this->rank();
     }
 }

◆ nonblocking_barrier()

void TIMPI::Communicator::nonblocking_barrier ( Request & req ) const

inherited

Start a barrier that doesn't block.

Definition at line 238 of file communicator.C.

References TIMPI::Request::get(), and TIMPI::Communicator::size().

Referenced by TIMPI::detail::push_parallel_nbx_helper().

 {
   if (this->size() > 1)
     {
       TIMPI_LOG_SCOPE("nonblocking_barrier()", "Communicator");
       timpi_call_mpi(MPI_Ibarrier (this->get(), req.get()));
     }
 }

◆ nonblocking_receive_packed_range() [1/3]

template<typename Context , typename OutputIter , typename T >

void TIMPI::Communicator::nonblocking_receive_packed_range	(	const unsigned int	src_processor_id,
		Context *	context,
		OutputIter	out,
		const T *	output_type,
		Request &	req,
		Status &	stat,
		const MessageTag &	tag = `any_tag`
	)		const

inlineinherited

Non-Blocking-receive range-of-pointers from one processor.

This is meant to receive messages from nonblocking_send_packed_range

Similar in design to the above receive_packed_range. However, this version requires a Request and a Status.

The Status must be a positively tested Status for a message of this type (i.e. a message does exist). It should most likely be generated by Communicator::packed_range_probe.

Definition at line 1290 of file parallel_implementation.h.

References TIMPI::Request::add_post_wait_work(), TIMPI::Communicator::receive(), and TIMPI::Status::size().

Referenced by TIMPI::push_parallel_packed_range().

 {
   typedef typename Packing<T>::buffer_type buffer_t;
 
   // Receive serialized variable size objects as a sequence of
   // buffer_t.
   // Allocate a buffer on the heap so we don't have to free it until
   // after the Request::wait()
   std::vector<buffer_t> * buffer = new std::vector<buffer_t>(stat.size());
   this->receive(src_processor_id, *buffer, req, tag);
 
   // Make the Request::wait() handle unpacking the buffer
   req.add_post_wait_work
     (new PostWaitUnpackBuffer<std::vector<buffer_t>, Context, OutputIter, T>(*buffer, context, out));
 
   // Make the Request::wait() then handle deleting the buffer
   req.add_post_wait_work
     (new PostWaitDeleteBuffer<std::vector<buffer_t>>(buffer));
 
   // The MessageTag should stay registered for the Request lifetime
   req.add_post_wait_work
     (new PostWaitDereferenceTag(tag));
 }

◆ nonblocking_receive_packed_range() [2/3]

template<typename Context , typename OutputIter , typename T >

void TIMPI::Communicator::nonblocking_receive_packed_range	(	const unsigned int	src_processor_id,
		Context *	context,
		OutputIter	out,
		const T *	output_type,
		Request &	req,
		Status &	stat,
		std::shared_ptr< std::vector< typename TIMPI::Packing< T >::buffer_type >> &	buffer,
		const MessageTag &	tag = `any_tag`
	)		const

inlineinherited

Non-Blocking-receive range-of-pointers from one processor.

This is meant to receive messages from nonblocking_send_packed_range

Similar in design to the above receive_packed_range. However, this version requires a Request and a Status.

The Status must be a positively tested Status for a message of this type (i.e. a message does exist). It should most likely be generated by Communicator::packed_range_probe.

◆ nonblocking_receive_packed_range() [3/3]

template<typename Context , typename OutputIter , typename T >

void TIMPI::Communicator::nonblocking_receive_packed_range	(	const unsigned int	src_processor_id,
		Context *	context,
		OutputIter	out,
		const T *	,
		Request &	req,
		Status &	stat,
		std::shared_ptr< std::vector< typename Packing< T >::buffer_type >> &	buffer,
		const MessageTag &	tag
	)		const

inlineinherited

Definition at line 1937 of file parallel_implementation.h.

References TIMPI::Request::add_post_wait_work(), TIMPI::Communicator::receive(), and TIMPI::Status::size().

 {
   // If they didn't pass in a buffer - let's make one
   if (buffer == nullptr)
     buffer = std::make_shared<std::vector<typename Packing<T>::buffer_type>>();
   else
     buffer->clear();
 
   // Receive serialized variable size objects as a sequence of
   // buffer_t.
   // Allocate a buffer on the heap so we don't have to free it until
   // after the Request::wait()
   buffer->resize(stat.size());
   this->receive(src_processor_id, *buffer, req, tag);
 
   // Make the Request::wait() handle unpacking the buffer
   req.add_post_wait_work
     (new PostWaitUnpackBuffer<std::vector<typename Packing<T>::buffer_type>, Context, OutputIter, T>(*buffer, context, out));
 
   // Make it dereference the shared pointer (possibly freeing the buffer)
   req.add_post_wait_work
     (new PostWaitDereferenceSharedPtr<std::vector<typename Packing<T>::buffer_type>>(buffer));
 }

◆ nonblocking_send_packed_range() [1/3]

template<typename Context , typename Iter >

void TIMPI::Communicator::nonblocking_send_packed_range	(	const unsigned int	dest_processor_id,
		const Context *	context,
		Iter	range_begin,
		const Iter	range_end,
		Request &	req,
		const MessageTag &	tag = `no_tag`
	)		const

inlineinherited

Similar to the above Nonblocking send_packed_range with a few important differences:

The total size of the packed buffer MUST be less than std::numeric_limits<int>::max()
Only one message is generated
On the receiving end the message should be tested for using Communicator::packed_range_probe()
The message must be received by Communicator::nonblocking_receive_packed_range()

Definition at line 777 of file parallel_implementation.h.

References TIMPI::Request::add_post_wait_work(), TIMPI::pack_range(), and TIMPI::Communicator::send().

Referenced by TIMPI::push_parallel_packed_range().

 {
   // Allocate a buffer on the heap so we don't have to free it until
   // after the Request::wait()
   typedef typename std::iterator_traits<Iter>::value_type T;
   typedef typename Packing<T>::buffer_type buffer_t;
 
   if (range_begin != range_end)
     {
       std::vector<buffer_t> * buffer = new std::vector<buffer_t>();
 
       range_begin =
         pack_range(context,
                    range_begin,
                    range_end,
                    *buffer,
                    // MPI-2/3 can only use signed integers for size,
                    // and with this API we need to fit a non-blocking
                    // send into one buffer
                    std::numeric_limits<CountType>::max());
 
       if (range_begin != range_end)
         timpi_error_msg("Non-blocking packed range sends cannot exceed " << std::numeric_limits<CountType>::max() << "in size");
 
       // Make the Request::wait() handle deleting the buffer
       req.add_post_wait_work
         (new PostWaitDeleteBuffer<std::vector<buffer_t>>
          (buffer));
 
       // Non-blocking send of the buffer
       this->send(dest_processor_id, *buffer, req, tag);
     }
 }

◆ nonblocking_send_packed_range() [2/3]

template<typename Context , typename Iter >

void TIMPI::Communicator::nonblocking_send_packed_range	(	const unsigned int	dest_processor_id,
		const Context *	context,
		Iter	range_begin,
		const Iter	range_end,
		Request &	req,
		std::shared_ptr< std::vector< typename TIMPI::Packing< typename std::iterator_traits< Iter >::value_type >::buffer_type >> &	buffer,
		const MessageTag &	tag = `no_tag`
	)		const

inlineinherited

Similar to the above Nonblocking send_packed_range with a few important differences:

The total size of the packed buffer MUST be less than std::numeric_limits<int>::max()
Only one message is generated
On the receiving end the message should be tested for using Communicator::packed_range_probe()
The message must be received by Communicator::nonblocking_receive_packed_range()

◆ nonblocking_send_packed_range() [3/3]

template<typename Context , typename Iter >

void TIMPI::Communicator::nonblocking_send_packed_range	(	const unsigned int	dest_processor_id,
		const Context *	context,
		Iter	range_begin,
		const Iter	range_end,
		Request &	req,
		std::shared_ptr< std::vector< typename Packing< typename std::iterator_traits< Iter >::value_type >::buffer_type >> &	buffer,
		const MessageTag &	tag
	)		const

inlineinherited

Definition at line 1584 of file parallel_implementation.h.

References TIMPI::Request::add_post_wait_work(), TIMPI::pack_range(), and TIMPI::Communicator::send().

 {
   // Allocate a buffer on the heap so we don't have to free it until
   // after the Request::wait()
   typedef typename std::iterator_traits<Iter>::value_type T;
   typedef typename Packing<T>::buffer_type buffer_t;
 
   if (range_begin != range_end)
     {
       if (buffer == nullptr)
         buffer = std::make_shared<std::vector<buffer_t>>();
       else
         buffer->clear();
 
       range_begin =
         pack_range(context,
                    range_begin,
                    range_end,
                    *buffer,
                    // MPI-2/3 can only use signed integers for size,
                    // and with this API we need to fit a non-blocking
                    // send into one buffer
                    std::numeric_limits<CountType>::max());
 
       if (range_begin != range_end)
         timpi_error_msg("Non-blocking packed range sends cannot exceed " << std::numeric_limits<CountType>::max() << "in size");
 
       // Make it dereference the shared pointer (possibly freeing the buffer)
       req.add_post_wait_work
         (new PostWaitDereferenceSharedPtr<std::vector<buffer_t>>(buffer));
 
       // Non-blocking send of the buffer
       this->send(dest_processor_id, *buffer, req, tag);
     }
 }

◆ operator=() [1/2]

Communicator& libMesh::Parallel::Communicator::operator= ( const Communicator & )

delete

◆ operator=() [2/2]

Communicator& libMesh::Parallel::Communicator::operator= ( Communicator && )

default

◆ packed_range_probe()

template<typename T >

Status TIMPI::Communicator::packed_range_probe	(	const unsigned int	src_processor_id,
		const MessageTag &	tag,
		bool &	flag
	)		const

inlineinherited

Non-Blocking message probe for a packed range message.

Allows information about a message to be examined before the message is actually received.

Template type must match the object type that will be in the packed range

Parameters

src_processor_id	The processor the message is expected from or TIMPI::any_source
tag	The message tag or TIMPI::any_tag
flag	Output. True if a message exists. False otherwise.

Referenced by TIMPI::push_parallel_packed_range().

◆ possibly_receive() [1/5]

template<typename T , typename A , typename std::enable_if< std::is_base_of< DataType, StandardType< T >>::value, int >::type = 0>

bool TIMPI::Communicator::possibly_receive	(	unsigned int &	src_processor_id,
		std::vector< T, A > &	buf,
		Request &	req,
		const MessageTag &	tag
	)		const

inlineinherited

Nonblocking-receive from one processor with user-defined type.

Checks to see if a message can be received from the src_processor_id . If so, it starts a non-blocking receive using the passed in request and returns true

Otherwise - if there is no message to receive it returns false

Note: The buf does NOT need to be properly sized before this call this will resize the buffer automatically

Parameters

src_processor_id	The pid to receive from or "any". will be set to the actual src being received from
buf	The buffer to receive into
req	The request to use
tag	The tag to use

Referenced by TIMPI::push_parallel_vector_data().

◆ possibly_receive() [2/5]

template<typename T , typename A , typename std::enable_if< Has_buffer_type< Packing< T >>::value, int >::type = 0>

bool TIMPI::Communicator::possibly_receive	(	unsigned int &	src_processor_id,
		std::vector< T, A > &	buf,
		Request &	req,
		const MessageTag &	tag
	)		const

inlineinherited

dispatches to possibly_receive_packed_range

Parameters

src_processor_id	The pid to receive from or "any". will be set to the actual src being received from
buf	The buffer to receive into
req	The request to use
tag	The tag to use

◆ possibly_receive() [3/5]

template<typename T , typename A , typename std::enable_if< std::is_base_of< DataType, StandardType< T >>::value, int >::type >

bool TIMPI::Communicator::possibly_receive	(	unsigned int &	src_processor_id,
		std::vector< T, A > &	buf,
		const DataType &	type,
		Request &	req,
		const MessageTag &	tag
	)		const

inlineinherited

Nonblocking-receive from one processor with user-defined type.

As above, but with manually-specified data type.

Parameters

src_processor_id	The pid to receive from or "any". will be set to the actual src being received from
buf	The buffer to receive into
type	The intrinsic datatype to receive
req	The request to use
tag	The tag to use

Definition at line 1971 of file parallel_implementation.h.

References TIMPI::Request::add_post_wait_work(), TIMPI::any_source, TIMPI::Request::get(), TIMPI::Status::get(), TIMPI::Status::size(), TIMPI::Communicator::size(), TIMPI::Status::source(), and TIMPI::MessageTag::value().

 {
   TIMPI_LOG_SCOPE("possibly_receive()", "Parallel");
 
   Status stat(type);
 
   int int_flag = 0;
 
   timpi_assert(src_processor_id < this->size() ||
                   src_processor_id == any_source);
 
   timpi_call_mpi(MPI_Iprobe(int(src_processor_id),
                             tag.value(),
                             this->get(),
                             &int_flag,
                             stat.get()));
 
   if (int_flag)
   {
     buf.resize(stat.size());
 
     src_processor_id = stat.source();
 
     timpi_call_mpi
       (TIMPI_IRECV(buf.data(), cast_int<CountType>(buf.size()), type,
                    src_processor_id, tag.value(), this->get(),
                    req.get()));
 
     // The MessageTag should stay registered for the Request lifetime
     req.add_post_wait_work
       (new PostWaitDereferenceTag(tag));
   }
 
   return int_flag;
 }

◆ possibly_receive() [4/5]

template<typename T , typename A , typename std::enable_if< Has_buffer_type< Packing< T >>::value, int >::type >

bool TIMPI::Communicator::possibly_receive	(	unsigned int &	src_processor_id,
		std::vector< T, A > &	buf,
		const NotADataType &	type,
		Request &	req,
		const MessageTag &	tag
	)		const

inlineinherited

Nonblocking-receive from one processor with user-defined type.

Dispatches to possibly_receive_packed_range

Parameters

src_processor_id	The pid to receive from or "any". will be set to the actual src being received from
buf	The buffer to receive into
type	The packable type to receive
req	The request to use
tag	The tag to use

Definition at line 2012 of file parallel_implementation.h.

References TIMPI::Communicator::possibly_receive_packed_range().

 {
   TIMPI_LOG_SCOPE("possibly_receive()", "Parallel");
 
   return this->possibly_receive_packed_range(src_processor_id,
                                              (void *)(nullptr),
                                              std::inserter(buf, buf.end()),
                                              (T *)(nullptr),
                                              req,
                                              tag);
 }

◆ possibly_receive() [5/5]

template<typename T , typename A1 , typename A2 >

bool TIMPI::Communicator::possibly_receive	(	unsigned int &	src_processor_id,
		std::vector< std::vector< T, A1 >, A2 > &	buf,
		const DataType &	type,
		Request &	req,
		const MessageTag &	tag
	)		const

inlineinherited

Definition at line 2031 of file parallel_implementation.h.

References TIMPI::Request::add_post_wait_work(), TIMPI::any_source, TIMPI::Status::get(), TIMPI::Communicator::receive(), TIMPI::Status::size(), TIMPI::Communicator::size(), TIMPI::Status::source(), and TIMPI::MessageTag::value().

 {
   TIMPI_LOG_SCOPE("possibly_receive()", "Parallel");
 
   Status stat(type);
 
   int int_flag = 0;
 
   timpi_assert(src_processor_id < this->size() ||
                   src_processor_id == any_source);
 
   timpi_call_mpi(MPI_Iprobe(int(src_processor_id),
                             tag.value(),
                             this->get(),
                             &int_flag,
                             stat.get()));
 
   if (int_flag)
   {
     src_processor_id = stat.source();
 
     std::vector<char> * recvbuf =
       new std::vector<char>(stat.size(StandardType<char>()));
 
     this->receive(src_processor_id, *recvbuf, MPI_PACKED, req, tag);
 
     // When we wait on the receive, we'll unpack the temporary buffer
     req.add_post_wait_work
       (new PostWaitUnpackNestedBuffer<std::vector<std::vector<T,A1>,A2>>
          (*recvbuf, buf, type, *this));
 
     // And then we'll free the temporary buffer
     req.add_post_wait_work
       (new PostWaitDeleteBuffer<std::vector<char>>(recvbuf));
 
     // The MessageTag should stay registered for the Request lifetime
     req.add_post_wait_work
       (new PostWaitDereferenceTag(tag));
   }
 
   return int_flag;
 }

◆ possibly_receive_packed_range()

template<typename Context , typename OutputIter , typename T >

bool TIMPI::Communicator::possibly_receive_packed_range	(	unsigned int &	src_processor_id,
		Context *	context,
		OutputIter	out,
		const T *	output_type,
		Request &	req,
		const MessageTag &	tag
	)		const

inherited

Nonblocking packed range receive from one processor with user-defined type.

Checks to see if a message can be received from the src_processor_id . If so, it starts a nonblocking packed range receive using the passed in request and returns true

Otherwise - if there is no message to receive it returns false

void Parallel::unpack(const T *, OutputIter data, const Context *) is used to unserialize type T

Parameters

src_processor_id	The pid to receive from or "any". will be set to the actual src being receieved from
context	Context pointer that will be passed into the unpack functions
out	The output iterator
output_type	The intrinsic datatype to receive
req	The request to use
tag	The tag to use

Referenced by TIMPI::Communicator::possibly_receive(), and TIMPI::push_parallel_packed_range().

◆ probe()

status TIMPI::Communicator::probe	(	const unsigned int	src_processor_id,
		const MessageTag &	tag = `any_tag`
	)		const

inherited

Blocking message probe.

Allows information about a message to be examined before the message is actually received.

Definition at line 283 of file communicator.C.

References TIMPI::any_source, TIMPI::ignore(), TIMPI::Communicator::size(), and TIMPI::MessageTag::value().

Referenced by TIMPI::pull_parallel_vector_data(), TIMPI::detail::push_parallel_alltoall_helper(), and TIMPI::Communicator::receive().

 {
   TIMPI_LOG_SCOPE("probe()", "Communicator");
 
 #ifndef TIMPI_HAVE_MPI
   timpi_not_implemented();
   ignore(src_processor_id, tag);
 #endif
 
   status stat;
 
   timpi_assert(src_processor_id < this->size() ||
                   src_processor_id == any_source);
 
   timpi_call_mpi
     (MPI_Probe (int(src_processor_id), tag.value(), this->get(), &stat));
 
   return stat;
 }

◆ product() [1/2]

template<typename T >

void TIMPI::Communicator::product ( T & r ) const

inlineinherited

Take a local variable and replace it with the product of its values on all processors.

Containers are replaced element-wise.

◆ product() [2/2]

template<typename T >

void TIMPI::Communicator::product	(	const T &	r,
		T &	o,
		Request &	req
	)		const

inlineinherited

Non-blocking product of the local value r into o with the request req.

◆ rank()

processor_id_type TIMPI::Communicator::rank ( ) const

inlineinherited

Definition at line 208 of file communicator.h.

References TIMPI::Communicator::_rank.

Referenced by TIMPI::Communicator::broadcast(), TIMPI::detail::empty_send_assertion(), fill_data(), fill_scalar_data(), fill_vector_data(), TIMPI::Communicator::maxloc(), TIMPI::Communicator::minloc(), TIMPI::pull_parallel_vector_data(), TIMPI::detail::push_parallel_alltoall_helper(), TIMPI::detail::push_parallel_nbx_helper(), TIMPI::detail::push_parallel_roundrobin_helper(), TIMPI::report_here(), TIMPI::Communicator::send_receive(), TIMPI::Communicator::send_receive_packed_range(), testAllGather(), testAllGatherHalfEmptyVectorString(), testAllGatherString(), testAllGatherVectorString(), testAllGatherVectorVector(), testAllGatherVectorVectorInPlace(), testAllGatherVectorVectorPacked(), testArrayContainerAllGather(), testBigUnion(), testBroadcast(), testBroadcastArrayType(), testBroadcastNestedType(), testBroadcastString(), testContainerAllGather(), testContainerBroadcast(), testContainerSendReceive(), testEmptyEntry(), testGather(), testGatherString(), testGatherString2(), testGettableStringAllGather(), testIrecvSend(), testIsendRecv(), testLargeSetUnion(), testMapContainerAllGather(), testMapMap(), testMapMax(), testMapSet(), testMax(), testMaxloc(), testMaxlocBool(), testMaxlocDouble(), testMaxlocPair(), testMaxVecBool(), testMin(), testMinLarge(), testMinloc(), testMinlocBool(), testMinlocDouble(), testMinlocPair(), testMinVecBool(), testMPIULongMin(), testNestingAllGather(), testNonblockingMax(), testNonblockingMin(), testNonblockingString(), testNonblockingSum(), testNonblockingTest(), testNonblockingWaitany(), testNonFixedTypeMapMax(), testNonFixedTypeSum(), testNullAllGather(), testNullSendReceive(), testPackedSetUnion(), testPairContainerAllGather(), testPush(), testPushImpl(), testPushMove(), testPushMultimapImpl(), testPushMultimapVecVecImpl(), testPushPackedImpl(), testPushPackedImplMove(), testPushPackedNestedImpl(), testPushVecVecImpl(), testRecvIsendSets(), testRecvIsendVecVecs(), testScatter(), testSemiVerifyInf(), testSemiVerifyString(), testSemiVerifyType(), testSemiVerifyVector(), testSendRecvVecVecs(), testSplit(), testSplitByType(), testSum(), testSumOpFunction(), testTupleContainerAllGather(), testTupleStringAllGather(), testUnion(), testVectorOfContainersAllGather(), and testVectorOfContainersBroadcast().

208 { return _rank; }

TIMPI::Communicator::_rank

processor_id_type _rank

Definition: communicator.h:237

◆ receive() [1/6]

template<typename T >

Status TIMPI::Communicator::receive	(	const unsigned int	dest_processor_id,
		T &	buf,
		const MessageTag &	tag = `any_tag`
	)		const

inlineinherited

Blocking-receive from one processor with data-defined type.

We do not currently support receives on one processor without MPI.

Definition at line 862 of file parallel_implementation.h.

References TIMPI::any_source, TIMPI::Status::get(), TIMPI::Communicator::probe(), TIMPI::Communicator::size(), and TIMPI::MessageTag::value().

Referenced by TIMPI::Communicator::nonblocking_receive_packed_range(), TIMPI::Communicator::possibly_receive(), TIMPI::pull_parallel_vector_data(), TIMPI::push_parallel_vector_data(), TIMPI::Communicator::receive(), TIMPI::Communicator::receive_packed_range(), testIrecvSend(), testIsendRecv(), testNonblockingString(), testRecvIsendSets(), testRecvIsendVecVecs(), and testSendRecvVecVecs().

 {
   TIMPI_LOG_SCOPE("receive()", "Parallel");
 
   // Get the status of the message, explicitly provide the
   // datatype so we can later query the size
   Status stat(this->probe(src_processor_id, tag), StandardType<T>(&buf));
 
   timpi_assert(src_processor_id < this->size() ||
                   src_processor_id == any_source);
 
   timpi_call_mpi
     (TIMPI_RECV (&buf, 1, StandardType<T>(&buf), src_processor_id,
                  tag.value(), this->get(), stat.get()));
 
   return stat;
 }

◆ receive() [2/6]

template<typename T >

void TIMPI::Communicator::receive	(	const unsigned int	dest_processor_id,
		T &	buf,
		Request &	req,
		const MessageTag &	tag = `any_tag`
	)		const

inlineinherited

Nonblocking-receive from one processor with data-defined type.

Definition at line 885 of file parallel_implementation.h.

References TIMPI::Request::add_post_wait_work(), TIMPI::any_source, TIMPI::Request::get(), TIMPI::Communicator::size(), and TIMPI::MessageTag::value().

 {
   TIMPI_LOG_SCOPE("receive()", "Parallel");
 
   timpi_assert(src_processor_id < this->size() ||
                   src_processor_id == any_source);
 
   timpi_call_mpi
     (TIMPI_IRECV (&buf, 1, StandardType<T>(&buf), src_processor_id,
                   tag.value(), this->get(), req.get()));
 
   // The MessageTag should stay registered for the Request lifetime
   req.add_post_wait_work
     (new PostWaitDereferenceTag(tag));
 }

◆ receive() [3/6]

template<typename T >

Status TIMPI::Communicator::receive	(	const unsigned int	dest_processor_id,
		T &	buf,
		const DataType &	type,
		const MessageTag &	tag = `any_tag`
	)		const

inlineinherited

Blocking-receive from one processor with user-defined type.

If T is a container, container-of-containers, etc., then type should be the DataType of the underlying fixed-size entries in the container(s).

Definition at line 155 of file serial_implementation.h.

159 { timpi_not_implemented(); return Status(); }

◆ receive() [4/6]

template<typename T >

void TIMPI::Communicator::receive	(	const unsigned int	dest_processor_id,
		T &	buf,
		const DataType &	type,
		Request &	req,
		const MessageTag &	tag = `any_tag`
	)		const

inlineinherited

Nonblocking-receive from one processor with user-defined type.

If T is a container, container-of-containers, etc., then type should be the DataType of the underlying fixed-size entries in the container(s).

Definition at line 162 of file serial_implementation.h.

167 { timpi_not_implemented(); }

◆ receive() [5/6]

template<typename T >

Status TIMPI::Communicator::receive	(	const unsigned int	src_processor_id,
		std::basic_string< T > &	buf,
		const MessageTag &	tag
	)		const

inlineinherited

Definition at line 818 of file parallel_implementation.h.

References TIMPI::Communicator::receive().

 {
   std::vector<T> tempbuf;  // Officially C++ won't let us get a
                            // modifiable array from a string
 
   Status stat = this->receive(src_processor_id, tempbuf, tag);
   buf.assign(tempbuf.begin(), tempbuf.end());
   return stat;
 }

◆ receive() [6/6]

template<typename T >

void TIMPI::Communicator::receive	(	const unsigned int	src_processor_id,
		std::basic_string< T > &	buf,
		Request &	req,
		const MessageTag &	tag
	)		const

inlineinherited

Definition at line 833 of file parallel_implementation.h.

References TIMPI::Request::add_post_wait_work(), and TIMPI::Communicator::receive().

 {
   // Officially C++ won't let us get a modifiable array from a
   // string, and we can't even put one on the stack for the
   // non-blocking case.
   std::vector<T> * tempbuf = new std::vector<T>(buf.size());
 
   // We can clear the string, but the Request::wait() will need to
   // handle copying our temporary buffer to it
   buf.clear();
 
   req.add_post_wait_work
     (new PostWaitCopyBuffer<std::vector<T>,
      std::back_insert_iterator<std::basic_string<T>>>
      (*tempbuf, std::back_inserter(buf)));
 
   // Make the Request::wait() then handle deleting the buffer
   req.add_post_wait_work
     (new PostWaitDeleteBuffer<std::vector<T>>(tempbuf));
 
   this->receive(src_processor_id, *tempbuf, req, tag);
 }

◆ receive_packed_range()

template<typename Context , typename OutputIter , typename T >

void TIMPI::Communicator::receive_packed_range	(	const unsigned int	dest_processor_id,
		Context *	context,
		OutputIter	out,
		const T *	output_type,
		const MessageTag &	tag = `any_tag`
	)		const

inlineinherited

Blocking-receive range-of-pointers from one processor.

This function does not receive raw pointers, but rather constructs new objects whose contents match the objects pointed to by the sender.

The objects will be of type T = iterator_traits<OutputIter>::value_type.

Using std::back_inserter as the output iterator allows receive to fill any container type. Using some null_output_iterator allows the receive to be dealt with solely by TIMPI::unpack(), for objects whose unpack() is written so as to not leak memory when used in this fashion.

A future version of this method should be created to preallocate memory when receiving vectors...

void TIMPI::unpack(vector<int>::iterator in, T ** out, Context *) is used to unserialize type T, typically into a new heap-allocated object whose pointer is returned as *out.

unsigned int TIMPI::packed_size(const T *, vector<int>::const_iterator) is used to advance to the beginning of the next object's data.

Definition at line 1226 of file parallel_implementation.h.

References TIMPI::Communicator::receive(), TIMPI::Status::source(), TIMPI::Status::tag(), and TIMPI::unpack_range().

Referenced by TIMPI::Communicator::send_receive_packed_range().

 {
   typedef typename Packing<T>::buffer_type buffer_t;
 
   // Receive serialized variable size objects as sequences of buffer_t
   std::size_t total_buffer_size = 0;
   Status stat = this->receive(src_processor_id, total_buffer_size, tag);
 
   // Use stat.source() and stat.tag() in subsequent receives - if
   // src_processor_id is or tag is "any" then we want to be sure we
   // try to receive messages all corresponding to the same send.
 
   std::size_t received_buffer_size = 0;
 
   // OutputIter might not have operator= implemented; for maximum
   // compatibility we'll rely on its copy constructor.
   std::unique_ptr<OutputIter> next_out_iter =
     std::make_unique<OutputIter>(out_iter);
 
   while (received_buffer_size < total_buffer_size)
     {
       std::vector<buffer_t> buffer;
       this->receive(stat.source(), buffer, MessageTag(stat.tag()));
       received_buffer_size += buffer.size();
       auto return_out_iter = unpack_range
         (buffer, context, *next_out_iter, output_type);
       next_out_iter = std::make_unique<OutputIter>(return_out_iter);
     }
 }

◆ reference_unique_tag()

void TIMPI::Communicator::reference_unique_tag ( int tagvalue ) const

inherited

Reference an already-acquired tag, so that we know it will be dereferenced multiple times before we can re-release it.

Definition at line 37 of file communicator.C.

References TIMPI::Communicator::used_tag_values.

Referenced by TIMPI::MessageTag::MessageTag(), and TIMPI::MessageTag::operator=().

 {
   // This had better be an already-acquired tag.
   timpi_assert(used_tag_values.count(tagvalue));
 
   used_tag_values[tagvalue]++;
 }

◆ scatter() [1/5]

template<typename T , typename A >

void TIMPI::Communicator::scatter	(	const std::vector< T, A > &	data,
		T &	recv,
		const unsigned int	root_id = `0`
	)		const

inlineinherited

Take a vector of local variables and scatter the ith item to the ith processor in the communicator.

The result is saved into recv.

Referenced by testScatter().

◆ scatter() [2/5]

template<typename T , typename A >

void TIMPI::Communicator::scatter	(	const std::vector< T, A > &	data,
		std::vector< T, A > &	recv,
		const unsigned int	root_id = `0`
	)		const

inlineinherited

Take a vector of local variables and scatter the ith equal-sized chunk to the ith processor in the communicator.

The data size must be a multiple of the communicator size. The result is saved into recv buffer. The recv buffer does not have to be sized prior to this operation.

◆ scatter() [3/5]

template<typename T , typename A1 , typename A2 >

void TIMPI::Communicator::scatter	(	const std::vector< T, A1 > &	data,
		const std::vector< CountType, A2 >	counts,
		std::vector< T, A1 > &	recv,
		const unsigned int	root_id = `0`
	)		const

inlineinherited

Take a vector of local variables and scatter the ith variable-sized chunk to the ith processor in the communicator.

The counts vector should contain the number of items for each processor. The result is saved into recv buffer. The recv buffer does not have to be sized prior to this operation.

◆ scatter() [4/5]

template<typename T , typename A1 , typename A2 >

void TIMPI::Communicator::scatter	(	const std::vector< T, A1 > &	data,
		const std::vector< int, A2 >	counts,
		std::vector< T, A1 > &	recv,
		const unsigned int	root_id = `0`
	)		const

inlineinherited

vector<int> based scatter, for backwards compatibility

◆ scatter() [5/5]

template<typename T , typename A1 , typename A2 >

void TIMPI::Communicator::scatter	(	const std::vector< std::vector< T, A1 >, A2 > &	data,
		std::vector< T, A1 > &	recv,
		const unsigned int	root_id = `0`,
		const bool	identical_buffer_sizes = `false`
	)		const

inlineinherited

Take a vector of vectors and scatter the ith inner vector to the ith processor in the communicator.

The result is saved into recv buffer. The recv buffer does not have to be sized prior to this operation.

◆ semiverify() [1/2]

template<typename T >

timpi_pure bool TIMPI::Communicator::semiverify ( const T * r ) const

inlineinherited

Check whether a local pointer points to the same value on all processors where it is not null, returning true if it does or false if not.

Useful in assertions and possibly in user error checking.

Containers must have the same value in every entry on all processors where the pointer is not null for this function to return true.

Referenced by testSemiVerifyInf(), testSemiVerifyString(), testSemiVerifyType(), and testSemiVerifyVector().

◆ semiverify() [2/2]

template<typename T >

bool TIMPI::Communicator::semiverify ( const T * r ) const

inlineinherited

Definition at line 2112 of file parallel_implementation.h.

References TIMPI::Communicator::max(), TIMPI::Communicator::min(), and TIMPI::Communicator::size().

 {
   if (this->size() > 1 && Attributes<T>::has_min_max == true)
     {
       T tempmin, tempmax;
       if (r)
         tempmin = tempmax = *r;
       else
         {
           Attributes<T>::set_highest(tempmin);
           Attributes<T>::set_lowest(tempmax);
         }
       this->min(tempmin);
       this->max(tempmax);
       bool invalid = r && ((*r != tempmin) ||
                            (*r != tempmax));
       this->max(invalid);
       return !invalid;
     }
 
   static_assert(Attributes<T>::has_min_max,
                 "Tried to semiverify an unverifiable type");
 
   return true;
 }

◆ send() [1/7]

template<typename T >

void TIMPI::Communicator::send	(	const unsigned int	dest_processor_id,
		const std::basic_string< T > &	buf,
		const MessageTag &	tag
	)		const

inlineinherited

Definition at line 303 of file parallel_implementation.h.

References TIMPI::Communicator::send_mode(), TIMPI::Communicator::size(), TIMPI::Communicator::SYNCHRONOUS, and TIMPI::MessageTag::value().

 {
   TIMPI_LOG_SCOPE("send()", "Parallel");
 
   T * dataptr = buf.empty() ? nullptr : const_cast<T *>(buf.data());
 
   timpi_assert_less(dest_processor_id, this->size());
 
   timpi_call_mpi
     (((this->send_mode() == SYNCHRONOUS) ?
       TIMPI_SSEND : TIMPI_SEND)
         (dataptr, cast_int<CountType>(buf.size()),
          StandardType<T>(dataptr), dest_processor_id, tag.value(),
          this->get()));
 }

◆ send() [2/7]

template<typename T >

void TIMPI::Communicator::send	(	const unsigned int	dest_processor_id,
		const std::basic_string< T > &	buf,
		Request &	req,
		const MessageTag &	tag
	)		const

inlineinherited

Definition at line 324 of file parallel_implementation.h.

References TIMPI::Request::add_post_wait_work(), TIMPI::Request::get(), TIMPI::Communicator::send_mode(), TIMPI::Communicator::size(), TIMPI::Communicator::SYNCHRONOUS, and TIMPI::MessageTag::value().

 {
   TIMPI_LOG_SCOPE("send()", "Parallel");
 
   T * dataptr = buf.empty() ? nullptr : const_cast<T *>(buf.data());
 
   timpi_assert_less(dest_processor_id, this->size());
 
   timpi_call_mpi
     (((this->send_mode() == SYNCHRONOUS) ?
       TIMPI_ISSEND : TIMPI_ISEND)
         (dataptr, cast_int<CountType>(buf.size()),
          StandardType<T>(dataptr), dest_processor_id, tag.value(),
          this->get(), req.get()));
 
   // The MessageTag should stay registered for the Request lifetime
   req.add_post_wait_work
     (new PostWaitDereferenceTag(tag));
 }

◆ send() [3/7]

template<typename T >

void TIMPI::Communicator::send	(	const unsigned int	dest_processor_id,
		const T &	buf,
		const MessageTag &	tag = `no_tag`
	)		const

inlineinherited

Blocking-send to one processor with data-defined type.

We do not currently support sends on one processor without MPI.

Definition at line 350 of file parallel_implementation.h.

References TIMPI::Communicator::send_mode(), TIMPI::Communicator::size(), TIMPI::Communicator::SYNCHRONOUS, and TIMPI::MessageTag::value().

Referenced by TIMPI::Communicator::nonblocking_send_packed_range(), TIMPI::pull_parallel_vector_data(), TIMPI::push_parallel_vector_data(), TIMPI::Communicator::send_packed_range(), TIMPI::Communicator::send_receive(), testIrecvSend(), testIsendRecv(), testNonblockingString(), testRecvIsendSets(), testRecvIsendVecVecs(), and testSendRecvVecVecs().

 {
   TIMPI_LOG_SCOPE("send()", "Parallel");
 
   T * dataptr = const_cast<T*> (&buf);
 
   timpi_assert_less(dest_processor_id, this->size());
 
   timpi_call_mpi
     (((this->send_mode() == SYNCHRONOUS) ?
       TIMPI_SSEND : TIMPI_SEND)
         (dataptr, 1, StandardType<T>(dataptr), dest_processor_id,
          tag.value(), this->get()));
 }

◆ send() [4/7]

template<typename T >

void TIMPI::Communicator::send	(	const unsigned int	dest_processor_id,
		const T &	buf,
		Request &	req,
		const MessageTag &	tag = `no_tag`
	)		const

inlineinherited

Nonblocking-send to one processor with data-defined type.

Definition at line 370 of file parallel_implementation.h.

References TIMPI::Request::add_post_wait_work(), TIMPI::Request::get(), TIMPI::Communicator::send_mode(), TIMPI::Communicator::size(), TIMPI::Communicator::SYNCHRONOUS, and TIMPI::MessageTag::value().

 {
   TIMPI_LOG_SCOPE("send()", "Parallel");
 
   T * dataptr = const_cast<T*>(&buf);
 
   timpi_assert_less(dest_processor_id, this->size());
 
   timpi_call_mpi
     (((this->send_mode() == SYNCHRONOUS) ?
       TIMPI_ISSEND : TIMPI_ISEND)
         (dataptr, 1, StandardType<T>(dataptr), dest_processor_id,
          tag.value(), this->get(), req.get()));
 
   // The MessageTag should stay registered for the Request lifetime
   req.add_post_wait_work
     (new PostWaitDereferenceTag(tag));
 }

◆ send() [5/7]

template<typename T >

void TIMPI::Communicator::send	(	const unsigned int	dest_processor_id,
		const T &	buf,
		const DataType &	type,
		const MessageTag &	tag = `no_tag`
	)		const

inlineinherited

Blocking-send to one processor with user-defined type.

If T is a container, container-of-containers, etc., then type should be the DataType of the underlying fixed-size entries in the container(s).

Definition at line 78 of file serial_implementation.h.

82 { timpi_not_implemented(); }

◆ send() [6/7]

template<typename T >

void TIMPI::Communicator::send	(	const unsigned int	dest_processor_id,
		const T &	buf,
		const DataType &	type,
		Request &	req,
		const MessageTag &	tag = `no_tag`
	)		const

inlineinherited

Nonblocking-send to one processor with user-defined type.

If T is a container, container-of-containers, etc., then type should be the DataType of the underlying fixed-size entries in the container(s).

Definition at line 85 of file serial_implementation.h.

90 { timpi_not_implemented(); }

◆ send() [7/7]

template<typename T >

void TIMPI::Communicator::send	(	const unsigned int	dest_processor_id,
		const T &	buf,
		const NotADataType &	type,
		Request &	req,
		const MessageTag &	tag = `no_tag`
	)		const

inlineinherited

Nonblocking-send to one processor with user-defined packable type.

Packing<T> must be defined for T

Definition at line 93 of file serial_implementation.h.

98 { timpi_not_implemented(); }

◆ send_mode() [1/2]

void TIMPI::Communicator::send_mode ( const SendMode sm )

inlineinherited

Explicitly sets the SendMode type used for send operations.

Definition at line 333 of file communicator.h.

References TIMPI::Communicator::_send_mode.

Referenced by TIMPI::Communicator::duplicate(), TIMPI::detail::push_parallel_nbx_helper(), TIMPI::Communicator::split(), TIMPI::Communicator::split_by_type(), testIrecvSend(), and testIsendRecv().

333 { _send_mode = sm; }

TIMPI::Communicator::_send_mode

SendMode _send_mode

Definition: communicator.h:238

◆ send_mode() [2/2]

SendMode TIMPI::Communicator::send_mode ( ) const

inlineinherited

Gets the user-requested SendMode.

Definition at line 338 of file communicator.h.

References TIMPI::Communicator::_send_mode.

Referenced by TIMPI::Communicator::duplicate(), TIMPI::Communicator::send(), TIMPI::Communicator::split(), and TIMPI::Communicator::split_by_type().

338 { return _send_mode; }

TIMPI::Communicator::_send_mode

SendMode _send_mode

Definition: communicator.h:238

◆ send_packed_range() [1/2]

template<typename Context , typename Iter >

void TIMPI::Communicator::send_packed_range	(	const unsigned int	dest_processor_id,
		const Context *	context,
		Iter	range_begin,
		const Iter	range_end,
		const MessageTag &	tag = `no_tag`,
		std::size_t	approx_buffer_size = `1000000`
	)		const

inlineinherited

Blocking-send range-of-pointers to one processor.

This function does not send the raw pointers, but rather constructs new objects at the other end whose contents match the objects pointed to by the sender.

void TIMPI::pack(const T *, vector<int> & data, const Context *) is used to serialize type T onto the end of a data vector.

unsigned int TIMPI::packable_size(const T *, const Context *) is used to allow data vectors to reserve memory, and for additional error checking

The approximate maximum size (in entries; number of bytes will likely be 4x or 8x larger) to use in a single data vector buffer can be specified for performance or memory usage reasons; if the range cannot be packed into a single buffer of this size then multiple buffers and messages will be used.

Definition at line 648 of file parallel_implementation.h.

References TIMPI::pack_range(), TIMPI::packed_range_size(), and TIMPI::Communicator::send().

Referenced by TIMPI::Communicator::send_receive_packed_range().

 {
   // We will serialize variable size objects from *range_begin to
   // *range_end as a sequence of plain data (e.g. ints) in this buffer
   typedef typename std::iterator_traits<Iter>::value_type T;
 
   std::size_t total_buffer_size =
     packed_range_size (context, range_begin, range_end);
 
   this->send(dest_processor_id, total_buffer_size, tag);
 
 #ifdef DEBUG
   std::size_t used_buffer_size = 0;
 #endif
 
   while (range_begin != range_end)
     {
       timpi_assert_greater (std::distance(range_begin, range_end), 0);
 
       std::vector<typename Packing<T>::buffer_type> buffer;
 
       const Iter next_range_begin = pack_range
         (context, range_begin, range_end, buffer, approx_buffer_size);
 
       timpi_assert_greater (std::distance(range_begin, next_range_begin), 0);
 
       range_begin = next_range_begin;
 
 #ifdef DEBUG
       used_buffer_size += buffer.size();
 #endif
 
       // Blocking send of the buffer
       this->send(dest_processor_id, buffer, tag);
     }
 
 #ifdef DEBUG
   timpi_assert_equal_to(used_buffer_size, total_buffer_size);
 #endif
 }

◆ send_packed_range() [2/2]

template<typename Context , typename Iter >

void TIMPI::Communicator::send_packed_range	(	const unsigned int	dest_processor_id,
		const Context *	context,
		Iter	range_begin,
		const Iter	range_end,
		Request &	req,
		const MessageTag &	tag = `no_tag`,
		std::size_t	approx_buffer_size = `1000000`
	)		const

inlineinherited

Nonblocking-send range-of-pointers to one processor.

This function does not send the raw pointers, but rather constructs new objects at the other end whose contents match the objects pointed to by the sender.

void TIMPI::pack(const T *, vector<int> & data, const Context *) is used to serialize type T onto the end of a data vector.

unsigned int TIMPI::packable_size(const T *, const Context *) is used to allow data vectors to reserve memory, and for additional error checking

The approximate maximum size (in entries; number of bytes will likely be 4x or 8x larger) to use in a single data vector buffer can be specified for performance or memory usage reasons; if the range cannot be packed into a single buffer of this size then multiple buffers and messages will be used.

Definition at line 696 of file parallel_implementation.h.

References TIMPI::Request::add_post_wait_work(), TIMPI::Request::add_prior_request(), TIMPI::pack_range(), TIMPI::packed_range_size(), and TIMPI::Communicator::send().

 {
   // Allocate a buffer on the heap so we don't have to free it until
   // after the Request::wait()
   typedef typename std::iterator_traits<Iter>::value_type T;
   typedef typename Packing<T>::buffer_type buffer_t;
 
   std::size_t total_buffer_size =
     packed_range_size (context, range_begin, range_end);
 
   // That local variable will be gone soon; we need a send buffer that
   // will stick around.  I heard you like buffering so I put a buffer
   // for your buffer size so you can buffer the size of your buffer.
   std::size_t * total_buffer_size_buffer = new std::size_t;
   *total_buffer_size_buffer = total_buffer_size;
 
   // Delete the buffer size's buffer when we're done
   Request intermediate_req = request();
   intermediate_req.add_post_wait_work
     (new PostWaitDeleteBuffer<std::size_t>(total_buffer_size_buffer));
   this->send(dest_processor_id, *total_buffer_size_buffer, intermediate_req, tag);
 
   // And don't finish up the full request until we're done with its
   // dependencies
   req.add_prior_request(intermediate_req);
 
 #ifdef DEBUG
   std::size_t used_buffer_size = 0;
 #endif
 
   while (range_begin != range_end)
     {
       timpi_assert_greater (std::distance(range_begin, range_end), 0);
 
       std::vector<buffer_t> * buffer = new std::vector<buffer_t>();
 
       const Iter next_range_begin = pack_range
         (context, range_begin, range_end, *buffer, approx_buffer_size);
 
       timpi_assert_greater (std::distance(range_begin, next_range_begin), 0);
 
       range_begin = next_range_begin;
 
 #ifdef DEBUG
       used_buffer_size += buffer->size();
 #endif
 
       Request next_intermediate_req;
 
       Request * my_req = (range_begin == range_end) ? &req : &next_intermediate_req;
 
       // Make the Request::wait() handle deleting the buffer
       my_req->add_post_wait_work
         (new PostWaitDeleteBuffer<std::vector<buffer_t>>
          (buffer));
 
       // Non-blocking send of the buffer
       this->send(dest_processor_id, *buffer, *my_req, tag);
 
       if (range_begin != range_end)
         req.add_prior_request(*my_req);
     }
 
 #ifdef DEBUG
   timpi_assert_equal_to(used_buffer_size, total_buffer_size);
 #endif
 }

◆ send_receive() [1/7]

template<typename T1 , typename T2 , typename std::enable_if< std::is_base_of< DataType, StandardType< T1 >>::value &&std::is_base_of< DataType, StandardType< T2 >>::value, int >::type >

void TIMPI::Communicator::send_receive	(	const unsigned int	timpi_dbg_varsend_tgt,
		const T1 &	send_val,
		const unsigned int	timpi_dbg_varrecv_source,
		T2 &	recv_val,
		const MessageTag &	,
		const MessageTag &
	)		const

inlineinherited

Send-receive data from one processor.

Definition at line 189 of file serial_implementation.h.

 {
   timpi_assert_equal_to (send_tgt, 0);
   timpi_assert_equal_to (recv_source, 0);
   recv_val = send_val;
 }

◆ send_receive() [2/7]

template<typename T , typename A , typename std::enable_if< Has_buffer_type< Packing< T >>::value, int >::type >

void TIMPI::Communicator::send_receive	(	const unsigned int	timpi_dbg_vardest_processor_id,
		const std::vector< T, A > &	send,
		const unsigned int	timpi_dbg_varsource_processor_id,
		std::vector< T, A > &	recv,
		const MessageTag &	,
		const MessageTag &
	)		const

inlineinherited

Definition at line 238 of file serial_implementation.h.

References TIMPI::Communicator::send().

 {
   timpi_assert_equal_to (dest_processor_id, 0);
   timpi_assert_equal_to (source_processor_id, 0);
   recv = send;
 }

◆ send_receive() [3/7]

template<typename T , typename A1 , typename A2 >

void TIMPI::Communicator::send_receive	(	const unsigned int	timpi_dbg_vardest_processor_id,
		const std::vector< std::vector< T, A1 >, A2 > &	send,
		const unsigned int	timpi_dbg_varsource_processor_id,
		std::vector< std::vector< T, A1 >, A2 > &	recv,
		const MessageTag &	,
		const MessageTag &
	)		const

inlineinherited

Definition at line 297 of file serial_implementation.h.

References TIMPI::Communicator::send().

 {
   timpi_assert_equal_to (dest_processor_id, 0);
   timpi_assert_equal_to (source_processor_id, 0);
   recv = send;
 }

◆ send_receive() [4/7]

template<typename T1 , typename T2 , typename std::enable_if< std::is_base_of< DataType, StandardType< T1 >>::value &&std::is_base_of< DataType, StandardType< T2 >>::value, int >::type >

void TIMPI::Communicator::send_receive	(	const unsigned int	dest_processor_id,
		const T1 &	send_data,
		const unsigned int	source_processor_id,
		T2 &	recv_data,
		const MessageTag &	send_tag = `no_tag`,
		const MessageTag &	recv_tag = `any_tag`
	)		const

inlineinherited

Send data send to one processor while simultaneously receiving other data recv from a (potentially different) processor.

This overload is defined for fixed-size data; other overloads exist for many other categories.

Definition at line 1397 of file parallel_implementation.h.

References TIMPI::any_source, TIMPI::Communicator::rank(), TIMPI::Communicator::size(), and TIMPI::MessageTag::value().

Referenced by TIMPI::push_parallel_vector_data().

 {
   TIMPI_LOG_SCOPE("send_receive()", "Parallel");
 
   if (dest_processor_id   == this->rank() &&
       source_processor_id == this->rank())
     {
       recv = sendvec;
       return;
     }
 
   timpi_assert_less(dest_processor_id, this->size());
   timpi_assert(source_processor_id < this->size() ||
                   source_processor_id == any_source);
 
   // MPI_STATUS_IGNORE is from MPI-2; using it with some versions of
   // MPICH may cause a crash:
   // https://bugzilla.mcs.anl.gov/globus/show_bug.cgi?id=1798
   timpi_call_mpi
     (TIMPI_SENDRECV(const_cast<T1*>(&sendvec), 1, StandardType<T1>(&sendvec),
                     dest_processor_id, send_tag.value(), &recv, 1,
                     StandardType<T2>(&recv), source_processor_id,
                     recv_tag.value(), this->get(), MPI_STATUS_IGNORE));
 }

◆ send_receive() [5/7]

template<typename T1 , typename T2 >

void TIMPI::Communicator::send_receive	(	const unsigned int	dest_processor_id,
		const T1 &	send_data,
		const DataType &	type1,
		const unsigned int	source_processor_id,
		T2 &	recv_data,
		const DataType &	type2,
		const MessageTag &	send_tag = `no_tag`,
		const MessageTag &	recv_tag = `any_tag`
	)		const

inlineinherited

Send data send to one processor while simultaneously receiving other data recv from a (potentially different) processor, using a user-specified MPI Dataype.

◆ send_receive() [6/7]

template<typename T , typename A , typename std::enable_if< std::is_base_of< DataType, StandardType< T >>::value, int >::type >

void TIMPI::Communicator::send_receive	(	const unsigned int	dest_processor_id,
		const std::vector< T, A > &	send_data,
		const unsigned int	source_processor_id,
		std::vector< T, A > &	recv_data,
		const MessageTag &	send_tag,
		const MessageTag &	recv_tag
	)		const

inlineinherited

Definition at line 1376 of file parallel_implementation.h.

References TIMPI::Communicator::send_receive_packed_range().

 {
   this->send_receive_packed_range(dest_processor_id, (void *)(nullptr),
                                   send_data.begin(), send_data.end(),
                                   source_processor_id, (void *)(nullptr),
                                   std::back_inserter(recv_data),
                                   (const T *)(nullptr),
                                   send_tag, recv_tag);
 }

◆ send_receive() [7/7]

template<typename T , typename A1 , typename A2 >

void TIMPI::Communicator::send_receive	(	const unsigned int	dest_processor_id,
		const std::vector< std::vector< T, A1 >, A2 > &	sendvec,
		const unsigned int	source_processor_id,
		std::vector< std::vector< T, A1 >, A2 > &	recv,
		const MessageTag &	send_tag,
		const MessageTag &	recv_tag
	)		const

inlineinherited

Definition at line 1509 of file parallel_implementation.h.

 {
   send_receive_vec_of_vec
     (dest_processor_id, sendvec, source_processor_id, recv,
      send_tag, recv_tag, *this);
 }

◆ send_receive_packed_range() [1/2]

template<typename Context1 , typename RangeIter , typename Context2 , typename OutputIter , typename T >

void TIMPI::Communicator::send_receive_packed_range	(	const unsigned int	timpi_dbg_vardest_processor_id,
		const Context1 *	context1,
		RangeIter	send_begin,
		const RangeIter	send_end,
		const unsigned int	timpi_dbg_varsource_processor_id,
		Context2 *	context2,
		OutputIter	out_iter,
		const T *	output_type,
		const MessageTag &	,
		const MessageTag &	,
		std::size_t
	)		const

inlineinherited

Send-receive range-of-pointers from one processor.

If you call this without MPI you might be making a mistake, but we'll support it.

Definition at line 322 of file serial_implementation.h.

References TIMPI::pack_range(), and TIMPI::unpack_range().

 {
   // This makes no sense on one processor unless we're deliberately
   // sending to ourself.
   timpi_assert_equal_to(dest_processor_id, 0);
   timpi_assert_equal_to(source_processor_id, 0);
 
   // On one processor, we just need to pack the range and then unpack
   // it again.
   typedef typename std::iterator_traits<RangeIter>::value_type T1;
   typedef typename Packing<T1>::buffer_type buffer_t;
 
   // OutputIter might not have operator= implemented; for maximum
   // compatibility we'll rely on its copy constructor.
   std::unique_ptr<OutputIter> next_out_iter =
     std::make_unique<OutputIter>(out_iter);
 
   while (send_begin != send_end)
     {
       timpi_assert_greater (std::distance(send_begin, send_end), 0);
 
       // We will serialize variable size objects from *range_begin to
       // *range_end as a sequence of ints in this buffer
       std::vector<buffer_t> buffer;
 
       const RangeIter next_send_begin = pack_range
         (context1, send_begin, send_end, buffer);
 
       timpi_assert_greater (std::distance(send_begin, next_send_begin), 0);
 
       send_begin = next_send_begin;
 
       auto return_out_iter = unpack_range
         (buffer, context2, *next_out_iter, output_type);
       next_out_iter = std::make_unique<OutputIter>(return_out_iter);
     }
 }

◆ send_receive_packed_range() [2/2]

template<typename Context1 , typename RangeIter , typename Context2 , typename OutputIter , typename T >

void TIMPI::Communicator::send_receive_packed_range	(	const unsigned int	dest_processor_id,
		const Context1 *	context1,
		RangeIter	send_begin,
		const RangeIter	send_end,
		const unsigned int	source_processor_id,
		Context2 *	context2,
		OutputIter	out,
		const T *	output_type,
		const MessageTag &	send_tag = `no_tag`,
		const MessageTag &	recv_tag = `any_tag`,
		std::size_t	approx_buffer_size = `1000000`
	)		const

inlineinherited

Send a range-of-pointers to one processor while simultaneously receiving another range from a (potentially different) processor.

This function does not send or receive raw pointers, but rather constructs new objects at each receiver whose contents match the objects pointed to by the sender.

The objects being sent will be of type T1 = iterator_traits<RangeIter>::value_type, and the objects being received will be of type T2 = iterator_traits<OutputIter>::value_type

void TIMPI::pack(const T1*, vector<int> & data, const Context1*) is used to serialize type T1 onto the end of a data vector.

Using std::back_inserter as the output iterator allows send_receive to fill any container type. Using some null_output_iterator allows the receive to be dealt with solely by TIMPI::unpack(), for objects whose unpack() is written so as to not leak memory when used in this fashion.

A future version of this method should be created to preallocate memory when receiving vectors...

void TIMPI::unpack(vector<int>::iterator in, T2** out, Context *) is used to unserialize type T2, typically into a new heap-allocated object whose pointer is returned as *out.

unsigned int TIMPI::packable_size(const T1*, const Context1*) is used to allow data vectors to reserve memory, and for additional error checking.

unsigned int TIMPI::packed_size(const T2*, vector<int>::const_iterator) is used to advance to the beginning of the next object's data.

Definition at line 1527 of file parallel_implementation.h.

References TIMPI::pack_range(), TIMPI::Communicator::rank(), TIMPI::Communicator::receive_packed_range(), TIMPI::Communicator::send_packed_range(), TIMPI::unpack_range(), and TIMPI::Request::wait().

Referenced by TIMPI::push_parallel_packed_range(), TIMPI::Communicator::send_receive(), testContainerSendReceive(), and testNullSendReceive().

 {
   TIMPI_LOG_SCOPE("send_receive()", "Parallel");
 
   timpi_assert_equal_to
     ((dest_processor_id  == this->rank()),
      (source_processor_id == this->rank()));
 
   if (dest_processor_id   == this->rank() &&
       source_processor_id == this->rank())
     {
       // We need to pack and unpack, even if we don't need to
       // communicate the buffer, just in case user Packing
       // specializations have side effects
 
       // OutputIter might not have operator= implemented; for maximum
       // compatibility we'll rely on its copy constructor.
       std::unique_ptr<OutputIter> next_out_iter =
         std::make_unique<OutputIter>(out_iter);
 
       typedef typename Packing<T>::buffer_type buffer_t;
       while (send_begin != send_end)
         {
           std::vector<buffer_t> buffer;
           send_begin = pack_range
             (context1, send_begin, send_end, buffer, approx_buffer_size);
           auto return_out_iter = unpack_range
             (buffer, context2, *next_out_iter, output_type);
           next_out_iter = std::make_unique<OutputIter>(return_out_iter);
         }
       return;
     }
 
   Request req;
 
   this->send_packed_range (dest_processor_id, context1, send_begin, send_end,
                            req, send_tag, approx_buffer_size);
 
   this->receive_packed_range (source_processor_id, context2, out_iter,
                               output_type, recv_tag);
 
   req.wait();
 }

◆ set_union() [1/2]

template<typename T >

void TIMPI::Communicator::set_union	(	T &	data,
		const unsigned int	root_id
	)		const

inlineinherited

Take a container (set, map, unordered_set, multimap, etc) of local variables on each processor, and collect their union over all processors, replacing the original on the processor with rank root_id.

If the data is a map or unordered_map and entries exist on different processors with the same key and different values, then the value with the lowest processor id takes precedence.

If the data is a multiset or multimap or unordered_multimap, and entries exist on different processors with the same key, these entries are duplicated in the gathered container.

Referenced by testBigUnion(), testLargeSetUnion(), testMapMap(), testMapSet(), testPackedSetUnion(), and testUnion().

◆ set_union() [2/2]

template<typename T >

void TIMPI::Communicator::set_union ( T & data ) const

inlineinherited

Take a container of local variables on each processor, and replace it with their union over all processors, replacing the original on all processors.

If the data is a multiset or multimap or unordered_multimap, and entries exist on different processors with the same key, these entries are duplicated in the gathered container.

◆ size() [1/2]

processor_id_type TIMPI::Communicator::size ( ) const

inlineinherited

Definition at line 211 of file communicator.h.

References TIMPI::Communicator::_size.

211 { return _size; }

TIMPI::Communicator::_size

processor_id_type _size

Definition: communicator.h:237

◆ size() [2/2]

constexpr processor_id_type TIMPI::Communicator::size ( ) const

inlineinherited

Definition at line 214 of file communicator.h.

214 { return 1; }

◆ split()

void TIMPI::Communicator::split	(	int	color,
		int	key,
		Communicator &	target
	)		const

inherited

Definition at line 97 of file communicator.C.

References TIMPI::Communicator::_I_duped_it, TIMPI::Communicator::assign(), TIMPI::Communicator::clear(), TIMPI::Communicator::send_mode(), and TIMPI::Communicator::sync_type().

Referenced by testSplit().

 {
   target.clear();
   MPI_Comm newcomm;
   timpi_call_mpi
     (MPI_Comm_split(this->get(), color, key, &newcomm));
 
   target.assign(newcomm);
   target._I_duped_it = (color != MPI_UNDEFINED);
   target.send_mode(this->send_mode());
   target.sync_type(this->sync_type());
 }

◆ split_by_type()

void TIMPI::Communicator::split_by_type	(	int	split_type,
		int	key,
		info	i,
		Communicator &	target
	)		const

inherited

Definition at line 111 of file communicator.C.

References TIMPI::Communicator::_I_duped_it, TIMPI::Communicator::assign(), TIMPI::Communicator::clear(), TIMPI::Communicator::send_mode(), and TIMPI::Communicator::sync_type().

Referenced by testSplitByType().

 {
   target.clear();
   MPI_Comm newcomm;
   timpi_call_mpi
     (MPI_Comm_split_type(this->get(), split_type, key, i, &newcomm));
 
   target.assign(newcomm);
   target._I_duped_it = (split_type != MPI_UNDEFINED);
   target.send_mode(this->send_mode());
   target.sync_type(this->sync_type());
 }

◆ sum() [1/2]

template<typename T >

void TIMPI::Communicator::sum ( T & r ) const

inlineinherited

Take a local variable and replace it with the sum of it's values on all processors.

Containers are replaced element-wise.

Referenced by testNonblockingSum(), testNonFixedTypeSum(), testSum(), and testSumOpFunction().

◆ sum() [2/2]

template<typename T >

void TIMPI::Communicator::sum	(	const T &	r,
		T &	o,
		Request &	req
	)		const

inlineinherited

Non-blocking sum of the local value r into o with the request req.

◆ sync_type() [1/3]

void TIMPI::Communicator::sync_type ( const SyncType st )

inlineinherited

Explicitly sets the SyncType used for sync operations.

Definition at line 343 of file communicator.h.

References TIMPI::Communicator::_sync_type.

Referenced by TIMPI::Communicator::duplicate(), main(), TIMPI::pull_parallel_vector_data(), TIMPI::push_parallel_packed_range(), TIMPI::push_parallel_vector_data(), TIMPI::Communicator::split(), TIMPI::Communicator::split_by_type(), testPullImpl(), testPullVecVecImpl(), testPushMultimapImpl(), testPushMultimapVecVecImpl(), and testStringSyncType().

343 { _sync_type = st; }

TIMPI::Communicator::_sync_type

SyncType _sync_type

Definition: communicator.h:239

◆ sync_type() [2/3]

void TIMPI::Communicator::sync_type ( const std::string & st )

inherited

Sets the sync type used for sync operations via a string.

Useful for changing the sync type via a CLI arg or parameter.

Definition at line 455 of file communicator.C.

References TIMPI::Communicator::ALLTOALL_COUNTS, TIMPI::Communicator::NBX, TIMPI::Communicator::SENDRECEIVE, and TIMPI::Communicator::sync_type().

 {
   SyncType type = NBX;
   if (st == "sendreceive")
     type = SENDRECEIVE;
   else if (st == "alltoall")
     type = ALLTOALL_COUNTS;
   else if (st != "nbx")
     timpi_error_msg("Unrecognized TIMPI sync type " << st);
   this->sync_type(type);
 }

◆ sync_type() [3/3]

SyncType TIMPI::Communicator::sync_type ( ) const

inlineinherited

Gets the user-requested SyncType.

Definition at line 355 of file communicator.h.

References TIMPI::Communicator::_sync_type.

Referenced by TIMPI::Communicator::duplicate(), TIMPI::Communicator::split(), TIMPI::Communicator::split_by_type(), and TIMPI::Communicator::sync_type().

355 { return _sync_type; }

TIMPI::Communicator::_sync_type

SyncType _sync_type

Definition: communicator.h:239

◆ verify() [1/2]

template<typename T >

timpi_pure bool TIMPI::Communicator::verify ( const T & r ) const

inlineinherited

Check whether a local variable has the same value on all processors, returning true if it does or false if not.

Useful in assertions and possibly in user error checking.

Containers must have the same value in every entry for this function to return true.

Referenced by TIMPI::Communicator::broadcast(), TIMPI::Communicator::max(), TIMPI::Communicator::maxloc(), TIMPI::Communicator::min(), and TIMPI::Communicator::minloc().

◆ verify() [2/2]

template<typename T >

bool TIMPI::Communicator::verify ( const T & r ) const

inlineinherited

Definition at line 2092 of file parallel_implementation.h.

References TIMPI::Communicator::max(), TIMPI::Communicator::min(), and TIMPI::Communicator::size().

 {
   if (this->size() > 1 && Attributes<T>::has_min_max == true)
     {
       T tempmin = r, tempmax = r;
       this->min(tempmin);
       this->max(tempmax);
       bool verified = (r == tempmin) &&
         (r == tempmax);
       this->min(verified);
       return verified;
     }
 
   static_assert(Attributes<T>::has_min_max,
                 "Tried to verify an unverifiable type");
 
   return true;
 }

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

src/parallel/include/timpi/communicator.h

Public Types

Public Member Functions

Detailed Description

Member Enumeration Documentation

◆ SendMode

◆ SyncType

Constructor & Destructor Documentation

◆ Communicator() [1/4]

◆ Communicator() [2/4]

◆ Communicator() [3/4]

◆ Communicator() [4/4]

◆ ~Communicator()

Member Function Documentation

◆ allgather() [1/8]

◆ allgather() [2/8]

◆ allgather() [3/8]

◆ allgather() [4/8]

◆ allgather() [5/8]

◆ allgather() [6/8]

◆ allgather() [7/8]

◆ allgather() [8/8]

◆ allgather_packed_range()

◆ alltoall()

◆ barrier()

◆ bitwise_and() [1/2]

◆ bitwise_and() [2/2]

◆ bitwise_or() [1/2]

◆ bitwise_or() [2/2]

◆ bitwise_xor() [1/2]

◆ bitwise_xor() [2/2]

◆ broadcast() [1/4]

◆ broadcast() [2/4]

◆ broadcast() [3/4]

◆ broadcast() [4/4]

◆ broadcast_packed_range()

◆ clear()

◆ dereference_unique_tag()

◆ duplicate() [1/2]

◆ duplicate() [2/2]

◆ gather() [1/4]

◆ gather() [2/4]

◆ gather() [3/4]

◆ gather() [4/4]

◆ gather_packed_range()

◆ get() [1/2]

◆ get() [2/2]

◆ get_unique_tag()

◆ logical_and() [1/2]

◆ logical_and() [2/2]

◆ logical_or() [1/2]

◆ logical_or() [2/2]

◆ logical_xor() [1/2]

◆ logical_xor() [2/2]

◆ max() [1/3]

◆ max() [2/3]

◆ max() [3/3]

◆ maxloc() [1/3]

◆ maxloc() [2/3]

◆ maxloc() [3/3]

◆ min() [1/3]

◆ min() [2/3]

◆ min() [3/3]

◆ minloc() [1/3]

◆ minloc() [2/3]

◆ minloc() [3/3]

◆ nonblocking_barrier()

◆ nonblocking_receive_packed_range() [1/3]

◆ nonblocking_receive_packed_range() [2/3]

◆ nonblocking_receive_packed_range() [3/3]

◆ nonblocking_send_packed_range() [1/3]

◆ nonblocking_send_packed_range() [2/3]

◆ nonblocking_send_packed_range() [3/3]

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ packed_range_probe()

◆ possibly_receive() [1/5]

◆ possibly_receive() [2/5]

◆ possibly_receive() [3/5]

◆ possibly_receive() [4/5]

◆ possibly_receive() [5/5]