No Title

Sample C code:

/**********************************************************
* MPI Example - Array Assignment - C Version
*
* DESCRIPTION:
*   In this simple example, the master task initiates numtasks-1 number of
*   worker tasks. It then distributes an equal portion of an array to each
*   worker task. Each worker task receives its portion of the array, and
*   performs a simple value assignment to each of its elements. The value
*   assigned to each element is simply that element's index in the array+1.
*   Each worker task then sends its portion of the array back to the master
*   task. As the master receives back each portion of the array, selected
*   elements are displayed.
****************************************************************/
#include "mpi.h"
#include <stdio.h>
#define ARRAYSIZE       60000
#define MASTER          0         /* taskid of first process */
int main(argc,argv)
int argc;
char *argv[];
{
int     numtasks,                  /* total number of MPI tasks in partitiion */
        numworkers,                /* number of worker tasks */
        taskid,                    /* task identifier */
        rc,                        /* return error code */
        dest,                      /* destination task id to send message */
        index,                     /* index into the array */
        i,                         /* loop variable */
        arraymsg = 1,              /* setting a message type */
        indexmsg = 2,              /* setting a message type */
        source,                    /* origin task id of message */
        chunksize;                 /* for partitioning the array */
float   data[ARRAYSIZE],           /* the intial array */
        result[ARRAYSIZE];         /* for holding results of array operations */
MPI_Status status;

/************************* initializations ***************************
* Find out how many tasks are in this partition and what my task id is. Then
* define the number of worker tasks and the array partition size as chunksize.
* Note: For this example, the MP_PROCS environment variable should be set
* to an odd number...to insure even distribution of the array to numtasks-1
* worker tasks.
******************************************************************/
   rc = MPI_Init(&argc,&argv);
   rc|= MPI_Comm_size(MPI_COMM_WORLD,&numtasks);
   rc|= MPI_Comm_rank(MPI_COMM_WORLD,&taskid);
   if (rc != MPI_SUCCESS)
      printf ("error initializing MPI and obtaining task ID information\n");
   else
      printf ("MPI task ID = %d\n", taskid);
   printf("%d tasks, I am task %d\n", numtasks, taskid);
   numworkers = numtasks-1;
   chunksize = (ARRAYSIZE / numworkers);
/**************************** master task ***************************/
   if (taskid == MASTER)
   {
      printf("\n*********** Starting MPI Example 1 ************\n");
      printf("MASTER: number of worker tasks will be= %d\n",numworkers);
      fflush(stdout);

      /* Initialize the array */
      for(i=0; i<ARRAYSIZE; i++)
         data[i] = 0.0;
      index = 0;

      /* Send each worker task its portion of the array */
      for (dest=1; dest<= numworkers; dest++)
      {
         printf("Sending to worker task %d\n",dest);
         fflush(stdout);
         MPI_Send(&index, 1, MPI_INT, dest, indexmsg, MPI_COMM_WORLD);
         MPI_Send(&data[index], chunksize, MPI_FLOAT, dest, arraymsg, MPI_COMM_WORLD);
         index = index + chunksize;
      }

      /* Now wait to receive back the results from each worker task and print */
      /* a few sample values */
      for (i=1; i<= numworkers; i++)
      {
         source = i;
         MPI_Recv(&index, 1, MPI_INT, source, indexmsg, MPI_COMM_WORLD, &status);
         MPI_Recv(&result[index], chunksize, MPI_FLOAT, source, arraymsg, MPI_COMM_WORLD, &status);
         printf("---------------------------------------------------\n");
         printf("MASTER: Sample results from worker task = %d\n",source);
         printf("   result[%d]=%f\n", index, result[index]);
         printf("   result[%d]=%f\n", index+100, result[index+100]);
         printf("   result[%d]=%f\n\n", index+1000, result[index+1000]);
         fflush(stdout);
      }
      printf("MASTER: All Done! \n");
   }

/**************************** worker task ****************************/

   if (taskid > MASTER)
   {
      /* Receive my portion of array from the master task */
      source = MASTER;
      MPI_Recv(&index, 1, MPI_INT, source, indexmsg, MPI_COMM_WORLD, &status);
      MPI_Recv(&result[index], chunksize, MPI_FLOAT, source, arraymsg, MPI_COMM_WORLD, &status);

      /* Do a simple value assignment to each of my array elements */
      for(i=index; i < index + chunksize; i++)
         result[i] = i + 1;

      /* Send my results back to the master task */
      dest = MASTER;
      MPI_Send(&index, 1, MPI_INT, dest, indexmsg, MPI_COMM_WORLD);
      MPI_Send(&result[index], chunksize, MPI_FLOAT, MASTER, arraymsg, MPI_COMM_WORLD);
   }
   MPI_Finalize();
}