Этот файл представляет собой заголовок верхнего уровня, который включает в себя все Boost. Заголовки библиотеки MPI. Пользователи, обеспокоенные временем компиляции, могут захотеть включить только определенные заголовки из Boost. Библиотека MPI.

Этот заголовок обеспечивает STL-совместимый распределитель, который использует средства распределения памяти MPI-2.

namespace boost {
  namespace mpi {
    template<typename T> class allocator;
    template<> class allocator<void>;
    template<typename T1, typename T2> 
      bool operator==(const allocator< T1 > &, const allocator< T2 > &);
    template<typename T1, typename T2> 
      bool operator!=(const allocator< T1 > &, const allocator< T2 > &);
  }
}

Этот заголовок содержит коллективные операции MPI, которые реализуют различные параллельные алгоритмы, требующие координации всех процессов внутри коммуникатора. Заголовок<collectives_fwd.hpp>предоставляет форвардные декларации для каждой из этих операций. Чтобы включить только конкретные коллективные алгоритмы, используйте заголовки.<boost/mpi/collectives/algorithm_name.hpp>.

namespace boost {
  namespace mpi {
    template<typename T> 
      void all_gather(const communicator &, const T &, std::vector< T > &);
    template<typename T> void all_gather(const communicator &, const T &, T *);
    template<typename T> 
      void all_gather(const communicator &, const T *, int, 
                      std::vector< T > &);
    template<typename T> 
      void all_gather(const communicator &, const T *, int, T *);
    template<typename T, typename Op> 
      void all_reduce(const communicator &, const T *, int, T *, Op);
    template<typename T, typename Op> 
      void all_reduce(const communicator &, const T &, T &, Op);
    template<typename T, typename Op> 
      T all_reduce(const communicator &, const T &, Op);
    template<typename T, typename Op> 
      void all_reduce(const communicator &, inplace_t< T * >, int, Op);
    template<typename T, typename Op> 
      void all_reduce(const communicator &, inplace_t< T >, Op);
    template<typename T> 
      void all_to_all(const communicator &, const std::vector< T > &, 
                      std::vector< T > &);
    template<typename T> void all_to_all(const communicator &, const T *, T *);
    template<typename T> 
      void all_to_all(const communicator &, const std::vector< T > &, int, 
                      std::vector< T > &);
    template<typename T> 
      void all_to_all(const communicator &, const T *, int, T *);
    template<typename T> void broadcast(const communicator &, T &, int);
    template<typename T> void broadcast(const communicator &, T *, int, int);
    template<typename T> 
      void broadcast(const communicator &, skeleton_proxy< T > &, int);
    template<typename T> 
      void broadcast(const communicator &, const skeleton_proxy< T > &, int);
    template<typename T> 
      void gather(const communicator &, const T &, std::vector< T > &, int);
    template<typename T> 
      void gather(const communicator &, const T &, T *, int);
    template<typename T> void gather(const communicator &, const T &, int);
    template<typename T> 
      void gather(const communicator &, const T *, int, std::vector< T > &, 
                  int);
    template<typename T> 
      void gather(const communicator &, const T *, int, T *, int);
    template<typename T> 
      void gather(const communicator &, const T *, int, int);
    template<typename T> 
      void gatherv(const communicator &, const std::vector< T > &, T *, 
                   const std::vector< int > &, const std::vector< int > &, 
                   int);
    template<typename T> 
      void gatherv(const communicator &, const T *, int, T *, 
                   const std::vector< int > &, const std::vector< int > &, 
                   int);
    template<typename T> 
      void gatherv(const communicator &, const std::vector< T > &, int);
    template<typename T> 
      void gatherv(const communicator &, const T *, int, int);
    template<typename T> 
      void gatherv(const communicator &, const T *, int, T *, 
                   const std::vector< int > &, int);
    template<typename T> 
      void gatherv(const communicator &, const std::vector< T > &, T *, 
                   const std::vector< int > &, int);
    template<typename T> 
      void scatter(const communicator &, const std::vector< T > &, T &, int);
    template<typename T> 
      void scatter(const communicator &, const T *, T &, int);
    template<typename T> void scatter(const communicator &, T &, int);
    template<typename T> 
      void scatter(const communicator &, const std::vector< T > &, T *, int, 
                   int);
    template<typename T> 
      void scatter(const communicator &, const T *, T *, int, int);
    template<typename T> void scatter(const communicator &, T *, int, int);
    template<typename T> 
      void scatterv(const communicator &, const std::vector< T > &, 
                    const std::vector< int > &, const std::vector< int > &, 
                    T *, int, int);
    template<typename T> 
      void scatterv(const communicator &, const T *, 
                    const std::vector< int > &, const std::vector< int > &, 
                    T *, int, int);
    template<typename T> void scatterv(const communicator &, T *, int, int);
    template<typename T> 
      void scatterv(const communicator &, const T *, 
                    const std::vector< int > &, T *, int);
    template<typename T> 
      void scatterv(const communicator &, const std::vector< T > &, 
                    const std::vector< int > &, T *, int);
    template<typename T, typename Op> 
      void reduce(const communicator &, const T &, T &, Op, int);
    template<typename T, typename Op> 
      void reduce(const communicator &, const T &, Op, int);
    template<typename T, typename Op> 
      void reduce(const communicator &, const T *, int, T *, Op, int);
    template<typename T, typename Op> 
      void reduce(const communicator &, const T *, int, Op, int);
    template<typename T, typename Op> 
      void scan(const communicator &, const T &, T &, Op);
    template<typename T, typename Op> 
      T scan(const communicator &, const T &, Op);
    template<typename T, typename Op> 
      void scan(const communicator &, const T *, int, T *, Op);
  }
}

