/* ---------------------------------------------------------------
 * MPI - MPI point-to-point communication benchmark.
 * FILE: timing.c
 * DESCRIPTION: this program performs the point-to-point blocking message
 * passing calls on a variety of message sizes.
 *
 *  AUTHOR: George Gusciora: Maui High Performance Computing Center
 * --------------------------------------------------------------- */
#include "mpi.h"
#include <stdio.h>
#define NUM_SIZES	22
#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, dst, src, type, MESSAGE_SIZE;
   double StartTime, EndTime;
   double round_trips[NUM_SIZES][NUMBER_REPS];
   double avg_round_trip[NUM_SIZES];
   double min_round_trip[NUM_SIZES];
   MPI_Status Stat;
   float speed;
   #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);
   type = 1;

   MESSAGE_SIZE=4;
   for(msize=0;msize<NUM_SIZES;msize++)
   {
      inmsg = (char *) malloc(MESSAGE_SIZE);
      outmsg = (char *) malloc(MESSAGE_SIZE);
      if (taskid == 0)
      {
         dst = 1; src = 1;
         for (repnum=0;repnum<NUMBER_REPS;repnum++)
         {
            #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_Send(outmsg, MESSAGE_SIZE, MPI_BYTE, dst, type, MPI_COMM_WORLD);
            MPI_Recv(inmsg, MESSAGE_SIZE, MPI_BYTE, src, type, MPI_COMM_WORLD, &Stat);

            #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

         }
      } else if (taskid == 1)
      {
         dst = 0; src = 0;
         for (repnum=0;repnum<NUMBER_REPS;repnum++)
         {
            MPI_Recv(inmsg, MESSAGE_SIZE, MPI_BYTE, src, type, MPI_COMM_WORLD, &Stat);
            MPI_Send(outmsg, MESSAGE_SIZE, MPI_BYTE, dst, type, MPI_COMM_WORLD);
         }
      }

      MESSAGE_SIZE*=2;
      free(inmsg);
      free(outmsg);
   }

   if (taskid == 0)
   {
      MESSAGE_SIZE=4;
      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=4;
      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]/2));
         MESSAGE_SIZE*=2;
      }

      MESSAGE_SIZE=4;
      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]/2));
         MESSAGE_SIZE*=2;
      }
   }
   MPI_Finalize();
   exit(0);
}