Simple MPI I/O and Error Handling

/**********************************************************************
 Copyright 2005, The Trustees of Indiana University. All right reserved.

 This program illustrates how MPI I/O can be used to copy a file...
  i.e. read from it and then write to a new file.

**********************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <mpi.h>       /* Include the MPI definitions */

#define USE_VT 1  /* 1 to call Intel Trace Collector API, 0 otherwise */

#if USE_VT
#include "VT.h"
#endif

void ErrorMessage(int, int, char*);


int main(int argc, char *argv[])
{
  int numprocs, myrank;
  int start, end, length;
  char* buffer;
  int error=0, my_get_size_error=0, get_size_error=0;
  MPI_Status    status;
  MPI_File      fh;
  MPI_Offset    filesize;

  /* Initialize MPI */
  MPI_Init(&argc, &argv);
  MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
  MPI_Comm_rank(MPI_COMM_WORLD, &myrank);

  if (argc != 3)
    {
      fprintf(stderr, "Usage: %s FileToReadIn FileToWriteTo\n", argv[0]);
      exit(-1);
    }


  /* Open file to read  */
  /* FIRST way of handling errors, not very clean, note open file */
  /* MPI_Abort () lets you return an error code */
  /* MPI_SUCCESS defined in mpi_errno.h which is included in mpi.h */

  /* While using LAM, linking to libVT causes MPI_File_open () to crash ; This problem   */
  /*   does not exist if MPICH is used */
#if USE_VT
    VT_traceoff();		/* Don't want to trace MPI_File_open () while using LAM  */
#endif
  error = MPI_File_open(MPI_COMM_WORLD, argv[1],
			MPI_MODE_RDONLY, MPI_INFO_NULL, &fh);
#if USE_VT
   VT_traceon();		/* Restart tracing  */
#endif

  if(error != MPI_SUCCESS) {
    fprintf(stdout, "Proc %d: Could not open file %s ; error code: %d\n", myrank, argv[1], error);
    MPI_Abort (MPI_COMM_WORLD, -1);
  }

  /* Get the size of file */
  error = MPI_File_get_size(fh, &filesize); 
  /* Not efficient use of variables, but our objective is show a mechanism to handle errors */
  if(error != MPI_SUCCESS) my_get_size_error = 1;  

  /* SECOND way of handling errors, much safer, still not copmplete. */
  MPI_Allreduce (&my_get_size_error, &get_size_error, 1, MPI_INT, 
		 MPI_LOR, MPI_COMM_WORLD);

  if (get_size_error == 0) {

    /* Calculate the range for each process to read */
    length = filesize / numprocs;
    start = length * myrank;
    if (myrank == numprocs-1)
      end = filesize;
    else
      end = start + length;
    fprintf(stdout, "Proc %d: range = (%d, %d); filesize was %d\n", myrank, start, end, filesize);
    
    /* Allocate space */
    buffer = (char *)malloc((end - start) * sizeof(char));
    if (buffer == NULL) ErrorMessage(-1, myrank, "malloc");
    
    /* Each process reads in different part of  the file */
    MPI_File_seek(fh, start, MPI_SEEK_SET); 
    error = MPI_File_read(fh, buffer, end-start, MPI_BYTE, &status);
    if(error != MPI_SUCCESS) ErrorMessage(error, myrank, "MPI_File_read");
  }
  else {
    fprintf (stderr, " Proc: %d: Error getting file size, will close file now and quit ... \n", myrank);
  }
  /* Close the file; Would have gotten here straight away if there was an error getting size */
  MPI_File_close(&fh);

  if (get_size_error == 0) {
    /* Open file to write */
#if USE_VT
    VT_traceoff();		/* Don't want to trace MPI_File_open () while using LAM  */
#endif
    error = MPI_File_open(MPI_COMM_WORLD, argv[2],
			  MPI_MODE_WRONLY | MPI_MODE_CREATE, MPI_INFO_NULL, &fh);
#if USE_VT
    VT_traceon();		/* Restart tracing  */
#endif

    if(error != MPI_SUCCESS) ErrorMessage(error, myrank, "MPI_File_open");
    
    error = MPI_File_write_at(fh, start, buffer, end-start, MPI_BYTE, &status);
    if(error != MPI_SUCCESS) ErrorMessage(error, myrank, "MPI_File_write");
    
    /* close the file */
    MPI_File_close(&fh);
  }
  
  /* Finalize MPI */
  MPI_Finalize();
  return 0;
}

void ErrorMessage(int error, int rank, char* string)
{
  fprintf(stderr, "Process %d: Error %d in %s\n", rank, error, string);
  MPI_Finalize();
  exit(-1);
}