#include <communicator.h>

Public Types
enum	SendMode { DEFAULT =0, SYNCHRONOUS }

Public Member Functions
	Communicator ()

	Communicator (const communicator &comm)

	Communicator (const Communicator &)=delete

Communicator &	operator= (const Communicator &)=delete

	Communicator (Communicator &&)=default

Communicator &	operator= (Communicator &&)=default

	~Communicator ()

void	split (int color, int key, 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) const

void	reference_unique_tag (int tagvalue) const

void	dereference_unique_tag (int tagvalue) const

void	clear ()

Communicator &	operator= (const communicator &comm)

processor_id_type	rank () const

processor_id_type	size () const

void	send_mode (const SendMode sm)

SendMode	send_mode () const

void	barrier () const

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

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

template<typename T >
void	min (T &r) const

template<typename T >
void	minloc (T &r, unsigned int &min_id) const

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

template<typename T >
void	max (T &r) const

template<typename T >
void	maxloc (T &r, unsigned int &max_id) const

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

template<typename T >
void	sum (T &r) const

template<typename T >
void	set_union (T &data, const unsigned int root_id) const

template<typename T >
void	set_union (T &data) const

status	probe (const unsigned int src_processor_id, const MessageTag &tag=any_tag) const

template<typename T >
Status	packed_range_probe (const unsigned int src_processor_id, const MessageTag &tag, bool &flag) const

template<typename T >
void	send (const unsigned int dest_processor_id, const T &buf, const MessageTag &tag=no_tag) const

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

template<typename T >
void	send (const unsigned int dest_processor_id, const T &buf, const DataType &type, const MessageTag &tag=no_tag) const

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

template<typename T >
Status	receive (const unsigned int dest_processor_id, T &buf, const MessageTag &tag=any_tag) const

template<typename T >
void	receive (const unsigned int dest_processor_id, T &buf, Request &req, const MessageTag &tag=any_tag) const

template<typename T >
Status	receive (const unsigned int dest_processor_id, T &buf, const DataType &type, const MessageTag &tag=any_tag) const

template<typename T >
void	receive (const unsigned int dest_processor_id, T &buf, const DataType &type, Request &req, const MessageTag &tag=any_tag) const

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) const

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) const

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

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 Parallel::Packing< typename std::iterator_traits< Iter >::value_type >::buffer_type >> &buffer, const MessageTag &tag=no_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

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

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 Parallel::Packing< T >::buffer_type >> &buffer, const MessageTag &tag=any_tag) const

template<typename T1 , typename T2 >
void	send_receive (const unsigned int dest_processor_id, const T1 &send, const unsigned int source_processor_id, T2 &recv, const MessageTag &send_tag=no_tag, const MessageTag &recv_tag=any_tag) 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) const

template<typename T1 , typename T2 >
void	send_receive (const unsigned int dest_processor_id, const T1 &send, const DataType &type1, const unsigned int source_processor_id, T2 &recv, const DataType &type2, const MessageTag &send_tag=no_tag, const MessageTag &recv_tag=any_tag) const

template<typename T , typename A >
void	gather (const unsigned int root_id, const T &send, std::vector< T, A > &recv) const

template<typename T , typename A >
void	gather (const unsigned int root_id, const std::basic_string< T > &send, std::vector< std::basic_string< T >, A > &recv, const bool identical_buffer_sizes=false) const

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

template<typename T , typename A >
void	allgather (const T &send, std::vector< T, A > &recv) const

template<typename T , typename A >
void	allgather (const std::basic_string< T > &send, std::vector< std::basic_string< T >, A > &recv, const bool identical_buffer_sizes=false) const

template<typename T , typename A >
void	allgather (std::vector< T, A > &r, const bool identical_buffer_sizes=false) const

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

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

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

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

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

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) const

template<typename Context , typename Iter , typename OutputIter >
void	allgather_packed_range (Context *context, Iter range_begin, const Iter range_end, OutputIter out) const

template<typename T , typename A >
void	alltoall (std::vector< T, A > &r) const

template<typename T >
void	broadcast (T &data, const unsigned int root_id=0) 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) const

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 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 >
void	send_receive (const unsigned int dest_processor_id, const std::vector< T, A > &sendvec, const unsigned int source_processor_id, std::vector< T, A > &recv, const MessageTag &send_tag, const MessageTag &recv_tag) const

template<>
void	broadcast (bool &data, const unsigned int root_id) const

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

template<typename Context1 , typename RangeIter , typename Context2 , typename OutputIter , typename T >
void	send_receive_packed_range (const unsigned int libmesh_dbg_var(dest_processor_id), const Context1 context1, RangeIter send_begin, const RangeIter send_end, const unsigned int libmesh_dbg_var(source_processor_id), Context2 context2, OutputIter out_iter, const T *output_type, const MessageTag &, const MessageTag &) const

template<typename T >
void	min (T &libmesh_mpi_var(r)) const

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

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 (T &libmesh_mpi_var(r)) const

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

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

template<typename T >
void	sum (T &libmesh_mpi_var(r)) const

template<typename T >
void	sum (std::complex< T > &libmesh_mpi_var(r)) const

template<typename T >
void	broadcast (T &libmesh_mpi_var(data), const unsigned int root_id) const

Private Member Functions
void	assign (const communicator &comm)

Private Attributes
communicator	_communicator

processor_id_type	_rank

processor_id_type	_size

SendMode	_send_mode

std::map< int, unsigned int >	used_tag_values

bool	_I_duped_it

Detailed Description

Encapsulates the MPI_Comm object. Allows the size of the group and this process's position in the group to be determined.

Methods of this object are the preferred way to perform distributed-memory parallel operations.

Definition at line 92 of file communicator.h.

Member Enumeration Documentation

◆ SendMode

enum libMesh::Parallel::Communicator::SendMode

Whether to use default or synchronous sends?

Enumerator
DEFAULT
SYNCHRONOUS

Definition at line 180 of file communicator.h.

180 { DEFAULT=0, SYNCHRONOUS };

libMesh::Parallel::Communicator::DEFAULT

Definition: communicator.h:180

libMesh::Parallel::Communicator::SYNCHRONOUS

Definition: communicator.h:180

Constructor & Destructor Documentation

◆ Communicator() [1/4]

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

Default Constructor.

Definition at line 57 of file communicator.C.

                             :
 #ifdef LIBMESH_HAVE_MPI
   _communicator(MPI_COMM_SELF),
 #endif
   _rank(0),
   _size(1),
   _send_mode(DEFAULT),
   used_tag_values(),
   _I_duped_it(false) {}

◆ Communicator() [2/4]

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

explicit

Definition at line 68 of file communicator.C.

References assign().

                                                      :
 #ifdef LIBMESH_HAVE_MPI
   _communicator(MPI_COMM_SELF),
 #endif
   _rank(0),
   _size(1),
   _send_mode(DEFAULT),
   used_tag_values(),
   _I_duped_it(false)
 {
   this->assign(comm);
 }

◆ Communicator() [3/4]

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

delete

◆ Communicator() [4/4]

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

default

◆ ~Communicator()

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

Definition at line 82 of file communicator.C.

References clear().

 {
   this->clear();
 }

Member Function Documentation

◆ allgather() [1/4]

template<typename T , typename A >

void libMesh::Parallel::Communicator::allgather	(	const T &	send,
		std::vector< T, A > &	recv
	)		const

inline

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

Definition at line 2746 of file parallel_implementation.h.

References size().

