/******************************************************************************
* FILE: mpl.ex1.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
* LAST REVISED:  09/14/93 for latest API changes  Blaise Barney
* LAST REVISED:  01/10/94 changed API to MPL      Stacy Pendell
* CONVERTED TO MPI: 11/12/94 by                   Xianneng Shen
****************************************************************************/

#include <stdio.h>
#include "mpi.h"
#define	ARRAYSIZE	60000	
#define MASTER		0	/* taskid of first process */

MPI_Status status;
main(int argc, char **argv) 
{
int	numtasks, 		/* total number of MPI process in partitiion */
	numworkers,		/* number of worker tasks */
	taskid,			/* task identifier */
	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 */

/************************* 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.
******************************************************************************/
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &taskid);
MPI_Comm_size(MPI_COMM_WORLD, &numtasks);
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, 0, MPI_COMM_WORLD);
    MPI_Send(&data[index], chunksize, MPI_FLOAT, dest, 0, 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, 1, MPI_COMM_WORLD, &status);
    MPI_Recv(&result[index], chunksize, MPI_FLOAT, source, 1, 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, 0, MPI_COMM_WORLD, &status);
  MPI_Recv(&result[index], chunksize, MPI_FLOAT, source, 0, 
          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 */

  MPI_Send(&index, 1, MPI_INT, MASTER, 1, MPI_COMM_WORLD);
  MPI_Send(&result[index], chunksize, MPI_FLOAT, MASTER, 1, MPI_COMM_WORLD);

  }
  MPI_Finalize();
}