/*********************************************************************
 * File: task_farm.c
 * Purpose: Parallel task farming on pre-compiled 
 *          executables specified as tasks in a file.
 * Usage example: mpiexec -machinefile xx -n yy ch -u task_farm.c zz  
 *                xx: host file
 *                yy: number of processes 
 *                zz: task file  
 *********************************************************************/
#include <mpi.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[]) {
  int myid, numprocs, req = 1;
  char tmp[512];
  MPI_Status status;

  MPI_Init(&argc, &argv);
  MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
  MPI_Comm_rank(MPI_COMM_WORLD, &myid);

  if(myid == 0) {
    int numtasks, i, taskscompleted = 0, activeprocs = numprocs - 1;
    FILE *fptr;
    double time1, time2;

    fptr = fopen(argv[1], "r");  // get the name of the task file
    numtasks = atoi(fgets(tmp, sizeof(tmp), fptr));  // get the number of tasks specified 
                                                     // in the first line of the task file  
    char line[numtasks][512];    // allocate a 2D char array to save the tasks 
    for(i=0; i<numtasks; i++) {  // get the tasks from the task file and save them to the char array
      fgets(line[i], sizeof(line[i]), fptr);
    }
    fclose(fptr);

    i = 0;
    time1 = MPI_Wtime();  // get the start time for the task farming 
    while(1) {
      // receive the request from any worker process for a task 
      MPI_Recv(&req, 1, MPI_INT, MPI_ANY_SOURCE, 1, MPI_COMM_WORLD, &status);
     
      // If all the tasks have been completed, the master process will get 
      // the end time when it receives the first request from a worker process, 
      // and notify the worker process to quit. Later on, when the master process 
      // receives a request from a worker process, it will just notify the worker 
      // process to quit. When all the worker processes have been notified to quit,
      // the master process will quit as well. 
      if(taskscompleted == numtasks) {
        if(activeprocs == (numprocs -1)) {
          time2 = MPI_Wtime();  // get the end time for the task farming
          printf("%f\n", time2 - time1);
        }
        strcpy(tmp, "quit");
        MPI_Send(&(tmp[0]), sizeof(tmp), MPI_CHAR, status.MPI_SOURCE, 0, MPI_COMM_WORLD);
        activeprocs--;
        if(activeprocs == 0) {
          MPI_Finalize();
          return 0;
        }
      }
      // If there are tasks that have not been completed yet, when the master process 
      // receives a request from a worker process, it will send a task to the worker
      // process. 
      else {
        MPI_Send(&(line[i][0]), sizeof(line[i]), MPI_CHAR, status.MPI_SOURCE, 0, MPI_COMM_WORLD);
        i++;
        taskscompleted++;
      }
    }
  }
  else {
    // The worker process continuouly requests a task from the master process and executes 
    // the received task until it is notified to quit. The worker process uses the function 
    // system() to run the task consisting of commands.
    while(1) {
      MPI_Send(&req, 1, MPI_INT, 0, 1, MPI_COMM_WORLD);
      MPI_Recv(&(tmp[0]), sizeof(tmp), MPI_CHAR, 0, 0, MPI_COMM_WORLD, &status);
      if(strcmp(tmp, "quit") == 0) {
        MPI_Finalize();
        return 0;
      }
      else {
        system(tmp);
      }
    }
  }
}