MPI/C – An Advanced Send & Receive

/* send_receive_advanced.c
 * PARALLEL [MPI] C PROGRAM TO DEMONSTRATE MPI_Send & MPI_Recv FUNCTIONS.
 * MASTER [proc_id = 0] SENDS SOME DATA TO A WORKER [proc_id = 1].
 * WORKER PERFORMS SOME MATHEMATICAL OPERATION AND RETURNS THE
 * 'NEW INFORMATION' TO MASTER.
 *
 * TESTED SUCCESSFULLY WITH MPICH2 (1.3.1) COMPILED AGAINST GCC (4.1.2) 
 * IN A LINUX BOX WITH QUAD CORE INTEL XEON PROCESSOR (1.86 GHz) & 4GB OF RAM.
 *
 * FIRST WRITTEN: GOWTHAM; Sat, 27 Nov 2010 17:10:10 -0500
 * LAST MODIFIED: GOWTHAM; Sat, 27 Nov 2010 18:15:23 -0500
 *
 * URL:
 * http://sgowtham.net/blog/2010/11/28/mpi-c-an-advanced-send-receive/
 *
 * COMPILATION:
 * mpicc -g -Wall -lm send_receive_advanced.c -o send_receive_advanced.x
 *
 * EXECUTION:
 * mpirun -machinefile MACHINEFILE -np NPROC ./send_receive_advanced.x
 *
 * NPROC       : NUMBER OF PROCESSORS ALLOCATED TO RUNNING THIS PROGRAM;
 *               MUST BE EQUAL TO 2
 * MACHINEFILE : FILE LISTING THE HOSTNAMES OF PROCESSORS ALLOCATED TO
 *               RUNNING THIS PROGRAM
 *
*/
 
/* STANDARD HEADERS AND DEFINITIONS 
 * REFERENCE: http://en.wikipedia.org/wiki/C_standard_library
*/
#include <stdio.h>  /* Core input/output operations                         */
#include <stdlib.h> /* Conversions, random numbers, memory allocation, etc. */
#include <math.h>   /* Common mathematical functions                        */
#include <time.h>   /* Converting between various date/time formats         */
#include <mpi.h>    /* MPI functionality                                    */
 
#define MASTER  0   /* Process ID for MASTER                                */
#define WORKER  1   /* Process ID for WORKER                                */
#define N      10   /* Array size                                           */
 
/* MAIN PROGRAM BEGINS */
int main(int argc, char **argv) {
 
  /* VARIABLE DECLARATION */
  int    proc_id,       /* Process identifier                    */
         n_procs,       /* Number of processors                  */
         i;             /* Dummy/Running index                   */
 
  double x[N],          /* 1D array of size N
                           Information sent from MASTER
                           Information received by WORKER        */
         y[N];          /* 1D array of size N
                           Information sent from WORKER
                           Information received by MASTER        */
 
  MPI_Status status;    /* MPI structure containing return codes
                           for message passing operations        */
 
  /* INITIALIZE MPI */
  MPI_Init(&argc, &argv);
 
  /* GET THE PROCESS ID AND NUMBER OF PROCESSORS */
  MPI_Comm_rank(MPI_COMM_WORLD, &proc_id);
  MPI_Comm_size(MPI_COMM_WORLD, &n_procs);
 
  /* IF MASTER, THEN DO THE FOLLOWING:
   * POPULATE x[N]
   * SEND x[N] TO WORKER 
   * RECEIVE y[N] FROM WORKER
   * DISPLAY y[N]
  */
  if (proc_id == MASTER) {
 
    /* POPULATE x[N] - EACH ARRAY ELEMENT IS JUST THE INDEX */
    for (i=0; i < N; i++) {
      x[i] = i;
    }
 
    /* SEND x[N] TO WORKER */
    /* MPI_Send(buf, count, datatype, dest, tag, comm) */
    printf("\n  Sending x[N] to WORKER [proc_id = 1] with TAG = 0\n");
    MPI_Send(x, N, MPI_DOUBLE, 1, 0, MPI_COMM_WORLD);
 
    /* RECEIVE y[N] FROM WORKER */
    /* MPI_Recv(buf, count, datatype, source, tag, comm, status) */
    printf("\n  Receiving y[N] from WORKER [proc_id = 1] with TAG = 1\n");
    MPI_Recv(y, N, MPI_DOUBLE, 1, 1, MPI_COMM_WORLD, &status);
 
    /* DISPLAY y[N] */
    for (i=0; i < N; i++) {
      printf("    y[%d] = %2.0lf\n", i, y[i]);
    }
 
  } /* MASTER LOOP ENDS */
 
 
  /* IF WORKER, THEN DO THE FOLLOWING:
   * RECEIVE x[N] FROM MASTER 
   * CREATE y[N]
   * SEND y[N] TO MASTER
  */
  if (proc_id == WORKER) {
 
    /* RECEIVE x[N] FROM MASTER */
    printf("\n  Receiving x[N] from MASTER [proc_id = 0] with TAG = 0\n");
    MPI_Recv(x, N, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, &status);
 
    /* CREATE A NEW ARRAY y[N]
     * A SIMPLE MATHEMATICAL MANIPULATION 
     * TAKE THE ELEMENTS OF x[N] AND SQUARE THEM
    */
    for (i=0; i < N; i++) {
      y[i] = x[i] * x[i];
    }
 
    /* SEND y[N] TO MASTER */
    printf("\n  Sending y[N] to MASTER [proc_id = 0] with TAG = 1\n");
    MPI_Send(y, N, MPI_DOUBLE, 0, 1, MPI_COMM_WORLD);
 
  } /* WORKER LOOP ENDS */
 
  /* FINALIZE MPI */
  MPI_Finalize();
 
  /* INDICATE THE TERMINATION OF THE PROGRAM */
  return 0;
 
} /* MAIN PROGRAM ENDS */