/* ---------------------------------------------------------------
 * MPI - MPI_Scatter() communication benchmark.
 * FILE: scatter.c
 * DESCRIPTION: this program performs the MPI_Scatter() communication call
 * on a variety of message sizes.
 *
 *  AUTHOR: George Gusciora: Maui High Performance Computing Center
 * --------------------------------------------------------------- */
#include "mpi.h"
#include <stdio.h>
#define NUM_SIZES	15
#define	NUMBER_REPS	10
#ifdef USE_RTC
   double rtc(void);
#endif
#ifdef USE_READREALTIME
   #include <sys/time.h>
   #include <sys/systemcfg.h>
#endif

int main(argc,argv)
int argc;
char *argv[];
{
   char *inmsg, *outmsg;
   int repnum, msize, numtasks, taskid, rc, source, MESSAGE_SIZE;
   double StartTime, EndTime;
   double round_trips[NUM_SIZES][NUMBER_REPS];
   double avg_round_trip[NUM_SIZES];
   double min_round_trip[NUM_SIZES];
   #ifdef USE_READREALTIME
      timebasestruct_t *StartTime_rrt, *EndTime_rrt;
      size_t size_of_timebasestruct_t;
      StartTime_rrt = (timebasestruct_t *) malloc(sizeof(timebasestruct_t));
      EndTime_rrt   = (timebasestruct_t *) malloc(sizeof(timebasestruct_t));
   #endif

   MPI_Init(&argc,&argv);
   MPI_Comm_size(MPI_COMM_WORLD,&numtasks);
   MPI_Comm_rank(MPI_COMM_WORLD,&taskid);

   if (taskid == 0)
      printf("Running scatter() test on %d nodes\n", numtasks);
   MESSAGE_SIZE=1024;
   for(msize=0;msize<NUM_SIZES;msize++)
   {
      inmsg = (char *) malloc(MESSAGE_SIZE);
      outmsg = (char *) malloc(MESSAGE_SIZE);
      source = 0;
      for (repnum=0;repnum<NUMBER_REPS;repnum++)
      {
         MPI_Barrier(MPI_COMM_WORLD);
         #ifdef USE_WTIME
            StartTime = MPI_Wtime();
         #endif
         #ifdef USE_RTC
            StartTime = rtc();
         #endif
         #ifdef USE_READREALTIME
            read_real_time(StartTime_rrt, size_of_timebasestruct_t);
         #endif

         MPI_Scatter(outmsg, MESSAGE_SIZE/numtasks, MPI_BYTE,
                     inmsg, MESSAGE_SIZE/numtasks, MPI_BYTE,
                     source, MPI_COMM_WORLD);
         MPI_Barrier(MPI_COMM_WORLD);
         #ifdef USE_WTIME
            EndTime = MPI_Wtime();
            round_trips[msize][repnum] = EndTime - StartTime;
         #endif
         #ifdef USE_RTC
            EndTime = rtc();
            round_trips[msize][repnum] = EndTime - StartTime;
         #endif
         #ifdef USE_READREALTIME
            read_real_time(EndTime_rrt, size_of_timebasestruct_t);
            round_trips[msize][repnum] = (EndTime_rrt->tb_high - StartTime_rrt->tb_high) +
                                         ((EndTime_rrt->tb_low - StartTime_rrt->tb_low)/1e9);
         #endif

      }
      MESSAGE_SIZE*=2;
   }

   if (taskid == 0)
   {
      MESSAGE_SIZE=1024;
      for(msize=0;msize<NUM_SIZES;msize++)
      {
         avg_round_trip[msize] = 0;
         min_round_trip[msize] = 100000000000000000000000000000000000000000000000000.0;
         for (repnum=0;repnum<NUMBER_REPS;repnum++)
         {
            avg_round_trip[msize]+= round_trips[msize][repnum];
            if (round_trips[msize][repnum] < min_round_trip[msize])
               min_round_trip[msize] = round_trips[msize][repnum];
         }
         avg_round_trip[msize]/= ((double) NUMBER_REPS);
         MESSAGE_SIZE*=2;
      }

      MESSAGE_SIZE=1024;
      for(msize=0;msize<NUM_SIZES;msize++)
      {
         printf("Average Round Trip for %d byte messages is %f uSec (%.2f Mbytes/sec)\n",
                 MESSAGE_SIZE,
                 1e6 * avg_round_trip[msize],
                 1e-6 * ((float) (MESSAGE_SIZE)) / avg_round_trip[msize]);
         MESSAGE_SIZE*=2;
      }

      MESSAGE_SIZE=1024;
      for(msize=0;msize<NUM_SIZES;msize++)
      {
         printf("Minimum Round Trip for %d byte messages is %f uSec (%.2f Mbytes/sec)\n",
                 MESSAGE_SIZE,
                 1e6 * min_round_trip[msize],
                 1e-6 * ((float) (MESSAGE_SIZE)) / min_round_trip[msize]);
         MESSAGE_SIZE*=2;
      }
   }

   MPI_Finalize();
   exit(0);
}