# Intro to MPI programming in C++

*Some notes from the MPI course at EPCC, Summer 2016*

MPI is the **Message Passing Interface**, a standard and series of libraries for writing parallel programs to run on distributed memory computing systems. Distributed memory systems are essentially a series of network computers, or compute nodes, each with their own processors and memory. The key difference between *distributed* memory systems and their *shared-memory* counterparts is that each compute node under the distributed model (MPI) has its own memory address space, and special messages must be sent between each node to exchange data. The message sending and receiving is a key part of writing MPI programs.

## A very basic example: calculating pi

There are dozens of hello world example MPI programs, but these are fairly trivial examples and don’t really show how a real computing problem might be broken up and shared between compute nodes (Do you really need a supercomputer to `std::cout`

“Hello, World!”?). This example uses an approximation for calculating pi to many significant digits. The approximation is given by:

where the answer becomes more acurate with increasing N.

The pseudo-code for the partial sum of pi for each iteration would be:

For a basic MPI-C++ program, the first bit of the program looks like this, including the MPI header and some variables declared:

First, some variables are created to hold the *rank*, i.e. the current process, and the *size*, which is used to represent the total number of ranks, or processes.

*istart* and *istop* will be used to calculate the iteration loop counter start and stop positions for each separate process.

Secondly, the `MPI_Status`

variable is defined, then the `MPI_Comm`

type variable. These are special types defined in the MPI headers that relate to the message passing interface.

The MPI environment is initialised with `MPI_Init(NULL, NULL);`

. The you can initialise the rank and size variables using the corresponding commands in MPI_Comm_rank() and MPI_Comm_size, passing a reference to the communicator object, and the respective variable.

By convention, the process with rank = 1 is used as the master process, and does the managing of collating data once it has been processed by the other ranks/processes.

The parameter `N`

is used in our pi approximation and will determine the number of iterations we do. It is used to calculate the number of iterations distributed to each process:

Then each loop will calculate a partial sum of pi from its given subset of N. Because the MPI processes have been initailised, as well as the variables for rank and size, the code below will have unique values of istart and istop for each rank/process:

Our partial sums have now been calculated, the last task is to collate them all together on the master process (rank=0), and sum them up:

The key part of the above code is that we are telling the master process (rank=0) to be ready to **receive** all the partial sums of pi. MPI requires both send and receive calls. However, the **send** command has to be issued from the respective processes themselves (There’s no ‘get’ command *per se*, it’s a two-stage process that has to be set up on each process correctly).

Now we tell the non-master processes to send their partial pi sums:

So now we’ve issued a command to send all the bits of pi, specified the data type, `MPI_DOUBLE`

and passed the other arguments required by `MPI_Ssend()`

.

Finally, we can do the last bit of the calculation needed in the original formual by multiplying by four. Then finalise the MPI processes.

.

The full program is given in a github Gist, which I will either embedd or provide a link to soon.