Assignment Number 3: Beowolf Cluster


#include <mpi.h>
#include <stdio.h>
# include<math.h>
# include <stdlib.h>
# define WORKTAG 1
# define DIETAG 2
struct Work {
 int dimension;
 int xStartPnt;
 int yStartPnt;
 int zStartPnt;
 int noOfSteps;
} *workList;
struct Result {
 int xStartPnt;
 int yStartPnt;
 int zStartPnt;
 int xEndPnt;
 int yEndPnt;
 int zEndPnt;
};
void setInitPointForRandWalks(int,int,int);
void masterProcess(int,int,int, MPI_Datatype, MPI_Datatype);
struct Work getNextWorkItem(void);
void slaveProcess(int, MPI_Datatype, MPI_Datatype);
struct Result getResultOfRandomWalk(struct Work);
MPI_Datatype getResultStructObject();
MPI_Datatype getWorkStructObject();
int main(int argc, char **argv) {
 int rank;
 MPI_Init(&argc, &argv);
 MPI_Comm_rank(MPI_COMM_WORLD, &rank); 
 int n=atoi(argv[1]);
 int s=atoi(argv[2]);;
 int w=atoi(argv[3]);;
 if (rank == 0) {//  masterProcess process
  masterProcess(n, s, w, getWorkStructObject(), getResultStructObject());
 } else {             //rank=1, 2, 3  slaveProcess processes
  slaveProcess(rank, getWorkStructObject(), getResultStructObject());
 }
 MPI_Finalize();
 return 0;
}

MPI_Datatype getResultStructObject() {
 struct Result result;
 MPI_Datatype resultStructTypeObj; 
 MPI_Datatype type[6] = {MPI_INT, MPI_INT, MPI_INT, MPI_INT, MPI_INT, MPI_INT}; 
 int blocklen[6] = {1, 1, 1,1,1,1};  
 MPI_Aint displacements[6];
   MPI_Aint addresses[7]; 
 MPI_Address( &result, &addresses[0]);  
 MPI_Address( &result.xStartPnt, &addresses[1]); 
MPI_Address( &result.yStartPnt, &addresses[2]); 
MPI_Address( &result.zStartPnt, &addresses[3]); 
MPI_Address( &result.xEndPnt, &addresses[4]); 
MPI_Address( &result.yEndPnt, &addresses[5]); 
MPI_Address( &result.zEndPnt, &addresses[6]); 
displacements[0] = addresses[1] - addresses[0]; 
displacements[1] = addresses[2] - addresses[0]; 
displacements[2] = addresses[3] - addresses[0]; 
displacements[3] = addresses[4] - addresses[0]; 
displacements[4] = addresses[5] - addresses[0]; 
displacements[5] = addresses[6] - addresses[0]; 
 MPI_Type_struct(6, blocklen, displacements, type, &resultStructTypeObj); 
 MPI_Type_commit(&resultStructTypeObj); 
 return resultStructTypeObj;
}
void setInitPointForRandWalks(int n,int s,int w) {
 workList = calloc(w, sizeof(struct Work));
 int i=0;
 for(i=0; i<w; i++) {  
  workList[i].dimension=n;  
  srand(i);
  workList[i].xStartPnt=rand()%n;
  srand(i*10);
  workList[i].yStartPnt=rand()%n;
  srand(i*20);
  workList[i].zStartPnt=rand()%n;
  workList[i].noOfSteps=s;
 }
}
MPI_Datatype getWorkStructObject() {
 struct Work work;
 MPI_Datatype workType; 
 MPI_Datatype type[5] = {MPI_INT, MPI_INT, MPI_INT, MPI_INT, MPI_INT}; 
 int blocklen[5] = {1, 1, 1,1,1};  
 MPI_Aint displacements[5];
   MPI_Aint addresses[6]; 
 MPI_Address( &work, &addresses[0]);  
 MPI_Address( &work.dimension, &addresses[1]); 
MPI_Address( &work.xStartPnt, &addresses[2]); 
MPI_Address( &work.yStartPnt, &addresses[3]); 
MPI_Address( &work.zStartPnt, &addresses[4]); 
MPI_Address( &work.noOfSteps, &addresses[5]); 
displacements[0] = addresses[1] - addresses[0]; 
displacements[1] = addresses[2] - addresses[0]; 
displacements[2] = addresses[3] - addresses[0]; 
displacements[3] = addresses[4] - addresses[0]; 
displacements[4] = addresses[5] - addresses[0]; 
 MPI_Type_struct(5, blocklen, displacements, type, &workType); 
 MPI_Type_commit(&workType); 
 return workType;
}
 