Этот заголовок содержит форвардные декларации для всех коллективных операций, содержащихся в заголовке<collectives.hpp>.

Этот заголовок определяет класс<communicator>, который является основой всей коммуникации в Boost. MPI и обеспечивает операции связи между точками.

namespace boost {
  namespace mpi {
    class communicator;
    enum comm_create_kind;
    const int any_source;    // A constant representing "any process.". 
    const int any_tag;    // A constant representing "any tag.". 
    BOOST_MPI_DECL bool operator==(const communicator &, const communicator &);
    bool operator!=(const communicator &, const communicator &);
  }
}

Этот заголовок предоставляет детали конфигурации MPI, которые раскрывают возможности базовой реализации MPI, и обеспечивает поддержку автосвязи в Windows.

MPICH_IGNORE_CXX_SEEK
BOOST_MPI_HOMOGENEOUS
BOOST_MPI_HAS_MEMORY_ALLOCATION
BOOST_MPI_HAS_NOARG_INITIALIZATION
BOOST_MPI_CALLING_CONVENTION
BOOST_MPI_BCAST_BOTTOM_WORKS_FINE
BOOST_MPI_DECL

Этот заголовок обеспечивает отображение от типов C++ к типам данных MPI.

BOOST_IS_MPI_DATATYPE(T)

namespace boost {
  namespace mpi {
    template<typename T> struct is_mpi_integer_datatype;
    template<typename T> struct is_mpi_floating_point_datatype;
    template<typename T> struct is_mpi_logical_datatype;
    template<typename T> struct is_mpi_complex_datatype;
    template<typename T> struct is_mpi_byte_datatype;
    template<typename T> struct is_mpi_builtin_datatype;
    template<typename T> struct is_mpi_datatype;
    template<typename T> MPI_Datatype get_mpi_datatype(const T &);
  }
}

Этот заголовок предоставляет форвардные декларации для содержимого заголовка<datatype.hpp>. Ожидается, что он будет использоваться в основном для классов C++, которые должны специализироваться<is_mpi_datatype>.

namespace boost {
  namespace mpi {
    struct packed;
    template<typename T> MPI_Datatype get_mpi_datatype();
  }
}

Этот заголовок предоставляет класс<environment>, который предоставляет процедуры для инициализации, завершения и запроса состояния среды Boost MPI.

namespace boost {
  namespace mpi {
    class environment;
    namespace threading {
      enum level;
      std::ostream & operator<<(std::ostream &, level);
      std::istream & operator>>(std::istream &, level &);
    }
  }
}

