/******************************************************************************
* MPI Example - Array Assignment - C Version
* FILE: mpi_array.c
* 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. 
* AUTHOR: Blaise Barney. Converted to MPI: George L. Gusciora (1/25/95)
* LAST REVISED: 12/14/95 Blaise Barney
****************************************************************************/
#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();
}