void masterProcess(int n,int s,int w, MPI_Datatype workType, MPI_Datatype resultStructTypeObj) {
 setInitPointForRandWalks(n, s, w);
 int noOfProcesses;
 int rankCounter = 1;
 struct Result result[w];
 struct Work work;
 MPI_Status status;
 MPI_Comm_size(MPI_COMM_WORLD, &noOfProcesses);
 int i;
 for (i=0;i<w; i++) {
  work = getNextWorkItem();  
  MPI_Send(&work,             
             1,                 
             workType,           
             rankCounter,              
             0,          
             MPI_COMM_WORLD);   
  rankCounter = rankCounter<3?rankCounter+1:1;
 }  
 int resultCounter = 0;
 while(resultCounter<w) {
  MPI_Recv(&result[resultCounter],          
             1,                 
             resultStructTypeObj,        
             MPI_ANY_SOURCE,    
             0,       
             MPI_COMM_WORLD,    
             &status);            
  resultCounter++;
 }
 for (i=0; i<w; i++) {
  printf("\nResult %d :", i);
  printf("\tStartPoint x=%d", result[i].xStartPnt); 
  printf(" StartPoint y=%d", result[i].yStartPnt); 
  printf(" StartPoint z=%d", result[i].zStartPnt); 
  printf("\t\tEndPoint x=%d", result[i].xEndPnt); 
  printf(" EndPoint y=%d", result[i].yEndPnt); 
  printf(" EndPoint z=%d\n", result[i].zEndPnt); 
    } 
 printf("\n\n");
 for(rankCounter=1;rankCounter<=3;rankCounter++) {
  MPI_Send(&work,             
     1,                 
     workType,           
     rankCounter,              
     DIETAG,          
     MPI_COMM_WORLD);  
}
}
struct Work getNextWorkItem() {
 static int workCounter = 0;
 struct Work nextWorkItem=workList[workCounter];
workCounter++;
 return nextWorkItem;
}
void slaveProcess(int rank, MPI_Datatype workType, MPI_Datatype resultStructTypeObj){
 struct Work work;
 struct Result result;
 MPI_Status status;
 while (1) {
   MPI_Recv(&work, 1, workType, 0, MPI_ANY_TAG,
     MPI_COMM_WORLD, &status);  
 int xStartPnt;
 int yStartPnt;
 int zStartPnt;
 int noOfSteps;
  if (status.MPI_TAG == DIETAG) {
   return;
  }
     result = getResultOfRandomWalk(work);  //Random walk  
  MPI_Send(&result, 1, resultStructTypeObj, 0, 0, MPI_COMM_WORLD);
 }
}
struct Result getResultOfRandomWalk(struct Work work) {
 struct Result result;
 int xCurrentPnt=work.xStartPnt;
 int yCurrentPnt=work.yStartPnt;
 int zCurrentPnt=work.zStartPnt;
 int randomNo = 0;
 int width = 0;
 int i;
 for ( i = 0; i < work.noOfSteps; i++) {
  int n = work.dimension;
  int rangeStart = 0;
  srand(i);
  randomNo = rand();
  randomNo = randomNo % (n*n*n);
  width = xCurrentPnt * (n -yCurrentPnt) * (n - zCurrentPnt);
  if (rangeStart <= randomNo && randomNo < (rangeStart + width)) {
   if (xCurrentPnt < n) {
    xCurrentPnt++;
   }
  } else {
   rangeStart = rangeStart + width;
   width = (n - xCurrentPnt) * yCurrentPnt * zCurrentPnt;
   if (rangeStart <= randomNo && randomNo < (rangeStart + width)) {
    if (xCurrentPnt > 1) {
     xCurrentPnt--;
    }
   } else {
    rangeStart = rangeStart + width;
    width = (n - xCurrentPnt) * yCurrentPnt * (n - zCurrentPnt);
    if (rangeStart <= randomNo && randomNo < (rangeStart + width)) {
     if (yCurrentPnt < n) {
      yCurrentPnt++;
     }
    } else {
     rangeStart = rangeStart + width;
     width = xCurrentPnt * (n - yCurrentPnt) * zCurrentPnt;
     if (rangeStart <= randomNo && randomNo < (rangeStart + width)) {
      if (yCurrentPnt > 1) {
       yCurrentPnt--;
      }
     } else {
      rangeStart = rangeStart + width;
      width = (n - xCurrentPnt) * (n - yCurrentPnt) * zCurrentPnt;
      if (rangeStart <= randomNo && randomNo < (rangeStart + width)) {
       if (zCurrentPnt < n) {
        zCurrentPnt++;
       }
      } else {
       rangeStart = rangeStart + width;
       width = xCurrentPnt * yCurrentPnt * (n - zCurrentPnt);
       if (rangeStart <= randomNo && randomNo < (rangeStart + width)) {
        if (zCurrentPnt > 1) {
         zCurrentPnt--;
        }
       }
      }
     }
    }
   }
  }
 }
  result.xStartPnt=work.xStartPnt;
  result.yStartPnt=work.yStartPnt;
  result.zStartPnt=work.zStartPnt;
  result.xEndPnt=xCurrentPnt;
  result.yEndPnt=yCurrentPnt;
  result.zEndPnt=zCurrentPnt;
 
  return result;
}