#line 1 "main.c"
/**********************************************************************
This is the main routine of the parallel sort utility. It is primarily
a testing harness for the parallel_sort() routine defined is par_sort.c.

It currently assumes the data starts and ends in a data file. Random
source data file can be automatically generated using the -g option.

Note that this routine does not test the unbalanced sorting
capabilities of parallel_sort() as it always divides the file into
"perfect" subdivisions according to the "infinity padding" rule.
**********************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/fcntl.h>
#include <sys/unistd.h>
#include <errno.h>
#include <signal.h>
#include "mimd.h"
#include "sort_util.h"
#include "element.h"

int myrank,nprocs;


static longint N=0;

static int print_out = 0;
static int generate = 0;
static int verify=0;

#define MEM_LIMIT 5*1024*1024
int mem_limit = MEM_LIMIT;
int worst_case = 0;

int reverse = 1;

/**********************************************************************
a simple comparison fn
**********************************************************************/
int comparison(element *i1,element *i2)
{
  int i=0,d;
  do {
    if ((d=(i1->i[i] - i2->i[i]))) return(d);
  } while (++i<ELISIZE);
  return(0);
}

/**********************************************************************
generate a random element
**********************************************************************/
void random_element(element *d)
{
  int i;
  if (worst_case) {
    for (i=0;i<ELSIZE;i++)
      d->c[i] = (random()%2)?255:0;
  } else {
    for (i=0;i<ELISIZE;i++) 
      d->i[i] = random();
  }
}

/**********************************************************************
print one element
**********************************************************************/
void print_element(element *d)
{
  int i;
  for (i=0;i<ELSIZE;i++)
    printf("%03d",d->c[i]);
}

/**********************************************************************
print the data in file
**********************************************************************/
void print_data(char *file)
{
  element d;
  int fd = open(file,O_RDONLY);
  if (fd < 0) return;

  while (read(fd,&d,sizeof(d))==sizeof(d)) {
    print_element(&d); printf("\n");
  }
  close(fd);
}


/* this silly global is a work around for memory fragmentation
   problems on the AP1000 (it has no MMU) */
element *data_ptr=NULL;

/**********************************************************************
generate some data
**********************************************************************/
void generate_data(char *file)
{
  int chunk,myN;
  int fd;
  longint start;
  if (NODE_NUMBER==0) {
    fd = open(file,O_WRONLY | O_CREAT | O_TRUNC,0644);
    MIMD_Barrier();
  } else {
    MIMD_Barrier();
    fd = open(file,O_WRONLY,0644);
  }

  if (fd < 0) return;

   
  chunk = MEM_LIMIT / sizeof(element);

  myN = (N+(NUM_NODES-1))/NUM_NODES;
  start = myN * NODE_NUMBER;
  myN = MIN(myN,N - start);
  if (myN < 0) myN = 0;

  if (myN) {
    if (data_ptr) {
      element *d = (element *)realloc(data_ptr,MIN(chunk,myN)*sizeof(element));
      if (!d) {
	free(data_ptr);
	data_ptr = NULL;
      } else {
	data_ptr = d;
      }
    }
    if (!data_ptr)
      data_ptr = (element *)malloc(MIN(chunk,myN)*sizeof(element));
    if (!data_ptr) {
      printf("Can't malloc in generate\n");
      exit(0);
    }
  }
  

  lseek(fd,start*sizeof(element),SEEK_SET);

  while (myN) {
    int s = MIN(myN,chunk);
    int i;
    for (i=0;i<s;i++)
      random_element(&data_ptr[i]);
    if (write(fd,data_ptr,s*sizeof(element)) != s*sizeof(element)) {
      printf("write failed generating data\n");
      exit(0);
    }
    myN -= s;
  }

  close(fd);
}

/**********************************************************************
copy a file in parallel
**********************************************************************/
void copy_file(char *infile,char *outfile)
{
  int fd1,fd2;
  longint size,start;
  int mysize;
  char *buf;

  fd1 = open(infile,O_RDONLY);
  fd2 = open(outfile,O_WRONLY | O_CREAT | O_TRUNC,0644);

  if (fd1 < 0 || fd1 < 0) {
    printf("failed to open files\n");
    exit(0);
  }

  size = lseek(fd1,0,SEEK_END);
  lseek(fd1,0,SEEK_SET);

  MIMD_Barrier();


  mysize = (size+(NUM_NODES-1)) / NUM_NODES;
  start = mysize * NODE_NUMBER;
  mysize = MIN(mysize,size - start);
  if (mysize < 0) mysize = 0;
  lseek(fd1,start,SEEK_SET);
  lseek(fd2,start,SEEK_SET);

  buf = malloc(MIN(mysize,MEM_LIMIT));
    
  while (mysize) {
    int s = MIN(mysize,MEM_LIMIT);
    if (read(fd1,buf,s) != s) {
      printf("read failure in copy_file\n");
      exit(0);
    }
    if (write(fd2,buf,s) != s) {
      printf("write failure in copy_file\n");
      exit(0);
    }
    mysize -= s;
  }

  free(buf);
  close(fd1);
  close(fd2);
}



