| // Copyright (C) 2005, 2006 Douglas Gregor <doug.gregor -at- gmail.com>. |
| |
| // Use, modification and distribution is subject to the Boost Software |
| // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at |
| // http://www.boost.org/LICENSE_1_0.txt) |
| |
| /** @file communicator.hpp |
| * |
| * This header defines the @c communicator class, which is the basis |
| * of all communication within Boost.MPI, and provides point-to-point |
| * communication operations. |
| */ |
| #ifndef BOOST_MPI_COMMUNICATOR_HPP |
| #define BOOST_MPI_COMMUNICATOR_HPP |
| |
| #include <boost/mpi/config.hpp> |
| #include <boost/mpi/exception.hpp> |
| #include <boost/optional.hpp> |
| #include <boost/shared_ptr.hpp> |
| #include <boost/mpi/datatype.hpp> |
| #include <utility> |
| #include <iterator> |
| #include <stdexcept> // for std::range_error |
| |
| // For (de-)serializing sends and receives |
| #include <boost/mpi/packed_oarchive.hpp> |
| #include <boost/mpi/packed_iarchive.hpp> |
| |
| // For (de-)serializing skeletons and content |
| #include <boost/mpi/skeleton_and_content_fwd.hpp> |
| |
| // For (de-)serializing arrays |
| #include <boost/serialization/array.hpp> |
| |
| #include <boost/mpi/detail/point_to_point.hpp> |
| #include <boost/mpi/status.hpp> |
| #include <boost/mpi/request.hpp> |
| |
| #ifdef BOOST_MSVC |
| # pragma warning(push) |
| # pragma warning(disable : 4800) // forcing to bool 'true' or 'false' |
| #endif |
| |
| namespace boost { namespace mpi { |
| |
| /** |
| * @brief A constant representing "any process." |
| * |
| * This constant may be used for the @c source parameter of @c receive |
| * operations to indicate that a message may be received from any |
| * source. |
| */ |
| const int any_source = MPI_ANY_SOURCE; |
| |
| /** |
| * @brief A constant representing "any tag." |
| * |
| * This constant may be used for the @c tag parameter of @c receive |
| * operations to indicate that a @c send with any tag will be matched |
| * by the receive. |
| */ |
| const int any_tag = MPI_ANY_TAG; |
| |
| /** |
| * @brief Enumeration used to describe how to adopt a C @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: |
| * |
| * - @c 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. |
| * |
| * - @c 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. |
| * |
| * - @c 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). |
| */ |
| enum comm_create_kind { comm_duplicate, comm_take_ownership, comm_attach }; |
| |
| /** |
| * INTERNAL ONLY |
| * |
| * Forward declaration of @c group needed for the @c group |
| * constructor and accessor. |
| */ |
| class group; |
| |
| /** |
| * INTERNAL ONLY |
| * |
| * Forward declaration of @c intercommunicator needed for the "cast" |
| * from a communicator to an intercommunicator. |
| */ |
| class intercommunicator; |
| |
| /** |
| * INTERNAL ONLY |
| * |
| * Forward declaration of @c graph_communicator needed for the "cast" |
| * from a communicator to a graph communicator. |
| */ |
| class graph_communicator; |
| |
| /** |
| * @brief A communicator that permits communication and |
| * synchronization among a set of processes. |
| * |
| * The @c communicator class abstracts a set of communicating |
| * processes in MPI. All of the processes that belong to a certain |
| * communicator can determine the size of the communicator, their rank |
| * within the communicator, and communicate with any other processes |
| * in the communicator. |
| */ |
| class BOOST_MPI_DECL communicator |
| { |
| public: |
| /** |
| * Build a new Boost.MPI communicator for @c MPI_COMM_WORLD. |
| * |
| * Constructs a Boost.MPI communicator that attaches to @c |
| * MPI_COMM_WORLD. This is the equivalent of constructing with |
| * @c (MPI_COMM_WORLD, comm_attach). |
| */ |
| communicator(); |
| |
| /** |
| * Build a new Boost.MPI communicator based on the MPI communicator |
| * @p comm. |
| * |
| * @p comm may be any valid MPI communicator. If @p comm is |
| * MPI_COMM_NULL, an empty communicator (that cannot be used for |
| * communication) is created and the @p kind parameter is |
| * ignored. Otherwise, the @p kind parameters determines how the |
| * Boost.MPI communicator will be related to @p comm: |
| * |
| * - If @p kind is @c comm_duplicate, duplicate @c comm to create |
| * a new communicator. This new communicator will be freed when |
| * the Boost.MPI communicator (and all copies of it) is destroyed. |
| * This option is only permitted if @p comm is a valid MPI |
| * intracommunicator or if the underlying MPI implementation |
| * supports MPI 2.0 (which supports duplication of |
| * intercommunicators). |
| * |
| * - If @p kind is @c comm_take_ownership, take ownership of @c |
| * comm. It will be freed automatically when all of the Boost.MPI |
| * communicators go out of scope. This option must not be used |
| * when @c comm is MPI_COMM_WORLD. |
| * |
| * - If @p kind is @c comm_attach, this Boost.MPI communicator |
| * will reference the existing MPI communicator @p comm but will |
| * not free @p comm 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). |
| */ |
| communicator(const MPI_Comm& comm, comm_create_kind kind); |
| |
| /** |
| * Build a new Boost.MPI communicator based on a subgroup of another |
| * MPI communicator. |
| * |
| * This routine will construct a new communicator containing all of |
| * the processes from communicator @c comm that are listed within |
| * the group @c subgroup. Equivalent to @c MPI_Comm_create. |
| * |
| * @param comm An MPI communicator. |
| * |
| * @param subgroup A subgroup of the MPI communicator, @p comm, for |
| * which we will construct a new communicator. |
| */ |
| communicator(const communicator& comm, const boost::mpi::group& subgroup); |
| |
| /** |
| * @brief Determine the rank of the executing process in a |
| * communicator. |
| * |
| * This routine is equivalent to @c MPI_Comm_rank. |
| * |
| * @returns The rank of the process in the communicator, which |
| * will be a value in [0, size()) |
| */ |
| int rank() const; |
| |
| /** |
| * @brief Determine the number of processes in a communicator. |
| * |
| * This routine is equivalent to @c MPI_Comm_size. |
| * |
| * @returns The number of processes in the communicator. |
| */ |
| int size() const; |
| |
| /** |
| * This routine constructs a new group whose members are the |
| * processes within this communicator. Equivalent to |
| * calling @c MPI_Comm_group. |
| */ |
| boost::mpi::group group() const; |
| |
| // ---------------------------------------------------------------- |
| // Point-to-point communication |
| // ---------------------------------------------------------------- |
| |
| /** |
| * @brief Send data to another process. |
| * |
| * This routine executes a potentially blocking send with tag @p tag |
| * to the process with rank @p dest. It can be received by the |
| * destination process with a matching @c recv call. |
| * |
| * The given @p value must be suitable for transmission over |
| * MPI. There are several classes of types that meet these |
| * requirements: |
| * |
| * - Types with mappings to MPI data types: If @c |
| * is_mpi_datatype<T> is convertible to @c mpl::true_, then @p |
| * value will be transmitted using the MPI data type |
| * @c get_mpi_datatype<T>(). All primitive C++ data types that have |
| * MPI equivalents, e.g., @c int, @c float, @c char, @c double, |
| * etc., have built-in mappings to MPI data types. You may turn a |
| * Serializable type with fixed structure into an MPI data type by |
| * specializing @c is_mpi_datatype for your type. |
| * |
| * - Serializable types: Any type that provides the @c serialize() |
| * functionality required by the Boost.Serialization library can be |
| * transmitted and received. |
| * |
| * - Packed archives and skeletons: Data that has been packed into |
| * an @c mpi::packed_oarchive or the skeletons of data that have |
| * been backed into an @c mpi::packed_skeleton_oarchive can be |
| * transmitted, but will be received as @c mpi::packed_iarchive and |
| * @c mpi::packed_skeleton_iarchive, respectively, to allow the |
| * values (or skeletons) to be extracted by the destination process. |
| * |
| * - Content: Content associated with a previously-transmitted |
| * skeleton can be transmitted by @c send and received by @c |
| * recv. The receiving process may only receive content into the |
| * content of a value that has been constructed with the matching |
| * skeleton. |
| * |
| * For types that have mappings to an MPI data type (including the |
| * concent of a type), an invocation of this routine will result in |
| * a single MPI_Send call. For variable-length data, e.g., |
| * serialized types and packed archives, two messages will be sent |
| * via MPI_Send: one containing the length of the data and the |
| * second containing the data itself. Note that the transmission |
| * mode for variable-length data is an implementation detail that |
| * is subject to change. |
| * |
| * @param dest The rank of the remote process to which the data |
| * will be sent. |
| * |
| * @param tag The tag that will be associated with this message. Tags |
| * may be any integer between zero and an implementation-defined |
| * upper limit. This limit is accessible via @c environment::max_tag(). |
| * |
| * @param value The value that will be transmitted to the |
| * receiver. The type @c T of this value must meet the aforementioned |
| * criteria for transmission. |
| */ |
| template<typename T> |
| void send(int dest, int tag, const T& value) const; |
| |
| /** |
| * @brief Send the skeleton of an object. |
| * |
| * This routine executes a potentially blocking send with tag @p |
| * tag to the process with rank @p dest. It can be received by the |
| * destination process with a matching @c recv call. This variation |
| * on @c send will be used when a send of a skeleton is explicitly |
| * requested via code such as: |
| * |
| * @code |
| * comm.send(dest, tag, skeleton(object)); |
| * @endcode |
| * |
| * The semantics of this routine are equivalent to that of sending |
| * a @c packed_skeleton_oarchive storing the skeleton of the @c |
| * object. |
| * |
| * @param dest The rank of the remote process to which the skeleton |
| * will be sent. |
| * |
| * @param tag The tag that will be associated with this message. Tags |
| * may be any integer between zero and an implementation-defined |
| * upper limit. This limit is accessible via @c environment::max_tag(). |
| * |
| * @param proxy The @c skeleton_proxy containing a reference to the |
| * object whose skeleton will be transmitted. |
| * |
| */ |
| template<typename T> |
| void send(int dest, int tag, const skeleton_proxy<T>& proxy) const; |
| |
| /** |
| * @brief Send an array of values to another process. |
| * |
| * This routine executes a potentially blocking send of an array of |
| * data with tag @p tag to the process with rank @p dest. It can be |
| * received by the destination process with a matching array @c |
| * recv call. |
| * |
| * If @c T is an MPI datatype, an invocation of this routine will |
| * be mapped to a single call to MPI_Send, using the datatype @c |
| * get_mpi_datatype<T>(). |
| * |
| * @param dest The process rank of the remote process to which |
| * the data will be sent. |
| * |
| * @param tag The tag that will be associated with this message. Tags |
| * may be any integer between zero and an implementation-defined |
| * upper limit. This limit is accessible via @c environment::max_tag(). |
| * |
| * @param values The array of values that will be transmitted to the |
| * receiver. The type @c T of these values must be mapped to an MPI |
| * data type. |
| * |
| * @param n The number of values stored in the array. The destination |
| * process must call receive with at least this many elements to |
| * correctly receive the message. |
| */ |
| template<typename T> |
| void send(int dest, int tag, const T* values, int n) const; |
| |
| /** |
| * @brief Send a message to another process without any data. |
| * |
| * This routine executes a potentially blocking send of a message |
| * to another process. The message contains no extra data, and can |
| * therefore only be received by a matching call to @c recv(). |
| * |
| * @param dest The process rank of the remote process to which |
| * the message will be sent. |
| * |
| * @param tag The tag that will be associated with this message. Tags |
| * may be any integer between zero and an implementation-defined |
| * upper limit. This limit is accessible via @c environment::max_tag(). |
| * |
| */ |
| void send(int dest, int tag) const; |
| |
| /** |
| * @brief Receive data from a remote process. |
| * |
| * This routine blocks until it receives a message from the process @p |
| * source with the given @p tag. The type @c T of the @p value must be |
| * suitable for transmission over MPI, which includes serializable |
| * types, types that can be mapped to MPI data types (including most |
| * built-in C++ types), packed MPI archives, skeletons, and content |
| * associated with skeletons; see the documentation of @c send for a |
| * complete description. |
| * |
| * @param source The process that will be sending data. This will |
| * either be a process rank within the communicator or the |
| * constant @c any_source, indicating that we can receive the |
| * message from any process. |
| * |
| * @param tag The tag that matches a particular kind of message sent |
| * by the source process. This may be any tag value permitted by @c |
| * send. Alternatively, the argument may be the constant @c any_tag, |
| * indicating that this receive matches a message with any tag. |
| * |
| * @param value Will contain the value of the message after a |
| * successful receive. The type of this value must match the value |
| * transmitted by the sender, unless the sender transmitted a packed |
| * archive or skeleton: in these cases, the sender transmits a @c |
| * packed_oarchive or @c packed_skeleton_oarchive and the |
| * destination receives a @c packed_iarchive or @c |
| * packed_skeleton_iarchive, respectively. |
| * |
| * @returns Information about the received message. |
| */ |
| template<typename T> |
| status recv(int source, int tag, T& value) const; |
| |
| /** |
| * @brief Receive a skeleton from a remote process. |
| * |
| * This routine blocks until it receives a message from the process @p |
| * source with the given @p tag containing a skeleton. |
| * |
| * @param source The process that will be sending data. This will |
| * either be a process rank within the communicator or the constant |
| * @c any_source, indicating that we can receive the message from |
| * any process. |
| * |
| * @param tag The tag that matches a particular kind of message |
| * sent by the source process. This may be any tag value permitted |
| * by @c send. Alternatively, the argument may be the constant @c |
| * any_tag, indicating that this receive matches a message with any |
| * tag. |
| * |
| * @param proxy The @c skeleton_proxy containing a reference to the |
| * object that will be reshaped to match the received skeleton. |
| * |
| * @returns Information about the received message. |
| */ |
| template<typename T> |
| status recv(int source, int tag, const skeleton_proxy<T>& proxy) const; |
| |
| /** |
| * @brief Receive a skeleton from a remote process. |
| * |
| * This routine blocks until it receives a message from the process @p |
| * source with the given @p tag containing a skeleton. |
| * |
| * @param source The process that will be sending data. This will |
| * either be a process rank within the communicator or the constant |
| * @c any_source, indicating that we can receive the message from |
| * any process. |
| * |
| * @param tag The tag that matches a particular kind of message |
| * sent by the source process. This may be any tag value permitted |
| * by @c send. Alternatively, the argument may be the constant @c |
| * any_tag, indicating that this receive matches a message with any |
| * tag. |
| * |
| * @param proxy The @c skeleton_proxy containing a reference to the |
| * object that will be reshaped to match the received skeleton. |
| * |
| * @returns Information about the received message. |
| */ |
| template<typename T> |
| status recv(int source, int tag, skeleton_proxy<T>& proxy) const; |
| |
| /** |
| * @brief Receive an array of values from a remote process. |
| * |
| * This routine blocks until it receives an array of values from the |
| * process @p source with the given @p tag. If the type @c T is |
| * |
| * @param source The process that will be sending data. This will |
| * either be a process rank within the communicator or the |
| * constant @c any_source, indicating that we can receive the |
| * message from any process. |
| * |
| * @param tag The tag that matches a particular kind of message sent |
| * by the source process. This may be any tag value permitted by @c |
| * send. Alternatively, the argument may be the constant @c any_tag, |
| * indicating that this receive matches a message with any tag. |
| * |
| * @param values Will contain the values in the message after a |
| * successful receive. The type of these elements must match the |
| * type of the elements transmitted by the sender. |
| * |
| * @param n The number of values that can be stored into the @p |
| * values array. This shall not be smaller than the number of |
| * elements transmitted by the sender. |
| * |
| * @throws std::range_error if the message to be received contains |
| * more than @p n values. |
| * |
| * @returns Information about the received message. |
| */ |
| template<typename T> |
| status recv(int source, int tag, T* values, int n) const; |
| |
| /** |
| * @brief Receive a message from a remote process without any data. |
| * |
| * This routine blocks until it receives a message from the process |
| * @p source with the given @p tag. |
| * |
| * @param source The process that will be sending the message. This |
| * will either be a process rank within the communicator or the |
| * constant @c any_source, indicating that we can receive the |
| * message from any process. |
| * |
| * @param tag The tag that matches a particular kind of message |
| * sent by the source process. This may be any tag value permitted |
| * by @c send. Alternatively, the argument may be the constant @c |
| * any_tag, indicating that this receive matches a message with any |
| * tag. |
| * |
| * @returns Information about the received message. |
| */ |
| status recv(int source, int tag) const; |
| |
| /** |
| * @brief Send a message to a remote process without blocking. |
| * |
| * The @c isend method is functionality identical to the @c send |
| * method and transmits data in the same way, except that @c isend |
| * will not block while waiting for the data to be |
| * transmitted. Instead, a request object will be immediately |
| * returned, allowing one to query the status of the communication |
| * or wait until it has completed. |
| * |
| * @param dest The rank of the remote process to which the data |
| * will be sent. |
| * |
| * @param tag The tag that will be associated with this message. Tags |
| * may be any integer between zero and an implementation-defined |
| * upper limit. This limit is accessible via @c environment::max_tag(). |
| * |
| * @param value The value that will be transmitted to the |
| * receiver. The type @c T of this value must meet the aforementioned |
| * criteria for transmission. |
| * |
| * @returns a @c request object that describes this communication. |
| */ |
| template<typename T> |
| request isend(int dest, int tag, const T& value) const; |
| |
| /** |
| * @brief Send the skeleton of an object without blocking. |
| * |
| * This routine is functionally identical to the @c send method for |
| * @c skeleton_proxy objects except that @c isend will not block |
| * while waiting for the data to be transmitted. Instead, a request |
| * object will be immediately returned, allowing one to query the |
| * status of the communication or wait until it has completed. |
| * |
| * The semantics of this routine are equivalent to a non-blocking |
| * send of a @c packed_skeleton_oarchive storing the skeleton of |
| * the @c object. |
| * |
| * @param dest The rank of the remote process to which the skeleton |
| * will be sent. |
| * |
| * @param tag The tag that will be associated with this message. Tags |
| * may be any integer between zero and an implementation-defined |
| * upper limit. This limit is accessible via @c environment::max_tag(). |
| * |
| * @param proxy The @c skeleton_proxy containing a reference to the |
| * object whose skeleton will be transmitted. |
| * |
| * @returns a @c request object that describes this communication. |
| */ |
| template<typename T> |
| request isend(int dest, int tag, const skeleton_proxy<T>& proxy) const; |
| |
| /** |
| * @brief Send an array of values to another process without |
| * blocking. |
| * |
| * This routine is functionally identical to the @c send method for |
| * arrays except that @c isend will not block while waiting for the |
| * data to be transmitted. Instead, a request object will be |
| * immediately returned, allowing one to query the status of the |
| * communication or wait until it has completed. |
| * |
| * @param dest The process rank of the remote process to which |
| * the data will be sent. |
| * |
| * @param tag The tag that will be associated with this message. Tags |
| * may be any integer between zero and an implementation-defined |
| * upper limit. This limit is accessible via @c environment::max_tag(). |
| * |
| * @param values The array of values that will be transmitted to the |
| * receiver. The type @c T of these values must be mapped to an MPI |
| * data type. |
| * |
| * @param n The number of values stored in the array. The destination |
| * process must call receive with at least this many elements to |
| * correctly receive the message. |
| * |
| * @returns a @c request object that describes this communication. |
| */ |
| template<typename T> |
| request isend(int dest, int tag, const T* values, int n) const; |
| |
| /** |
| * @brief Send a message to another process without any data |
| * without blocking. |
| * |
| * This routine is functionally identical to the @c send method for |
| * sends with no data, except that @c isend will not block while |
| * waiting for the message to be transmitted. Instead, a request |
| * object will be immediately returned, allowing one to query the |
| * status of the communication or wait until it has completed. |
| * |
| * @param dest The process rank of the remote process to which |
| * the message will be sent. |
| * |
| * @param tag The tag that will be associated with this message. Tags |
| * may be any integer between zero and an implementation-defined |
| * upper limit. This limit is accessible via @c environment::max_tag(). |
| * |
| * |
| * @returns a @c request object that describes this communication. |
| */ |
| request isend(int dest, int tag) const; |
| |
| /** |
| * @brief Prepare to receive a message from a remote process. |
| * |
| * The @c irecv method is functionally identical to the @c recv |
| * method and receive data in the same way, except that @c irecv |
| * will not block while waiting for data to be |
| * transmitted. Instead, it immediately returns a request object |
| * that allows one to query the status of the receive or wait until |
| * it has completed. |
| * |
| * @param source The process that will be sending data. This will |
| * either be a process rank within the communicator or the |
| * constant @c any_source, indicating that we can receive the |
| * message from any process. |
| * |
| * @param tag The tag that matches a particular kind of message sent |
| * by the source process. This may be any tag value permitted by @c |
| * send. Alternatively, the argument may be the constant @c any_tag, |
| * indicating that this receive matches a message with any tag. |
| * |
| * @param value Will contain the value of the message after a |
| * successful receive. The type of this value must match the value |
| * transmitted by the sender, unless the sender transmitted a packed |
| * archive or skeleton: in these cases, the sender transmits a @c |
| * packed_oarchive or @c packed_skeleton_oarchive and the |
| * destination receives a @c packed_iarchive or @c |
| * packed_skeleton_iarchive, respectively. |
| * |
| * @returns a @c request object that describes this communication. |
| */ |
| template<typename T> |
| request irecv(int source, int tag, T& value) const; |
| |
| /** |
| * @brief Initiate receipt of an array of values from a remote process. |
| * |
| * This routine initiates a receive operation for an array of values |
| * transmitted by process @p source with the given @p tag. |
| * |
| * @param source The process that will be sending data. This will |
| * either be a process rank within the communicator or the |
| * constant @c any_source, indicating that we can receive the |
| * message from any process. |
| * |
| * @param tag The tag that matches a particular kind of message sent |
| * by the source process. This may be any tag value permitted by @c |
| * send. Alternatively, the argument may be the constant @c any_tag, |
| * indicating that this receive matches a message with any tag. |
| * |
| * @param values Will contain the values in the message after a |
| * successful receive. The type of these elements must match the |
| * type of the elements transmitted by the sender. |
| * |
| * @param n The number of values that can be stored into the @p |
| * values array. This shall not be smaller than the number of |
| * elements transmitted by the sender. |
| * |
| * @returns a @c request object that describes this communication. |
| */ |
| template<typename T> |
| request irecv(int source, int tag, T* values, int n) const; |
| |
| /** |
| * @brief Initiate receipt of a message from a remote process that |
| * carries no data. |
| * |
| * This routine initiates a receive operation for a message from |
| * process @p source with the given @p tag that carries no data. |
| * |
| * @param source The process that will be sending the message. This |
| * will either be a process rank within the communicator or the |
| * constant @c any_source, indicating that we can receive the |
| * message from any process. |
| * |
| * @param tag The tag that matches a particular kind of message |
| * sent by the source process. This may be any tag value permitted |
| * by @c send. Alternatively, the argument may be the constant @c |
| * any_tag, indicating that this receive matches a message with any |
| * tag. |
| * |
| * @returns a @c request object that describes this communication. |
| */ |
| request irecv(int source, int tag) const; |
| |
| /** |
| * @brief Waits until a message is available to be received. |
| * |
| * This operation waits until a message matching (@p source, @p tag) |
| * is available to be received. It then returns information about |
| * that message. The functionality is equivalent to @c MPI_Probe. To |
| * check if a message is available without blocking, use @c iprobe. |
| * |
| * @param source Determine if there is a message available from |
| * this rank. If @c any_source, then the message returned may come |
| * from any source. |
| * |
| * @param tag Determine if there is a message available with the |
| * given tag. If @c any_tag, then the message returned may have any |
| * tag. |
| * |
| * @returns Returns information about the first message that |
| * matches the given criteria. |
| */ |
| status probe(int source = any_source, int tag = any_tag) const; |
| |
| /** |
| * @brief Determine if a message is available to be received. |
| * |
| * This operation determines if a message matching (@p source, @p |
| * tag) is available to be received. If so, it returns information |
| * about that message; otherwise, it returns immediately with an |
| * empty optional. The functionality is equivalent to @c |
| * MPI_Iprobe. To wait until a message is available, use @c wait. |
| * |
| * @param source Determine if there is a message available from |
| * this rank. If @c any_source, then the message returned may come |
| * from any source. |
| * |
| * @param tag Determine if there is a message available with the |
| * given tag. If @c any_tag, then the message returned may have any |
| * tag. |
| * |
| * @returns If a matching message is available, returns |
| * information about that message. Otherwise, returns an empty |
| * @c boost::optional. |
| */ |
| optional<status> |
| iprobe(int source = any_source, int tag = any_tag) const; |
| |
| #ifdef barrier |
| // Linux defines a function-like macro named "barrier". So, we need |
| // to avoid expanding the macro when we define our barrier() |
| // function. However, some C++ parsers (Doxygen, for instance) can't |
| // handle this syntax, so we only use it when necessary. |
| void (barrier)() const; |
| #else |
| /** |
| * @brief Wait for all processes within a communicator to reach the |
| * barrier. |
| * |
| * This routine is a collective operation that blocks each process |
| * until all processes have entered it, then releases all of the |
| * processes "simultaneously". It is equivalent to @c MPI_Barrier. |
| */ |
| void barrier() const; |
| #endif |
| |
| /** @brief Determine if this communicator is valid for |
| * communication. |
| * |
| * Evaluates @c true in a boolean context if this communicator is |
| * valid for communication, i.e., does not represent |
| * MPI_COMM_NULL. Otherwise, evaluates @c false. |
| */ |
| operator bool() const { return (bool)comm_ptr; } |
| |
| /** |
| * @brief Access the MPI communicator associated with a Boost.MPI |
| * communicator. |
| * |
| * This routine permits the implicit conversion from a Boost.MPI |
| * communicator to an MPI communicator. |
| * |
| * @returns The associated MPI communicator. |
| */ |
| operator MPI_Comm() const; |
| |
| /** |
| * Split the communicator into multiple, disjoint communicators |
| * each of which is based on a particular color. This is a |
| * collective operation that returns a new communicator that is a |
| * subgroup of @p this. This routine is functionally equivalent to |
| * @c MPI_Comm_split. |
| * |
| * @param color The color of this process. All processes with the |
| * same @p color value will be placed into the same group. |
| * |
| * @returns A new communicator containing all of the processes in |
| * @p this that have the same @p color. |
| */ |
| communicator split(int color) const; |
| |
| /** |
| * Split the communicator into multiple, disjoint communicators |
| * each of which is based on a particular color. This is a |
| * collective operation that returns a new communicator that is a |
| * subgroup of @p this. This routine is functionally equivalent to |
| * @c MPI_Comm_split. |
| * |
| * @param color The color of this process. All processes with the |
| * same @p color value will be placed into the same group. |
| * |
| * @param key A key value that will be used to determine the |
| * ordering of processes with the same color in the resulting |
| * communicator. If omitted, the rank of the processes in @p this |
| * will determine the ordering of processes in the resulting |
| * group. |
| * |
| * @returns A new communicator containing all of the processes in |
| * @p this that have the same @p color. |
| */ |
| communicator split(int color, int key) const; |
| |
| /** |
| * Determine if the communicator is in fact an intercommunicator |
| * and, if so, return that intercommunicator. |
| * |
| * @returns an @c optional containing the intercommunicator, if this |
| * communicator is in fact an intercommunicator. Otherwise, returns |
| * an empty @c optional. |
| */ |
| optional<intercommunicator> as_intercommunicator() const; |
| |
| /** |
| * Determine if the communicator has a graph topology and, if so, |
| * return that @c graph_communicator. Even though the communicators |
| * have different types, they refer to the same underlying |
| * communication space and can be used interchangeably for |
| * communication. |
| * |
| * @returns an @c optional containing the graph communicator, if this |
| * communicator does in fact have a graph topology. Otherwise, returns |
| * an empty @c optional. |
| */ |
| optional<graph_communicator> as_graph_communicator() const; |
| |
| /** |
| * Determines whether this communicator has a Cartesian topology. |
| */ |
| bool has_cartesian_topology() const; |
| |
| #if 0 |
| template<typename Extents> |
| communicator |
| with_cartesian_topology(const Extents& extents, |
| bool periodic = false, |
| bool reorder = false) const; |
| |
| template<typename DimInputIterator, typename PeriodicInputIterator> |
| communicator |
| with_cartesian_topology(DimInputIterator first_dim, |
| DimInputIterator last_dim, |
| PeriodicInputIterator first_periodic, |
| bool reorder = false); |
| |
| template<typename Allocator, std::size_t NumDims> |
| communicator |
| with_cartesian_topology(const multi_array<bool, NumDims, Allocator>& periods, |
| bool reorder = false); |
| #endif |
| |
| /** Abort all tasks in the group of this communicator. |
| * |
| * Makes a "best attempt" to abort all of the tasks in the group of |
| * this communicator. Depending on the underlying MPI |
| * implementation, this may either abort the entire program (and |
| * possibly return @p errcode to the environment) or only abort |
| * some processes, allowing the others to continue. Consult the |
| * documentation for your MPI implementation. This is equivalent to |
| * a call to @c MPI_Abort |
| * |
| * @param errcode The error code to return from aborted processes. |
| * @returns Will not return. |
| */ |
| void abort(int errcode) const; |
| |
| protected: |
| /** |
| * INTERNAL ONLY |
| * |
| * Function object that frees an MPI communicator and deletes the |
| * memory associated with it. Intended to be used as a deleter with |
| * shared_ptr. |
| */ |
| struct comm_free |
| { |
| void operator()(MPI_Comm* comm) const |
| { |
| int finalized; |
| BOOST_MPI_CHECK_RESULT(MPI_Finalized, (&finalized)); |
| if (!finalized) |
| BOOST_MPI_CHECK_RESULT(MPI_Comm_free, (comm)); |
| delete comm; |
| } |
| }; |
| |
| |
| /** |
| * INTERNAL ONLY |
| * |
| * We're sending a type that has an associated MPI datatype, so we |
| * map directly to that datatype. |
| */ |
| template<typename T> |
| void send_impl(int dest, int tag, const T& value, mpl::true_) const; |
| |
| /** |
| * INTERNAL ONLY |
| * |
| * We're sending a type that does not have an associated MPI |
| * datatype, so it must be serialized then sent as MPI_PACKED data, |
| * to be deserialized on the receiver side. |
| */ |
| template<typename T> |
| void send_impl(int dest, int tag, const T& value, mpl::false_) const; |
| |
| /** |
| * INTERNAL ONLY |
| * |
| * We're sending an array of a type that has an associated MPI |
| * datatype, so we map directly to that datatype. |
| */ |
| template<typename T> |
| void |
| array_send_impl(int dest, int tag, const T* values, int n, mpl::true_) const; |
| |
| /** |
| * INTERNAL ONLY |
| * |
| * We're sending an array of a type that does not have an associated |
| * MPI datatype, so it must be serialized then sent as MPI_PACKED |
| * data, to be deserialized on the receiver side. |
| */ |
| template<typename T> |
| void |
| array_send_impl(int dest, int tag, const T* values, int n, |
| mpl::false_) const; |
| |
| /** |
| * INTERNAL ONLY |
| * |
| * We're sending a type that has an associated MPI datatype, so we |
| * map directly to that datatype. |
| */ |
| template<typename T> |
| request isend_impl(int dest, int tag, const T& value, mpl::true_) const; |
| |
| /** |
| * INTERNAL ONLY |
| * |
| * We're sending a type that does not have an associated MPI |
| * datatype, so it must be serialized then sent as MPI_PACKED data, |
| * to be deserialized on the receiver side. |
| */ |
| template<typename T> |
| request isend_impl(int dest, int tag, const T& value, mpl::false_) const; |
| |
| /** |
| * INTERNAL ONLY |
| * |
| * We're sending an array of a type that has an associated MPI |
| * datatype, so we map directly to that datatype. |
| */ |
| template<typename T> |
| request |
| array_isend_impl(int dest, int tag, const T* values, int n, |
| mpl::true_) const; |
| |
| /** |
| * INTERNAL ONLY |
| * |
| * We're sending an array of a type that does not have an associated |
| * MPI datatype, so it must be serialized then sent as MPI_PACKED |
| * data, to be deserialized on the receiver side. |
| */ |
| template<typename T> |
| request |
| array_isend_impl(int dest, int tag, const T* values, int n, |
| mpl::false_) const; |
| |
| /** |
| * INTERNAL ONLY |
| * |
| * We're receiving a type that has an associated MPI datatype, so we |
| * map directly to that datatype. |
| */ |
| template<typename T> |
| status recv_impl(int source, int tag, T& value, mpl::true_) const; |
| |
| /** |
| * INTERNAL ONLY |
| * |
| * We're receiving a type that does not have an associated MPI |
| * datatype, so it must have been serialized then sent as |
| * MPI_PACKED. We'll receive it and then deserialize. |
| */ |
| template<typename T> |
| status recv_impl(int source, int tag, T& value, mpl::false_) const; |
| |
| /** |
| * INTERNAL ONLY |
| * |
| * We're receiving an array of a type that has an associated MPI |
| * datatype, so we map directly to that datatype. |
| */ |
| template<typename T> |
| status |
| array_recv_impl(int source, int tag, T* values, int n, mpl::true_) const; |
| |
| /** |
| * INTERNAL ONLY |
| * |
| * We're receiving a type that does not have an associated MPI |
| * datatype, so it must have been serialized then sent as |
| * MPI_PACKED. We'll receive it and then deserialize. |
| */ |
| template<typename T> |
| status |
| array_recv_impl(int source, int tag, T* values, int n, mpl::false_) const; |
| |
| /** |
| * INTERNAL ONLY |
| * |
| * We're receiving a type that has an associated MPI datatype, so we |
| * map directly to that datatype. |
| */ |
| template<typename T> |
| request irecv_impl(int source, int tag, T& value, mpl::true_) const; |
| |
| /** |
| * INTERNAL ONLY |
| * |
| * We're receiving a type that does not have an associated MPI |
| * datatype, so it must have been serialized then sent as |
| * MPI_PACKED. We'll receive it and then deserialize. |
| */ |
| template<typename T> |
| request irecv_impl(int source, int tag, T& value, mpl::false_) const; |
| |
| /** |
| * INTERNAL ONLY |
| * |
| * We're receiving a type that has an associated MPI datatype, so we |
| * map directly to that datatype. |
| */ |
| template<typename T> |
| request |
| array_irecv_impl(int source, int tag, T* values, int n, mpl::true_) const; |
| |
| /** |
| * INTERNAL ONLY |
| * |
| * We're receiving a type that does not have an associated MPI |
| * datatype, so it must have been serialized then sent as |
| * MPI_PACKED. We'll receive it and then deserialize. |
| */ |
| template<typename T> |
| request |
| array_irecv_impl(int source, int tag, T* values, int n, mpl::false_) const; |
| |
| shared_ptr<MPI_Comm> comm_ptr; |
| }; |
| |
| /** |
| * @brief Determines whether two communicators are identical. |
| * |
| * Equivalent to calling @c MPI_Comm_compare and checking whether the |
| * result is @c MPI_IDENT. |
| * |
| * @returns True when the two communicators refer to the same |
| * underlying MPI communicator. |
| */ |
| BOOST_MPI_DECL bool operator==(const communicator& comm1, const communicator& comm2); |
| |
| /** |
| * @brief Determines whether two communicators are different. |
| * |
| * @returns @c !(comm1 == comm2) |
| */ |
| inline bool operator!=(const communicator& comm1, const communicator& comm2) |
| { |
| return !(comm1 == comm2); |
| } |
| |
| |
| /************************************************************************ |
| * Implementation details * |
| ************************************************************************/ |
| // Count elements in a message |
| template<typename T> |
| inline optional<int> status::count() const |
| { |
| return count_impl<T>(is_mpi_datatype<T>()); |
| } |
| |
| template<typename T> |
| optional<int> status::count_impl(mpl::true_) const |
| { |
| if (m_count != -1) |
| return m_count; |
| |
| int return_value; |
| BOOST_MPI_CHECK_RESULT(MPI_Get_count, |
| (&m_status, get_mpi_datatype<T>(T()), &return_value)); |
| if (return_value == MPI_UNDEFINED) |
| return optional<int>(); |
| else |
| /* Cache the result. */ |
| return m_count = return_value; |
| } |
| |
| template<typename T> |
| inline optional<int> status::count_impl(mpl::false_) const |
| { |
| if (m_count == -1) |
| return optional<int>(); |
| else |
| return m_count; |
| } |
| |
| // We're sending a type that has an associated MPI datatype, so we |
| // map directly to that datatype. |
| template<typename T> |
| void |
| communicator::send_impl(int dest, int tag, const T& value, mpl::true_) const |
| { |
| BOOST_MPI_CHECK_RESULT(MPI_Send, |
| (const_cast<T*>(&value), 1, get_mpi_datatype<T>(value), |
| dest, tag, MPI_Comm(*this))); |
| } |
| |
| // We're sending a type that does not have an associated MPI |
| // datatype, so it must be serialized then sent as MPI_PACKED data, |
| // to be deserialized on the receiver side. |
| template<typename T> |
| void |
| communicator::send_impl(int dest, int tag, const T& value, mpl::false_) const |
| { |
| packed_oarchive oa(*this); |
| oa << value; |
| send(dest, tag, oa); |
| } |
| |
| // Single-element receive may either send the element directly or |
| // serialize it via a buffer. |
| template<typename T> |
| void communicator::send(int dest, int tag, const T& value) const |
| { |
| this->send_impl(dest, tag, value, is_mpi_datatype<T>()); |
| } |
| |
| // We're sending an array of a type that has an associated MPI |
| // datatype, so we map directly to that datatype. |
| template<typename T> |
| void |
| communicator::array_send_impl(int dest, int tag, const T* values, int n, |
| mpl::true_) const |
| { |
| BOOST_MPI_CHECK_RESULT(MPI_Send, |
| (const_cast<T*>(values), n, |
| get_mpi_datatype<T>(*values), |
| dest, tag, MPI_Comm(*this))); |
| } |
| |
| // We're sending an array of a type that does not have an associated |
| // MPI datatype, so it must be serialized then sent as MPI_PACKED |
| // data, to be deserialized on the receiver side. |
| template<typename T> |
| void |
| communicator::array_send_impl(int dest, int tag, const T* values, int n, |
| mpl::false_) const |
| { |
| packed_oarchive oa(*this); |
| oa << n << boost::serialization::make_array(values, n); |
| send(dest, tag, oa); |
| } |
| |
| // Array send must send the elements directly |
| template<typename T> |
| void communicator::send(int dest, int tag, const T* values, int n) const |
| { |
| this->array_send_impl(dest, tag, values, n, is_mpi_datatype<T>()); |
| } |
| |
| // We're receiving a type that has an associated MPI datatype, so we |
| // map directly to that datatype. |
| template<typename T> |
| status communicator::recv_impl(int source, int tag, T& value, mpl::true_) const |
| { |
| status stat; |
| |
| BOOST_MPI_CHECK_RESULT(MPI_Recv, |
| (const_cast<T*>(&value), 1, |
| get_mpi_datatype<T>(value), |
| source, tag, MPI_Comm(*this), &stat.m_status)); |
| return stat; |
| } |
| |
| template<typename T> |
| status |
| communicator::recv_impl(int source, int tag, T& value, mpl::false_) const |
| { |
| // Receive the message |
| packed_iarchive ia(*this); |
| status stat = recv(source, tag, ia); |
| |
| // Deserialize the data in the message |
| ia >> value; |
| |
| return stat; |
| } |
| |
| // Single-element receive may either receive the element directly or |
| // deserialize it from a buffer. |
| template<typename T> |
| status communicator::recv(int source, int tag, T& value) const |
| { |
| return this->recv_impl(source, tag, value, is_mpi_datatype<T>()); |
| } |
| |
| template<typename T> |
| status |
| communicator::array_recv_impl(int source, int tag, T* values, int n, |
| mpl::true_) const |
| { |
| status stat; |
| BOOST_MPI_CHECK_RESULT(MPI_Recv, |
| (const_cast<T*>(values), n, |
| get_mpi_datatype<T>(*values), |
| source, tag, MPI_Comm(*this), &stat.m_status)); |
| return stat; |
| } |
| |
| template<typename T> |
| status |
| communicator::array_recv_impl(int source, int tag, T* values, int n, |
| mpl::false_) const |
| { |
| // Receive the message |
| packed_iarchive ia(*this); |
| status stat = recv(source, tag, ia); |
| |
| // Determine how much data we are going to receive |
| int count; |
| ia >> count; |
| |
| // Deserialize the data in the message |
| boost::serialization::array<T> arr(values, count > n? n : count); |
| ia >> arr; |
| |
| if (count > n) { |
| boost::throw_exception( |
| std::range_error("communicator::recv: message receive overflow")); |
| } |
| |
| stat.m_count = count; |
| return stat; |
| } |
| |
| // Array receive must receive the elements directly into a buffer. |
| template<typename T> |
| status communicator::recv(int source, int tag, T* values, int n) const |
| { |
| return this->array_recv_impl(source, tag, values, n, is_mpi_datatype<T>()); |
| } |
| |
| // We're sending a type that has an associated MPI datatype, so we |
| // map directly to that datatype. |
| template<typename T> |
| request |
| communicator::isend_impl(int dest, int tag, const T& value, mpl::true_) const |
| { |
| request req; |
| BOOST_MPI_CHECK_RESULT(MPI_Isend, |
| (const_cast<T*>(&value), 1, |
| get_mpi_datatype<T>(value), |
| dest, tag, MPI_Comm(*this), &req.m_requests[0])); |
| return req; |
| } |
| |
| // We're sending a type that does not have an associated MPI |
| // datatype, so it must be serialized then sent as MPI_PACKED data, |
| // to be deserialized on the receiver side. |
| template<typename T> |
| request |
| communicator::isend_impl(int dest, int tag, const T& value, mpl::false_) const |
| { |
| shared_ptr<packed_oarchive> archive(new packed_oarchive(*this)); |
| *archive << value; |
| request result = isend(dest, tag, *archive); |
| result.m_data = archive; |
| return result; |
| } |
| |
| // Single-element receive may either send the element directly or |
| // serialize it via a buffer. |
| template<typename T> |
| request communicator::isend(int dest, int tag, const T& value) const |
| { |
| return this->isend_impl(dest, tag, value, is_mpi_datatype<T>()); |
| } |
| |
| template<typename T> |
| request |
| communicator::array_isend_impl(int dest, int tag, const T* values, int n, |
| mpl::true_) const |
| { |
| request req; |
| BOOST_MPI_CHECK_RESULT(MPI_Isend, |
| (const_cast<T*>(values), n, |
| get_mpi_datatype<T>(*values), |
| dest, tag, MPI_Comm(*this), &req.m_requests[0])); |
| return req; |
| } |
| |
| template<typename T> |
| request |
| communicator::array_isend_impl(int dest, int tag, const T* values, int n, |
| mpl::false_) const |
| { |
| shared_ptr<packed_oarchive> archive(new packed_oarchive(*this)); |
| *archive << n << boost::serialization::make_array(values, n); |
| request result = isend(dest, tag, *archive); |
| result.m_data = archive; |
| return result; |
| } |
| |
| |
| // Array isend must send the elements directly |
| template<typename T> |
| request communicator::isend(int dest, int tag, const T* values, int n) const |
| { |
| return array_isend_impl(dest, tag, values, n, is_mpi_datatype<T>()); |
| } |
| |
| namespace detail { |
| /** |
| * Internal data structure that stores everything required to manage |
| * the receipt of serialized data via a request object. |
| */ |
| template<typename T> |
| struct serialized_irecv_data |
| { |
| serialized_irecv_data(const communicator& comm, int source, int tag, |
| T& value) |
| : comm(comm), source(source), tag(tag), ia(comm), value(value) |
| { |
| } |
| |
| void deserialize(status& stat) |
| { |
| ia >> value; |
| stat.m_count = 1; |
| } |
| |
| communicator comm; |
| int source; |
| int tag; |
| std::size_t count; |
| packed_iarchive ia; |
| T& value; |
| }; |
| |
| template<> |
| struct serialized_irecv_data<packed_iarchive> |
| { |
| serialized_irecv_data(const communicator& comm, int source, int tag, |
| packed_iarchive& ia) |
| : comm(comm), source(source), tag(tag), ia(ia) { } |
| |
| void deserialize(status&) { /* Do nothing. */ } |
| |
| communicator comm; |
| int source; |
| int tag; |
| std::size_t count; |
| packed_iarchive& ia; |
| }; |
| |
| /** |
| * Internal data structure that stores everything required to manage |
| * the receipt of an array of serialized data via a request object. |
| */ |
| template<typename T> |
| struct serialized_array_irecv_data |
| { |
| serialized_array_irecv_data(const communicator& comm, int source, int tag, |
| T* values, int n) |
| : comm(comm), source(source), tag(tag), ia(comm), values(values), n(n) |
| { |
| } |
| |
| void deserialize(status& stat); |
| |
| communicator comm; |
| int source; |
| int tag; |
| std::size_t count; |
| packed_iarchive ia; |
| T* values; |
| int n; |
| }; |
| |
| template<typename T> |
| void serialized_array_irecv_data<T>::deserialize(status& stat) |
| { |
| // Determine how much data we are going to receive |
| int count; |
| ia >> count; |
| |
| // Deserialize the data in the message |
| boost::serialization::array<T> arr(values, count > n? n : count); |
| ia >> arr; |
| |
| if (count > n) { |
| boost::throw_exception( |
| std::range_error("communicator::recv: message receive overflow")); |
| } |
| |
| stat.m_count = count; |
| } |
| } |
| |
| template<typename T> |
| optional<status> |
| request::handle_serialized_irecv(request* self, request_action action) |
| { |
| typedef detail::serialized_irecv_data<T> data_t; |
| shared_ptr<data_t> data = static_pointer_cast<data_t>(self->m_data); |
| |
| if (action == ra_wait) { |
| status stat; |
| if (self->m_requests[1] == MPI_REQUEST_NULL) { |
| // Wait for the count message to complete |
| BOOST_MPI_CHECK_RESULT(MPI_Wait, |
| (self->m_requests, &stat.m_status)); |
| // Resize our buffer and get ready to receive its data |
| data->ia.resize(data->count); |
| BOOST_MPI_CHECK_RESULT(MPI_Irecv, |
| (data->ia.address(), data->ia.size(), MPI_PACKED, |
| stat.source(), stat.tag(), |
| MPI_Comm(data->comm), self->m_requests + 1)); |
| } |
| |
| // Wait until we have received the entire message |
| BOOST_MPI_CHECK_RESULT(MPI_Wait, |
| (self->m_requests + 1, &stat.m_status)); |
| |
| data->deserialize(stat); |
| return stat; |
| } else if (action == ra_test) { |
| status stat; |
| int flag = 0; |
| |
| if (self->m_requests[1] == MPI_REQUEST_NULL) { |
| // Check if the count message has completed |
| BOOST_MPI_CHECK_RESULT(MPI_Test, |
| (self->m_requests, &flag, &stat.m_status)); |
| if (flag) { |
| // Resize our buffer and get ready to receive its data |
| data->ia.resize(data->count); |
| BOOST_MPI_CHECK_RESULT(MPI_Irecv, |
| (data->ia.address(), data->ia.size(),MPI_PACKED, |
| stat.source(), stat.tag(), |
| MPI_Comm(data->comm), self->m_requests + 1)); |
| } else |
| return optional<status>(); // We have not finished yet |
| } |
| |
| // Check if we have received the message data |
| BOOST_MPI_CHECK_RESULT(MPI_Test, |
| (self->m_requests + 1, &flag, &stat.m_status)); |
| if (flag) { |
| data->deserialize(stat); |
| return stat; |
| } else |
| return optional<status>(); |
| } else { |
| return optional<status>(); |
| } |
| } |
| |
| template<typename T> |
| optional<status> |
| request::handle_serialized_array_irecv(request* self, request_action action) |
| { |
| typedef detail::serialized_array_irecv_data<T> data_t; |
| shared_ptr<data_t> data = static_pointer_cast<data_t>(self->m_data); |
| |
| if (action == ra_wait) { |
| status stat; |
| if (self->m_requests[1] == MPI_REQUEST_NULL) { |
| // Wait for the count message to complete |
| BOOST_MPI_CHECK_RESULT(MPI_Wait, |
| (self->m_requests, &stat.m_status)); |
| // Resize our buffer and get ready to receive its data |
| data->ia.resize(data->count); |
| BOOST_MPI_CHECK_RESULT(MPI_Irecv, |
| (data->ia.address(), data->ia.size(), MPI_PACKED, |
| stat.source(), stat.tag(), |
| MPI_Comm(data->comm), self->m_requests + 1)); |
| } |
| |
| // Wait until we have received the entire message |
| BOOST_MPI_CHECK_RESULT(MPI_Wait, |
| (self->m_requests + 1, &stat.m_status)); |
| |
| data->deserialize(stat); |
| return stat; |
| } else if (action == ra_test) { |
| status stat; |
| int flag = 0; |
| |
| if (self->m_requests[1] == MPI_REQUEST_NULL) { |
| // Check if the count message has completed |
| BOOST_MPI_CHECK_RESULT(MPI_Test, |
| (self->m_requests, &flag, &stat.m_status)); |
| if (flag) { |
| // Resize our buffer and get ready to receive its data |
| data->ia.resize(data->count); |
| BOOST_MPI_CHECK_RESULT(MPI_Irecv, |
| (data->ia.address(), data->ia.size(),MPI_PACKED, |
| stat.source(), stat.tag(), |
| MPI_Comm(data->comm), self->m_requests + 1)); |
| } else |
| return optional<status>(); // We have not finished yet |
| } |
| |
| // Check if we have received the message data |
| BOOST_MPI_CHECK_RESULT(MPI_Test, |
| (self->m_requests + 1, &flag, &stat.m_status)); |
| if (flag) { |
| data->deserialize(stat); |
| return stat; |
| } else |
| return optional<status>(); |
| } else { |
| return optional<status>(); |
| } |
| } |
| |
| // We're receiving a type that has an associated MPI datatype, so we |
| // map directly to that datatype. |
| template<typename T> |
| request |
| communicator::irecv_impl(int source, int tag, T& value, mpl::true_) const |
| { |
| request req; |
| BOOST_MPI_CHECK_RESULT(MPI_Irecv, |
| (const_cast<T*>(&value), 1, |
| get_mpi_datatype<T>(value), |
| source, tag, MPI_Comm(*this), &req.m_requests[0])); |
| return req; |
| } |
| |
| template<typename T> |
| request |
| communicator::irecv_impl(int source, int tag, T& value, mpl::false_) const |
| { |
| typedef detail::serialized_irecv_data<T> data_t; |
| shared_ptr<data_t> data(new data_t(*this, source, tag, value)); |
| request req; |
| req.m_data = data; |
| req.m_handler = request::handle_serialized_irecv<T>; |
| |
| BOOST_MPI_CHECK_RESULT(MPI_Irecv, |
| (&data->count, 1, |
| get_mpi_datatype<std::size_t>(data->count), |
| source, tag, MPI_Comm(*this), &req.m_requests[0])); |
| |
| return req; |
| } |
| |
| template<typename T> |
| request |
| communicator::irecv(int source, int tag, T& value) const |
| { |
| return this->irecv_impl(source, tag, value, is_mpi_datatype<T>()); |
| } |
| |
| template<typename T> |
| request |
| communicator::array_irecv_impl(int source, int tag, T* values, int n, |
| mpl::true_) const |
| { |
| request req; |
| BOOST_MPI_CHECK_RESULT(MPI_Irecv, |
| (const_cast<T*>(values), n, |
| get_mpi_datatype<T>(*values), |
| source, tag, MPI_Comm(*this), &req.m_requests[0])); |
| return req; |
| } |
| |
| template<typename T> |
| request |
| communicator::array_irecv_impl(int source, int tag, T* values, int n, |
| mpl::false_) const |
| { |
| typedef detail::serialized_array_irecv_data<T> data_t; |
| shared_ptr<data_t> data(new data_t(*this, source, tag, values, n)); |
| request req; |
| req.m_data = data; |
| req.m_handler = request::handle_serialized_array_irecv<T>; |
| |
| BOOST_MPI_CHECK_RESULT(MPI_Irecv, |
| (&data->count, 1, |
| get_mpi_datatype<std::size_t>(data->count), |
| source, tag, MPI_Comm(*this), &req.m_requests[0])); |
| |
| return req; |
| } |
| |
| |
| // Array receive must receive the elements directly into a buffer. |
| template<typename T> |
| request communicator::irecv(int source, int tag, T* values, int n) const |
| { |
| return this->array_irecv_impl(source, tag, values, n, is_mpi_datatype<T>()); |
| } |
| |
| /** |
| * INTERNAL ONLY |
| */ |
| template<> |
| BOOST_MPI_DECL void |
| communicator::send<packed_oarchive>(int dest, int tag, |
| const packed_oarchive& ar) const; |
| |
| /** |
| * INTERNAL ONLY |
| */ |
| template<> |
| BOOST_MPI_DECL void |
| communicator::send<packed_skeleton_oarchive> |
| (int dest, int tag, const packed_skeleton_oarchive& ar) const; |
| |
| /** |
| * INTERNAL ONLY |
| */ |
| template<> |
| BOOST_MPI_DECL void |
| communicator::send<content>(int dest, int tag, const content& c) const; |
| |
| /** |
| * INTERNAL ONLY |
| */ |
| template<> |
| BOOST_MPI_DECL status |
| communicator::recv<packed_iarchive>(int source, int tag, |
| packed_iarchive& ar) const; |
| |
| /** |
| * INTERNAL ONLY |
| */ |
| template<> |
| BOOST_MPI_DECL status |
| communicator::recv<packed_skeleton_iarchive> |
| (int source, int tag, packed_skeleton_iarchive& ar) const; |
| |
| /** |
| * INTERNAL ONLY |
| */ |
| template<> |
| BOOST_MPI_DECL status |
| communicator::recv<const content>(int source, int tag, |
| const content& c) const; |
| |
| /** |
| * INTERNAL ONLY |
| */ |
| template<> |
| inline status |
| communicator::recv<content>(int source, int tag, |
| content& c) const |
| { |
| return recv<const content>(source,tag,c); |
| } |
| |
| /** |
| * INTERNAL ONLY |
| */ |
| template<> |
| BOOST_MPI_DECL request |
| communicator::isend<packed_oarchive>(int dest, int tag, |
| const packed_oarchive& ar) const; |
| |
| /** |
| * INTERNAL ONLY |
| */ |
| template<> |
| BOOST_MPI_DECL request |
| communicator::isend<packed_skeleton_oarchive> |
| (int dest, int tag, const packed_skeleton_oarchive& ar) const; |
| |
| /** |
| * INTERNAL ONLY |
| */ |
| template<> |
| BOOST_MPI_DECL request |
| communicator::isend<content>(int dest, int tag, const content& c) const; |
| |
| /** |
| * INTERNAL ONLY |
| */ |
| template<> |
| BOOST_MPI_DECL request |
| communicator::irecv<packed_skeleton_iarchive> |
| (int source, int tag, packed_skeleton_iarchive& ar) const; |
| |
| /** |
| * INTERNAL ONLY |
| */ |
| template<> |
| BOOST_MPI_DECL request |
| communicator::irecv<const content>(int source, int tag, |
| const content& c) const; |
| |
| /** |
| * INTERNAL ONLY |
| */ |
| template<> |
| inline request |
| communicator::irecv<content>(int source, int tag, |
| content& c) const |
| { |
| return irecv<const content>(source, tag, c); |
| } |
| |
| |
| } } // end namespace boost::mpi |
| |
| // If the user has already included skeleton_and_content.hpp, include |
| // the code to send/receive skeletons and content. |
| #ifdef BOOST_MPI_SKELETON_AND_CONTENT_HPP |
| # include <boost/mpi/detail/communicator_sc.hpp> |
| #endif |
| |
| #ifdef BOOST_MSVC |
| # pragma warning(pop) |
| #endif |
| |
| #endif // BOOST_MPI_COMMUNICATOR_HPP |