University of Moratuwa

Department of Information Technology

B18_L4S1_IN 4700 - Semester I Lab Session 03 – 2022

Group Communication

 The Broadcast Group Communication Primitive

o Broadcasting is sending a message to all members (including yourself) of the
group
o Syntax of the MPI_Bcast() call:

MPI_Bcast(void* buffer,
int count,
MPI_Datatype datatype,
int rootID,
MPI_Comm comm )

 On entry (i.e., before the call), only the rootID processor contains the correct
value in the buffer buffer
 On exit (i.e., when the call returns - finishes), all processors have a copy
of buffer

Example 01:

int main(int argc, char **argv)

{
char buff[128];
int secret_num;
 int numprocs;
int myid;
int i;

MPI_Status stat;

MPI_Init(&argc,&argv);
MPI_Comm_size(MPI_COMM_WORLD,&numprocs);
MPI_Comm_rank(MPI_COMM_WORLD,&myid);

// ------------------------------------------
// Node 0 obtains the secret number
// ------------------------------------------
if ( myid == 0 )
{
secret_num = atoi(argv[1]);
}

// ------------------------------------------
// Node 0 shares the secret with everybody
// ------------------------------------------
MPI_Bcast (&secret_num, 1, MPI_INT, 0, MPI_COMM_WORLD);

if ( myid == 0 )
{
for( i = 1; i < numprocs; i++)
{
MPI_Recv(buff, 128, MPI_CHAR, i, 0, MPI_COMM_WORLD, &stat);
cout << buff << endl;
}
}
else
{
sprintf(buff, "Processor %d knows the secret code: %d",
myid, secret_num);
MPI_Send(buff, 128, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
}

MPI_Finalize();

Compile and run file

1. mpicc -o BCast BCast.c

2. mpirun -np 4 ./BCast
 The Scatter Group Communication primitive
o The MPI_Scatter() is used to split an array into N parts and send one of the
parts to each MPI process
o Syntax of the MPI_Scatter() call:

MPI_Scatter(void* sendbuf,
int sendcount,
MPI_Datatype sendtype,

void* recvbuf,
int recvcount,
MPI_Datatype recvtype,

int rootID,
MPI_Comm comm)

 sendbuf - the data (must be valid for the rootID processor)

 sendcount - number of items sent to each process (valid for rootID
only)
 sendtype - type of data sent (valid for rootID only)
 recvbuf - buffer for receiving data
 recvcount - number of items to receive
 recvtype - type of data received
 rootID - id of root processor (who is doing the send operation)
 comm - the communicator group

 Example 02:
 Processor 0 distributes 2 integer to every processor
 Each processor adds the numbers and returns the sum to proc 0

int main(int argc, char **argv)

{
 int buff[100];
int recvbuff[2];
int numprocs;
int myid;
int i, k;
int mysum;

MPI_Status stat;

MPI_Init(&argc,&argv);
MPI_Comm_size(MPI_COMM_WORLD,&numprocs);
MPI_Comm_rank(MPI_COMM_WORLD,&myid);

if ( myid == 0 )
{
cout << "WE have " << numprocs << " processors" << endl;
// -----------------------------------------------
// Node 0 prepare 2 number for each processor
// [1][2] [3][4] [5][6] .... etc
// -----------------------------------------------
k = 1;
for ( i = 0; i < 2*numprocs; i += 2 )
{
buff[i] = k++;

buff[i+1] = k++;
}
}

// ------------------------------------------
// Node 0 scatter the array to the processors:
// ------------------------------------------

MPI_Scatter (buff, 2, MPI_INT, recvbuff, 2, MPI_INT, 0, MPI_COMM_WORLD);

^^^ !!! ^^^ !!!

if ( myid == 0 )
{
mysum = recvbuff[0] + recvbuff[1];
cout << "Processor " << myid << ": sum = " << mysum << endl;

for( i = 1; i < numprocs; i++)

{
MPI_Recv(&mysum, 1, MPI_INT, i, 0, MPI_COMM_WORLD, &stat);
cout << "Processor " << i << ": sum = " << mysum << endl;
}
}
else
{
mysum = recvbuff[0] + recvbuff[1];
 MPI_Send(&mysum, 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
}

MPI_Finalize();
}

 The Gather Group Communication primitives

o The MPI_Gather() is usually used in conjunction with
the MPI_Gather() call.

It does the reverse of MPI_Gather()....

o Syntax of the MPI_Gather() call:

MPI_Gather(void* sendbuf,
int sendcount,
MPI_Datatype sendtype,

void* recvbuf,
int recvcount,
MPI_Datatype recvtype,

int rootID,
MPI_Comm comm)

 sendbuf - the data (must be valid for ALL processors)

 sendcount - number of items sent to the rootID process
 sendtype - type of data sent
 recvbuf - buffer for receiving data
 recvcount - number of items to receive (per processor)
 recvtype - type of data received
 rootID - id of root processor who is doing the RECEIVE operation
 comm - the communicator group
Example 03: Same example above, with MPI_Gather()

 Processor 0 distributes 2 integer to every processor

 Each processor adds the numbers and returns the sum to proc 0

int main(int argc, char **argv)

{
int buff[100];
int recvbuff[2];
int numprocs;

int myid;
int i, k;
int mysum;

MPI_Status stat;

MPI_Init(&argc,&argv);
MPI_Comm_size(MPI_COMM_WORLD,&numprocs);
MPI_Comm_rank(MPI_COMM_WORLD,&myid);

if ( myid == 0 )
{
cout << "WE have " << numprocs << " processors" << endl;

// -----------------------------------------------
// Node 0 prepare 2 number for each processor
// [1][2] [3][4] [5][6] .... etc
// -----------------------------------------------
k = 1;
for ( i = 0; i < 2*numprocs; i += 2 )
{
buff[i] = k++;
buff[i+1] = k++;
}
}

// ------------------------------------------
// Node 0 scatter the array to the processors:
// ------------------------------------------

MPI_Scatter (buff, 2, MPI_INT, recvbuff, 2, MPI_INT, 0, MPI_COMM_WORLD);

mysum = recvbuff[0] + recvbuff[1]; // Everyone calculate sum

// ------------------------------------------
// Node 0 collects the results in "buff":
// ------------------------------------------
MPI_Gather (&mysum, 1, MPI_INT, &buff, 1, MPI_INT, 0, MPI_COMM_WORLD);

// ------------------------------------------
// Node 0 prints result
// ------------------------------------------
if ( myid == 0 )
{
for( i = 0; i < numprocs; i++)
{
cout << "Processor " << i << ": sum = " << buff[i] << endl;
}
}
MPI_Finalize();
}

 The Reduce Group Communication primitives

 Often, the data gathered by the MPI_Gather() need to be operated on to

produce the final result.
 For example, results of the computations could be a part of a sum and the
results gathered needs to be added up to produce the final sum.

 MPI provides a convenient on the fly gather and compute function to make
the programming easier: MPI_Reduce()....
 Syntax of the MPI_Reduce() call:

MPI_Reduce(void* sendbuf,

void* recvbuf,
int recvcount,
MPI_Datatype recvtype,
MPI_Op op,

int rootID,
MPI_Comm comm)

 sendbuf - the data (must be valid for ALL processors)

 recvbuf - buffer used to receiving data and simultaneously perform
the "reducing operation".
 recvcount - number of items to receive (per processor)
 recvtype - type of data received
  op - type of operation used as the "reducing operation"
 rootID - id of root processor who is doing the RECEIVE and
REDUCE operation
 comm - the communicator group

Example 04: computing Pi using MPI_Reduce()

 Each processor computes a part of the integral

 Processor 0 adds the returned sums together

double f(double a)
{
return( 2.0 / sqrt(1 - a*a) );
}

/* =======================
MAIN
======================= */

int main(int argc, char *argv[])

{
int N;
double w, x;
int i, myid;
double mypi, final_pi;

MPI_Init(&argc,&argv); // Initialize
 MPI_Comm_size(MPI_COMM_WORLD, &num_procs); // Get # processors
MPI_Comm_rank(MPI_COMM_WORLD, &myid); // Get my rank (id)

if ( myid == 0 )
N = atoi(argv[1]);

MPI_Bcast (&N, 1, MPI_INT, 0, MPI_COMM_WORLD);

w = 1.0/(double) N;

/* *******************************************************************
*/

mypi = 0.0;

for (i = myid; i < N; i = i + num_procs)

{
x = w*(i + 0.5);
mypi = mypi + w*f(x);
}

/* *******************************************************************
*/

MPI_Reduce ( &mypi, &final_pi, 1, MPI_DOUBLE, MPI_SUM, 0,

MPI_COMM_WORLD);

if ( myid == 0 )
{
cout << "Pi = " << final_pi << endl << endl;
}

MPI_Finalize();
}