Boost  v1.57.0
doxygen for www.boost.org
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
boost::mpi Namespace Reference

Namespaces

 detail
 
 python
 
 threading
 

Classes

struct  bitwise_and
 Compute the bitwise AND of two integral values. More...
 
struct  bitwise_or
 Compute the bitwise OR of two integral values. More...
 
struct  bitwise_xor
 Compute the bitwise exclusive OR of two integral values. More...
 
class  communicator
 A communicator that permits communication and synchronization among a set of processes. More...
 
class  content
 A proxy object that transfers the content of an object without its structure. More...
 
class  environment
 Initialize, finalize, and query the MPI environment. More...
 
class  exception
 Catch-all exception class for MPI errors. More...
 
class  graph_communicator
 An MPI communicator with a graph topology. More...
 
class  group
 A group is a representation of a subset of the processes within a communicator. More...
 
struct  inplace_t
 Wrapper type to explicitly indicate that a input data can be overriden with an output value. More...
 
struct  inplace_t< T * >
 
class  intercommunicator
 Communication facilities among processes in different groups. More...
 
struct  is_commutative
 Determine if a function object type is commutative. More...
 
struct  is_mpi_builtin_datatype
 Type trait that determines if there exists a built-in MPI data type for a given C++ type. More...
 
struct  is_mpi_byte_datatype
 Type trait that determines if there exists a built-in byte MPI data type for a given C++ type. More...
 
struct  is_mpi_complex_datatype
 Type trait that determines if there exists a built-in complex MPI data type for a given C++ type. More...
 
struct  is_mpi_datatype
 Type trait that determines if a C++ type can be mapped to an MPI data type. More...
 
struct  is_mpi_datatype< bool >
 INTERNAL ONLY. More...
 
struct  is_mpi_datatype< boost::detail::csr_edge_descriptor< Vertex, EdgeIndex > >
 
struct  is_mpi_datatype< boost::detail::edge_base< Directed, Vertex > >
 
struct  is_mpi_datatype< boost::detail::edge_desc_impl< Directed, Vertex > >
 
struct  is_mpi_datatype< boost::detail::parallel::edge_descriptor< Edge > >
 
struct  is_mpi_datatype< boost::detail::parallel::global_descriptor< LocalDescriptor > >
 
struct  is_mpi_datatype< boost::detail::parallel::msg_add_edge_data< Vertex, LocalVertex > >
 
struct  is_mpi_datatype< boost::detail::parallel::msg_add_edge_with_property_data< Vertex, LocalVertex, EdgeProperty > >
 
struct  is_mpi_datatype< boost::detail::parallel::msg_nonlocal_edge_data< EdgeProperty, EdgeDescriptor > >
 
struct  is_mpi_datatype< boost::detail::parallel::msg_remove_edge_data< EdgeDescriptor > >
 
struct  is_mpi_datatype< boost::graph::distributed::mpi_process_group::message_header >
 
struct  is_mpi_datatype< std::pair< T, U > >
 specialization of is_mpi_datatype for pairs More...
 
struct  is_mpi_datatype< void * >
 
struct  is_mpi_floating_point_datatype
 Type trait that determines if there exists a built-in floating point MPI data type for a given C++ type. More...
 
struct  is_mpi_integer_datatype
 Type trait that determines if there exists a built-in integer MPI data type for a given C++ type. More...
 
struct  is_mpi_logical_datatype
 Type trait that determines if there exists a built-in logical MPI data type for a given C++ type. More...
 
struct  is_mpi_op
 Determine if a function object has an associated MPI_Op. More...
 
struct  is_mpi_op< bitwise_and< T >, T >
 INTERNAL ONLY. More...
 
struct  is_mpi_op< bitwise_or< T >, T >
 INTERNAL ONLY. More...
 
struct  is_mpi_op< bitwise_xor< T >, T >
 INTERNAL ONLY. More...
 
struct  is_mpi_op< logical_xor< T >, T >
 INTERNAL ONLY. More...
 
struct  is_mpi_op< maximum< T >, T >
 INTERNAL ONLY. More...
 
struct  is_mpi_op< minimum< T >, T >
 INTERNAL ONLY. More...
 
struct  is_mpi_op< std::logical_and< T >, T >
 INTERNAL ONLY. More...
 
struct  is_mpi_op< std::logical_or< T >, T >
 INTERNAL ONLY. More...
 
struct  is_mpi_op< std::multiplies< T >, T >
 INTERNAL ONLY. More...
 
struct  is_mpi_op< std::plus< T >, T >
 INTERNAL ONLY. More...
 
struct  logical_xor
 Compute the logical exclusive OR of two integral values. More...
 
struct  maximum
 Compute the maximum of two values. More...
 
struct  minimum
 Compute the minimum of two values. More...
 
struct  packed
 a dummy data type giving MPI_PACKED as its MPI_Datatype More...
 
class  packed_iarchive
 An archive that unpacks binary data from an MPI buffer. More...
 
class  packed_oarchive
 An archive that packs binary data into an MPI buffer. More...
 
class  packed_skeleton_iarchive
 An archiver that reconstructs a data structure based on the binary skeleton stored in a buffer. More...
 
class  packed_skeleton_oarchive
 An archiver that records the binary skeleton of a data structure into a buffer. More...
 
class  request
 A request for a non-blocking send or receive. More...
 
struct  skeleton_proxy
 A proxy that requests that the skeleton of an object be transmitted. More...
 
class  status
 Contains information about a message that has been or can be received. More...
 
class  timer
 A simple timer that provides access to the MPI timing facilities. More...
 

Typedefs

typedef packed_iprimitive iprimitive
 
typedef packed_oprimitive oprimitive
 

Enumerations

enum  comm_create_kind {
  comm_duplicate,
  comm_take_ownership,
  comm_attach
}
 Enumeration used to describe how to adopt a C MPI_Comm into a Boost.MPI communicator. More...
 

Functions

template<typename T >
void all_gather (const communicator &comm, const T &in_value, T *out_values)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename T >
void all_gather (const communicator &comm, const T &in_value, std::vector< T > &out_values)
 Gather the values stored at every process into vectors of values from each process. More...
 
template<typename T >
void all_gather (const communicator &comm, const T *in_values, int n, T *out_values)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename T >
void all_gather (const communicator &comm, const T *in_values, int n, std::vector< T > &out_values)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename T , typename Op >
void all_reduce (const communicator &comm, const T *value, int n, T *out_value, Op op)
 Combine the values stored by each process into a single value available to all processes. More...
 
template<typename T , typename Op >
void all_reduce (const communicator &comm, inplace_t< T * > value, int n, Op op)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename T , typename Op >
void all_reduce (const communicator &comm, inplace_t< T > value, Op op)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename T , typename Op >
void all_reduce (const communicator &comm, const T &value, T &out_value, Op op)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename T , typename Op >
T all_reduce (const communicator &comm, const T &value, Op op)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename T >
void all_to_all (const communicator &comm, const T *in_values, T *out_values)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename T >
void all_to_all (const communicator &comm, const std::vector< T > &in_values, std::vector< T > &out_values)
 Send data from every process to every other process. More...
 
template<typename T >
void all_to_all (const communicator &comm, const T *in_values, int n, T *out_values)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename T >
void all_to_all (const communicator &comm, const std::vector< T > &in_values, int n, std::vector< T > &out_values)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<>
BOOST_MPI_DECL void broadcast< const packed_oarchive > (const communicator &comm, const packed_oarchive &oa, int root)
 INTERNAL ONLY. More...
 