Referenced by allgather(), libMesh::LaplaceMeshSmoother::allgather_graph(), allgather_packed_range(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::DofMap::distribute_dofs(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), gather(), libMesh::Nemesis_IO::read(), and libMesh::DistributedMesh::renumber_dof_objects().

 {
   LOG_SCOPE ("allgather()","Parallel");
 
   libmesh_assert(this->size());
   recv.resize(this->size());
 
   unsigned int comm_size = this->size();
   if (comm_size > 1)
     {
       StandardType<T> send_type(&sendval);
 
       libmesh_call_mpi
         (MPI_Allgather (const_cast<T*>(&sendval), 1, send_type, recv.data(), 1,
                         send_type, this->get()));
     }
   else if (comm_size > 0)
     recv[0] = sendval;
 }

◆ allgather() [2/4]

template<typename T , typename A >

void libMesh::Parallel::Communicator::allgather	(	const std::basic_string< T > &	send,
		std::vector< std::basic_string< T >, A > &	recv,
		const bool	identical_buffer_sizes = `false`
	)		const

inline

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

Definition at line 1374 of file parallel_implementation.h.

References allgather(), and size().

 {
   LOG_SCOPE ("allgather()","Parallel");
 
   libmesh_assert(this->size());
   recv.assign(this->size(), "");
 
   // serial case
   if (this->size() < 2)
     {
       recv.resize(1);
       recv[0] = sendval;
       return;
     }
 
   std::vector<int>
     sendlengths  (this->size(), 0),
     displacements(this->size(), 0);
 
   const int mysize = static_cast<int>(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
   unsigned int 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::string r(globalsize, 0);
 
   // and get the data from the remote processors.
   libmesh_call_mpi
     (MPI_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() [3/4]

template<typename T , typename A >

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

inline

Take a vector of 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.

Definition at line 2770 of file parallel_implementation.h.

References allgather(), size(), and verify().

 {
   if (this->size() < 2)
     return;
 
   LOG_SCOPE("allgather()", "Parallel");
 
   if (identical_buffer_sizes)
     {
       if (r.empty())
         return;
 
       libmesh_assert(this->verify(r.size()));
 
       std::vector<T,A> r_src(r.size()*this->size());
       r_src.swap(r);
       StandardType<T> send_type(r_src.data());
 
       libmesh_call_mpi
         (MPI_Allgather (r_src.data(), cast_int<int>(r_src.size()),
                         send_type, r.data(), cast_int<int>(r_src.size()),
                         send_type, this->get()));
       // libmesh_assert(this->verify(r));
       return;
     }
 
   std::vector<int>
     sendlengths  (this->size(), 0),
     displacements(this->size(), 0);
 
   const int mysize = static_cast<int>(r.size());
   this->allgather(mysize, sendlengths);
 
   // Find the total size of the final array and
   // set up the displacement offsets for each processor.
   unsigned int 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;
 
   // copy the input buffer
   std::vector<T,A> r_src(globalsize);
   r_src.swap(r);
 
   StandardType<T> send_type(r.data());
 
   // and get the data from the remote processors.
   // Pass nullptr if our vector is empty.
   libmesh_call_mpi
     (MPI_Allgatherv (r_src.empty() ? nullptr : r_src.data(), mysize,
                      send_type, r.data(), sendlengths.data(),
                      displacements.data(), send_type, this->get()));
 }

◆ allgather() [4/4]

template<typename T , typename A >

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

inline

AllGather overload for vectors of string types

Definition at line 2834 of file parallel_implementation.h.

References allgather(), end, size(), and verify().

 {
   if (this->size() < 2)
     return;
 
   LOG_SCOPE("allgather()", "Parallel");
 
   if (identical_buffer_sizes)
     {
       libmesh_assert(this->verify(r.size()));
 
       // identical_buffer_sizes doesn't buy us much since we have to
       // communicate the lengths of strings within each buffer anyway
       if (r.empty())
         return;
     }
 
   // Concatenate the input buffer into a send buffer, and keep track
   // of input string lengths
   std::vector<int> mystrlengths (r.size());
   std::vector<T> concat_src;
 
   int myconcatsize = 0;
   for (unsigned int i=0; i != r.size(); ++i)
     {
       int stringlen = cast_int<int>(r[i].size());
       mystrlengths[i] = stringlen;
       myconcatsize += stringlen;
     }
   concat_src.reserve(myconcatsize);
   for (unsigned int i=0; i != r.size(); ++i)
     concat_src.insert
       (concat_src.end(), r[i].begin(), r[i].end());
 
   // Get the string lengths from all other processors
   std::vector<int> strlengths = mystrlengths;
   this->allgather(strlengths, identical_buffer_sizes);
 
   // We now know how many strings we'll be receiving
   r.resize(strlengths.size());
 
   // Get the concatenated data sizes from all other processors
   std::vector<int> concat_sizes;
   this->allgather(myconcatsize, concat_sizes);
 
   // Find the total size of the final concatenated array and
   // set up the displacement offsets for each processor.
   std::vector<int> displacements(this->size(), 0);
   unsigned int globalsize = 0;
   for (unsigned int i=0; i != this->size(); ++i)
     {
       displacements[i] = globalsize;
       globalsize += concat_sizes[i];
     }
 
   // Check for quick return
   if (globalsize == 0)
     return;
 
   // Get the concatenated data from the remote processors.
   // Pass nullptr if our vector is empty.
   std::vector<T> concat(globalsize);
 
   // We may have concat_src.empty(), but we know concat has at least
   // one element we can use as an example for StandardType
   StandardType<T> send_type(concat.data());
 
   libmesh_call_mpi
     (MPI_Allgatherv (concat_src.empty() ?
                      nullptr : concat_src.data(), myconcatsize,
                      send_type, concat.data(), concat_sizes.data(),
                      displacements.data(), send_type, this->get()));
 
   // Finally, split concatenated data into strings
   const T * begin = concat.data();
   for (unsigned int i=0; i != r.size(); ++i)
     {
       const T * end = begin + strlengths[i];
       r[i].assign(begin, end);
       begin = end;
     }
 }

◆ allgather_packed_range()

template<typename Context , typename Iter , typename OutputIter >

void libMesh::Parallel::Communicator::allgather_packed_range	(	Context *	context,
		Iter	range_begin,
		const Iter	range_end,
		OutputIter	out
	)		const

inline

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

Definition at line 3176 of file parallel_implementation.h.

References allgather(), max(), libMesh::Parallel::pack_range(), and libMesh::Parallel::unpack_range().

 {
   typedef typename std::iterator_traits<Iter>::value_type T;
   typedef typename Parallel::Packing<T>::buffer_type buffer_t;
 
   bool nonempty_range = (range_begin != range_end);
   this->max(nonempty_range);
 
   while (nonempty_range)
     {
       // 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;
 
       range_begin = Parallel::pack_range
         (context, range_begin, range_end, buffer);
 
       this->allgather(buffer, false);
 
       libmesh_assert(buffer.size());
 
       Parallel::unpack_range
         (buffer, context, out_iter, (T*)nullptr);
 
       nonempty_range = (range_begin != range_end);
       this->max(nonempty_range);
     }
 }

◆ alltoall()

template<typename T , typename A >

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

inline

Effectively transposes the input vector across all processors. The jth entry on processor i is replaced with the ith entry from processor j.

Definition at line 3092 of file parallel_implementation.h.

References libMesh::libmesh_ignore(), size(), and verify().

Referenced by libMesh::SparsityPattern::Build::parallel_sync(), libMesh::Parallel::push_parallel_vector_data(), and libMesh::Nemesis_IO::read().

 {
   if (this->size() < 2 || buf.empty())
     return;
 
   LOG_SCOPE("alltoall()", "Parallel");
 
   // the per-processor size.  this is the same for all
   // processors using MPI_Alltoall, could be variable
   // using MPI_Alltoallv
   const int size_per_proc =
     cast_int<int>(buf.size()/this->size());
   libmesh_ignore(size_per_proc);
 
   libmesh_assert_equal_to (buf.size()%this->size(), 0);
 
   libmesh_assert(this->verify(size_per_proc));
 
   StandardType<T> send_type(buf.data());
 
   libmesh_call_mpi
     (MPI_Alltoall (MPI_IN_PLACE, size_per_proc, send_type, buf.data(),
                    size_per_proc, send_type, this->get()));
 }

◆ assign()

void libMesh::Parallel::Communicator::assign ( const communicator & comm )

private

Utility function for setting our member variables from an MPI communicator

Definition at line 155 of file communicator.C.

References _communicator, _rank, _send_mode, _size, and DEFAULT.

Referenced by Communicator(), duplicate(), operator=(), and split().

 {
   _communicator = comm;
 #ifdef LIBMESH_HAVE_MPI
   if (_communicator != MPI_COMM_NULL)
     {
       int i;
       libmesh_call_mpi
         (MPI_Comm_size(_communicator, &i));
 
       libmesh_assert_greater_equal (i, 0);
       _size = cast_int<processor_id_type>(i);
 
       libmesh_call_mpi
         (MPI_Comm_rank(_communicator, &i));
 
       libmesh_assert_greater_equal (i, 0);
       _rank = cast_int<processor_id_type>(i);
     }
   else
     {
       _rank = 0;
       _size = 1;
     }
 #endif
   _send_mode = DEFAULT;
 }

◆ barrier()

void libMesh::Parallel::Communicator::barrier ( ) const

Pause execution until all processors reach a certain point.

Definition at line 188 of file communicator.C.

References size().

Referenced by libMesh::NameBasedIO::write(), and libMesh::XdrIO::write().

 {
   if (this->size() > 1)
     {
       LOG_SCOPE("barrier()", "Parallel");
       libmesh_call_mpi(MPI_Barrier (this->get()));
     }
 }

◆ broadcast() [1/4]

template<typename T >

void libMesh::Parallel::Communicator::broadcast	(	T &	data,
		const unsigned int	root_id = `0`
	)		const

inline

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 vector, the user is responsible for resizing it on all processors, except in the case when data is a vector of strings.

◆ broadcast() [2/4]

template<>

void libMesh::Parallel::Communicator::broadcast	(	bool &	data,
		const unsigned int	root_id
	)		const

inline

Definition at line 1434 of file parallel_implementation.h.

References data, rank(), and size().

 {
   if (this->size() == 1)
     {
       libmesh_assert (!this->rank());
       libmesh_assert (!root_id);
       return;
     }
 
   libmesh_assert_less (root_id, this->size());
 
   LOG_SCOPE("broadcast()", "Parallel");
 
   // We don't want to depend on MPI-2 or C++ MPI, so we don't have
   // MPI::BOOL available
   char char_data = data;
 
   // Spread data to remote processors.
   libmesh_call_mpi
     (MPI_Bcast (&char_data, 1, StandardType<char>(&char_data),
                 root_id, this->get()));
 
   data = char_data;
 }

◆ broadcast() [3/4]

template<typename T >

void libMesh::Parallel::Communicator::broadcast	(	std::basic_string< T > &	data,
		const unsigned int	root_id
	)		const

inline

Definition at line 1461 of file parallel_implementation.h.

References broadcast(), data, rank(), and size().

 {
   if (this->size() == 1)
     {
       libmesh_assert (!this->rank());
       libmesh_assert (!root_id);
       return;
     }
 
   libmesh_assert_less (root_id, this->size());
 
   LOG_SCOPE("broadcast()", "Parallel");
 
   std::size_t data_size = data.size();
   this->broadcast(data_size, root_id);
 
   std::vector<T> data_c(data_size);
 #ifndef NDEBUG
   std::string 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);
 
   data.assign(data_c.begin(), data_c.end());
 
 #ifndef NDEBUG
   if (this->rank() == root_id)
     libmesh_assert_equal_to (data, orig);
 #endif
 }

◆ broadcast() [4/4]

template<typename T >

void libMesh::Parallel::Communicator::broadcast	(	T &	libmesh_mpi_vardata,
		const unsigned int	root_id
	)		const

inline

Definition at line 3120 of file parallel_implementation.h.

References data, libMesh::libmesh_ignore(), rank(), and size().

 {
   libmesh_ignore(root_id); // Only needed for MPI and/or dbg/devel
   if (this->size() == 1)
     {
       libmesh_assert (!this->rank());
       libmesh_assert (!root_id);
       return;
     }
 
   libmesh_assert_less (root_id, this->size());
 
   LOG_SCOPE("broadcast()", "Parallel");
 
   // Spread data to remote processors.
   libmesh_call_mpi
     (MPI_Bcast (&data, 1, StandardType<T>(&data), root_id,
                 this->get()));
 }

◆ broadcast_packed_range()

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

void libMesh::Parallel::Communicator::broadcast_packed_range	(	const Context *	context1,
		Iter	range_begin,
		const Iter	range_end,
		OutputContext *	context2,
		OutputIter	out,
		const unsigned int	root_id = `0`
	)		const

inline

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 Parallel::pack(const T *, vector<int> & data, const Context *) is used to serialize type T onto the end of a data vector.

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

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

Definition at line 1672 of file parallel_implementation.h.

References broadcast(), libMesh::Parallel::pack_range(), rank(), and libMesh::Parallel::unpack_range().

 {
   typedef typename std::iterator_traits<Iter>::value_type T;
   typedef typename Parallel::Packing<T>::buffer_type buffer_t;
 
   do
     {
       // 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;
 
       if (this->rank() == root_id)
         range_begin = Parallel::pack_range
           (context1, range_begin, range_end, buffer);
 
       // this->broadcast(vector) requires the receiving vectors to
       // already be the appropriate size
       std::size_t buffer_size = buffer.size();
       this->broadcast (buffer_size, root_id);
 
       // We continue until there's nothing left to broadcast
       if (!buffer_size)
         break;
 
       buffer.resize(buffer_size);
 
       // Broadcast the packed data
       this->broadcast (buffer, root_id);
 
       if (this->rank() != root_id)
         Parallel::unpack_range
           (buffer, context2, out_iter, (T*)nullptr);
     } while (true);  // break above when we reach buffer_size==0
 }

◆ clear()

void libMesh::Parallel::Communicator::clear ( )

Free and reset this communicator

Definition at line 132 of file communicator.C.

References _communicator, and _I_duped_it.

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

                          {
 #ifdef LIBMESH_HAVE_MPI
   if (_I_duped_it)
     {
       libmesh_assert (_communicator != MPI_COMM_NULL);
       libmesh_call_mpi
         (MPI_Comm_free(&_communicator));
 
       _communicator = MPI_COMM_NULL;
     }
   _I_duped_it = false;
 #endif
 }

◆ dereference_unique_tag()

void libMesh::Parallel::Communicator::dereference_unique_tag ( int tagvalue ) const

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

Definition at line 44 of file communicator.C.

References used_tag_values.

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

 {
   // This had better be an already-acquired tag.
   libmesh_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 libMesh::Parallel::Communicator::duplicate ( const Communicator & comm )

Definition at line 108 of file communicator.C.

References _communicator, and send_mode().

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

◆ duplicate() [2/2]

void libMesh::Parallel::Communicator::duplicate ( const communicator & comm )

Definition at line 116 of file communicator.C.

References _communicator, _I_duped_it, and assign().

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

◆ gather() [1/3]

template<typename T , typename A >

void libMesh::Parallel::Communicator::gather	(	const unsigned int	root_id,
		const T &	send,
		std::vector< T, A > &	recv
	)		const

inline

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

Definition at line 2606 of file parallel_implementation.h.

References rank(), and size().

Referenced by gather(), gather_packed_range(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

 {
   libmesh_assert_less (root_id, this->size());
 
   if (this->rank() == root_id)
     recv.resize(this->size());
 
   if (this->size() > 1)
     {
       LOG_SCOPE("gather()", "Parallel");
 
       StandardType<T> send_type(&sendval);
 
       libmesh_call_mpi
         (MPI_Gather(const_cast<T*>(&sendval), 1, send_type,
                     recv.empty() ? nullptr : recv.data(), 1, send_type,
                     root_id, this->get()));
     }
   else
     recv[0] = sendval;
 }

◆ gather() [2/3]

template<typename T , typename A >

void libMesh::Parallel::Communicator::gather	(	const unsigned int	root_id,
		const std::basic_string< T > &	send,
		std::vector< std::basic_string< T >, A > &	recv,
		const bool	identical_buffer_sizes = `false`
	)		const

inline

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

Definition at line 2686 of file parallel_implementation.h.

References gather(), rank(), and size().

 {
   libmesh_assert_less (root_id, this->size());
 
   if (this->rank() == root_id)
     recv.resize(this->size());
 
   if (this->size() > 1)
     {
       LOG_SCOPE ("gather()","Parallel");
 
       std::vector<int>
         sendlengths  (this->size(), 0),
         displacements(this->size(), 0);
 
       const int mysize = static_cast<int>(sendval.size());
 
       if (identical_buffer_sizes)
         sendlengths.assign(this->size(), mysize);
       else
         // first comm step to determine buffer sizes from all processors
         this->gather(root_id, mysize, sendlengths);
 
       // Find the total size of the final array and
       // set up the displacement offsets for each processor
       unsigned int globalsize = 0;
       for (unsigned int i=0; i < this->size(); ++i)
         {
           displacements[i] = globalsize;
           globalsize += sendlengths[i];
         }
 
       // monolithic receive buffer
       std::string r;
       if (this->rank() == root_id)
         r.resize(globalsize, 0);
 
       // and get the data from the remote processors.
       libmesh_call_mpi
         (MPI_Gatherv (const_cast<T*>(sendval.data()),
                       mysize, StandardType<T>(),
                       this->rank() == root_id ? &r[0] : nullptr,
                       sendlengths.data(), displacements.data(),
                       StandardType<T>(), root_id, this->get()));
 
       // slice receive buffer up
       if (this->rank() == root_id)
         for (unsigned int i=0; i != this->size(); ++i)
           recv[i] = r.substr(displacements[i], sendlengths[i]);
     }
   else
     recv[0] = sendval;
 }

◆ gather() [3/3]

template<typename T , typename A >

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

inline

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.

Definition at line 2633 of file parallel_implementation.h.

References allgather(), rank(), and size().

 {
   if (this->size() == 1)
     {
       libmesh_assert (!this->rank());
       libmesh_assert (!root_id);
       return;
     }
 
   libmesh_assert_less (root_id, this->size());
 
   std::vector<int>
     sendlengths  (this->size(), 0),
     displacements(this->size(), 0);
 
   const int mysize = static_cast<int>(r.size());
   this->allgather(mysize, sendlengths);
 
   LOG_SCOPE("gather()", "Parallel");
 
   // Find the total size of the final array and
   // set up the displacement offsets for each processor.
   unsigned int 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;
 
   // copy the input buffer
   std::vector<T,A> r_src(r);
 
   // now resize it to hold the global data
   // on the receiving processor
   if (root_id == this->rank())
     r.resize(globalsize);
 
   // and get the data from the remote processors
   libmesh_call_mpi
     (MPI_Gatherv (r_src.empty() ? nullptr : r_src.data(), mysize,
                   StandardType<T>(), r.empty() ? nullptr : r.data(),
                   sendlengths.data(), displacements.data(),
                   StandardType<T>(), root_id, this->get()));
 }

◆ gather_packed_range()

template<typename Context , typename Iter , typename OutputIter >

void libMesh::Parallel::Communicator::gather_packed_range	(	const unsigned int	root_id,
		Context *	context,
		Iter	range_begin,
		const Iter	range_end,
		OutputIter	out
	)		const

inline

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

Definition at line 3143 of file parallel_implementation.h.

References gather(), max(), libMesh::Parallel::pack_range(), and libMesh::Parallel::unpack_range().

 {
   typedef typename std::iterator_traits<Iter>::value_type T;
   typedef typename Parallel::Packing<T>::buffer_type buffer_t;
 
   bool nonempty_range = (range_begin != range_end);
   this->max(nonempty_range);
 
   while (nonempty_range)
     {
       // 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;
 
       range_begin = Parallel::pack_range
         (context, range_begin, range_end, buffer);
 
       this->gather(root_id, buffer);
 
       Parallel::unpack_range
         (buffer, context, out_iter, (T*)(nullptr));
 
       nonempty_range = (range_begin != range_end);
       this->max(nonempty_range);
     }
 }

◆ get() [1/2]

communicator& libMesh::Parallel::Communicator::get ( )

inline

Definition at line 141 of file communicator.h.

References _communicator.

Referenced by libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult_add(), libMesh::PetscDMWrapper::add_dofs_helper(), libMesh::PetscDMWrapper::add_dofs_to_section(), libMesh::PetscDMWrapper::build_section(), libMesh::PetscDMWrapper::build_sf(), libMesh::PetscDMWrapper::check_section_n_dofs(), libMesh::PetscDMWrapper::init_and_attach_petscdm(), libMesh::libmesh_petsc_snes_jacobian(), libMesh::libmesh_petsc_snes_residual_helper(), and libMesh::PetscDMWrapper::set_point_range_in_section().

141 { return _communicator; }

libMesh::Parallel::Communicator::_communicator

communicator _communicator

Definition: communicator.h:190

◆ get() [2/2]

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

inline

Definition at line 143 of file communicator.h.

References _communicator.

143 { return _communicator; }

libMesh::Parallel::Communicator::_communicator

communicator _communicator

Definition: communicator.h:190

◆ get_unique_tag()

MessageTag libMesh::Parallel::Communicator::get_unique_tag ( int tagvalue ) const

Get a tag that is unique to this Communicator.

Note: If people are also using magic numbers or copying communicators around then we can't guarantee the tag is unique to this MPI_Comm.

Definition at line 201 of file communicator.C.

References used_tag_values.

Referenced by libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::Parallel::pull_parallel_vector_data(), libMesh::Parallel::push_parallel_vector_data(), libMesh::Nemesis_IO::read(), libMesh::System::read_SCALAR_dofs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::System::write_serialized_blocked_dof_objects(), and libMesh::XdrIO::write_serialized_nodes().

 {
   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;
       libmesh_assert(!used_tag_values.count(tagvalue));
     }
   used_tag_values[tagvalue] = 1;
 
   // #ifndef NDEBUG
   //   // Make sure everyone called get_unique_tag and make sure
   //   // everyone got the same value
   //   int maxval = tagvalue;
   //   this->max(maxval);
   //   libmesh_assert_equal_to (tagvalue, maxval);
   // #endif
 
   return MessageTag(tagvalue, this);
 }

◆ max() [1/3]

template<typename T >

void libMesh::Parallel::Communicator::max ( T & r ) const

Take a local variable and replace it with the maximum of it's values on all processors. Containers are replaced element-wise.

◆ max() [2/3]

template<typename T >

void libMesh::Parallel::Communicator::max ( T & libmesh_mpi_varr ) const

inline

Definition at line 2280 of file parallel_implementation.h.

References size().

 {
   if (this->size() > 1)
     {
       LOG_SCOPE("max(scalar)", "Parallel");
 
       libmesh_call_mpi
         (MPI_Allreduce (MPI_IN_PLACE, &r, 1,
                         StandardType<T>(&r),
                         OpFunction<T>::max(),
                         this->get()));
     }
 }

◆ max() [3/3]

template<typename A >

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

inline

Definition at line 2332 of file parallel_implementation.h.

References size(), and verify().

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

◆ maxloc() [1/3]

template<typename T >

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

inline

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 2354 of file parallel_implementation.h.

References libMesh::libmesh_ignore(), libMesh::Parallel::DataPlusInt< T >::rank, rank(), size(), and libMesh::Parallel::DataPlusInt< T >::val.

 {
   if (this->size() > 1)
     {
       LOG_SCOPE("maxloc(scalar)", "Parallel");
 
       DataPlusInt<T> data_in;
       libmesh_ignore(data_in); // unused ifndef LIBMESH_HAVE_MPI
       data_in.val = r;
       data_in.rank = this->rank();
       libmesh_call_mpi
         (MPI_Allreduce (MPI_IN_PLACE, &data_in, 1,
                         dataplusint_type<T>(),
                         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 libMesh::Parallel::Communicator::maxloc	(	std::vector< T, A1 > &	r,
		std::vector< unsigned int, A2 > &	max_id
	)		const

inline

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 2404 of file parallel_implementation.h.

References libMesh::Parallel::DataPlusInt< T >::rank, rank(), size(), libMesh::Parallel::DataPlusInt< T >::val, and verify().

 {
   if (this->size() > 1 && !r.empty())
     {
       LOG_SCOPE("maxloc(vector)", "Parallel");
 
       libmesh_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());
       libmesh_call_mpi
         (MPI_Allreduce (data_in.data(), data_out.data(),
                         cast_int<int>(r.size()),
                         dataplusint_type<T>(),
                         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 libMesh::Parallel::Communicator::maxloc	(	std::vector< bool, A1 > &	r,
		std::vector< unsigned int, A2 > &	max_id
	)		const

inline

Definition at line 2441 of file parallel_implementation.h.

References libMesh::Parallel::DataPlusInt< T >::rank, rank(), size(), libMesh::Parallel::DataPlusInt< T >::val, and verify().

 {
   if (this->size() > 1 && !r.empty())
     {
       LOG_SCOPE("maxloc(vector<bool>)", "Parallel");
 
       libmesh_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());
       libmesh_call_mpi
         (MPI_Allreduce (data_in.data(), data_out.data(),
                         cast_int<int>(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 libMesh::Parallel::Communicator::min ( T & r ) const

Take a local variable and replace it with the minimum of it's values on all processors. Containers are replaced element-wise.

Referenced by libMesh::MeshTools::create_bounding_box(), libMesh::MeshTools::create_nodal_bounding_box(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::MeshTools::create_subdomain_bounding_box(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::LocationMap< T >::init(), libMesh::MeshTools::libmesh_assert_consistent_distributed(), libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Elem >(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_object_ids(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), semiverify(), and verify().

◆ min() [2/3]

template<typename T >

void libMesh::Parallel::Communicator::min ( T & libmesh_mpi_varr ) const

inline

Definition at line 2087 of file parallel_implementation.h.

References size().

 {
   if (this->size() > 1)
     {
       LOG_SCOPE("min(scalar)", "Parallel");
 
       libmesh_call_mpi
         (MPI_Allreduce (MPI_IN_PLACE, &r, 1,
                         StandardType<T>(&r), OpFunction<T>::min(),
                         this->get()));
     }
 }

◆ min() [3/3]

template<typename A >

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

inline

Definition at line 2139 of file parallel_implementation.h.

References size(), and verify().

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

◆ minloc() [1/3]

template<typename T >

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

inline

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 2161 of file parallel_implementation.h.

References libMesh::libmesh_ignore(), libMesh::Parallel::DataPlusInt< T >::rank, rank(), size(), and libMesh::Parallel::DataPlusInt< T >::val.

 {
   if (this->size() > 1)
     {
       LOG_SCOPE("minloc(scalar)", "Parallel");
 
       DataPlusInt<T> data_in;
       libmesh_ignore(data_in); // unused ifndef LIBMESH_HAVE_MPI
       data_in.val = r;
       data_in.rank = this->rank();
       libmesh_call_mpi
         (MPI_Allreduce (MPI_IN_PLACE, &data_in, 1, dataplusint_type<T>(),
                         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 libMesh::Parallel::Communicator::minloc	(	std::vector< T, A1 > &	r,
		std::vector< unsigned int, A2 > &	min_id
	)		const

inline

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 2208 of file parallel_implementation.h.

References libMesh::Parallel::DataPlusInt< T >::rank, rank(), size(), libMesh::Parallel::DataPlusInt< T >::val, and verify().

 {
   if (this->size() > 1 && !r.empty())
     {
       LOG_SCOPE("minloc(vector)", "Parallel");
 
       libmesh_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());
       libmesh_call_mpi
         (MPI_Allreduce (data_in.data(), data_out.data(),
                         cast_int<int>(r.size()),
                         dataplusint_type<T>(),
                         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 libMesh::Parallel::Communicator::minloc	(	std::vector< bool, A1 > &	r,
		std::vector< unsigned int, A2 > &	min_id
	)		const

inline

Definition at line 2244 of file parallel_implementation.h.

References libMesh::Parallel::DataPlusInt< T >::rank, rank(), size(), libMesh::Parallel::DataPlusInt< T >::val, and verify().

 {
   if (this->size() > 1 && !r.empty())
     {
       LOG_SCOPE("minloc(vector<bool>)", "Parallel");
 
       libmesh_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());
       libmesh_call_mpi
         (MPI_Allreduce (data_in.data(), data_out.data(),
                         cast_int<int>(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_receive_packed_range() [1/2]

template<typename Context , typename OutputIter , typename T >

void libMesh::Parallel::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

inline

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 1117 of file parallel_implementation.h.

References libMesh::Parallel::Request::add_post_wait_work(), libMesh::out, receive(), and libMesh::Parallel::Status::size().

 {
   libmesh_experimental();
 
   typedef typename Parallel::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 Parallel::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 Parallel::PostWaitDeleteBuffer<std::vector<buffer_t>>(buffer));
 }

◆ nonblocking_receive_packed_range() [2/2]

template<typename Context , typename OutputIter , typename T >

void libMesh::Parallel::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 Parallel::Packing< T >::buffer_type >> &	buffer,
		const MessageTag &	tag = `any_tag`
	)		const

inline

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 1715 of file parallel_implementation.h.

References libMesh::Parallel::Request::add_post_wait_work(), libMesh::out, receive(), and libMesh::Parallel::Status::size().

 {
   libmesh_experimental();
 
   // If they didn't pass in a buffer - let's make one
   if (buffer == nullptr)
     buffer = std::make_shared<std::vector<typename Parallel::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 Parallel::PostWaitUnpackBuffer<std::vector<typename Parallel::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 Parallel::PostWaitDereferenceSharedPtr<std::vector<typename Parallel::Packing<T>::buffer_type>>(buffer));
 }

◆ nonblocking_send_packed_range() [1/2]

template<typename Context , typename Iter >

void libMesh::Parallel::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

inline

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 686 of file parallel_implementation.h.

References libMesh::Parallel::Request::add_post_wait_work(), std::max(), libMesh::Parallel::pack_range(), and send().

 {
   libmesh_experimental();
 
   // 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 Parallel::Packing<T>::buffer_type buffer_t;
 
   if (range_begin != range_end)
     {
       std::vector<buffer_t> * buffer = new std::vector<buffer_t>();
 
       range_begin =
         Parallel::pack_range(context,
                              range_begin,
                              range_end,
                              *buffer,
                              // MPI-2 can only use integers for size
                              std::numeric_limits<int>::max());
 
       if (range_begin != range_end)
         libmesh_error_msg("Non-blocking packed range sends cannot exceed " << std::numeric_limits<int>::max() << "in size");
 
       // Make the Request::wait() handle deleting the buffer
       req.add_post_wait_work
         (new Parallel::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/2]

template<typename Context , typename Iter >

void libMesh::Parallel::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 Parallel::Packing< typename std::iterator_traits< Iter >::value_type >::buffer_type >> &	buffer,
		const MessageTag &	tag = `no_tag`
	)		const

inline

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 1329 of file parallel_implementation.h.

References libMesh::Parallel::Request::add_post_wait_work(), std::max(), libMesh::Parallel::pack_range(), and send().

 {
   libmesh_experimental();
 
   // 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 Parallel::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 =
         Parallel::pack_range(context,
                              range_begin,
                              range_end,
                              *buffer,
                              // MPI-2 can only use integers for size
                              std::numeric_limits<int>::max());
 
       if (range_begin != range_end)
         libmesh_error_msg("Non-blocking packed range sends cannot exceed " << std::numeric_limits<int>::max() << "in size");
 
       // Make it dereference the shared pointer (possibly freeing the buffer)
       req.add_post_wait_work
         (new Parallel::PostWaitDereferenceSharedPtr<std::vector<buffer_t>>(buffer));
 
       // Non-blocking send of the buffer
       this->send(dest_processor_id, *buffer, req, tag);
     }
 }

◆ operator=() [1/3]

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

delete

◆ operator=() [2/3]

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

default

◆ operator=() [3/3]

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

Definition at line 147 of file communicator.C.

References assign(), and clear().

 {
   this->clear();
   this->assign(comm);
   return *this;
 }

◆ packed_range_probe()

template<typename T >

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

inline

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 Parallel::any_source
tag	The message tag or Parallel::any_tag
flag	Output. True if a message exists. False otherwise.

Definition at line 188 of file parallel_implementation.h.

References libMesh::Parallel::Status::get(), and libMesh::Parallel::MessageTag::value().

 {
   LOG_SCOPE("packed_range_probe()", "Parallel");
 
   libmesh_experimental();
 
   Status stat((StandardType<typename Packing<T>::buffer_type>()));
 
   int int_flag;
 
   libmesh_call_mpi(MPI_Iprobe(src_processor_id,
                               tag.value(),
                               this->get(),
                               &int_flag,
                               stat.get()));
 
   flag = int_flag;
 
   return stat;
 }

◆ probe()

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

inline

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

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

Definition at line 174 of file parallel_implementation.h.

References libMesh::Parallel::MessageTag::value().

Referenced by libMesh::Parallel::pull_parallel_vector_data(), libMesh::Parallel::push_parallel_vector_data(), and receive().

 {
   LOG_SCOPE("probe()", "Parallel");
 
   status stat;
 
   libmesh_call_mpi
     (MPI_Probe (src_processor_id, tag.value(), this->get(), &stat));
 
   return stat;
 }

◆ rank()

processor_id_type libMesh::Parallel::Communicator::rank ( ) const

inline

Definition at line 173 of file communicator.h.

References _rank.

Referenced by broadcast(), broadcast_packed_range(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::ExodusII_IO::copy_elemental_solution(), gather(), maxloc(), minloc(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::ParallelObject::processor_id(), libMesh::Parallel::pull_parallel_vector_data(), libMesh::Parallel::push_parallel_vector_data(), scatter(), send_receive(), libMesh::split_mesh(), libMesh::Parallel::sync_dofobject_data_by_id(), and libMesh::Parallel::sync_dofobject_data_by_xyz().

173 { return _rank; }

libMesh::Parallel::Communicator::_rank

processor_id_type _rank

Definition: communicator.h:191

◆ receive() [1/6]

template<typename T >

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

inline

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

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

Definition at line 771 of file parallel_implementation.h.

References libMesh::Parallel::Status::get(), probe(), and libMesh::Parallel::MessageTag::value().

Referenced by libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::SystemSubsetBySubdomain::init(), libMesh::MeshRefinement::make_coarsening_compatible(), nonblocking_receive_packed_range(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::Parallel::pull_parallel_vector_data(), libMesh::Parallel::push_parallel_vector_data(), libMesh::Nemesis_IO::read(), libMesh::System::read_SCALAR_dofs(), libMesh::System::read_serialized_blocked_dof_objects(), receive(), receive_packed_range(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

 {
   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));
 
   libmesh_call_mpi
     (MPI_Recv (&buf, 1, StandardType<T>(&buf), src_processor_id,
                tag.value(), this->get(), stat.get()));
 
   return stat;
 }

◆ receive() [2/6]

template<typename T >

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

inline

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

Definition at line 791 of file parallel_implementation.h.

References libMesh::Parallel::Request::add_post_wait_work(), libMesh::Parallel::Request::get(), and libMesh::Parallel::MessageTag::value().

 {
   LOG_SCOPE("receive()", "Parallel");
 
   libmesh_call_mpi
     (MPI_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 Parallel::PostWaitDereferenceTag(tag));
 }

◆ receive() [3/6]

template<typename T >

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

inline

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 1823 of file parallel_implementation.h.

1827 { libmesh_not_implemented(); return Status(); }

◆ receive() [4/6]

template<typename T >

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

inline

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 1830 of file parallel_implementation.h.

1835 { libmesh_not_implemented(); }

◆ receive() [5/6]

template<typename T >

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

inline

Definition at line 727 of file parallel_implementation.h.

References 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 libMesh::Parallel::Communicator::receive	(	const unsigned int	src_processor_id,
		std::basic_string< T > &	buf,
		Request &	req,
		const MessageTag &	tag
	)		const

inline

Definition at line 742 of file parallel_implementation.h.

References libMesh::Parallel::Request::add_post_wait_work(), and 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>();
 
   // 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 Parallel::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 Parallel::PostWaitDeleteBuffer<std::vector<T>>(tempbuf));
 
   this->receive(src_processor_id, tempbuf, req, tag);
 }

◆ receive_packed_range()

template<typename Context , typename OutputIter , typename T >

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

inline

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 libMesh::null_output_iterator allows the receive to be dealt with solely by Parallel::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 Parallel::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 Parallel::packed_size(const T *, vector<int>::const_iterator) is used to advance to the beginning of the next object's data.

Definition at line 1060 of file parallel_implementation.h.

References receive(), libMesh::Parallel::Status::source(), libMesh::Parallel::Status::tag(), and libMesh::Parallel::unpack_range().

Referenced by send_receive_packed_range().

 {
   typedef typename Parallel::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;
   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();
       Parallel::unpack_range
         (buffer, context, out_iter, output_type);
     }
 }

◆ reference_unique_tag()

void libMesh::Parallel::Communicator::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.

Definition at line 35 of file communicator.C.

References used_tag_values.

Referenced by libMesh::Parallel::MessageTag::MessageTag(), and libMesh::Parallel::MessageTag::operator=().

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

◆ scatter() [1/4]

template<typename T , typename A >

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

inline

Take a vector of local variables and scatter the ith item to the ith processor in the communicator. The result is saved into recv.

Definition at line 2921 of file parallel_implementation.h.

References data, libMesh::libmesh_ignore(), rank(), and size().

Referenced by scatter().

 {
   libmesh_ignore(root_id); // Only needed for MPI and/or dbg/devel
   libmesh_assert_less (root_id, this->size());
 
   // Do not allow the root_id to scatter a nullptr vector.
   // That would leave recv in an indeterminate state.
   libmesh_assert (this->rank() != root_id || this->size() == data.size());
 
   if (this->size() == 1)
     {
       libmesh_assert (!this->rank());
       libmesh_assert (!root_id);
       recv = data[0];
       return;
     }
 
   LOG_SCOPE("scatter()", "Parallel");
 
   T * data_ptr = const_cast<T*>(data.empty() ? nullptr : data.data());
   libmesh_ignore(data_ptr); // unused ifndef LIBMESH_HAVE_MPI
 
   libmesh_call_mpi
     (MPI_Scatter (data_ptr, 1, StandardType<T>(data_ptr),
                   &recv, 1, StandardType<T>(&recv), root_id, this->get()));
 }

◆ scatter() [2/4]

template<typename T , typename A >

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

inline

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.

Definition at line 2953 of file parallel_implementation.h.

References broadcast(), data, libMesh::libmesh_ignore(), rank(), and size().

 {
   libmesh_assert_less (root_id, this->size());
 
   if (this->size() == 1)
     {
       libmesh_assert (!this->rank());
       libmesh_assert (!root_id);
       recv.assign(data.begin(), data.end());
       return;
     }
 
   LOG_SCOPE("scatter()", "Parallel");
 
   int recv_buffer_size = 0;
   if (this->rank() == root_id)
     {
       libmesh_assert(data.size() % this->size() == 0);
       recv_buffer_size = cast_int<int>(data.size() / this->size());
     }
 
   this->broadcast(recv_buffer_size);
   recv.resize(recv_buffer_size);
 
   T * data_ptr = const_cast<T*>(data.empty() ? nullptr : data.data());
   T * recv_ptr = recv.empty() ? nullptr : recv.data();
   libmesh_ignore(data_ptr, recv_ptr); // unused ifndef LIBMESH_HAVE_MPI
 
   libmesh_call_mpi
     (MPI_Scatter (data_ptr, recv_buffer_size, StandardType<T>(data_ptr),
                   recv_ptr, recv_buffer_size, StandardType<T>(recv_ptr), root_id, this->get()));
 }

◆ scatter() [3/4]

template<typename T , typename A1 , typename A2 >

void libMesh::Parallel::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

inline

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.

Definition at line 2991 of file parallel_implementation.h.

References data, libMesh::libmesh_ignore(), rank(), scatter(), and size().

 {
   libmesh_assert_less (root_id, this->size());
 
   if (this->size() == 1)
     {
       libmesh_assert (!this->rank());
       libmesh_assert (!root_id);
       libmesh_assert (counts.size() == this->size());
       recv.assign(data.begin(), data.begin() + counts[0]);
       return;
     }
 
   std::vector<int,A2> displacements(this->size(), 0);
   if (root_id == this->rank())
     {
       libmesh_assert(counts.size() == this->size());
 
       // Create a displacements vector from the incoming counts vector
       unsigned int globalsize = 0;
       for (unsigned int i=0; i < this->size(); ++i)
         {
           displacements[i] = globalsize;
           globalsize += counts[i];
         }
 
       libmesh_assert(data.size() == globalsize);
     }
 
   LOG_SCOPE("scatter()", "Parallel");
 
   // Scatter the buffer sizes to size remote buffers
   int recv_buffer_size = 0;
   this->scatter(counts, recv_buffer_size, root_id);
   recv.resize(recv_buffer_size);
 
   T * data_ptr = const_cast<T*>(data.empty() ? nullptr : data.data());
   int * count_ptr = const_cast<int*>(counts.empty() ? nullptr : counts.data());
   T * recv_ptr = recv.empty() ? nullptr : recv.data();
   libmesh_ignore(data_ptr, count_ptr, recv_ptr); // unused ifndef LIBMESH_HAVE_MPI
 
   // Scatter the non-uniform chunks
   libmesh_call_mpi
     (MPI_Scatterv (data_ptr, count_ptr, displacements.data(), StandardType<T>(data_ptr),
                    recv_ptr, recv_buffer_size, StandardType<T>(recv_ptr), root_id, this->get()));
 }

◆ scatter() [4/4]

template<typename T , typename A1 , typename A2 >

void libMesh::Parallel::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

inline

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.

Definition at line 3044 of file parallel_implementation.h.

References data, end, rank(), scatter(), and size().

 {
   libmesh_assert_less (root_id, this->size());
 
   if (this->size() == 1)
     {
       libmesh_assert (!this->rank());
       libmesh_assert (!root_id);
       libmesh_assert (data.size() == this->size());
       recv.assign(data[0].begin(), data[0].end());
       return;
     }
 
   std::vector<T,A1> stacked_data;
   std::vector<int> counts;
 
   if (root_id == this->rank())
     {
       libmesh_assert (data.size() == this->size());
 
       if (!identical_buffer_sizes)
         counts.resize(this->size());
 
       for (std::size_t i=0; i < data.size(); ++i)
         {
           if (!identical_buffer_sizes)
             counts[i] = cast_int<int>(data[i].size());
 #ifndef NDEBUG
           else
             // Check that buffer sizes are indeed equal
             libmesh_assert(!i || data[i-1].size() == data[i].size());
 #endif
           std::copy(data[i].begin(), data[i].end(), std::back_inserter(stacked_data));
         }
     }
 
   if (identical_buffer_sizes)
     this->scatter(stacked_data, recv, root_id);
   else
     this->scatter(stacked_data, counts, recv, root_id);
 }

◆ semiverify()

template<typename T >

bool libMesh::Parallel::Communicator::semiverify ( const T * r ) const

inline

Verify that a local pointer points to the same value on all processors where it is not nullptr. Containers must have the same value in every entry.

Definition at line 1948 of file parallel_implementation.h.

References max(), min(), libMesh::Parallel::Attributes< T >::set_highest(), libMesh::Parallel::Attributes< T >::set_lowest(), and size().

Referenced by libMesh::MeshTools::libmesh_assert_consistent_distributed_nodes(), libMesh::MeshTools::libmesh_assert_parallel_consistent_new_node_procids(), libMesh::MeshTools::libmesh_assert_parallel_consistent_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::MeshTools::libmesh_assert_valid_neighbors(), and libMesh::MeshTools::libmesh_assert_valid_unique_ids().

 {
   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/6]

template<typename T >

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

inline

Definition at line 213 of file parallel_implementation.h.

References send_mode(), SYNCHRONOUS, and libMesh::Parallel::MessageTag::value().

 {
   LOG_SCOPE("send()", "Parallel");
 
   T * dataptr = buf.empty() ? nullptr : const_cast<T *>(buf.data());
 
   libmesh_call_mpi
     (((this->send_mode() == SYNCHRONOUS) ?
       MPI_Ssend : MPI_Send) (dataptr,
                              cast_int<int>(buf.size()),
                              StandardType<T>(dataptr),
                              dest_processor_id,
                              tag.value(),
                              this->get()));
 }

◆ send() [2/6]

template<typename T >

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

inline

Definition at line 234 of file parallel_implementation.h.

References libMesh::Parallel::Request::add_post_wait_work(), libMesh::Parallel::Request::get(), send_mode(), SYNCHRONOUS, and libMesh::Parallel::MessageTag::value().

 {
   LOG_SCOPE("send()", "Parallel");
 
   T * dataptr = buf.empty() ? nullptr : const_cast<T *>(buf.data());
 
   libmesh_call_mpi
     (((this->send_mode() == SYNCHRONOUS) ?
       MPI_Issend : MPI_Isend) (dataptr,
                                cast_int<int>(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 Parallel::PostWaitDereferenceTag(tag));
 }

◆ send() [3/6]

template<typename T >

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

inline

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

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

Definition at line 261 of file parallel_implementation.h.

References send_mode(), SYNCHRONOUS, and libMesh::Parallel::MessageTag::value().

Referenced by libMesh::BoundaryInfo::build_node_list_from_side_list(), libMesh::SystemSubsetBySubdomain::init(), libMesh::MeshRefinement::make_coarsening_compatible(), nonblocking_send_packed_range(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::Parallel::pull_parallel_vector_data(), libMesh::Parallel::push_parallel_vector_data(), libMesh::Nemesis_IO::read(), libMesh::System::read_SCALAR_dofs(), libMesh::System::read_serialized_blocked_dof_objects(), send_packed_range(), libMesh::MeshRefinement::uniformly_coarsen(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

 {
   LOG_SCOPE("send()", "Parallel");
 
   T * dataptr = const_cast<T*> (&buf);
 
   libmesh_call_mpi
     (((this->send_mode() == SYNCHRONOUS) ?
       MPI_Ssend : MPI_Send) (dataptr,
                              1,
                              StandardType<T>(dataptr),
                              dest_processor_id,
                              tag.value(),
                              this->get()));
 }

◆ send() [4/6]

template<typename T >

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

inline

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

Definition at line 282 of file parallel_implementation.h.

References libMesh::Parallel::Request::add_post_wait_work(), libMesh::Parallel::Request::get(), send_mode(), SYNCHRONOUS, and libMesh::Parallel::MessageTag::value().

 {
   LOG_SCOPE("send()", "Parallel");
 
   T * dataptr = const_cast<T*>(&buf);
 
   libmesh_call_mpi
     (((this->send_mode() == SYNCHRONOUS) ?
       MPI_Issend : MPI_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 Parallel::PostWaitDereferenceTag(tag));
 }

◆ send() [5/6]

template<typename T >

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

inline

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 1775 of file parallel_implementation.h.

1779 { libmesh_not_implemented(); }

◆ send() [6/6]

template<typename T >

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

inline

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 1782 of file parallel_implementation.h.

1787 { libmesh_not_implemented(); }

◆ send_mode() [1/2]

void libMesh::Parallel::Communicator::send_mode ( const SendMode sm )

inline

Explicitly sets the SendMode type used for send operations.

Definition at line 205 of file communicator.h.

References _send_mode.

Referenced by duplicate(), and split().

205 { _send_mode = sm; }

libMesh::Parallel::Communicator::_send_mode

SendMode _send_mode

Definition: communicator.h:192

◆ send_mode() [2/2]

SendMode libMesh::Parallel::Communicator::send_mode ( ) const

inline

Gets the user-requested SendMode.

Definition at line 210 of file communicator.h.

References _send_mode.

Referenced by duplicate(), send(), and split().

210 { return _send_mode; }

libMesh::Parallel::Communicator::_send_mode

SendMode _send_mode

Definition: communicator.h:192

◆ send_packed_range() [1/2]

template<typename Context , typename Iter >

void libMesh::Parallel::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`
	)		const

inline

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 Parallel::pack(const T *, vector<int> & data, const Context *) is used to serialize type T onto the end of a data vector.

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

Definition at line 562 of file parallel_implementation.h.

References libMesh::Parallel::pack_range(), libMesh::Parallel::packed_range_size(), and send().

Referenced by 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 =
     Parallel::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)
     {
       libmesh_assert_greater (std::distance(range_begin, range_end), 0);
 
       std::vector<typename Parallel::Packing<T>::buffer_type> buffer;
 
       const Iter next_range_begin = Parallel::pack_range
         (context, range_begin, range_end, buffer);
 
       libmesh_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
   libmesh_assert_equal_to(used_buffer_size, total_buffer_size);
 #endif
 }

◆ send_packed_range() [2/2]

template<typename Context , typename Iter >

void libMesh::Parallel::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`
	)		const

inline

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 Parallel::pack(const T *, vector<int> & data, const Context *) is used to serialize type T onto the end of a data vector.

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

Definition at line 609 of file parallel_implementation.h.

References libMesh::Parallel::Request::add_post_wait_work(), libMesh::Parallel::Request::add_prior_request(), libMesh::Parallel::pack_range(), libMesh::Parallel::packed_range_size(), and 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 Parallel::Packing<T>::buffer_type buffer_t;
 
   std::size_t total_buffer_size =
     Parallel::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 Parallel::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)
     {
       libmesh_assert_greater (std::distance(range_begin, range_end), 0);
 
       std::vector<buffer_t> * buffer = new std::vector<buffer_t>();
 
       const Iter next_range_begin =
         Parallel::pack_range(context, range_begin, range_end,
                              *buffer);
 
       libmesh_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 Parallel::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);
     }
 }

◆ send_receive() [1/3]

template<typename T1 , typename T2 >

void libMesh::Parallel::Communicator::send_receive	(	const unsigned int	send_tgt,
		const T1 &	send_val,
		const unsigned int	recv_source,
		T2 &	recv_val,
		const MessageTag &	send_tag = `no_tag`,
		const MessageTag &	recv_tag = `any_tag`
	)		const

inline

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

Send-receive data from one processor.

Definition at line 1178 of file parallel_implementation.h.

References rank(), and libMesh::Parallel::MessageTag::value().

Referenced by send_receive().

 {
   LOG_SCOPE("send_receive()", "Parallel");
 
   if (dest_processor_id   == this->rank() &&
       source_processor_id == this->rank())
     {
       recv = sendvec;
       return;
     }
 
   // 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
   libmesh_call_mpi
     (MPI_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() [2/3]

template<typename T1 , typename T2 >

void libMesh::Parallel::Communicator::send_receive	(	const unsigned int	dest_processor_id,
		const T1 &	send,
		const DataType &	type1,
		const unsigned int	source_processor_id,
		T2 &	recv,
		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.

◆ send_receive() [3/3]

template<typename T , typename A >

void libMesh::Parallel::Communicator::send_receive	(	const unsigned int	dest_processor_id,
		const std::vector< T, A > &	sendvec,
		const unsigned int	source_processor_id,
		std::vector< T, A > &	recv,
		const MessageTag &	send_tag,
		const MessageTag &	recv_tag
	)		const

inline

Definition at line 1214 of file parallel_implementation.h.

References rank(), and send_receive().

 {
   if (dest_processor_id   == this->rank() &&
       source_processor_id == this->rank())
     {
       LOG_SCOPE("send_receive()", "Parallel");
       recv = sendvec;
       return;
     }
 
   const T* example = sendvec.empty() ?
     (recv.empty() ? nullptr : recv.data()) : sendvec.data();
 
   // Call the user-defined type version with automatic
   // type conversion based on template argument:
   this->send_receive (dest_processor_id, sendvec,
                       StandardType<T>(example),
                       source_processor_id, recv,
                       StandardType<T>(example),
                       send_tag, recv_tag);
 }

◆ send_receive_packed_range() [1/2]

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

void libMesh::Parallel::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`
	)		const

inline

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 Parallel::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 libMesh::null_output_iterator allows the receive to be dealt with solely by Parallel::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 Parallel::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 Parallel::packable_size(const T1*, const Context1*) is used to allow data vectors to reserve memory, and for additional error checking.

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

Definition at line 1302 of file parallel_implementation.h.

References receive_packed_range(), send_packed_range(), and libMesh::Parallel::Request::wait().

 {
   LOG_SCOPE("send_receive()", "Parallel");
 
   Parallel::Request req;
 
   this->send_packed_range (dest_processor_id, context1, send_begin, send_end,
                            req, send_tag);
 
   this->receive_packed_range (source_processor_id, context2, out_iter,
                               output_type, recv_tag);
 
   req.wait();
 }

◆ send_receive_packed_range() [2/2]

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

void libMesh::Parallel::Communicator::send_receive_packed_range	(	const unsigned int	libmesh_dbg_vardest_processor_id,
		const Context1 *	context1,
		RangeIter	send_begin,
		const RangeIter	send_end,
		const unsigned int	libmesh_dbg_varsource_processor_id,
		Context2 *	context2,
		OutputIter	out_iter,
		const T *	output_type,
		const MessageTag &	,
		const MessageTag &
	)		const

inline

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 1876 of file parallel_implementation.h.

References libMesh::Parallel::pack_range(), and libMesh::Parallel::unpack_range().

 {
   // This makes no sense on one processor unless we're deliberately
   // sending to ourself.
   libmesh_assert_equal_to(dest_processor_id, 0);
   libmesh_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 Parallel::Packing<T1>::buffer_type buffer_t;
 
   while (send_begin != send_end)
     {
       libmesh_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 = Parallel::pack_range
         (context1, send_begin, send_end, buffer);
 
       libmesh_assert_greater (std::distance(send_begin, next_send_begin), 0);
 
       send_begin = next_send_begin;
 
       Parallel::unpack_range
         (buffer, context2, out_iter, output_type);
     }
 }

◆ set_union() [1/2]

template<typename T >

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

Take a container of local variables on each processor, and collect their union over all processors, replacing the set on processor 0.

Referenced by libMesh::BoundaryInfo::_find_id_maps(), libMesh::MeshBase::cache_elem_dims(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), DMlibMeshSetSystem_libMesh(), libMesh::MeshBase::subdomain_ids(), and libMesh::BoundaryInfo::sync().

◆ set_union() [2/2]

template<typename T >

void libMesh::Parallel::Communicator::set_union ( T & data ) const

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

◆ size()

processor_id_type libMesh::Parallel::Communicator::size ( ) const

inline

Definition at line 175 of file communicator.h.

References _size.

Referenced by allgather(), alltoall(), barrier(), broadcast(), libMesh::EquationSystems::build_parallel_solution_vector(), gather(), libMesh::OptimizationSystem::initialize_equality_constraints_storage(), libMesh::OptimizationSystem::initialize_inequality_constraints_storage(), max(), maxloc(), min(), minloc(), libMesh::ParallelObject::n_processors(), libMesh::SparsityPattern::Build::parallel_sync(), libMesh::Parallel::pull_parallel_vector_data(), libMesh::Parallel::push_parallel_vector_data(), scatter(), semiverify(), libMesh::split_mesh(), sum(), libMesh::Parallel::sync_dofobject_data_by_id(), libMesh::Parallel::sync_dofobject_data_by_xyz(), and verify().

175 { return _size; }

libMesh::Parallel::Communicator::_size

processor_id_type _size

Definition: communicator.h:191

◆ split()

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

Definition at line 89 of file communicator.C.

References _I_duped_it, assign(), clear(), and send_mode().

 {
   target.clear();
   MPI_Comm newcomm;
   libmesh_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());
 }

◆ sum() [1/3]

template<typename T >

void libMesh::Parallel::Communicator::sum ( T & r ) const

Take a local variable and replace it with the sum of it's values on all processors. Containers are replaced element-wise.

Referenced by libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::System::calculate_norm(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::MeshRefinement::create_parent_error_vector(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::DofMap::get_info(), libMesh::DistributedMesh::n_active_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::CondensedEigenSystem::n_global_non_condensed_dofs(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::BoundaryInfo::n_shellface_conds(), libMesh::DistributedMesh::parallel_n_elem(), libMesh::DistributedMesh::parallel_n_nodes(), libMesh::Nemesis_IO::read(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::System::read_serialized_vector(), libMesh::ErrorEstimator::reduce_error(), libMesh::MeshTools::total_weight(), and libMesh::XdrIO::write_serialized_connectivity().

◆ sum() [2/3]

template<typename T >

void libMesh::Parallel::Communicator::sum ( T & libmesh_mpi_varr ) const

inline

Definition at line 2478 of file parallel_implementation.h.

References size().

 {
   if (this->size() > 1)
     {
       LOG_SCOPE("sum()", "Parallel");
 
       libmesh_call_mpi
         (MPI_Allreduce (MPI_IN_PLACE, &r, 1,
                         StandardType<T>(&r),
                         OpFunction<T>::sum(),
                         this->get()));
     }
 }

◆ sum() [3/3]

template<typename T >

void libMesh::Parallel::Communicator::sum ( std::complex< T > & libmesh_mpi_varr ) const

inline

Definition at line 2515 of file parallel_implementation.h.

References size().

 {
   if (this->size() > 1)
     {
       LOG_SCOPE("sum()", "Parallel");
 
       libmesh_call_mpi
         (MPI_Allreduce (MPI_IN_PLACE, &r, 2,
                         StandardType<T>(),
                         OpFunction<T>::sum(),
                         this->get()));
     }
 }

◆ verify()

template<typename T >

bool libMesh::Parallel::Communicator::verify ( const T & r ) const

inline

Verify that a local variable has the same value on all processors. Containers must have the same value in every entry.

Definition at line 1928 of file parallel_implementation.h.

References max(), min(), and size().

Referenced by allgather(), alltoall(), libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::MeshTools::create_processor_bounding_box(), libMesh::MeshTools::create_subdomain_bounding_box(), libMesh::MeshCommunication::delete_remote_elements(), max(), maxloc(), min(), and minloc().

 {
   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;
 }

Member Data Documentation

◆ _communicator

communicator libMesh::Parallel::Communicator::_communicator

private

Definition at line 190 of file communicator.h.

Referenced by assign(), clear(), duplicate(), get(), and libMesh::ParallelObject::operator=().

◆ _I_duped_it

bool libMesh::Parallel::Communicator::_I_duped_it

private

Definition at line 197 of file communicator.h.

Referenced by clear(), duplicate(), and split().

◆ _rank

processor_id_type libMesh::Parallel::Communicator::_rank

private

Definition at line 191 of file communicator.h.

Referenced by assign(), and rank().

◆ _send_mode

SendMode libMesh::Parallel::Communicator::_send_mode

private

Definition at line 192 of file communicator.h.

Referenced by assign(), and send_mode().

◆ _size

processor_id_type libMesh::Parallel::Communicator::_size

private

Definition at line 191 of file communicator.h.

Referenced by assign(), and size().

◆ used_tag_values

std::map<int, unsigned int> libMesh::Parallel::Communicator::used_tag_values

mutableprivate

Definition at line 196 of file communicator.h.

Referenced by dereference_unique_tag(), get_unique_tag(), and reference_unique_tag().

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

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ SendMode

Constructor & Destructor Documentation

◆ Communicator() [1/4]

◆ Communicator() [2/4]

◆ Communicator() [3/4]

◆ Communicator() [4/4]

◆ ~Communicator()

Member Function Documentation

◆ allgather() [1/4]

◆ allgather() [2/4]

◆ allgather() [3/4]

◆ allgather() [4/4]

◆ allgather_packed_range()

◆ alltoall()

◆ assign()

◆ barrier()

◆ 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/3]

◆ gather() [2/3]

◆ gather() [3/3]

◆ gather_packed_range()

◆ get() [1/2]

◆ get() [2/2]

◆ get_unique_tag()

◆ 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_receive_packed_range() [1/2]

◆ nonblocking_receive_packed_range() [2/2]

◆ nonblocking_send_packed_range() [1/2]

◆ nonblocking_send_packed_range() [2/2]

◆ operator=() [1/3]

◆ operator=() [2/3]

◆ operator=() [3/3]

◆ packed_range_probe()

◆ probe()

◆ rank()

◆ receive() [1/6]

◆ receive() [2/6]

◆ receive() [3/6]

◆ receive() [4/6]

◆ receive() [5/6]

◆ receive() [6/6]

◆ receive_packed_range()

◆ reference_unique_tag()

◆ scatter() [1/4]

◆ scatter() [2/4]

◆ scatter() [3/4]

◆ scatter() [4/4]

◆ semiverify()

◆ send() [1/6]

◆ send() [2/6]

◆ send() [3/6]

◆ send() [4/6]

◆ send() [5/6]

◆ send() [6/6]

◆ send_mode() [1/2]