The MPI immediate_process_group class is a process group that sends messages immediately and will block while waiting to receive messages. Its send operation maps closely to MPI_Isend and its receive operation map closely to MPI_Ireceive.
Since the immediate_process_group class is a model of the Immediate Process Group and MPI Process Group concepts, documentation of any functions that provide only the minimal required behavior will be omitted. Please refer to the concept descriptions for the semantics of these operations.
namespace boost { namespace mpi {
class immediate_process_group
{
public:
typedef int process_id_type;
typedef int process_size_type;
typedef MPI_Comm communicator_type;
struct communication_category
: virtual parallel::immediate_process_group_tag, virtual mpi_process_group_tag { };
immediate_process_group(communicator_type parent_comm = MPI_COMM_WORLD);
immediate_process_group(const immediate_process_group& other,
const receiver_type& handler);
void replace_handler(const receiver_type& handler);
immediate_process_group base() const;
};
immediate_process_group::process_id_type process_id(const immediate_process_group& pg);
immediate_process_group::process_size_type num_processes(const immediate_process_group& pg);
immediate_process_group::communicator_type communicator(const immediate_process_group& pg);
template<typename T>
void
send(const immediate_process_group& pg, immediate_process_group::process_id_type dest,
int tag, const T& value);
template<typename T>
void
send(const immediate_process_group& pg, immediate_process_group::process_id_type dest,
int tag, const T values[], std::size_t n);
template<typename T>
immediate_process_group::process_id_type
receive(const immediate_process_group& pg, int tag, T& value);
template<typename T>
immediate_process_group::process_id_type
receive(const immediate_process_group& pg,
immediate_process_group::process_id_type source, int tag, T& value);
template<typename T>
std::pair<immediate_process_group::process_id_type, std::size_t>
receive(const immediate_process_group& pg, int tag, T values[], std::size_t n);
template<typename T>
std::pair<immediate_process_group::process_id_type, std::size_t>
receive(const immediate_process_group& pg,
immediate_process_group::process_id_type source, int tag, T values[],
std::size_t n);
optional<std::pair<immediate_process_group::process_id_type, int> >
probe(const immediate_process_group& pg);
std::pair<immediate_process_group::process_id_type, int>
wait(const immediate_process_group& pg);
void synchronize(const immediate_process_group& pg);
} } // end namespace boost::mpi
<boost/mpi/immediate_process_group.hpp>
immediate_process_group(communicator_type parent_comm = MPI_COMM_WORLD);
Construct a new process group. The communicator used by the new process group will be a duplicate (created with MPI_Comm_dup``_) of the communicator ``parent_comm.
std::pair<immediate_process_group::process_id_type, int> wait(const immediate_process_group& pg);
This operation blocks until a message is available from any sender and with any tag. When a message is available, wait(pg) is equivalent to *probe(pg).
Copyright (C) 2005 The Trustees of Indiana University.
Authors: Douglas Gregor and Andrew Lumsdaine