template<>
BOOST_MPI_DECL void broadcast< packed_oarchive > (const communicator &comm, packed_oarchive &oa, int root)
 INTERNAL ONLY. More...
 
template<>
BOOST_MPI_DECL void broadcast< packed_iarchive > (const communicator &comm, packed_iarchive &ia, int root)
 INTERNAL ONLY. More...
 
template<>
BOOST_MPI_DECL void broadcast< const packed_skeleton_oarchive > (const communicator &comm, const packed_skeleton_oarchive &oa, int root)
 INTERNAL ONLY. More...
 
template<>
void broadcast< packed_skeleton_oarchive > (const communicator &comm, packed_skeleton_oarchive &oa, int root)
 INTERNAL ONLY. More...
 
template<>
void broadcast< packed_skeleton_iarchive > (const communicator &comm, packed_skeleton_iarchive &ia, int root)
 INTERNAL ONLY. More...
 
template<>
void broadcast< content > (const communicator &comm, content &c, int root)
 INTERNAL ONLY. More...
 
template<>
void broadcast< const content > (const communicator &comm, const content &c, int root)
 INTERNAL ONLY. More...
 
template<typename T >
void broadcast (const communicator &comm, T &value, int root)
 Broadcast a value from a root process to all other processes. More...
 
template<typename T >
void broadcast (const communicator &comm, T *values, int n, int root)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename T >
void gather (const communicator &comm, const T &in_value, T *out_values, int root)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename T >
void gather (const communicator &comm, const T &in_value, int root)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename T >
void gather (const communicator &comm, const T &in_value, std::vector< T > &out_values, int root)
 Gather the values stored at every process into a vector at the root process. More...
 
template<typename T >
void gather (const communicator &comm, const T *in_values, int n, T *out_values, int root)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename T >
void gather (const communicator &comm, const T *in_values, int n, std::vector< T > &out_values, int root)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename T >
void gather (const communicator &comm, const T *in_values, int n, int root)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename T , typename Op >
void reduce (const communicator &comm, const T *in_values, int n, T *out_values, Op op, int root)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename T , typename Op >
void reduce (const communicator &comm, const T *in_values, int n, Op op, int root)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename T , typename Op >
void reduce (const communicator &comm, std::vector< T > const &in_values, Op op, int root)
 
template<typename T , typename Op >
void reduce (const communicator &comm, std::vector< T > const &in_values, std::vector< T > &out_values, Op op, int root)
 
template<typename T , typename Op >
void reduce (const communicator &comm, const T &in_value, T &out_value, Op op, int root)
 Combine the values stored by each process into a single value at the root. More...
 
template<typename T , typename Op >
void reduce (const communicator &comm, const T &in_value, Op op, int root)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename T , typename Op >
void scan (const communicator &comm, const T &in_value, T &out_value, Op op)
 Compute a prefix reduction of values from all processes in the communicator. More...
 
template<typename T , typename Op >
void scan (const communicator &comm, const T *in_values, int n, T *out_values, Op op)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename T , typename Op >
T scan (const communicator &comm, const T &in_value, Op op)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename T >
void scatter (const communicator &comm, const T *in_values, T &out_value, int root)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename T >
void scatter (const communicator &comm, const std::vector< T > &in_values, T &out_value, int root)
 Scatter the values stored at the root to all processes within the communicator. More...
 
template<typename T >
void scatter (const communicator &comm, T &out_value, int root)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename T >
void scatter (const communicator &comm, const T *in_values, T *out_values, int n, int root)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename T >
void scatter (const communicator &comm, const std::vector< T > &in_values, T *out_values, int n, int root)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename T >
void scatter (const communicator &comm, T *out_values, int n, int root)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename T >
void broadcast (const communicator &comm, skeleton_proxy< T > &value, int root)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename T >
void broadcast (const communicator &comm, const skeleton_proxy< T > &value, int root)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
BOOST_MPI_DECL bool operator== (const communicator &comm1, const communicator &comm2)
 Determines whether two communicators are identical. More...
 
bool operator!= (const communicator &comm1, const communicator &comm2)
 Determines whether two communicators are different. More...
 
template<typename T >
MPI_Datatype get_mpi_datatype (const T &x)
 Returns an MPI data type for a C++ type. More...
 
template<>
MPI_Datatype get_mpi_datatype< packed > (const packed &)
 INTERNAL ONLY. More...
 
template<>
struct BOOST_JOIN (is_mpi_, BOOST_JOIN(builtin, _datatype))< packed >
 
template<>
MPI_Datatype get_mpi_datatype< char > (const char &)
 INTERNAL ONLY. More...
 
template<>
MPI_Datatype get_mpi_datatype< short > (const short &)
 INTERNAL ONLY. More...
 
template<>
struct BOOST_JOIN (is_mpi_, BOOST_JOIN(integer, _datatype))< short >
 
template<>
MPI_Datatype get_mpi_datatype< int > (const int &)
 INTERNAL ONLY. More...
 
template<>
MPI_Datatype get_mpi_datatype< long > (const long &)
 INTERNAL ONLY. More...
 
template<>
MPI_Datatype get_mpi_datatype< float > (const float &)
 INTERNAL ONLY. More...
 
template<>
struct BOOST_JOIN (is_mpi_, BOOST_JOIN(floating_point, _datatype))< float >
 
template<>
MPI_Datatype get_mpi_datatype< double > (const double &)
 INTERNAL ONLY. More...
 
template<>
MPI_Datatype get_mpi_datatype< long double > (const long double &)
 INTERNAL ONLY. More...
 
template<>
MPI_Datatype get_mpi_datatype< unsigned char > (const unsigned char &)
 INTERNAL ONLY. More...
 
template<>
MPI_Datatype get_mpi_datatype< unsigned short > (const unsigned short &)
 INTERNAL ONLY. More...
 
template<>
MPI_Datatype get_mpi_datatype< unsigned > (const unsigned &)
 INTERNAL ONLY. More...
 
template<>
MPI_Datatype get_mpi_datatype< unsigned long > (const unsigned long &)
 INTERNAL ONLY. More...
 
template<>
MPI_Datatype get_mpi_datatype< std::pair< float, int > > (const std::pair< float, int > &)
 INTERNAL ONLY. More...
 
template<>
MPI_Datatype get_mpi_datatype< std::pair< double, int > > (const std::pair< double, int > &)
 INTERNAL ONLY. More...
 
template<>
MPI_Datatype get_mpi_datatype< std::pair< long double, int > > (const std::pair< long double, int > &)
 INTERNAL ONLY. More...
 
template<>
MPI_Datatype get_mpi_datatype< std::pair< long, int > > (const std::pair< long, int > &)
 INTERNAL ONLY. More...
 
template<>
MPI_Datatype get_mpi_datatype< std::pair< short, int > > (const std::pair< short, int > &)
 INTERNAL ONLY. More...
 
template<>
MPI_Datatype get_mpi_datatype< std::pair< int, int > > (const std::pair< int, int > &)
 INTERNAL ONLY. More...
 
template<>
MPI_Datatype get_mpi_datatype< bool > (const bool &)
 Support for bool. More...
 
template<>
MPI_Datatype get_mpi_datatype< boost::archive::library_version_type > (const boost::archive::library_version_type &)
 
template<>
MPI_Datatype get_mpi_datatype< boost::archive::version_type > (const boost::archive::version_type &)
 
template<>
MPI_Datatype get_mpi_datatype< boost::archive::class_id_type > (const boost::archive::class_id_type &)
 