Этот заголовок предоставляет классы исключений, которые сообщают об ошибках MPI пользователю, и макросы, которые переводят коды ошибок MPI в Boost. Исключения MPI.

BOOST_MPI_CHECK_RESULT(MPIFunc, Args)

namespace boost {
  namespace mpi {
    class exception;
  }
}

Этот заголовок определяет средства для поддержки MPI-коммуникаторов с топологиями графов, используя графический интерфейс, определенный библиотекой Boost Graph. Можно построить коммуникатор, топология которого описывается любым графом, отвечающим требованиям графических концепций библиотеки Boost Graph. Аналогично, любой коммуникатор, имеющий топологию графов, может рассматриваться библиотекой Boost Graph как граф, что позволяет использовать алгоритмы графов BGL в топологии процессов.

namespace boost {
  template<> struct graph_traits<mpi::graph_communicator>;
  namespace mpi {
    class graph_communicator;
    // Returns the source vertex from an edge in the graph topology of a communicator. 
    int source(const std::pair< int, int > & edge, const graph_communicator &);
    // Returns the target vertex from an edge in the graph topology of a communicator. 
    int target(const std::pair< int, int > & edge, const graph_communicator &);
    // Returns an iterator range containing all of the edges outgoing from the given vertex in a graph topology of a communicator. 
    unspecified out_edges(int vertex, const graph_communicator & comm);
    // Returns the out-degree of a vertex in the graph topology of a communicator. 
    int out_degree(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. 
    unspecified adjacent_vertices(int vertex, 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. 
    std::pair< counting_iterator< int >, counting_iterator< int > > 
    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. 
    int num_vertices(const graph_communicator & comm);
    // Returns an iterator range that contains all of the edges with the communicator's graph topology. 
    unspecified edges(const graph_communicator & comm);
    // Returns the number of edges in the communicator's graph topology. 
    int num_edges(const graph_communicator & comm);
    identity_property_map get(vertex_index_t, const graph_communicator &);
    int get(vertex_index_t, const graph_communicator &, int);
  }
}

Этот заголовок определяет класс<group>, который позволяет манипулировать и запрашивать группы процессов.

namespace boost {
  namespace mpi {
    class group;
    BOOST_MPI_DECL bool operator==(const group &, const group &);
    bool operator!=(const group &, const group &);
    BOOST_MPI_DECL group operator|(const group &, const group &);
    BOOST_MPI_DECL group operator&(const group &, const group &);
    BOOST_MPI_DECL group operator-(const group &, const group &);
  }
}

Этот заголовок предоставляет помощникам указание на коллективную работу MPI, что буфер может использоваться как в качестве входа, так и вывода.

namespace boost {
  namespace mpi {
    template<typename T> struct inplace_t;
    template<typename T> struct inplace_t<T *>;
    template<typename T> inplace_t< T > inplace(T &);
    template<typename T> inplace_t< T * > inplace(T *);
  }
}

Этот заголовок определяет класс<intercommunicator>, который позволяет осуществлять связь между различными группами процессов.

namespace boost {
  namespace mpi {
    class intercommunicator;
  }
}

Этот заголовок определяет операции для выполнения неблокирующих запросов связи.

namespace boost {
  namespace mpi {
    template<typename ForwardIterator> 
      std::pair< status, ForwardIterator > 
      wait_any(ForwardIterator, ForwardIterator);
    template<typename ForwardIterator> 
      optional< std::pair< status, ForwardIterator > > 
      test_any(ForwardIterator, ForwardIterator);
    template<typename ForwardIterator, typename OutputIterator> 
      OutputIterator 
      wait_all(ForwardIterator, ForwardIterator, OutputIterator);
    template<typename ForwardIterator> 
      void wait_all(ForwardIterator, ForwardIterator);
    template<typename ForwardIterator, typename OutputIterator> 
      optional< OutputIterator > 
      test_all(ForwardIterator, ForwardIterator, OutputIterator);
    template<typename ForwardIterator> 
      bool test_all(ForwardIterator, ForwardIterator);
    template<typename BidirectionalIterator, typename OutputIterator> 
      std::pair< OutputIterator, BidirectionalIterator > 
      wait_some(BidirectionalIterator, BidirectionalIterator, OutputIterator);
    template<typename BidirectionalIterator> 
      BidirectionalIterator 
      wait_some(BidirectionalIterator, BidirectionalIterator);
    template<typename BidirectionalIterator, typename OutputIterator> 
      std::pair< OutputIterator, BidirectionalIterator > 
      test_some(BidirectionalIterator, BidirectionalIterator, OutputIterator);
    template<typename BidirectionalIterator> 
      BidirectionalIterator 
      test_some(BidirectionalIterator, BidirectionalIterator);
  }
}

Этот заголовок обеспечивает отображение от объектов функций до<MPI_Op>констант, используемых в коллективных операциях MPI. Он также предоставляет несколько новых типов функциональных объектов, не присутствующих в стандартном<>заголовке, которые имеют прямое отображение на<MPI_Op>.

namespace boost {
  namespace mpi {
    template<typename Op, typename T> struct is_mpi_op;
    template<typename Op, typename T> struct is_commutative;
    template<typename T> struct maximum;
    template<typename T> struct minimum;
    template<typename T> struct bitwise_and;
    template<typename T> struct bitwise_or;
    template<typename T> struct logical_xor;
    template<typename T> struct bitwise_xor;
  }
}

Этот заголовок предоставляет возможности для упаковки Сериализируемых типов данных в буфер с использованием<MPI_Pack>. Затем буферы могут передаваться через MPI, а затем распаковываться либо через объекты в<packed_oarchive.hpp>, либо<MPI_Unpack>.

namespace boost {
  namespace mpi {
    class packed_iarchive;
    typedef packed_iprimitive iprimitive;
  }
}

Этот заголовок предоставляет возможности для распаковки Сериализируемых типов данных из буфера с использованием<MPI_Unpack>. Буферы обычно принимаются через MPI и упаковываются либо через объекты в<packed_iarchive.hpp>, либо<MPI_Pack>.

namespace boost {
  namespace mpi {
    class packed_oarchive;
    typedef packed_oprimitive oprimitive;
  }
}

Этот заголовок взаимодействует с Python-связями для Boost. MPI. Процедуры в этом заголовке могут использоваться для регистрации пользовательских и библиотечных типов данных с помощью Boost. MPI для эффективной (де-)сериализации и раздельной передачи скелетов и содержимого.

namespace boost {
  namespace mpi {
    namespace python {
      template<typename T> 
        void register_serialized(const T & = T(), PyTypeObject * = 0);
      template<typename T> 
        void register_skeleton_and_content(const T & = T(), 
                                           PyTypeObject * = 0);
    }
  }
}

Этот заголовок определяет класс<request>, который содержит запрос на неблокирующую связь.

namespace boost {
  namespace mpi {
    class request;
  }
}

Этот заголовок предоставляет средства, которые позволяют передавать и принимать структуру типов данных (так называемый «скелет») отдельно от содержимого, хранящегося в этих типах данных. Эти средства полезны, когда данные в стабильной структуре данных (например, сетка или график) должны быть переданы повторно. В этом случае передача скелета только один раз экономит как коммуникационные усилия (его не нужно отправлять снова), так и локальные вычисления (сериализация должна выполняться только один раз для контента).

namespace boost {
  namespace mpi {
    template<typename T> struct skeleton_proxy;
    class content;
    class packed_skeleton_iarchive;
    class packed_skeleton_oarchive;
    template<typename T> const skeleton_proxy< T > skeleton(T &);
    template<typename T> const content get_content(const T &);
  }
}

Этот заголовок содержит все заявления, необходимые для использования передающих скелетов структур данных и содержимого структур данных отдельно. Для фактической передачи скелетов или содержимого включите заголовок<boost/mpi/skeleton_and_content.hpp>.

Этот заголовок определяет класс<status>, который сообщает о результатах точечной связи.

namespace boost {
  namespace mpi {
    class status;
  }
}

Этот заголовок предоставляет класс<timer>, который обеспечивает доступ к таймерам MPI.

namespace boost {
  namespace mpi {
    class timer;
  }
}