/******************************************************************************
* MPL Example - Array Assignment - C Version
* FILE: mpl_array.c
* OTHER FILES: make.mpl_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
* LAST REVISED:  3/31/94 Blaise Barney
****************************************************************************/

#include <stdio.h>

#define	ARRAYSIZE	600000
#define MASTER		0	/* taskid of first process */


main() {
int	numtasks, 			/* total number of MPL tasks 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 */
	nbytes,				/* number of bytes in 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.
******************************************************************************/
mpc_environ(&numtasks, &taskid);
numworkers = numtasks-1;
chunksize = (ARRAYSIZE / numworkers);

/**************************** master task ************************************/
if (taskid == MASTER) {
  printf("\n*********** Starting MPL 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);
    mpc_bsend(&index,sizeof(int),dest,indexmsg);
    mpc_bsend(&data[index],chunksize*sizeof(float),dest,arraymsg);
    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;
    mpc_brecv(&index, sizeof(int), &source, &indexmsg, &nbytes);
    mpc_brecv(&result[index], chunksize*sizeof(float), &source, 
              &arraymsg, &nbytes);
    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;
  mpc_brecv(&index, sizeof(int), &source, &indexmsg, &nbytes);
  mpc_brecv(&result[index], chunksize*sizeof(float), &source, 
            &arraymsg, &nbytes);

  /* 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 */
  mpc_bsend(&index,sizeof(int),MASTER,indexmsg);
  mpc_bsend(&result[index],chunksize*sizeof(float),MASTER,arraymsg);
  }

}