template<>
MPI_Datatype get_mpi_datatype< boost::archive::class_id_reference_type > (const boost::archive::class_id_reference_type &)
 
template<>
MPI_Datatype get_mpi_datatype< boost::archive::class_id_optional_type > (const boost::archive::class_id_optional_type &)
 
template<>
MPI_Datatype get_mpi_datatype< boost::archive::object_id_type > (const boost::archive::object_id_type &)
 
template<>
MPI_Datatype get_mpi_datatype< boost::archive::object_reference_type > (const boost::archive::object_reference_type &)
 
template<>
MPI_Datatype get_mpi_datatype< boost::archive::tracking_type > (const boost::archive::tracking_type &)
 
template<>
MPI_Datatype get_mpi_datatype< boost::serialization::collection_size_type > (const boost::serialization::collection_size_type &)
 
template<>
MPI_Datatype get_mpi_datatype< boost::serialization::item_version_type > (const boost::serialization::item_version_type &)
 
template<typename T >
MPI_Datatype get_mpi_datatype ()
 
int source (const std::pair< int, int > &edge, const graph_communicator &)
 Returns the source vertex from an edge in the graph topology of a communicator. More...
 
int target (const std::pair< int, int > &edge, const graph_communicator &)
 Returns the target vertex from an edge in the graph topology of a communicator. More...
 
std::pair
< detail::comm_out_edge_iterator,
detail::comm_out_edge_iterator
out_edges (int vertex, const graph_communicator &comm)
 Returns an iterator range containing all of the edges outgoing from the given vertex in a graph topology of a communicator. More...
 
int out_degree (int vertex, const graph_communicator &comm)
 Returns the out-degree of a vertex in the graph topology of a communicator. More...
 
std::pair
< detail::comm_adj_iterator,
detail::comm_adj_iterator
adjacent_vertices (int vertex, const graph_communicator &comm)
 Returns an iterator range containing all of the neighbors of the given vertex in the communicator's graph topology. More...
 
std::pair< counting_iterator
< int >, counting_iterator
< int > > 
vertices (const graph_communicator &comm)
 Returns an iterator range that contains all of the vertices with the communicator's graph topology, i.e., all of the process ranks in the communicator. More...
 
int num_vertices (const graph_communicator &comm)
 Returns the number of vertices within the graph topology of the communicator, i.e., the number of processes in the communicator. More...
 
std::pair
< detail::comm_edge_iterator,
detail::comm_edge_iterator
edges (const graph_communicator &comm)
 Returns an iterator range that contains all of the edges with the communicator's graph topology. More...
 
int num_edges (const graph_communicator &comm)
 Returns the number of edges in the communicator's graph topology. More...
 
identity_property_map get (vertex_index_t, const graph_communicator &)
 Returns a property map that maps from vertices in a communicator's graph topology to their index values. More...
 
int get (vertex_index_t, const graph_communicator &, int vertex)
 Returns the index of a vertex in the communicator's graph topology. More...
 
BOOST_MPI_DECL bool operator== (const group &g1, const group &g2)
 Determines whether two process groups are identical. More...
 
bool operator!= (const group &g1, const group &g2)
 Determines whether two process groups are not identical. More...
 
BOOST_MPI_DECL group operator| (const group &g1, const group &g2)
 Computes the union of two process groups. More...
 
BOOST_MPI_DECL group operator& (const group &g1, const group &g2)
 Computes the intersection of two process groups. More...
 
BOOST_MPI_DECL group operator- (const group &g1, const group &g2)
 Computes the difference between two process groups. More...
 
template<typename T >
inplace_t< Tinplace (T &inout)
 Wrapp a input data to indicate that it can be overriden with an ouput value. More...
 
template<typename T >
inplace_t< T * > inplace (T *inout)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename ForwardIterator >
std::pair< status,
ForwardIterator > 
wait_any (ForwardIterator first, ForwardIterator last)
 Wait until any non-blocking request has completed. More...
 
template<typename ForwardIterator >
optional< std::pair< status,
ForwardIterator > > 
test_any (ForwardIterator first, ForwardIterator last)
 Test whether any non-blocking request has completed. More...
 
template<typename ForwardIterator , typename OutputIterator >
OutputIterator wait_all (ForwardIterator first, ForwardIterator last, OutputIterator out)
 Wait until all non-blocking requests have completed. More...
 
template<typename ForwardIterator >
void wait_all (ForwardIterator first, ForwardIterator last)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename ForwardIterator , typename OutputIterator >
optional< OutputIterator > test_all (ForwardIterator first, ForwardIterator last, OutputIterator out)
 Tests whether all non-blocking requests have completed. More...
 
template<typename ForwardIterator >
bool test_all (ForwardIterator first, ForwardIterator last)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename BidirectionalIterator , typename OutputIterator >
std::pair< OutputIterator,
BidirectionalIterator > 
wait_some (BidirectionalIterator first, BidirectionalIterator last, OutputIterator out)
 Wait until some non-blocking requests have completed. More...
 
template<typename BidirectionalIterator >
BidirectionalIterator wait_some (BidirectionalIterator first, BidirectionalIterator last)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<typename BidirectionalIterator , typename OutputIterator >
std::pair< OutputIterator,
BidirectionalIterator > 
test_some (BidirectionalIterator first, BidirectionalIterator last, OutputIterator out)
 Test whether some non-blocking requests have completed. More...
 
template<typename BidirectionalIterator >
BidirectionalIterator test_some (BidirectionalIterator first, BidirectionalIterator last)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
 
template<class T >
const skeleton_proxy< Tskeleton (T &x)
 Create a skeleton proxy object. More...
 
template<class T >
const content get_content (const T &x)
 Returns the content of an object, suitable for transmission via Boost.MPI. More...
 
template<>
MPI_Datatype get_mpi_datatype< void * > (void *const &x)
 

Variables

const int any_source = MPI_ANY_SOURCE
 A constant representing "any process.". More...
 
const int any_tag = MPI_ANY_TAG
 A constant representing "any tag.". More...
 

Typedef Documentation

typedef packed_iprimitive boost::mpi::iprimitive
typedef packed_oprimitive boost::mpi::oprimitive

Enumeration Type Documentation

Enumeration used to describe how to adopt a C MPI_Comm into a Boost.MPI communicator.

The values for this enumeration determine how a Boost.MPI communicator will behave when constructed with an MPI communicator. The options are:

  • comm_duplicate: Duplicate the MPI_Comm communicator to create a new communicator (e.g., with MPI_Comm_dup). This new MPI_Comm communicator will be automatically freed when the Boost.MPI communicator (and all copies of it) is destroyed.
  • comm_take_ownership: Take ownership of the communicator. It will be freed automatically when all of the Boost.MPI communicators go out of scope. This option must not be used with MPI_COMM_WORLD.
  • comm_attach: The Boost.MPI communicator will reference the existing MPI communicator but will not free it when the Boost.MPI communicator goes out of scope. This option should only be used when the communicator is managed by the user or MPI library (e.g., MPI_COMM_WORLD).
Enumerator
comm_duplicate 
comm_take_ownership 
comm_attach 

Function Documentation

std::pair<detail::comm_adj_iterator, detail::comm_adj_iterator> boost::mpi::adjacent_vertices ( int  vertex,
const graph_communicator &  comm 
)

Returns an iterator range containing all of the neighbors of the given vertex in the communicator's graph topology.

template<typename T >
void boost::mpi::all_gather ( const communicator &  comm,
const T in_value,
T out_values 
)
inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::mpi::detail::all_gather_impl().

