Merge pull request #27 from aobolensk/03-mpi-boost

Author: allnes

03-mpi-api/03-mpi-api.tex

@@ -64,6 +64,61 @@
     \tableofcontents
 \end{frame}
 
+\section{Boost.MPI}
+
+\begin{frame}{Boost.MPI}
+  Boost.MPI is a part of the Boost C++ libraries that provides C++ bindings for the Message Passing Interface (MPI).
+
+  Boost.MPI makes it easier to write distributed applications in C++ by wrapping the complex MPI API with C++-friendly abstractions, improving safety and reducing the amount of boilerplate code.
+
+  Key Features of Boost.MPI:
+  \begin{itemize}
+    \item Simplified use of MPI with C++ bindings.
+    \item Supports complex data types through Boost.Serialization.
+    \item Easier management of distributed tasks and communication.
+    \item Compatible with common MPI implementations like MPICH, OpenMPI, MS MPI, etc.
+  \end{itemize}
+
+  Note: C API mapptint ot Boost.MPI: \href{https://www.boost.org/doc/libs/1_86_0/doc/html/mpi/c_mapping.html}{link}
+
+  {\footnotesize For more details see Boost.MPI docs: \href{https://www.boost.org/doc/libs/1_86_0/doc/html/mpi.html}{link}}
+\end{frame}
+
+\begin{frame}[fragile]{Boost.MPI example}
+  \lstset{style=CStyle, caption=Hello World example with Boost MPI}
+  \begin{lstlisting}
+#include <boost/mpi.hpp>
+#include <iostream>
+
+// Namespace alias for convenience
+namespace mpi = boost::mpi;
+
+int main(int argc, char* argv[]) {
+  // Initialize the MPI environment
+  mpi::environment env(argc, argv);
+  mpi::communicator world;
+
+  // Get the rank (ID) of the current process and the total number of processes
+  int rank = world.rank();
+  int size = world.size();
+
+  if (rank == 0) {
+    // If this is the root process (rank 0), send a message to another process
+    std::string message = "Hello from process 0";
+    world.send(1, 0, message);  // Send to process 1
+    std::cout << "Process 0 sent: " << message << std::endl;
+  } else if (rank == 1) {
+    // If this is process 1, receive the message
+    std::string received_message;
+    world.recv(0, 0, received_message);  // Receive from process 0
+    std::cout << "Process 1 received: " << received_message << std::endl;
+  }
+
+  return 0;
+}
+  \end{lstlisting}
+\end{frame}
+
 \section{Advanced Send/Receive API}
 
 \begin{frame}{Why Using \texttt{MPI\_Send} and \texttt{MPI\_Recv} Is Not Enough?}
@@ -79,7 +134,11 @@ \section{Advanced Send/Receive API}
 \begin{frame}{\texttt{MPI\_Isend}}
   Non-Blocking Send function. Initiates a send operation that returns immediately.
 
-  \texttt{int MPI\_Isend(const void *buf, int count, MPI\_Datatype datatype, int dest, int tag, MPI\_Comm comm, MPI\_Request *request);}
+  {
+    \footnotesize
+    \texttt{int MPI\_Isend(const void *buf, int count, MPI\_Datatype datatype, int dest, int tag, MPI\_Comm comm, MPI\_Request *request);} \\
+    \texttt{boost::mpi::request boost::mpi::communicator::isend(int dest, int tag, const T* values, int n);}
+  }
 
   Parameters:
 
@@ -92,13 +151,17 @@ \section{Advanced Send/Receive API}
     \item comm: Communicator
     \item request: Communication request handle
   \end{itemize}
-  Usage: Allows the sender to proceed with computation while the message is being sent.
+  {\footnotesize Usage: Allows the sender to proceed with computation while the message is being sent.}
 \end{frame}
 
 \begin{frame}{\texttt{MPI\_Irecv}}
   Non-Blocking Receive function. Initiates a receive operation that returns immediately.
 
-  \texttt{int MPI\_Irecv(void *buf, int count, MPI\_Datatype datatype, int source, int tag, MPI\_Comm comm, MPI\_Request *request);}
+  {
+    \footnotesize
+    \texttt{int MPI\_Irecv(void *buf, int count, MPI\_Datatype datatype, int source, int tag, MPI\_Comm comm, MPI\_Request *request);} \\
+    \texttt{boost::mpi::request boost::mpi::communicator::irecv(int source, int tag, T\& value);}
+  }
 
   Parameters:
 
@@ -111,7 +174,7 @@ \section{Advanced Send/Receive API}
     \item comm: Communicator
     \item request: Communication request handle
   \end{itemize}
-  Usage: Allows the receiver to proceed with computation while waiting for the message.
+  {\footnotesize Usage: Allows the receiver to proceed with computation while waiting for the message.}
 \end{frame}
 
 \section{Synchronization}
@@ -137,7 +200,11 @@ \section{Synchronization}
 \begin{frame}{\texttt{MPI\_Barrier}}
   Global Synchronization function. It blocks processes until all of them have reached the barrier.
 
-  \texttt{int MPI\_Barrier(MPI\_Comm comm);}
+  {
+    \footnotesize
+    \texttt{int MPI\_Barrier(MPI\_Comm comm);} \\
+    \texttt{void boost::mpi::communicator::barrier();}
+  }
 
   Usage:
 
@@ -175,7 +242,11 @@ \section{Collective operations}
 \begin{frame}{Broadcast (\texttt{MPI\_Bcast})}
   Send data from one process to all other processes.
 
-  \texttt{int MPI\_Bcast(void *buffer, int count, MPI\_Datatype datatype, int root, MPI\_Comm comm);}
+  {
+    \footnotesize
+    \texttt{int MPI\_Bcast(void *buffer, int count, MPI\_Datatype datatype, int root, MPI\_Comm comm);} \\
+    \texttt{void broadcast(const communicator\& comm, T\& value, int root);} (needs \texttt{\#include <boost/mpi/collectives.hpp>})
+  }
 
   \begin{minipage}[t]{0.6\textwidth}
     Parameters:
@@ -201,7 +272,11 @@ \section{Collective operations}
 
   Can be seen as the opposite operation to broadcast.
 
-  \texttt{int MPI\_Reduce(const void *sendbuf, void *recvbuf, int count, MPI\_Datatype datatype, MPI\_Op op, int root, MPI\_Comm comm);}
+  {
+    \footnotesize
+    \texttt{int MPI\_Reduce(const void *sendbuf, void *recvbuf, int count, MPI\_Datatype datatype, MPI\_Op op, int root, MPI\_Comm comm);} \\
+    \texttt{void reduce(const communicator\& comm, const T\& in\_value, T\& out\_value, Op op, int root);} (needs \texttt{\#include <boost/mpi/collectives.hpp>})
+  }
 
   \begin{minipage}[t]{0.2\textwidth}
     Supported operations:
@@ -224,7 +299,11 @@ \section{Collective operations}
 \begin{frame}{\texttt{MPI\_Gather}}
   Collect data from all processes to a single root process.
 
-  \texttt{int MPI\_Gather(const void *sendbuf, int sendcount, MPI\_Datatype sendtype, void *recvbuf, int recvcount, MPI\_Datatype recvtype, int root, MPI\_Comm comm);}
+  {
+    \footnotesize
+    \texttt{int MPI\_Gather(const void *sendbuf, int sendcount, MPI\_Datatype sendtype, void *recvbuf, int recvcount, MPI\_Datatype recvtype, int root, MPI\_Comm comm);} \\
+    \texttt{void gather(const communicator\& comm, const T\& in\_value, std::vector<T>\& out\_values, int root);} (needs \texttt{\#include <boost/mpi/collectives.hpp>})
+  }
 
   \begin{minipage}[t]{0.6\textwidth}
     Parameters:
@@ -245,7 +324,11 @@ \section{Collective operations}
 \begin{frame}{\texttt{MPI\_Scatter}}
   Distribute distinct chunks of data from root to all processes.
 
-  \texttt{int MPI\_Scatter(const void *sendbuf, int sendcount, MPI\_Datatype sendtype, void *recvbuf, int recvcount, MPI\_Datatype recvtype, int root, MPI\_Comm comm);}
+  {
+    \footnotesize
+    \texttt{int MPI\_Scatter(const void *sendbuf, int sendcount, MPI\_Datatype sendtype, void *recvbuf, int recvcount, MPI\_Datatype recvtype, int root, MPI\_Comm comm);} \\
+    \texttt{void scatter(const communicator\& comm, const std::vector<T>\& in\_values, T\& out\_value, int root);} (needs \texttt{\#include <boost/mpi/collectives.hpp>})
+  }
 
   \begin{minipage}[t]{0.6\textwidth}
     Parameters:
@@ -266,15 +349,24 @@ \section{Collective operations}
 \begin{frame}{\texttt{MPI\_AllGather}}
   Gather data from all processes and distributes the combined data to all processes.
 
-  \texttt{int MPI\_Allgather(const void *sendbuf, int sendcount, MPI\_Datatype sendtype, void *recvbuf, int recvcount, MPI\_Datatype recvtype, MPI\_Comm comm);}
+  {
+    \footnotesize
+    \texttt{int MPI\_Allgather(const void *sendbuf, int sendcount, MPI\_Datatype sendtype, void *recvbuf, int recvcount, MPI\_Datatype recvtype, MPI\_Comm comm);} \\
+    \texttt{void all\_gather(const communicator\& comm, const T\& in\_value, 
+    std::vector<T>\& out\_values);} (needs \texttt{\#include <boost/mpi/collectives.hpp>})
+  }
 
   Usage of this function reduces the need for separate gather and broadcast operations.
 \end{frame}
 
 \begin{frame}{All-to-All (\texttt{MPI\_Alltoall})}
   Description: Each process sends data to and receives data from all other processes. It can be seen as transposing a matrix distributed across processes.
 
-  \texttt{int MPI\_Alltoall(const void *sendbuf, int sendcount, MPI\_Datatype sendtype, void *recvbuf, int recvcount, MPI\_Datatype recvtype, MPI\_Comm comm);}
+  {
+    \footnotesize
+    \texttt{int MPI\_Alltoall(const void *sendbuf, int sendcount, MPI\_Datatype sendtype, void *recvbuf, int recvcount, MPI\_Datatype recvtype, MPI\_Comm comm);} \\
+    \texttt{void all\_to\_all(const communicator\& comm, const std::vector<T>\& in\_values, std::vector<T>\& out\_values);} (needs \texttt{\#include <boost/mpi/collectives.hpp>})
+  }
 
   Note: This operation is communication-intensive.
 \end{frame}
@@ -304,6 +396,7 @@ \section{Collective operations}
 \begin{frame}{References}
   \begin{enumerate}
     \item MPI Standard \href{https://www.mpi-forum.org/docs/}{https://www.mpi-forum.org/docs/}
+    \item Boost.MPI Chapter in Boost documentation \href{https://www.boost.org/doc/libs/1_86_0/doc/html/mpi.html}{https://www.boost.org/doc/libs/1_86_0/doc/html/mpi.html}
     \item Open MPI v4.0.7 documentation: \href{https://www.open-mpi.org/doc/v4.0/}{https://www.open-mpi.org/doc/v4.0/}
   \end{enumerate}
 \end{frame}

03-mpi-api/03-mpi-api.toc

@@ -1,3 +1,4 @@
-\beamer@sectionintoc {1}{Advanced Send/Receive API}{3}{0}{1}
-\beamer@sectionintoc {2}{Synchronization}{6}{0}{2}
-\beamer@sectionintoc {3}{Collective operations}{8}{0}{3}
+\beamer@sectionintoc {1}{Boost.MPI}{3}{0}{1}
+\beamer@sectionintoc {2}{Advanced Send/Receive API}{5}{0}{2}
+\beamer@sectionintoc {3}{Synchronization}{8}{0}{3}
+\beamer@sectionintoc {4}{Collective operations}{10}{0}{4}