#include <stdio.h>
#include <mpi.h>
#include <malloc.h>

int main(int argc, char **argv )
 {
  int myid, numprocs;
  int ans,i,w,index;
  int complete = 0;
  int iter = 50;
  int *a,*b,*c,*worker;
  int dispatched = 0;
  int returned = 0;
  int Unit_of_Work[2];
  int *result;
  int Work = 1;
  int idle = -1;

  MPI_Request *recv_req;
  MPI_Status status;

  MPI_Init(&argc, &argv);
  MPI_Comm_size(MPI_COMM_WORLD,&numprocs);
  MPI_Comm_rank(MPI_COMM_WORLD,&myid);
  if (numprocs >= 2)
   {
    if (myid == 0) // Master
     {
      a = (int *) malloc(iter*sizeof(int));
      b = (int *) malloc(iter*sizeof(int));
      c = (int *) malloc(iter*sizeof(int));
      worker = (int *) malloc(numprocs*sizeof(int));
      result = (int *) malloc(numprocs*sizeof(int));
      recv_req = (MPI_Request *) malloc(numprocs*sizeof(MPI_Request));

      for (i=0; i<iter; i++) { a[i] = i; b[i] = i; c[i]=0; }
      // initialize worker status
      for (w=1; w<numprocs; w++) { worker[w] = idle;} 
      while(complete < iter)
       {
        for (w=1; w<numprocs; w++)
         {
          if ((worker[w] == idle) && (complete < iter))
           {
            printf ("Master sending UoW[%d] to Worker %d\n",complete,w);
            Unit_of_Work[0] = a[complete];
            Unit_of_Work[1] = b[complete];
            // Send the Unit of Work
            MPI_Send(Unit_of_Work,2,MPI_INT,w,0,MPI_COMM_WORLD);
            // Post a non-blocking Recv for that Unit of Work
            MPI_Irecv(&result[w],1,MPI_INT,w,0,MPI_COMM_WORLD,&recv_req[w]);
            worker[w] = complete;
            dispatched++;
            complete++; // next unit of work to send out
           }
         } // foreach idle worker
        // Collect returned results
        returned = 0;
        for(w=1; w<=dispatched; w++)
         {
          MPI_Waitany(dispatched, &recv_req[1], &index, &status); 
          printf("Master receiving a result back from Worker %d c[%d]=%d\n",status.MPI_SOURCE,worker[status.MPI_SOURCE],result[status.MPI_SOURCE]);
          c[worker[status.MPI_SOURCE]] = result[status.MPI_SOURCE];
          worker[status.MPI_SOURCE] = idle;
          returned++;
         }
        dispatched -= returned;
       } //while work to be done
      //signal each worker to that there is no more work to be done
      Unit_of_Work[0] = -1;
      Unit_of_Work[1] = -1;
      for (w=1; w<numprocs; w++) 
       {
        printf("Master telling worker %d to shut down\n",w);
        MPI_Send(Unit_of_Work,2,MPI_INT,w,0,MPI_COMM_WORLD);  
       }
      for (i=0; i <iter; i++)
       {
        printf("a[%d] + b[%d] = %d\n",i,i,c[i]);
       }    
     } // Master 
    else  // Workers
     {
      printf("Worker %d Ready\n",myid);
      while (Work == 1)
       {
        MPI_Recv(Unit_of_Work,2,MPI_INT,0,0,MPI_COMM_WORLD,&status);
        printf("Worker %d received message UoW[0] = %d UoW[1] = %d\n",myid,Unit_of_Work[0],Unit_of_Work[1]);
        if ((Unit_of_Work[0] == -1) && (Unit_of_Work[1] == -1))
         {
          Work = -1;
          printf("Worker %d Shutting Down\n",myid);
         }
        else
         {
          ans = Unit_of_Work[0] + Unit_of_Work[1];
          printf("Worker %d Returning an answer for UoW[0] = %d + UoW[1] = %d = %d\n",myid,Unit_of_Work[0],Unit_of_Work[1],ans);
          MPI_Send(&ans,1,MPI_INT,0,0,MPI_COMM_WORLD);
         }
      }
     } // Workers
   }
  else
   printf("ERROR:Must have at least 2 processes to run\n");

  MPI_Finalize();
  return 0;
 }