template<typename T >
void boost::mpi::all_gather ( const communicator &  comm,
const T in_value,
std::vector< T > &  out_values 
)

Gather the values stored at every process into vectors of values from each process.

all_gather is a collective algorithm that collects the values stored at each process into a vector of values indexed by the process number they came from. The type T of the values may be any type that is serializable or has an associated MPI data type.

When the type T has an associated MPI data type, this routine invokes MPI_Allgather to gather the values.

Parameters
commThe communicator over which the all-gather will occur.
in_valueThe value to be transmitted by each process. To gather an array of values, in_values points to the n local values to be transmitted.
out_valuesA vector or pointer to storage that will be populated with the values from each process, indexed by the process ID number. If it is a vector, the vector will be resized accordingly.

References all_gather(), and boost::mpi::communicator::size().

template<typename T >
void boost::mpi::all_gather ( const communicator &  comm,
const T in_values,
int  n,
T out_values 
)
inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::mpi::detail::all_gather_impl().

template<typename T >
void boost::mpi::all_gather ( const communicator &  comm,
const T in_values,
int  n,
std::vector< T > &  out_values 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::n, and boost::mpi::communicator::size().

Referenced by all_gather().

template<typename T , typename Op >
void boost::mpi::all_reduce ( const communicator &  comm,
const T value,
int  n,
T out_value,
Op  op 
)
inline

Combine the values stored by each process into a single value available to all processes.

all_reduce is a collective algorithm that combines the values stored by each process into a single value available to all processes. The values are combined in a user-defined way, specified via a function object. The type T of the values may be any type that is serializable or has an associated MPI data type. One can think of this operation as a all_gather, followed by an std::accumulate() over the gather values and using the operation op.

When the type T has an associated MPI data type, this routine invokes MPI_Allreduce to perform the reduction. If possible, built-in MPI operations will be used; otherwise, all_reduce() will create a custom MPI_Op for the call to MPI_Allreduce.

Parameters
commThe communicator over which the reduction will occur.
valueThe local value to be combined with the local values of every other process. For reducing arrays, in_values is a pointer to the local values to be reduced and n is the number of values to reduce. See reduce for more information.

If wrapped in a inplace_t object, combine the usage of both input and $c out_value and the local value will be overwritten (a convenience function inplace is provided for the wrapping).

Parameters
out_valueWill receive the result of the reduction operation. If this parameter is omitted, the outgoing value will instead be returned.
opThe binary operation that combines two values of type T and returns a third value of type T. For types T that has ssociated MPI data types, op will either be translated into an MPI_Op (via MPI_Op_create) or, if possible, mapped directly to a built-in MPI operation. See is_mpi_op in the operations.hpp header for more details on this mapping. For any non-built-in operation, commutativity will be determined by the is_commmutative trait (also in operations.hpp): users are encouraged to mark commutative operations as such, because it gives the implementation additional lattitude to optimize the reduction operation.
nIndicated the size of the buffers of array type.
Returns
If no out_value parameter is supplied, returns the result of the reduction operation.

References boost::mpi::detail::all_reduce_impl().

Referenced by all_reduce(), boost::numeric::odeint::mpi_nested_algebra< InnerAlgebra >::norm_inf(), and boost::numeric::odeint::same_size_impl< mpi_state< InnerState1 >, mpi_state< InnerState2 > >::same_size().

template<typename T , typename Op >
void boost::mpi::all_reduce ( const communicator &  comm,
inplace_t< T * >  inout_values,
int  n,
Op  op 
)
inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References all_reduce(), and boost::mpi::inplace_t< T * >::buffer.

template<typename T , typename Op >
void boost::mpi::all_reduce ( const communicator &  comm,
inplace_t< T inout_values,
Op  op 
)
inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References all_reduce(), and boost::mpi::inplace_t< T >::buffer.

template<typename T , typename Op >
void boost::mpi::all_reduce ( const communicator &  comm,
const T in_value,
T out_value,
Op  op 
)
inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::mpi::detail::all_reduce_impl().

template<typename T , typename Op >
T boost::mpi::all_reduce ( const communicator &  comm,
const T in_value,
Op  op 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References T.

template<typename T >
void boost::mpi::all_to_all ( const communicator &  comm,
const T in_values,
T out_values 
)
inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::mpi::detail::all_to_all_impl().

Referenced by boost::mpi::detail::all_to_all_impl().

template<typename T >
void boost::mpi::all_to_all ( const communicator &  comm,
const std::vector< T > &  in_values,
std::vector< T > &  out_values 
)

Send data from every process to every other process.

all_to_all is a collective algorithm that transmits p values from every process to every other process. On process i, jth value of the in_values vector is sent to process j and placed in the ith position of the out_values vector in process j. The type T of the values may be any type that is serializable or has an associated MPI data type. If n is provided, then arrays of n values will be transferred from one process to another.

When the type T has an associated MPI data type, this routine invokes MPI_Alltoall to scatter the values.

Parameters
commThe communicator over which the all-to-all communication will occur.
in_valuesA vector or pointer to storage that contains the values to send to each process, indexed by the process ID number.
out_valuesA vector or pointer to storage that will be updated to contain the values received from other processes. The jth value in out_values will come from the procss with rank j.

References all_to_all(), BOOST_ASSERT, and boost::mpi::communicator::size().

template<typename T >
void boost::mpi::all_to_all ( const communicator &  comm,
const T in_values,
int  n,
T out_values 
)
inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::mpi::detail::all_to_all_impl().

template<typename T >
void boost::mpi::all_to_all ( const communicator &  comm,
const std::vector< T > &  in_values,
int  n,
std::vector< T > &  out_values 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References BOOST_ASSERT, boost::n, and boost::mpi::communicator::size().

Referenced by all_to_all().

template<>
struct boost::mpi::BOOST_JOIN ( is_mpi_  ,
BOOST_JOIN(builtin,_datatype)   
)
template<>
struct boost::mpi::BOOST_JOIN ( is_mpi_  ,
BOOST_JOIN(integer,_datatype)   
)
template<>
struct boost::mpi::BOOST_JOIN ( is_mpi_  ,
BOOST_JOIN(floating_point,_datatype)   
)
template<typename T >
void boost::mpi::broadcast ( const communicator &  comm,
T value,
int  root 
)

Broadcast a value from a root process to all other processes.

broadcast is a collective algorithm that transfers a value from an arbitrary root process to every other process that is part of the given communicator. The broadcast algorithm can transmit any Serializable value, values that have associated MPI data types, packed archives, skeletons, and the content of skeletons; see the send primitive for communicators for a complete list. The type T shall be the same for all processes that are a part of the communicator comm, unless packed archives are being transferred: with packed archives, the root sends a packed_oarchive or packed_skeleton_oarchive whereas the other processes receive a packed_iarchive or packed_skeleton_iarchve, respectively.

When the type T has an associated MPI data type, this routine invokes MPI_Bcast to perform the broadcast.

Parameters
commThe communicator over which the broadcast will occur.
valueThe value (or values, if n is provided) to be transmitted (if the rank of comm is equal to root) or received (if the rank of comm is not equal to root). When the value is a skeleton_proxy, only the skeleton of the object will be broadcast. In this case, the root will build a skeleton from the object help in the proxy and all of the non-roots will reshape the objects held in their proxies based on the skeleton sent from the root.
nWhen supplied, the number of values that the pointer values points to, for broadcasting an array of values. The value of n must be the same for all processes in comm.
rootThe rank/process ID of the process that will be transmitting the value.

References boost::mpi::detail::broadcast_impl().

Referenced by boost::mpi::detail::all_gather_impl(), boost::mpi::detail::all_reduce_impl(), and boost::mpi::detail::broadcast_impl().

template<typename T >
void boost::mpi::broadcast ( const communicator &  comm,
T values,
int  n,
int  root 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::mpi::detail::broadcast_impl().

template<typename T >
void boost::mpi::broadcast ( const communicator &  comm,
skeleton_proxy< T > &  value,
int  root 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename T >
void boost::mpi::broadcast ( const communicator &  comm,
const skeleton_proxy< T > &  value,
int  root 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<>
void boost::mpi::broadcast< const content > ( const communicator &  comm,
const content &  c,
int  root 
)

INTERNAL ONLY.

template<>
BOOST_MPI_DECL void boost::mpi::broadcast< const packed_oarchive > ( const communicator &  comm,
const packed_oarchive &  oa,
int  root 
)

INTERNAL ONLY.

template<>
BOOST_MPI_DECL void boost::mpi::broadcast< const packed_skeleton_oarchive > ( const communicator &  comm,
const packed_skeleton_oarchive &  oa,
int  root 
)

INTERNAL ONLY.

template<>
void boost::mpi::broadcast< content > ( const communicator &  comm,
content &  c,
int  root 
)

INTERNAL ONLY.

template<>
BOOST_MPI_DECL void boost::mpi::broadcast< packed_iarchive > ( const communicator &  comm,
packed_iarchive &  ia,
int  root 
)

INTERNAL ONLY.

template<>
BOOST_MPI_DECL void boost::mpi::broadcast< packed_oarchive > ( const communicator &  comm,
packed_oarchive &  oa,
int  root 
)

INTERNAL ONLY.

template<>
void boost::mpi::broadcast< packed_skeleton_iarchive > ( const communicator &  comm,
packed_skeleton_iarchive &  ia,
int  root 
)

INTERNAL ONLY.

template<>
void boost::mpi::broadcast< packed_skeleton_oarchive > ( const communicator &  comm,
packed_skeleton_oarchive &  oa,
int  root 
)

INTERNAL ONLY.

std::pair<detail::comm_edge_iterator, detail::comm_edge_iterator> boost::mpi::edges ( const graph_communicator &  comm)

Returns an iterator range that contains all of the edges with the communicator's graph topology.

Referenced by boost::mpi::graph_communicator::setup_graph().

template<typename T >
void boost::mpi::gather ( const communicator &  comm,
const T in_value,
T out_values,
int  root 
)
template<typename T >
void boost::mpi::gather ( const communicator &  comm,
const T in_value,
int  root 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References BOOST_ASSERT, boost::mpi::detail::gather_impl(), boost::mpi::communicator::rank(), and boost::units::root().

template<typename T >
void boost::mpi::gather ( const communicator &  comm,
const T in_value,
std::vector< T > &  out_values,
int  root 
)

Gather the values stored at every process into a vector at the root process.

gather is a collective algorithm that collects the values stored at each process into a vector of values at the root process. This vector is indexed by the process number that the value came from. The type T of the values may be any type that is serializable or has an associated MPI data type.

When the type T has an associated MPI data type, this routine invokes MPI_Gather to gather the values.

Parameters
commThe communicator over which the gather will occur.
in_valueThe value to be transmitted by each process. For gathering arrays of values, in_values points to storage for n*comm.size() values.
out_valuesA vector or pointer to storage that will be populated with the values from each process, indexed by the process ID number. If it is a vector, it will be resized accordingly. For non-root processes, this parameter may be omitted. If it is still provided, however, it will be unchanged.
rootThe process ID number that will collect the values. This value must be the same on all processes.

References gather(), boost::mpi::communicator::rank(), boost::units::root(), and boost::mpi::communicator::size().

template<typename T >
void boost::mpi::gather ( const communicator &  comm,
const T in_values,
int  n,
T out_values,
int  root 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::mpi::detail::gather_impl(), boost::mpi::communicator::rank(), and boost::units::root().

template<typename T >
void boost::mpi::gather ( const communicator &  comm,
const T in_values,
int  n,
std::vector< T > &  out_values,
int  root 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References gather(), boost::n, boost::mpi::communicator::rank(), boost::units::root(), and boost::mpi::communicator::size().

template<typename T >
void boost::mpi::gather ( const communicator &  comm,
const T in_values,
int  n,
int  root 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References BOOST_ASSERT, boost::mpi::detail::gather_impl(), boost::mpi::communicator::rank(), and boost::units::root().

Referenced by gather().

identity_property_map boost::mpi::get ( vertex_index_t  ,
const graph_communicator &   
)
inline

Returns a property map that maps from vertices in a communicator's graph topology to their index values.

Since the vertices are ranks in the communicator, the returned property map is the identity property map.

int boost::mpi::get ( vertex_index_t  ,
const graph_communicator &  ,
int  vertex 
)
inline

Returns the index of a vertex in the communicator's graph topology.

Since the vertices are ranks in the communicator, this is the identity function.

References boost::vertex().

template<class T >
const content boost::mpi::get_content ( const T x)

Returns the content of an object, suitable for transmission via Boost.MPI.

The function creates an absolute MPI datatype for the object, where all offsets are counted from the address 0 (a.k.a. MPI_BOTTOM) instead of the address &x of the object. This allows the creation of MPI data types for complex data structures containing pointers, such as linked lists or trees.

The disadvantage, compared to relative MPI data types is that for each object a new MPI data type has to be created.

The contents of an object can only be transmitted when the receiver already has an object with the same structure or shape as the sender. To accomplish this, first transmit the skeleton of the object using, e.g., skeleton() or skeleton_proxy.

The type T has to allow creation of an absolute MPI data type (content).

Parameters
xthe object for which the content will be transmitted.
Returns
the content of the object x, which can be used for transmission via send, recv, or broadcast.

Referenced by boost::mpi::python::detail::do_get_content< T >::operator()().

template<typename T >
MPI_Datatype boost::mpi::get_mpi_datatype ( )

References get_mpi_datatype(), and T.

template<typename T >
MPI_Datatype boost::mpi::get_mpi_datatype ( const T x)

Returns an MPI data type for a C++ type.

The function creates an MPI data type for the given object x. The first time it is called for a class T, the MPI data type is created and cached. Subsequent calls for objects of the same type T return the cached MPI data type. The type T must allow creation of an MPI data type. That is, it must be Serializable and is_mpi_datatype<T> must derive mpl::true_.

For fundamental MPI types, a copy of the MPI data type of the MPI library is returned.

Note that since the data types are cached, the caller should never call MPI_Type_free() for the MPI data type returned by this call.

Parameters
xfor an optimized call, a constructed object of the type should be passed; otherwise, an object will be default-constructed.
Returns
The MPI data type corresponding to type T.

References BOOST_MPL_ASSERT.

Referenced by get_mpi_datatype(), and boost::graph::distributed::send_oob().

template<>
MPI_Datatype boost::mpi::get_mpi_datatype< bool > ( const bool &  )
inline

Support for bool.

There is no corresponding MPI_BOOL. INTERNAL ONLY

References boost::mpi::detail::build_mpi_datatype_for_bool(), and boost::detail::type.

template<>
MPI_Datatype boost::mpi::get_mpi_datatype< char > ( const char &  )
inline

INTERNAL ONLY.

template<>
MPI_Datatype boost::mpi::get_mpi_datatype< double > ( const double &  )
inline

INTERNAL ONLY.

template<>
MPI_Datatype boost::mpi::get_mpi_datatype< float > ( const float &  )
inline

INTERNAL ONLY.

template<>
MPI_Datatype boost::mpi::get_mpi_datatype< int > ( const int &  )
inline

INTERNAL ONLY.

template<>
MPI_Datatype boost::mpi::get_mpi_datatype< long > ( const long &  )
inline

INTERNAL ONLY.

template<>
MPI_Datatype boost::mpi::get_mpi_datatype< long double > ( const long double &  )
inline

INTERNAL ONLY.

template<>
MPI_Datatype boost::mpi::get_mpi_datatype< packed > ( const packed &  )
inline

INTERNAL ONLY.

template<>
MPI_Datatype boost::mpi::get_mpi_datatype< short > ( const short &  )
inline

INTERNAL ONLY.

template<>
MPI_Datatype boost::mpi::get_mpi_datatype< std::pair< double, int > > ( const std::pair< double, int > &  )
inline

INTERNAL ONLY.

template<>
MPI_Datatype boost::mpi::get_mpi_datatype< std::pair< float, int > > ( const std::pair< float, int > &  )
inline

INTERNAL ONLY.

template<>
MPI_Datatype boost::mpi::get_mpi_datatype< std::pair< int, int > > ( const std::pair< int, int > &  )
inline

INTERNAL ONLY.

template<>
MPI_Datatype boost::mpi::get_mpi_datatype< std::pair< long double, int > > ( const std::pair< long double, int > &  )
inline

INTERNAL ONLY.

template<>
MPI_Datatype boost::mpi::get_mpi_datatype< std::pair< long, int > > ( const std::pair< long, int > &  )
inline

INTERNAL ONLY.

template<>
MPI_Datatype boost::mpi::get_mpi_datatype< std::pair< short, int > > ( const std::pair< short, int > &  )
inline

INTERNAL ONLY.

template<>
MPI_Datatype boost::mpi::get_mpi_datatype< unsigned > ( const unsigned &  )
inline

INTERNAL ONLY.

template<>
MPI_Datatype boost::mpi::get_mpi_datatype< unsigned char > ( const unsigned char &  )
inline

INTERNAL ONLY.

template<>
MPI_Datatype boost::mpi::get_mpi_datatype< unsigned long > ( const unsigned long &  )
inline

INTERNAL ONLY.

template<>
MPI_Datatype boost::mpi::get_mpi_datatype< unsigned short > ( const unsigned short &  )
inline

INTERNAL ONLY.

template<>
MPI_Datatype boost::mpi::get_mpi_datatype< void * > ( void *const &  x)
inline
template<typename T >
inplace_t<T> boost::mpi::inplace ( T inout)

Wrapp a input data to indicate that it can be overriden with an ouput value.

Parameters
inoutthe contributing input value, it will be overriden with the output value where one is expected. If it is a pointer, the number of elements will be provided separatly.
Returns
The wrapped value or pointer.
template<typename T >
inplace_t<T*> boost::mpi::inplace ( T inout)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

int boost::mpi::num_edges ( const graph_communicator &  comm)

Returns the number of edges in the communicator's graph topology.

int boost::mpi::num_vertices ( const graph_communicator &  comm)
inline

Returns the number of vertices within the graph topology of the communicator, i.e., the number of processes in the communicator.

References boost::mpi::communicator::size().

Referenced by boost::mpi::graph_communicator::setup_graph().

bool boost::mpi::operator!= ( const group &  g1,
const group &  g2 
)
inline

Determines whether two process groups are not identical.

Equivalent to calling MPI_Group_compare and checking whether the result is not MPI_IDENT.

Returns
False when the two process groups contain the same processes in the same order.
bool boost::mpi::operator!= ( const communicator &  comm1,
const communicator &  comm2 
)
inline

Determines whether two communicators are different.

Returns
!(comm1 == comm2)
BOOST_MPI_DECL group boost::mpi::operator& ( const group &  g1,
const group &  g2 
)

Computes the intersection of two process groups.

This routine returns a new group that contains all processes that are in group g1 and in group g2, ordered in the same way as g1. Equivalent to MPI_Group_intersection.

BOOST_MPI_DECL group boost::mpi::operator- ( const group &  g1,
const group &  g2 
)

Computes the difference between two process groups.

This routine returns a new group that contains all processes that are in group g1 but not in group g2, ordered in the same way as g1. Equivalent to MPI_Group_difference.

BOOST_MPI_DECL bool boost::mpi::operator== ( const group &  g1,
const group &  g2 
)

Determines whether two process groups are identical.

Equivalent to calling MPI_Group_compare and checking whether the result is MPI_IDENT.

Returns
True when the two process groups contain the same processes in the same order.
BOOST_MPI_DECL bool boost::mpi::operator== ( const communicator &  comm1,
const communicator &  comm2 
)

Determines whether two communicators are identical.

Equivalent to calling MPI_Comm_compare and checking whether the result is MPI_IDENT.

Returns
True when the two communicators refer to the same underlying MPI communicator.
BOOST_MPI_DECL group boost::mpi::operator| ( const group &  g1,
const group &  g2 
)

Computes the union of two process groups.

This routine returns a new group that contains all processes that are either in group g1 or in group g2 (or both). The processes that are in g1 will be first in the resulting group, followed by the processes from g2 (but not also in g1). Equivalent to MPI_Group_union.

int boost::mpi::out_degree ( int  vertex,
const graph_communicator &  comm 
)

Returns the out-degree of a vertex in the graph topology of a communicator.

std::pair<detail::comm_out_edge_iterator, detail::comm_out_edge_iterator> boost::mpi::out_edges ( int  vertex,
const graph_communicator &  comm 
)

Returns an iterator range containing all of the edges outgoing from the given vertex in a graph topology of a communicator.

template<typename T , typename Op >
void boost::mpi::reduce ( const communicator &  comm,
const T in_values,
int  n,
T out_values,
Op  op,
int  root 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::mpi::communicator::rank(), boost::mpi::detail::reduce_impl(), and boost::units::root().

Referenced by boost::mpi::detail::all_reduce_impl(), and reduce().

template<typename T , typename Op >
void boost::mpi::reduce ( const communicator &  comm,
const T in_values,
int  n,
Op  op,
int  root 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References BOOST_ASSERT, boost::mpi::communicator::rank(), boost::mpi::detail::reduce_impl(), and boost::units::root().

template<typename T , typename Op >
void boost::mpi::reduce ( const communicator &  comm,
std::vector< T > const &  in_values,
Op  op,
int  root 
)

References reduce(), and boost::units::root().

template<typename T , typename Op >
void boost::mpi::reduce ( const communicator &  comm,
std::vector< T > const &  in_values,
std::vector< T > &  out_values,
Op  op,
int  root 
)

References reduce(), and boost::units::root().

template<typename T , typename Op >
void boost::mpi::reduce ( const communicator &  comm,
const T in_value,
T out_value,
Op  op,
int  root 
)

Combine the values stored by each process into a single value at the root.

reduce is a collective algorithm that combines the values stored by each process into a single value at the root. The values can be combined arbitrarily, specified via a function object. The type T of the values may be any type that is serializable or has an associated MPI data type. One can think of this operation as a gather to the root, followed by an std::accumulate() over the gathered values and using the operation op.

When the type T has an associated MPI data type, this routine invokes MPI_Reduce to perform the reduction. If possible, built-in MPI operations will be used; otherwise, reduce() will create a custom MPI_Op for the call to MPI_Reduce.

Parameters
commThe communicator over which the reduction will occur.
in_valueThe local value to be combined with the local values of every other process. For reducing arrays, in_values contains a pointer to the local values. In this case, n is the number of values that will be reduced. Reduction occurs independently for each of the n values referenced by in_values, e.g., calling reduce on an array of n values is like calling reduce n separate times, one for each location in in_values and out_values.
out_valueWill receive the result of the reduction operation, but only for the root process. Non-root processes may omit if parameter; if they choose to supply the parameter, it will be unchanged. For reducing arrays, out_values contains a pointer to the storage for the output values.
opThe binary operation that combines two values of type T into a third value of type T. For types T that has ssociated MPI data types, op will either be translated into an MPI_Op (via MPI_Op_create) or, if possible, mapped directly to a built-in MPI operation. See is_mpi_op in the operations.hpp header for more details on this mapping. For any non-built-in operation, commutativity will be determined by the is_commmutative trait (also in operations.hpp): users are encouraged to mark commutative operations as such, because it gives the implementation additional lattitude to optimize the reduction operation.
rootThe process ID number that will receive the final, combined value. This value must be the same on all processes.

References boost::mpi::communicator::rank(), boost::mpi::detail::reduce_impl(), and boost::units::root().

template<typename T , typename Op >
void boost::mpi::reduce ( const communicator &  comm,
const T in_value,
Op  op,
int  root 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References BOOST_ASSERT, boost::mpi::communicator::rank(), boost::mpi::detail::reduce_impl(), and boost::units::root().

template<typename T , typename Op >
void boost::mpi::scan ( const communicator &  comm,
const T in_value,
T out_value,
Op  op 
)
inline

Compute a prefix reduction of values from all processes in the communicator.

scan is a collective algorithm that combines the values stored by each process with the values of all processes with a smaller rank. The values can be arbitrarily combined, specified via a function object op. The type T of the values may be any type that is serializable or has an associated MPI data type. One can think of this operation as a gather to some process, followed by an std::prefix_sum() over the gathered values using the operation op. The ith process returns the ith value emitted by std::prefix_sum().

When the type T has an associated MPI data type, this routine invokes MPI_Scan to perform the reduction. If possible, built-in MPI operations will be used; otherwise, scan() will create a custom MPI_Op for the call to MPI_Scan.

Parameters
commThe communicator over which the prefix reduction will occur.
in_valueThe local value to be combined with the local values of other processes. For the array variant, the in_values parameter points to the n local values that will be combined.
out_valueIf provided, the ith process will receive the value op(in_value[0], op(in_value[1], op(..., in_value[i]) ... )). For the array variant, out_values contains a pointer to storage for the n output values. The prefix reduction occurs independently for each of the n values referenced by in_values, e.g., calling scan on an array of n values is like calling scan n separate times, one for each location in in_values and out_values.
opThe binary operation that combines two values of type T into a third value of type T. For types T that has ssociated MPI data types, op will either be translated into an MPI_Op (via MPI_Op_create) or, if possible, mapped directly to a built-in MPI operation. See is_mpi_op in the operations.hpp header for more details on this mapping. For any non-built-in operation, commutativity will be determined by the is_commmutative trait (also in operations.hpp).
Returns
If no out_value parameter is provided, returns the result of prefix reduction.

References boost::mpi::detail::scan_impl().

template<typename T , typename Op >
void boost::mpi::scan ( const communicator &  comm,
const T in_values,
int  n,
T out_values,
Op  op 
)
inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::mpi::detail::scan_impl().

template<typename T , typename Op >
T boost::mpi::scan ( const communicator &  comm,
const T in_value,
Op  op 
)
inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::mpi::detail::scan_impl(), and T.

template<typename T >
void boost::mpi::scatter ( const communicator &  comm,
const T in_values,
T out_value,
int  root 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::mpi::communicator::rank(), boost::units::root(), and boost::mpi::detail::scatter_impl().

Referenced by scatter(), and boost::numeric::odeint::split_impl< Source, mpi_state< InnerState >, typename boost::enable_if< boost::has_range_const_iterator< Source > >::type >::split().

template<typename T >
void boost::mpi::scatter ( const communicator &  comm,
const std::vector< T > &  in_values,
T out_value,
int  root 
)

Scatter the values stored at the root to all processes within the communicator.

scatter is a collective algorithm that scatters the values stored in the root process (inside a vector) to all of the processes in the communicator. The vector out_values (only significant at the root) is indexed by the process number to which the corresponding value will be sent. The type T of the values may be any type that is serializable or has an associated MPI data type.

When the type T has an associated MPI data type, this routine invokes MPI_Scatter to scatter the values.

Parameters
commThe communicator over which the gather will occur.
in_valuesA vector or pointer to storage that will contain the values to send to each process, indexed by the process rank. For non-root processes, this parameter may be omitted. If it is still provided, however, it will be unchanged.
out_valueThe value received by each process. When scattering an array of values, out_values points to the n values that will be received by each process.
rootThe process ID number that will scatter the values. This value must be the same on all processes.

References boost::mpi::communicator::rank(), boost::units::root(), and T.

template<typename T >
void boost::mpi::scatter ( const communicator &  comm,
T out_value,
int  root 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References BOOST_ASSERT, boost::mpi::communicator::rank(), boost::units::root(), and boost::mpi::detail::scatter_impl().

template<typename T >
void boost::mpi::scatter ( const communicator &  comm,
const T in_values,
T out_values,
int  n,
int  root 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::mpi::communicator::rank(), boost::units::root(), and boost::mpi::detail::scatter_impl().

template<typename T >
void boost::mpi::scatter ( const communicator &  comm,
const std::vector< T > &  in_values,
T out_values,
int  n,
int  root 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::mpi::communicator::rank(), boost::units::root(), and scatter().

template<typename T >
void boost::mpi::scatter ( const communicator &  comm,
T out_values,
int  n,
int  root 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References BOOST_ASSERT, boost::mpi::communicator::rank(), boost::units::root(), and boost::mpi::detail::scatter_impl().

Referenced by scatter().

template<class T >
const skeleton_proxy< T > boost::mpi::skeleton ( T x)
inline

Create a skeleton proxy object.

This routine creates an instance of the skeleton_proxy class. It will typically be used when calling send, recv, or broadcast, to indicate that only the skeleton (structure) of an object should be transmitted and not its contents.

Parameters
xthe object whose structure will be transmitted.
Returns
a skeleton_proxy object referencing x

References boost::flyweights::x.

int boost::mpi::source ( const std::pair< int, int > &  edge,
const graph_communicator &   
)
inline

Returns the source vertex from an edge in the graph topology of a communicator.

Referenced by boost::mpi::communicator::irecv(), and boost::mpi::communicator::recv().

int boost::mpi::target ( const std::pair< int, int > &  edge,
const graph_communicator &   
)
inline

Returns the target vertex from an edge in the graph topology of a communicator.

Referenced by boost::mpi::graph_communicator::setup_graph().

template<typename ForwardIterator , typename OutputIterator >
optional<OutputIterator> boost::mpi::test_all ( ForwardIterator  first,
ForwardIterator  last,
OutputIterator  out 
)

Tests whether all non-blocking requests have completed.

This routine takes in a set of requests stored in the iterator range [first,last) and determines whether all of these requests have been completed. However, due to limitations of the underlying MPI implementation, if any of the requests refers to a non-blocking send or receive of a serialized data type, test_all will always return the equivalent of false (i.e., the requests cannot all be finished at this time). This routine performs the same functionality as wait_all, except that this routine will not block. This routine provides functionality equivalent to MPI_Testall.

Parameters
firstThe iterator that denotes the beginning of the sequence of request objects.
lastThe iterator that denotes the end of the sequence of request objects.
outIf provided and all requests hav been completed, an output iterator through which the status of each request will be emitted. The status objects are emitted in the same order as the requests are retrieved from [first,last).
Returns
If an out parameter was provided, the value out after all of the status objects have been emitted (if all requests were completed) or an empty optional<>. If no out parameter was provided, returns true if all requests have completed or false otherwise.

References BOOST_MPI_CHECK_RESULT, boost::xpressive::first, boost::multiprecision::backends::i, boost::last, boost::mpi::status::m_status, boost::n, and boost::out.

template<typename ForwardIterator >
bool boost::mpi::test_all ( ForwardIterator  first,
ForwardIterator  last 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References BOOST_MPI_CHECK_RESULT, boost::xpressive::first, boost::last, and boost::n.

template<typename ForwardIterator >
optional<std::pair<status, ForwardIterator> > boost::mpi::test_any ( ForwardIterator  first,
ForwardIterator  last 
)

Test whether any non-blocking request has completed.

This routine takes in a set of requests stored in the iterator range [first,last) and tests whether any of these requests has been completed. This routine is similar to wait_any, but will not block waiting for requests to completed. It provides functionality equivalent to MPI_Testany.

Parameters
firstThe iterator that denotes the beginning of the sequence of request objects.
lastThe iterator that denotes the end of the sequence of request objects.
Returns
If any outstanding requests have completed, a pair containing the status object that corresponds to the completed operation and the iterator referencing the completed request. Otherwise, an empty optional<>.

References boost::current, boost::xpressive::first, boost::last, and boost::xpressive::make_pair.

template<typename BidirectionalIterator , typename OutputIterator >
std::pair<OutputIterator, BidirectionalIterator> boost::mpi::test_some ( BidirectionalIterator  first,
BidirectionalIterator  last,
OutputIterator  out 
)

Test whether some non-blocking requests have completed.

This routine takes in a set of requests stored in the iterator range [first,last) and tests to see if any of the requests has completed. It completes all of the requests it can, partitioning the input sequence into pending requests followed by completed requests. If an output iterator is provided, status objects will be emitted for each of the completed requests. This routine is similar to wait_some, but does not wait until any requests have completed. This routine provides functionality equivalent to MPI_Testsome.

Parameters
firstThe iterator that denotes the beginning of the sequence of request objects.
lastThe iterator that denotes the end of the sequence of request objects. This may not be equal to first.
outIf provided, the status objects corresponding to completed requests will be emitted through this output iterator.
Returns
If the out parameter was provided, a pair containing the output iterator out after all of the status objects have been written through it and an iterator referencing the first completed request. If no out parameter was provided, only the iterator referencing the first completed request will be emitted.

References boost::current, boost::xpressive::first, boost::last, boost::xpressive::make_pair, and boost::expressions::reverse.

template<typename BidirectionalIterator >
BidirectionalIterator boost::mpi::test_some ( BidirectionalIterator  first,
BidirectionalIterator  last 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::current, boost::xpressive::first, and boost::last.

std::pair<counting_iterator<int>, counting_iterator<int> > boost::mpi::vertices ( const graph_communicator &  comm)
inline

Returns an iterator range that contains all of the vertices with the communicator's graph topology, i.e., all of the process ranks in the communicator.

References boost::xpressive::make_pair, and boost::mpi::communicator::size().

template<typename ForwardIterator , typename OutputIterator >
OutputIterator boost::mpi::wait_all ( ForwardIterator  first,
ForwardIterator  last,
OutputIterator  out 
)

Wait until all non-blocking requests have completed.

This routine takes in a set of requests stored in the iterator range [first,last) and waits until all of these requests have been completed. It provides functionality equivalent to MPI_Waitall.

Parameters
firstThe iterator that denotes the beginning of the sequence of request objects.
lastThe iterator that denotes the end of the sequence of request objects.
outIf provided, an output iterator through which the status of each request will be emitted. The status objects are emitted in the same order as the requests are retrieved from [first,last).
Returns
If an out parameter was provided, the value out after all of the status objects have been emitted.

References BOOST_MPI_CHECK_RESULT, boost::filesystem::detail::copy(), boost::current, boost::distance(), boost::fusion::distance(), boost::multiprecision::backends::i, boost::last, boost::mpi::status::m_status, and boost::out.

template<typename ForwardIterator >
void boost::mpi::wait_all ( ForwardIterator  first,
ForwardIterator  last 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References BOOST_MPI_CHECK_RESULT, boost::current, boost::distance(), boost::fusion::distance(), and boost::last.

template<typename ForwardIterator >
std::pair<status, ForwardIterator> boost::mpi::wait_any ( ForwardIterator  first,
ForwardIterator  last 
)

Wait until any non-blocking request has completed.

This routine takes in a set of requests stored in the iterator range [first,last) and waits until any of these requests has been completed. It provides functionality equivalent to MPI_Waitany.

Parameters
firstThe iterator that denotes the beginning of the sequence of request objects.
lastThe iterator that denotes the end of the sequence of request objects. This may not be equal to first.
Returns
A pair containing the status object that corresponds to the completed operation and the iterator referencing the completed request.

References boost::fusion::advance(), BOOST_ASSERT, BOOST_MPI_CHECK_RESULT, boost::current, boost::exception, boost::xpressive::first, boost::last, boost::mpi::status::m_status, boost::xpressive::make_pair, boost::n, and boost::throw_exception().

template<typename BidirectionalIterator , typename OutputIterator >
std::pair<OutputIterator, BidirectionalIterator> boost::mpi::wait_some ( BidirectionalIterator  first,
BidirectionalIterator  last,
OutputIterator  out 
)

Wait until some non-blocking requests have completed.

This routine takes in a set of requests stored in the iterator range [first,last) and waits until at least one of the requests has completed. It then completes all of the requests it can, partitioning the input sequence into pending requests followed by completed requests. If an output iterator is provided, status objects will be emitted for each of the completed requests. This routine provides functionality equivalent to MPI_Waitsome.

Parameters
firstThe iterator that denotes the beginning of the sequence of request objects.
lastThe iterator that denotes the end of the sequence of request objects. This may not be equal to first.
outIf provided, the status objects corresponding to completed requests will be emitted through this output iterator.
Returns
If the out parameter was provided, a pair containing the output iterator out after all of the status objects have been written through it and an iterator referencing the first completed request. If no out parameter was provided, only the iterator referencing the first completed request will be emitted.

References boost::fusion::advance(), BOOST_ASSERT, BOOST_MPI_CHECK_RESULT, boost::current, boost::xpressive::first, boost::last, boost::mpi::status::m_status, boost::xpressive::make_pair, boost::n, boost::out, and boost::expressions::reverse.

template<typename BidirectionalIterator >
BidirectionalIterator boost::mpi::wait_some ( BidirectionalIterator  first,
BidirectionalIterator  last 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::fusion::advance(), BOOST_ASSERT, BOOST_MPI_CHECK_RESULT, boost::current, boost::xpressive::first, boost::last, and boost::n.

Variable Documentation

const int boost::mpi::any_source = MPI_ANY_SOURCE

A constant representing "any process.".

This constant may be used for the source parameter of receive operations to indicate that a message may be received from any source.

const int boost::mpi::any_tag = MPI_ANY_TAG

A constant representing "any tag.".

This constant may be used for the tag parameter of receive operations to indicate that a send with any tag will be matched by the receive.