/**********************************************************************
verify the data is sorted correctly
**********************************************************************/
void verify_sort(char *infile,char *outfile)
{
  double t1,t2;
  int i;
  element *d,d1;
  int fd = open(infile,O_RDONLY);
  int size;
  if (fd < 0) return;

  size = lseek(fd,0,SEEK_END);
  lseek(fd,0,SEEK_SET);
  d = (element *)malloc(size);
  if (!d) {
    printf("couldn't malloc %d bytes\n",size);
    exit(0);
  }
  if (read(fd,d,size) != size) {
    printf("failed to read data\n");
    exit(0);
  }
  close(fd);

  t1 = MIMD_Uptime();
  qsort(d,size/sizeof(element),sizeof(element),(QSORT_CAST)comparison);
  t2 = MIMD_Uptime();

  printf("verify sort of %d items took %g secs\n",
	 (int)(size/sizeof(element)),t2-t1);

  fd = open(outfile,O_RDONLY);
  if (fd < 0) return;

#if HIDIOS
  tbuffer(fd,256*1024);
#endif

  for (i=0;i<size/sizeof(element);i++) {
    if (read(fd,&d1,sizeof(d1))!=sizeof(d1))
      return;
    if (comparison(&d1,&d[i]) != 0) {
      printf("sort failed at %d\n",i);
      printf("bad="); print_element(&d1); printf("\n");
      printf("good="); print_element(&d[i]); printf("\n");
      return;
    }
  }

  printf("Sort is OK\n");
  free(d);
  close(fd);
}


/**********************************************************************
do the actual sorting
**********************************************************************/
void sort_data(char *file)
{
  int fd;
  double t1,t2;
  int res;  
  longint size;

  MIMD_Barrier();

  fd = open(file,O_RDWR);
  if (fd < 0) return;

  size = lseek(fd,0,SEEK_END) / sizeof(element);

  MIMD_Barrier();
  t1 = MIMD_Uptime();

  reverse = 1;
  parallel_sort(fd,sizeof(element),comparison);

  MIMD_Barrier();
  t2 = MIMD_Uptime();

  close(fd);


  printf("sorted %d items in %g secs\n",(int)size,t2-t1);
  if (IS_BOTTOM_NODE)
    printf("TOTAL: Sorted %d items in %g secs (%g items/sec)\n",
	   (int)size,t2-t1,size/(t2-t1));
}

int segv_handler(int sig,int code,struct sigcontext *scp,char *addr)
{
  printf("Got segv at 0x%X\n",((int)scp->sc_pc) - (((int)&N)-8));
  fflush(stdout);
  signal(SIGSEGV,SIG_DFL);
}

/**********************************************************************
the main entry point
**********************************************************************/
int MPID_main(int argc, char **argv)
{
  int loop=0,delete=0;
  char *infile,*outfile;
  
  MPI_Init(&argc, &argv);
  MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
  MPI_Comm_size(MPI_COMM_WORLD, &nprocs);

  printf("hello!\n");

  signal(SIGSEGV,segv_handler);

  srandom(NODE_NUMBER);

  while (argc > 1 && argv[1][0] == '-') {    
    switch (argv[1][1]) {
    case 'p':
      print_out = 1;
      break;

    case 'v':
      verify = 1;
      break;

    case 'D':
      delete = 1;
      break;

    case 'i':
      {
	extern int internal_timing;
	internal_timing = 1;
      }
      break;

    case 'l':
      argv++; argc--;
      loop = atoi(argv[1]);
      break;

    case 'w':
      worst_case = 1;
      break;

    case 'g':
      argv++; argc--;
      generate = 1;
      N = atoi(argv[1]);
      break;

    case 's':
      argv++; argc--;
      srandom(atoi(argv[1]) + NODE_NUMBER);
      break;

    case 'm':
      argv++; argc--;
      mem_limit = atoi(argv[1])*1024;
      break;

    default:
      printf("Unknown option %s\n",argv[1]);
    }
    argv++; argc--;
  }


  if (argc < 3) {
    printf("Usage: capsort <infile> <outfile>\n");
    exit(0);
  }
    
  infile = argv[1];
  outfile = argv[2];


  do {
    MIMD_Barrier();
    printf("Starting up at %g\n",MIMD_Uptime());
    if (generate)
      generate_data(infile);

    MIMD_Barrier();

    if (strcmp(infile,outfile)) {
      printf("Copying file at %g\n",MIMD_Uptime());
      copy_file(infile,outfile);
    }

    MIMD_Barrier();

    if (print_out) {
      if (IS_BOTTOM_NODE) 
	print_data(infile);
      MIMD_Barrier();
    }
    
    MIMD_Barrier();
    
    sort_data(outfile);
    
    MIMD_Barrier();
    
    if (print_out) {
      MIMD_Barrier();
      if (IS_BOTTOM_NODE) 
	print_data(outfile);
    }
    
    MIMD_Barrier();
    
    if (verify && IS_BOTTOM_NODE) {
      verify_sort(infile,outfile);
    }
    
    MIMD_Barrier();
    
#if 1
    mem_limit *= 2;
#else
    N *= 2;
#endif
  if (delete && NODE_NUMBER==0) {
    unlink(infile);
    unlink(outfile);
  }
  } while (loop--);


  MIMD_Finalize();
  return(0);
}