[svn-r3851]

Purpose:
    Bug fix.
Description:
    The Pablo instrumentation would not build because the HAVE_PABLO flag
    was renamed H5_HAVE_PABLO.  Also, there were problems with MPI I/O
    tracing when the MPI did not follow the MPI I/O standards exactly.A
Solution:
    Renamed all conditional compiliation flags so that they begin H5_ .
    Added entries HDF_MPI_xxx for all MPI I/O functions HDF_MPI_xxx used in
    HDF.  These functions record data, call the corresponding function
    MPI_xxx directly, then record exit data.  Previously this was done in
    the MPI I/O portion of the Trace Library, but caused link conflicts.
Platforms tested:
    IRIX64/IRIX32/Linux/Solaris/VClass32/VClass64

8 files changed, 2352 insertions, 1541 deletions

diff --git a/pablo/HDFTrace.h b/pablo/HDFTrace.h
index 1bcf8d6..a8e2a47 100644
--- a/pablo/HDFTrace.h
+++ b/pablo/HDFTrace.h
@@ -131,7 +131,41 @@ extern char *hdfRecordPointer;
 #define FAMILY_MISC      	0270
 #define FAMILY_HDFPROCNAME     	0300
 
+#define mpiOpenBeginID             900800
+#define mpiOpenEndID               900801
+
+#define mpiCloseBeginID            900802
+#define mpiCloseEndID              900803
+
+#define mpiSetSizeBeginID          900806
+#define mpiSetSizeEndID            900807
+
+#define mpiGetSizeBeginID          900810
+#define mpiGetSizeEndID            900811
+
+#define mpiSetViewBeginID          900816
+#define mpiSetViewEndID            900817
+
+#define mpiGetViewBeginID          900818
+#define mpiGetViewEndID            900819
+
+#define mpiReadAtBeginID           900820
+#define mpiReadAtEndID             900821
+
+#define mpiReadAtAllBeginID        900822
+#define mpiReadAtAllEndID          900823
+
+#define mpiWriteAtBeginID          900824
+#define mpiWriteAtEndID            900825
+
+#define mpiWriteAtAllBeginID       900826
+#define mpiWriteAtAllEndID         900827
+
+#define mpiSyncBeginID             900856
+#define mpiSyncEndID               900857
+
 typedef struct {
+        long numBytes;
         long setID;
         char *setName;
 } HDFsetInfo ;
diff --git a/pablo/HDFmpioProtos.h b/pablo/HDFmpioProtos.h
index e5d33ef..5a08c4e 100644
--- a/pablo/HDFmpioProtos.h
+++ b/pablo/HDFmpioProtos.h
@@ -1,31 +1,13 @@
 #define MPI_File_open HDF_MPI_File_open
 #define MPI_File_close HDF_MPI_File_close
-#define MPI_File_delete HDF_MPI_File_delete
 #define MPI_File_set_size HDF_MPI_File_set_size
-#define MPI_File_preallocate HDF_MPI_File_preallocate
 #define MPI_File_get_size HDF_MPI_File_get_size
-#define MPI_File_get_group HDF_MPI_File_get_group
-#define MPI_File_get_amode HDF_MPI_File_get_amode
 #define MPI_File_set_view HDF_MPI_File_set_view
 #define MPI_File_get_view HDF_MPI_File_get_view
 #define MPI_File_read_at HDF_MPI_File_read_at
 #define MPI_File_read_at_all HDF_MPI_File_read_at_all
 #define MPI_File_write_at HDF_MPI_File_write_at
 #define MPI_File_write_at_all HDF_MPI_File_write_at_all
-#define MPI_File_iread_at HDF_MPI_File_iread_at
-#define MPI_File_iwrite_at HDF_MPI_File_iwrite_at
-#define MPI_File_read HDF_MPI_File_read
-#define MPI_File_read_all HDF_MPI_File_read_all
-#define MPI_File_write HDF_MPI_File_write
-#define MPI_File_write_all HDF_MPI_File_write_all
-#define MPI_File_iread HDF_MPI_File_iread
-#define MPI_File_iwrite HDF_MPI_File_iwrite
-#define MPI_File_seek HDF_MPI_File_seek
-#define MPI_File_get_position HDF_MPI_File_get_position
-#define MPI_File_get_byte_offset HDF_MPI_File_get_byte_offset
-#define MPI_File_get_type_extent HDF_MPI_File_get_type_extent
-#define MPI_File_set_atomicity HDF_MPI_File_set_atomicity
-#define MPI_File_get_atomicity HDF_MPI_File_get_atomicity
 #define MPI_File_sync HDF_MPI_File_sync
 
 int HDF_MPI_File_open( MPI_Comm comm, char *filename, int amode, 
@@ -33,10 +15,7 @@ int HDF_MPI_File_open( MPI_Comm comm, char *filename, int amode,
 int HDF_MPI_File_close( MPI_File *fh );
 int HDF_MPI_File_delete( char *filename, MPI_Info info );
 int HDF_MPI_File_set_size( MPI_File fh, MPI_Offset size );
-int HDF_MPI_File_preallocate( MPI_File fh, MPI_Offset size);
 int HDF_MPI_File_get_size( MPI_File fh, MPI_Offset *size );
-int HDF_MPI_File_get_group( MPI_File fh, MPI_Group *group );
-int HDF_MPI_File_get_amode( MPI_File fh, int *amode );
 int HDF_MPI_File_set_view( MPI_File fh, MPI_Offset disp, MPI_Datatype etype, 
 			    MPI_Datatype filetype, char *datarep, 
 			    MPI_Info info );
@@ -55,32 +34,4 @@ int HDF_MPI_File_write_at( MPI_File fh, MPI_Offset offset, void *buf,
 int HDF_MPI_File_write_at_all( MPI_File fh, MPI_Offset offset, void *buf, 
                                 int count, MPI_Datatype datatype, 
                                 MPI_Status *status );
-
-int HDF_MPI_File_iread_at( MPI_File fh, MPI_Offset offset, void *buf, 
-                            int count, MPI_Datatype datatype, 
-                            MPIO_Request *request );
-int HDF_MPI_File_iwrite_at( MPI_File fh, MPI_Offset offset, void *buf, 
-                             int count, MPI_Datatype datatype, 
-                             MPIO_Request *request );
-int HDF_MPI_File_read( MPI_File fh, void *buf, int count, 
-                             MPI_Datatype datatype, MPI_Status *status );
-int HDF_MPI_File_read_all( MPI_File fh, void *buf, int count, 
-                            MPI_Datatype datatype, MPI_Status *status );
-int HDF_MPI_File_write( MPI_File fh, void *buf, int count, 
-                         MPI_Datatype datatype, MPI_Status *status );
-int HDF_MPI_File_write_all( MPI_File fh, void *buf, int count, 
-                             MPI_Datatype datatype, MPI_Status *status );
-int HDF_MPI_File_iread( MPI_File fh, void *buf, int count, 
-			 MPI_Datatype datatype, MPIO_Request *request );
-int HDF_MPI_File_iwrite( MPI_File fh, void *buf, int count, 
-			  MPI_Datatype datatype, MPIO_Request *request );
-int HDF_MPI_File_seek( MPI_File fh, 
-		        MPI_Offset offset, int whence ) ;
-int HDF_MPI_File_get_position( MPI_File fh, MPI_Offset *offset );
-int HDF_MPI_File_get_byte_offset( MPI_File fh, MPI_Offset offset, 
-                                   MPI_Offset *disp) ;
-int HDF_MPI_File_get_type_extent( MPI_File fh, MPI_Datatype datatype, 
-			           MPI_Aint *extent );
-int HDF_MPI_File_set_atomicity( MPI_File fh, int flag );
-int HDF_MPI_File_get_atomicity( MPI_File fh, int *flag );
 int HDF_MPI_File_sync( MPI_File fh );
diff --git a/pablo/HDFrecord_RT.h b/pablo/HDFrecord_RT.h
index 808eaef..3fb3f31 100644
--- a/pablo/HDFrecord_RT.h
+++ b/pablo/HDFrecord_RT.h
@@ -102,13 +102,52 @@
 /*======================================================================*
 // Enumeration of time fields in an HDFrec_t below			*
 //======================================================================*/
-enum TimeFields { HDF_, MPI, Malloc, AllIO, Open, Close, Read, Write, ARead,
-                  AWrite, Seek, Wait, Misc, nTallyFields };
+enum TimeFields { HDF_, 
+                  MPI, 
+                  Malloc, 
+                  AllIO, 
+                  Open,
+                  Close,
+                  Read,
+                  Write,
+                  Aread,
+                  Awrite,
+                  Seek,
+                  Wait,
+                  Misc,
+                  MPIOread,
+                  MPIOreadAll,
+                  MPIOwrite,
+                  MPIOwriteAll,
+                  MPIOiRead,
+                  MPIOiWrite,
+                  MPIOother,
+                  nTallyFields,
+                  MPIOreadTrans,
+                  MPIOreadAllTrans,
+                  MPIOwriteTrans,
+                  MPIOwriteAllTrans
+                };
 /*======================================================================*
 // Enumeration of byte fields in an HDFrec_t below			*
 //======================================================================*/
-enum ByteFields{ MallocBytes, ReadBytes, WriteBytes, AReadBytes, AWriteBytes,
-                 nByteFields };
+enum ByteFields{ MallocBytes,
+                 ReadBytes,
+                 WriteBytes,
+                 AreadBytes,
+                 AwriteBytes,
+                 MPIOreadBytesReq,
+                 MPIOreadBytesTrans,
+                 MPIOwriteBytesReq,
+                 MPIOwriteBytesTrans,
+                 MPIOreadAllBytesReq,
+                 MPIOreadAllBytesTrans,
+                 MPIOwriteAllBytesReq,
+                 MPIOwriteAllBytesTrans,
+                 MPIOiReadBytesReq,
+                 MPIOiWriteBytesReq,
+                 nByteFields,
+                 nHistFields = AwriteBytes+1 };
 /*======================================================================*
 // Definition of first and last IO event.         	 		*
 //======================================================================*/
@@ -121,16 +160,16 @@ int BktLim[] = { 1, 4*ONEK, 64*ONEK, 256*ONEK, INT_MAX } ;
 // Definition of structure used to account activity in an HDF call	*
 //======================================================================*/
 typedef struct {
-  	int     nCalls;   		/* number of proc calls		*/
-  	CLOCK   lastCall;		/* time of last call		*/
-  	CLOCK   incDur;			/* inclusive duration		*/
-  	CLOCK   excDur;			/* exclusive duration		*/
-	CLOCK   times[nTallyFields];	/* Tally op/calls times		*/
-	int     counts[nTallyFields];	/* Tally op/calls counts	*/
-	int     bytes[nByteFields];	/* Tally bytes transferred	*/
-	int     Hists[nByteFields][nBkts];  /* Historgrams		*/
-	long	hdfID;			/* data set ID			*/
-	long	xRef;			/* data set cross reference	*/
+  	int   nCalls;   		/* number of proc calls		*/
+  	CLOCK lastCall;			/* time of last call		*/
+  	CLOCK incDur;			/* inclusive duration		*/
+  	CLOCK excDur;			/* exclusive duration		*/
+	CLOCK times[nTallyFields];	/* Tally op/calls times		*/
+	int counts[nTallyFields];	/* Tally op/calls counts	*/
+	int bytes[nByteFields];		/* Tally bytes transferred	*/
+	int Hists[nHistFields][nBkts];  /* Historgrams			*/
+	long hdfID;			/* data set ID			*/
+	long xRef;			/* data set cross reference	*/
 } HDFrec_t;
 /*======================================================================*
 // Node used to maintain linked lists of HDF procedure activity.       	*
diff --git a/pablo/Makefile.in b/pablo/Makefile.in
index d5941ad..c70c933 100644
--- a/pablo/Makefile.in
+++ b/pablo/Makefile.in
@@ -14,11 +14,12 @@ TRACE=perl ../bin/trace
 ## For Pablo instrumenation of parallel code, remove the # from in front of
 ## PABLO_MPIO_FLAGS.
 ## Set PABLO_INC equal to the path of the include directory for the Pablo
-## TraceLibrary
+## TraceLibrary.  This can be done by setting the environment variable
+## PABLO_TRACELIB to the path where the Pablo Trace Library ins installed.
 ###############################################################################
-#PABLO_MPIO_FLAGS = -DHAVE_PARALLEL -DHAVE_MPIOTRACE	
-PABLO_INC = 
-PABLO_FLAGS = -I. -I../src -I$(PABLO_INC) -DHAVE_PABLO $(PABLO_MPIO_FLAGS)
+#PABLO_MPIO_FLAGS = -DH5_HAVE_PARALLEL -DH5_HAVE_MPIOTRACE	
+PABLO_INC = $(PABLO_TRACELIB)/include
+PABLO_FLAGS = -I. -I../src -I$(PABLO_INC) -DH5_HAVE_PABLO $(PABLO_MPIO_FLAGS)
 
 ## This is our main target:
 LIB=libhdf5-inst.a
@@ -29,17 +30,22 @@ SRCDIRS = ./. ../src/.
 #  should be make to the SRCFILES macro also and the LIB_SRC variable now has
 #  directory paths included in it (which may cause problems somewhere). - QAK
 LIB_SRC= \
-    H5.c H5A.c H5AC.c H5B.c H5D.c H5E.c H5F.c H5Farray.c H5Fcontig.c \
-    H5Fistore.c H5Fseq.c H5FD.c H5FDsec2.c H5FDfamily.c H5FDmpio.c H5FDcore.c \
-    H5FDdpss.c H5FDmulti.c H5FDgass.c H5FDlog.c H5FDsrb.c H5FDstdio.c \
-    H5FDstream.c H5FL.c H5G.c H5Gent.c H5Gnode.c H5Gstab.c H5HG.c H5HL.c H5I.c \
-    H5MF.c H5MM.c H5O.c H5Oattr.c H5Ocomp.c H5Ocont.c H5Odtype.c H5Oefl.c \
-    H5Ofill.c H5Olayout.c H5Omtime.c H5Oname.c H5Onull.c H5Osdspace.c \
-    H5Oshared.c H5Ostab.c H5P.c H5R.c H5S.c H5Sall.c H5Shyper.c \
-    H5Smpio.c H5Snone.c H5Spoint.c H5Sselect.c H5T.c H5Tbit.c H5Tconv.c \
-    H5Tinit.c H5Tvlen.c H5TB.c H5TS.c H5V.c H5Z.c H5Zdeflate.c 
-
-PABLO_OBJ = PabloHDF.o PabloHDF_RT.o PabloHDF_SDDF.o PabloHDFff.o
+    H5.c H5FDmulti.c H5HG.c H5Oname.c H5T.c \
+    H5A.c H5FDsec2.c H5HL.c H5Onull.c H5TB.c \
+    H5AC.c H5FDsrb.c H5I.c H5Osdspace.c H5TS.c \
+    H5B.c H5FDstdio.c H5MF.c H5Oshared.c H5Tbit.c \
+    H5D.c H5FDstream.c H5MM.c H5Ostab.c H5Tconv.c \
+    H5E.c H5FL.c H5O.c H5P.c H5Tinit.c \
+    H5F.c H5Farray.c H5Oattr.c H5R.c H5Tvlen.c \
+    H5FD.c H5Fcontig.c H5Ocomp.c H5S.c H5V.c \
+    H5FDcore.c H5Fistore.c H5Ocont.c H5Sall.c H5Z.c \
+    H5FDdpss.c H5Fseq.c H5Odtype.c H5Shyper.c H5Zdeflate.c \
+    H5FDfamily.c H5G.c H5Oefl.c H5Smpio.c H5detect.c \
+    H5FDgass.c H5Gent.c H5Ofill.c H5Snone.c \
+    H5FDlog.c H5Gnode.c H5Olayout.c H5Spoint.c \
+    H5FDmpio.c H5Gstab.c H5Omtime.c H5Sselect.c
+
+PABLO_OBJ = PabloHDF.o PabloHDF_RT.o PabloHDF_SDDF.o 
 
 LIB_COBJ = $(LIB_SRC:.c=.o)
 LIB_OBJ  = $(PABLO_OBJ) $(LIB_COBJ)
@@ -47,6 +53,8 @@ lib_obj: $(LIB_OBJ)
 
 copy_src: 
 	cp ../src/*.c .
+	touch ../src/*.c
+	touch *.c
 	touch copy_src
 
 # 'vpath' directive is only supported in gmake, take out - QAK
@@ -67,7 +75,7 @@ PABLO_HDR = HDFentryNames.h HDFidList.h ProcIDs.h HDFTrace.h ProcTrace.h \
 ##
 lib: $(LIB)
 $(LIB): $(LIB_OBJ) 
-	$(AR) -rc $@ $(LIB_OBJ)
+	$(AR) -rc $@ *.o
 	$(RANLIB) $@
 ##
 ## Dummy this out so that there is no redundant make of the library
@@ -144,11 +152,12 @@ maintainer-clean: distclean
 PABLO_INCLUDES = HDFentryNames.h HDFidList.h ProcIDs.h HDFTrace.h ProcTrace.h \
                  ProcTrace.inc
 
-PABLO_CLEAN = HDFentryNames.h HDFidList.h ProcMasks.h HDFentries.txt
+PABLO_CLEAN = HDFentryNames.h HDFidList.h ProcMasks.h HDFentries.txt \
+	      ProcTrace.inc
 
 HDFentries.txt: ../src/*.c
-	grep "FUNC_ENTER.*(H5" ../src/*.c | \
-	sed "s/.*(H5/H5/;s/[,)].*//" | sort -u > $@
+	grep "FUNC_ENTER[_INIT ]*(" ../src/*.c | \
+	sed "s/.*FUNC_ENTER[_INIT ]*(//;s/[,)].*//" | sort -u > $@
 
 HDFentryNames.h: HDFentries.txt
 	sed "s/.*/\"&\",/" $? > $@
@@ -180,7 +189,7 @@ ProcTrace.inc: HDFidList.h
 
 
 PabloHDF.o: PabloHDF.c $(PABLO_INCLUDES) copy_src
-	$(CC) $(CFLAGS) $(CPPFLAGS) $(PABLO_FLAGS) -c $<
+	$(CC) -g $(CFLAGS) $(CPPFLAGS) $(PABLO_FLAGS) -c $<
 
 PabloHDF_RT.o: PabloHDF_RT.c $(PABLO_INCLUDES) copy_src
 	$(CC) $(CFLAGS) $(CPPFLAGS) $(PABLO_FLAGS) -c $<
@@ -189,4 +198,4 @@ PabloHDF_SDDF.o: PabloHDF_SDDF.c $(PABLO_INCLUDES) copy_src
 	$(CC) $(CFLAGS) $(CPPFLAGS) $(PABLO_FLAGS) -c $<
 
 PabloHDFff.o: PabloHDFff.f $(PABLO_INCLUDES) copy_src 
-	$(F77) -O -c PabloHDFff.f
+	$(F77) $(FFLAGS) -O -c PabloHDFff.f
diff --git a/pablo/PabloHDF.c b/pablo/PabloHDF.c
index 8a61687..b890b07 100644
--- a/pablo/PabloHDF.c
+++ b/pablo/PabloHDF.c
@@ -126,9 +126,10 @@ extern void preInitIOTrace( void );
 #define	ID_timeStamp		9999
 #define	DUMMY_HDF		10000
 
-#ifdef HAVE_PARALLEL
-#include "mpio.h"
-#endif /* HAVE_PARALLEL*/
+#ifdef H5_HAVE_PARALLEL
+#include "mpi.h"
+int HDF_get_Bytes( MPI_Datatype datatype, int count );
+#endif /* H5_HAVE_PARALLEL*/
 
 void HDFinitTrace_RT ( const char *, int );
 void HDFinitTrace_SDDF ( const char *, int );
@@ -144,6 +145,7 @@ void endHDFtraceEvent (int , int , char *, int );
 void HDFtraceEvent_RT ( int , HDFsetInfo *, unsigned );
 void HDFtraceIOEvent( int , void *, unsigned );
 extern int IOtracingEnabled;
+extern int suppressMPIOtrace;
 char *hdfRecordPointer;
 double WriteTotals = 0.0;
 double ReadTotals = 0.0;
@@ -166,132 +168,162 @@ double ReadTotals = 0.0;
 // fortran to C interface.                                              *
 // This is called from hdfinittracef_                                   *
 //======================================================================*/
-void hinittracex_( char *file, int *len, int flags[], int *nflags,
-                                                       unsigned *out_sw )
+void 
+hinittracex_( char *file, 
+              int *len, 
+              int flags[], 
+              int *nflags, 
+              unsigned *out_sw )
 {
-        char *traceFileName;
-	int i;
-	traceFileName = (char *)malloc(*len+1);
-	for ( i = 0; i < *len; ++i ) {
-	   traceFileName[i] = file[i];
-	}
-	traceFileName[*len+1] = 0;
-	/*==============================================================*
-	// Allocate space for trace indicators.				*
-	//==============================================================*/
-        procTrace = ( int * ) malloc( NUM_HDF_IDS*sizeof(int) );
-        if ( procTrace == NULL ) {
-           fprintf(stderr,">> Error: Unable to allocate procTrace ");
-           fprintf(stderr,"array in program HDFinitTrace. <<<\n");
-           fprintf(stderr,">>> Exiting program! <<<\n");
-           exit (-1);
-	}
-	/*==============================================================*
-	// Initialize to 0.						*
-	//==============================================================*/
-	for ( i = 0; i <= NUM_HDF_IDS; ++i ) {
-	   procTrace[i] = 0;      
-	}
-	/*==============================================================*
-	// Read in the flags indicating which procedures to trace.	*
-	// The last parameter passed is an indicator of the type of 	*
-	// tracing to do.  This indicator has a value larger than any   *
-	// of the flags.						*
-	//==============================================================*/
-	for ( i = 0; i < *nflags; ++i ) {
-	   procTrace[flags[i]] = 1;
-	}
-	OUTPUT_SWITCH = *out_sw;
-	/*==============================================================*
-	// if no flags were passed, the default is to trace all of the  *
-	// procedures.							*
-	//==============================================================*/
-	if ( *nflags == 0 || procTrace[ID_ALLHDF] ) {
-	   for ( i = ID_HDF_Last_Entry + 1; i < NUM_HDF_IDS; ++i ) {
-	      procTrace[i] = 1;      
-	   }
-   	}
-	if ( OUTPUT_SWITCH == RUNTIME_TRACE 
-	                     || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) {
-	   HDFinitTrace_SDDF( traceFileName, OUTPUT_SWITCH );
-	   IOtracingEnabled = 1;
-	} else if ( OUTPUT_SWITCH == SUMMARY_TRACE 
-	                     || OUTPUT_SWITCH == MPI_SUMMARY_TRACE ) {
-	   HDFinitTrace_RT( traceFileName, OUTPUT_SWITCH );
-	   IOtracingEnabled = 1;
-	} else if ( OUTPUT_SWITCH == NO_TRACE ) {
-	   IOtracingEnabled = 0;
-	} else {
-	   fprintf(stderr,">> Error in HDFinitTrace: the third argument ");
-           fprintf(stderr,"must have a value between %4d<<\n",RUNTIME_TRACE);
-	   fprintf(stderr,">> and %4d, inclusive.",NO_TRACE);
-	   fprintf(stderr,"  The value received was %4u.", OUTPUT_SWITCH);
-	   fprintf(stderr," Exiting Program.     <<\n");
-	   exit (-1);
-	}
+   char *traceFileName;
+   int i;
+   traceFileName = (char *)malloc(*len+1);
+   for ( i = 0; i < *len; ++i ) 
+   {
+      traceFileName[i] = file[i];
+   }
+   traceFileName[*len+1] = 0;
+   /*===================================================================*
+   // Allocate space for trace indicators.				*
+   //===================================================================*/
+   procTrace = ( int * ) malloc( NUM_HDF_IDS*sizeof(int) );
+   if ( procTrace == NULL ) 
+   {
+       fprintf(stderr,">> Error: Unable to allocate procTrace ");
+       fprintf(stderr,"array in program HDFinitTrace. <<<\n");
+       fprintf(stderr,">>> Exiting program! <<<\n");
+       exit (-1);
+   }
+   /*===================================================================*
+   // Initialize to 0.							*
+   //===================================================================*/
+   for ( i = 0; i <= NUM_HDF_IDS; ++i ) 
+   {
+      procTrace[i] = 0;      
+   }
+   /*===================================================================*
+   // Read in the flags indicating which procedures to trace.		*
+   // The last parameter passed is an indicator of the type of 		*
+   // tracing to do.  This indicator has a value larger than any   	*
+   // of the flags.							*
+   //===================================================================*/
+   for ( i = 0; i < *nflags; ++i ) 
+   {
+      procTrace[flags[i]] = 1;
+   }
+   OUTPUT_SWITCH = *out_sw;
+   /*===================================================================*
+   // if no flags were passed, the default is to trace all of the  	*
+   // procedures.							*
+   //===================================================================*/
+   if ( *nflags == 0 || procTrace[ID_ALLHDF] ) 
+   {
+      for ( i = 0; i < NUM_HDF_IDS; ++i ) 
+      {
+         procTrace[i] = 1;      
+      }
+   }
+   if ( OUTPUT_SWITCH == RUNTIME_TRACE 
+                        || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) 
+   {
+      HDFinitTrace_SDDF( traceFileName, OUTPUT_SWITCH );
+      IOtracingEnabled = 1;
+   } 
+   else if ( OUTPUT_SWITCH == SUMMARY_TRACE 
+                        || OUTPUT_SWITCH == MPI_SUMMARY_TRACE ) 
+   {
+      HDFinitTrace_RT( traceFileName, OUTPUT_SWITCH );
+      IOtracingEnabled = 1;
+   } 
+   else if ( OUTPUT_SWITCH == NO_TRACE ) 
+   {
+      IOtracingEnabled = 0;
+   } 
+   else 
+   {
+      fprintf(stderr,">> Error in HDFinitTrace: the third argument ");
+      fprintf(stderr,"must have a value between %4d<<\n",RUNTIME_TRACE);
+      fprintf(stderr,">> and %4d, inclusive.",NO_TRACE);
+      fprintf(stderr,"  The value received was %4u.", OUTPUT_SWITCH);
+      fprintf(stderr," Exiting Program.     <<\n");
+      exit (-1);
+   }
 }
 void HDFinitTrace( const char *traceFileName, int id_flag, ... )
 {
-	int i, nIDs;
-	va_list ap;
-
-	/*==============================================================*
-	// Allocate space for trace indicators.				*
-	//==============================================================*/
-        procTrace = ( int * ) malloc( NUM_HDF_IDS*sizeof(int) );
-        if ( procTrace == NULL ) {
-           fprintf(stderr,">> Error: Unable to allocate procTrace ");
-           fprintf(stderr,"array in program HDFinitTrace. <<<\n");
-           fprintf(stderr,">>> Exiting program! <<<\n");
-           exit (-1);
-	}
-	/*==============================================================*
-	// Initialize to 0.						*
-	//==============================================================*/
-	for ( i = 0; i < NUM_HDF_IDS; ++i ) {
-	   procTrace[i] = 0;      
-	}
-	/*==============================================================*
-	// Read in the flags indicating which procedures to trace.	*
-	// The last parameter passed is an indicator of the type of 	*
-	// tracing to do.  This indicator has a value larger than any   *
-	// of the flags.						*
-	//==============================================================*/
-	nIDs = 0;
-	va_start( ap, id_flag );
-	while ( id_flag > NO_TRACE ) {
-	   procTrace[id_flag] = 1;
-	   ++nIDs;
-           id_flag = va_arg ( ap, int );
-	}
-	OUTPUT_SWITCH = id_flag;
-	/*==============================================================*
-	// if no flags were passed, the default is to trace all of the  *
-	// procedures.							*
-	//==============================================================*/
-	if ( nIDs == 0 || procTrace[ID_ALLHDF] ) {
-	   for ( i = ID_HDF_Last_Entry + 1; i < NUM_HDF_IDS; ++i ) {
-	      procTrace[i] = 1;      
-	   }
-   	}
-	if ( OUTPUT_SWITCH == RUNTIME_TRACE 
-	                     || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) {
-	   HDFinitTrace_SDDF( traceFileName, OUTPUT_SWITCH );
-	   IOtracingEnabled = 1;
-	} else if ( OUTPUT_SWITCH == SUMMARY_TRACE 
-	                     || OUTPUT_SWITCH == MPI_SUMMARY_TRACE ) {
-	   HDFinitTrace_RT( traceFileName, OUTPUT_SWITCH );
-	   IOtracingEnabled = 1;
-        } else if ( OUTPUT_SWITCH == NO_TRACE ) {
-           IOtracingEnabled = 0;
-        } else {
-           fprintf(stderr,">> Error in HDFinitTrace: the third argument ");
-           fprintf(stderr,"must have a value between %4d<<\n",RUNTIME_TRACE);
-           fprintf(stderr,">> and %4d, inclusive.",NO_TRACE);
-           fprintf(stderr,"  The value received was %4u.", OUTPUT_SWITCH);
-           fprintf(stderr," Exiting Program.     <<\n");
-           exit (-1);
-        }
+   int i, nIDs;
+   va_list ap;
+
+   /*===================================================================*
+   // Allocate space for trace indicators.				*
+   //===================================================================*/
+   procTrace = ( int * ) malloc( NUM_HDF_IDS*sizeof(int) );
+   if ( procTrace == NULL ) 
+   {
+      fprintf(stderr,">> Error: Unable to allocate procTrace ");
+      fprintf(stderr,"array in program HDFinitTrace. <<<\n");
+      fprintf(stderr,">>> Exiting program! <<<\n");
+      exit (-1);
+   }
+   /*===================================================================*
+   // Initialize to 0.							*
+   //===================================================================*/
+   for ( i = 0; i < NUM_HDF_IDS; ++i ) 
+   {
+      procTrace[i] = 0;      
+   }
+   /*===================================================================*
+   // Read in the flags indicating which procedures to trace.		*
+   // The last parameter passed is an indicator of the type of 		*
+   // tracing to do.  This indicator has a value larger than any   	*
+   // of the flags.							*
+   //===================================================================*/
+   nIDs = 0;
+   va_start( ap, id_flag );
+   while ( id_flag > NO_TRACE ) 
+   {
+      procTrace[id_flag] = 1;
+      ++nIDs;
+      id_flag = va_arg ( ap, int );
+   }
+   OUTPUT_SWITCH = id_flag;
+   /*===================================================================*
+   // if no flags were passed, the default is to trace all of the  	*
+   // procedures.							*
+   //===================================================================*/
+   if ( nIDs == 0 || procTrace[ID_ALLHDF] ) 
+   {
+      for ( i = 0; i < NUM_HDF_IDS; ++i ) 
+      {
+         procTrace[i] = 1;      
+      }
+   }
+   suppressMPIOtrace = TRUE;
+   if ( OUTPUT_SWITCH == RUNTIME_TRACE 
+                        || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) 
+   {
+      HDFinitTrace_SDDF( traceFileName, OUTPUT_SWITCH );
+      IOtracingEnabled = 1;
+   } 
+   else if ( OUTPUT_SWITCH == SUMMARY_TRACE 
+                        || OUTPUT_SWITCH == MPI_SUMMARY_TRACE ) 
+   {
+      HDFinitTrace_RT( traceFileName, OUTPUT_SWITCH );
+      IOtracingEnabled = 1;
+   } 
+   else if ( OUTPUT_SWITCH == NO_TRACE ) 
+   {
+       IOtracingEnabled = 0;
+   } 
+   else 
+   {
+       fprintf(stderr,">> Error in HDFinitTrace: the third argument ");
+       fprintf(stderr,"must have a value between %4d<<\n",RUNTIME_TRACE);
+       fprintf(stderr,">> and %4d, inclusive.",NO_TRACE);
+       fprintf(stderr,"  The value received was %4u.", OUTPUT_SWITCH);
+       fprintf(stderr," Exiting Program.     <<\n");
+       exit (-1);
+   }
 }
 /*======================================================================*
 // NAME									*
@@ -303,124 +335,155 @@ void HDFinitTrace( const char *traceFileName, int id_flag, ... )
 //======================================================================*/
 void hdfendtrace_( void ) 
 {
-	HDFendTrace ();
+   HDFendTrace ();
 }
 void HDFendTrace(void)
 {
-	if ( OUTPUT_SWITCH == RUNTIME_TRACE 
-	                     || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) {
-	   HDFendTrace_SDDF( OUTPUT_SWITCH );
-	} else if ( OUTPUT_SWITCH == SUMMARY_TRACE 
-	                     || OUTPUT_SWITCH == MPI_SUMMARY_TRACE ) {
-	   HDFendTrace_RT( OUTPUT_SWITCH );
-	}
+   if ( OUTPUT_SWITCH == RUNTIME_TRACE 
+	                     || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) 
+   {
+      HDFendTrace_SDDF( OUTPUT_SWITCH );
+   } 
+   else if ( OUTPUT_SWITCH == SUMMARY_TRACE 
+                   || OUTPUT_SWITCH == MPI_SUMMARY_TRACE ) 
+   {
+      HDFendTrace_RT( OUTPUT_SWITCH );
+   }
 }
 void startHDFtraceEvent(int eventID)
 {
-	if ( OUTPUT_SWITCH == RUNTIME_TRACE 
-	                     || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) {
-	   traceEvent( eventID, NULL, 0 ) ;
-	} else {
-	   HDFtraceEvent_RT( eventID, NULL, 0 ) ;
-	} 
+   if ( OUTPUT_SWITCH == RUNTIME_TRACE 
+	                     || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) 
+   {
+      traceEvent( eventID, NULL, 0 ) ;
+   } 
+   else 
+   {
+      HDFtraceEvent_RT( eventID, NULL, 0 ) ;
+   } 
 }
 void endHDFtraceEvent(int eventID, int setID, char *setName, int IDtype )
 {
-	HDFsetInfo info;
-	info.setID = setID;
-	info.setName = setName;
-	if ( OUTPUT_SWITCH == RUNTIME_TRACE 
-	                     || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) {
-	   traceEvent( eventID, (char *)&info, 0 ) ;
-	} else if ( OUTPUT_SWITCH == SUMMARY_TRACE 
-	                     || OUTPUT_SWITCH == MPI_SUMMARY_TRACE ) {
-	   HDFtraceEvent_RT( eventID, &info, 0 ) ;
-	} else if ( OUTPUT_SWITCH != NO_TRACE ) {
-	   fprintf(stderr,"endHDFtraceEvent: ");
-	   fprintf(stderr,"invalid OUTPUT_SWITCH %d, IDtype = %d\n",
+   HDFsetInfo info;
+   info.setID = setID;
+   info.setName = setName;
+   if ( OUTPUT_SWITCH == RUNTIME_TRACE 
+	                     || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) 
+   {
+      traceEvent( eventID, (char *)&info, 0 ) ;
+   } 
+   else if ( OUTPUT_SWITCH == SUMMARY_TRACE 
+	                     || OUTPUT_SWITCH == MPI_SUMMARY_TRACE ) 
+   {
+      HDFtraceEvent_RT( eventID, &info, 0 ) ;
+   } 
+   else if ( OUTPUT_SWITCH != NO_TRACE ) 
+   {
+      fprintf(stderr,"endHDFtraceEvent: ");
+      fprintf(stderr,"invalid OUTPUT_SWITCH %d, IDtype = %d\n",
                                                   OUTPUT_SWITCH, IDtype ) ;
-	}
+   }
 }
-/******************************************************************************/
-
-/*+	Open routines      			                             +*/
-/*+     -------------            				             +*/
-/*+	                                                                     +*/
-/*+ Routine:  FILE *HDFtraceFOPEN( const char *filename, const char *type )  +*/
-/*+		  substitute for fopen()                                     +*/
-/*+     	  generates fopenBeginID, fopenEndID		             +*/
-/*+		  record Open (fopenBegin)                                   +*/
-/*+			Mode = -1                                            +*/
-/*+									     +*/
-FILE *HDFtraceFOPEN( const char *filename, const char *type )
+/*****************************************************************************/
+/* The HDFtraceXXXX routines are substitutes for the standard I/O routines.  */
+/* When libhdf5-inst.a is compiled, macros in HDFTrace.h substitute the name */
+/* HDFtraceWrite for write, HDFtraceRead for Read, etc.  These routines are  */
+/* then called when standard I/O is done.				     */
+/*****************************************************************************/
+/*****************************************************************************/
+/*+	Open routines      	   	                                    +*/
+/*+     -------------            				            +*/
+/*+	                                                                    +*/
+/*+ Routine:  FILE *HDFtraceFOPEN( const char *filename, const char *type ) +*/
+/*+		  substitute for fopen()                                    +*/
+/*+     	  generates fopenBeginID, fopenEndID		            +*/
+/*+		  record Open (fopenBegin)                                  +*/
+/*+			Mode = -1                                           +*/
+/*+									    +*/
+/*****************************************************************************/
+FILE*HDFtraceFOPEN( const char *filename, const char *type )
 {
-    FILE *fp;
-    int fd, id;
-    int flags = 0;
-    struct open_args openArgs;
-    size_t typeLen;
+   FILE *fp;
+   int fd, id;
+   int flags = 0;
+   struct open_args openArgs;
+   size_t typeLen;
 	
-    if ( IOtracingEnabled ) {
-        strcpy( openArgs.filename, filename );
+   if ( IOtracingEnabled ) 
+   {
+      strcpy( openArgs.filename, filename );
 	 
-	/* check for 'b' - usually if 2 chars, second is '+' */
-	typeLen = strlen( type );
-	if ( ( typeLen == 2 ) && ( type [1] == 'b' ) ) {
-	    typeLen = 1;
-	}
-
-        if ( typeLen == 1 ) {
-            switch( type[0] ) {
-              case 'r':
-                  flags = flags | O_RDONLY;
-                  break;
-              case 'w':
-                  flags = O_TRUNC | O_CREAT | O_WRONLY;
-                  break;
-              case 'a':
-                  flags = flags | O_APPEND | O_CREAT | O_WRONLY;
-                  break;
-            }
-        } else {
-            switch( type[0] ) {
-              case 'r':
-                  flags = O_RDWR;
-                  break;
-              case 'w':
-                  flags = O_TRUNC | O_CREAT | O_RDWR;
-                  break;
-              case 'a':
-                  flags = O_APPEND | O_CREAT | O_RDWR;
-                  break;    
-            }
-        }
-        openArgs.flags = flags;
-        openArgs.mode= -1;
-
-        HDFtraceIOEvent( fopenBeginID, (void *)&openArgs, sizeof(openArgs) );
-    }
-
-    fp = fopen( filename, type );
-    if ( fp != NULL ) {
-	fd = fileno( fp );
-        id = set_c_mappedID( fd );
-    } else {
-        id = -1;
-    }
-
-    if ( IOtracingEnabled ) {
-        HDFtraceIOEvent( fopenEndID, (void *) &id, int_SIZE );   
-    }
-
-    return( fp );
+      /* check for 'b' - usually if 2 chars, second is '+' */
+      typeLen = strlen( type );
+      if ( ( typeLen == 2 ) && ( type [1] == 'b' ) ) 
+      {
+         typeLen = 1;
+      }
+
+      if ( typeLen == 1 ) 
+      {
+         switch( type[0] ) 
+         {
+            case 'r':
+               flags = flags | O_RDONLY;
+               break;
+            case 'w':
+               flags = O_TRUNC | O_CREAT | O_WRONLY;
+               break;
+            case 'a':
+               flags = flags | O_APPEND | O_CREAT | O_WRONLY;
+               break;
+         }
+      } 
+      else 
+      {
+         switch( type[0] ) 
+         {
+            case 'r':
+               flags = O_RDWR;
+               break;
+            case 'w':
+               flags = O_TRUNC | O_CREAT | O_RDWR;
+               break;
+            case 'a':
+               flags = O_APPEND | O_CREAT | O_RDWR;
+               break;    
+         }
+      }
+      openArgs.flags = flags;
+      openArgs.mode= -1;
+
+      HDFtraceIOEvent( fopenBeginID, (void *)&openArgs, sizeof(openArgs) );
+   }
+
+   fp = fopen( filename, type );
+   if ( fp != NULL ) 
+   {
+      fd = fileno( fp );
+      id = set_c_mappedID( fd );
+   } 
+   else 
+   {
+      id = -1;
+   }
+
+   if ( IOtracingEnabled ) 
+   {
+     HDFtraceIOEvent( fopenEndID, (void *) &id, int_SIZE );   
+   }
+
+   return( fp );
 }
 
-/*+	Routine:  int HDFtraceCREAT( const char *path, mode_t mode )         +*/
-/*+		  substitute for creat()                                     +*/
-/*+     	  generates openBeginID, openEndID		             +*/
-/*+		  record Open (openBeginID)                                  +*/
-/*+									     +*/
-int HDFtraceCREAT( const char *path, mode_t mode )
+/*****************************************************************************/
+/*+	Routine:  int HDFtraceCREAT( const char *path, mode_t mode )        +*/
+/*+		  substitute for creat()                                    +*/
+/*+     	  generates openBeginID, openEndID		            +*/
+/*+		  record Open (openBeginID)                                 +*/
+/*+									    +*/
+/*****************************************************************************/
+int 
+HDFtraceCREAT( const char *path, mode_t mode )
 {
     struct open_args openArgs;
     int fd;
@@ -444,504 +507,583 @@ int HDFtraceCREAT( const char *path, mode_t mode )
     return( fd );
 }
 
-/******************************************************************************/
-
-/*+	Flush routines				                             +*/
-/*+     --------------				                             +*/
-/*+	                                                                     +*/
-/*+	Routine:  int HDFtraceFFLUSH( FILE *stream )                         +*/
-/*+		  substitute for fflush()                                    +*/
-/*+               generates fflushBeginID, fflushEndID                       +*/
-/*+	          record Flush (fflushBeginID)                               +*/
-/*+									     +*/
+/*****************************************************************************/
+/*+	Flush routines				                            +*/
+/*+     --------------				                            +*/
+/*+	                                                                    +*/
+/*+	Routine:  int HDFtraceFFLUSH( FILE *stream )                        +*/
+/*+		  substitute for fflush()                                   +*/
+/*+               generates fflushBeginID, fflushEndID                      +*/
+/*+	          record Flush (fflushBeginID)                              +*/
+/*+		   							    +*/
+/*****************************************************************************/
 int HDFtraceFFLUSH( FILE *stream )
 {
-    int ret;
-    int id;
-    int fd;
-
-    if ( IOtracingEnabled ) {
-	/*
-	 * If stream is NULL, all files open for write are flushed.
-	 * We show this with a -2 in the trace record as too much overhead
-	 * to try and tell what files those are and generate individual
-	 * trace records.
-	 */
-        if ( stream == NULL ) {   
-	    id = -2;
-        } else {
-            fd = fileno( stream );
-	    id = c_mappedID( fd );
-            HDFtraceIOEvent( fflushBeginID, (void *) 0, int_SIZE );
-        }
-    }
-
-    ret = fflush( stream );
-
-    if ( IOtracingEnabled ) {
-        HDFtraceIOEvent( fflushEndID, (void *) &id, 0 );
-    }
-
-    /* 
-     * Note that if fflush called on stream open for reading, the file pointer
-     * is moved to EOF if it isn't there already.  We don't account for that
-     * in our file positioning information.
-     */
-
-    return( ret );
+   int ret;
+   int id;
+   int fd;
+
+   if ( IOtracingEnabled ) 
+   {
+      /*
+       * If stream is NULL, all files open for write are flushed.
+       * We show this with a -2 in the trace record as too much overhead
+       * to try and tell what files those are and generate individual
+       * trace records.
+       */
+      if ( stream == NULL ) 
+      {   
+         id = -2;
+      } 
+      else 
+      {
+         fd = fileno( stream );
+         id = c_mappedID( fd );
+         HDFtraceIOEvent( fflushBeginID, (void *) 0, int_SIZE );
+     }
+   }
+
+   ret = fflush( stream );
+
+   if ( IOtracingEnabled ) 
+   {
+      HDFtraceIOEvent( fflushEndID, (void *) &id, 0 );
+   }
+
+   /* 
+    * Note that if fflush called on stream open for reading, the file pointer
+    * is moved to EOF if it isn't there already.  We don't account for that
+    * in our file positioning information.
+    */
+
+   return( ret );
 }
 
-/******************************************************************************/
-/*+	Close routines				                             +*/
-/*+     --------------				                             +*/
-/*+	                                                                     +*/
-/*+	Routine:  int HDFtraceFCLOSE( FILE *stream )                         +*/
-/*+		  substitute for fclose()                                    +*/
-/*+               generates fcloseBeginID, fcloseEndID                       +*/
-/*+	          record Close (fcloseBeginID)                               +*/
-/*+									     +*/
-int HDFtraceFCLOSE( FILE *stream )
+/*****************************************************************************/
+/*+	Close routines				                            +*/
+/*+     --------------				                            +*/
+/*+	                                                                    +*/
+/*+	Routine:  int HDFtraceFCLOSE( FILE *stream )                        +*/
+/*+		  substitute for fclose()                                   +*/
+/*+               generates fcloseBeginID, fcloseEndID                      +*/
+/*+	          record Close (fcloseBeginID)                              +*/
+/*+									    +*/
+/*****************************************************************************/
+int 
+HDFtraceFCLOSE( FILE *stream )
 {
-    int ret;
-    int id;
-    int fd = fileno( stream );
+   int ret;
+   int id;
+   int fd = fileno( stream );
 
-    if ( IOtracingEnabled ) {
-	id = c_mappedID( fd );
-        HDFtraceIOEvent( fcloseBeginID, (void *) &id, int_SIZE );
-    }
+   if ( IOtracingEnabled ) 
+   {
+      id = c_mappedID( fd );
+      HDFtraceIOEvent( fcloseBeginID, (void *) &id, int_SIZE );
+   }
 
-    ret = fclose( stream );
+   ret = fclose( stream );
 
-    if ( IOtracingEnabled ) {
-        HDFtraceIOEvent( fcloseEndID, (void *) 0, 0 );
-    }
+   if ( IOtracingEnabled ) 
+   {
+      HDFtraceIOEvent( fcloseEndID, (void *) 0, 0 );
+   }
 
-    return( ret );
+   return( ret );
 }
 
-/*+     Routine:  int HDFtrace3OPEN( char *path, int flags, mode_t mode )    +*/
-/*+               substitute for open() when called with 3 arguments         +*/
-/*+               generates openBeginID, openEndID                           +*/
-/*+               record Open (openBeginID)                                  +*/
-/*+                                                                          +*/
-int HDFtrace3OPEN( const char *path, int flags, mode_t mode )
+/*****************************************************************************/
+/*+     Routine:  int HDFtrace3OPEN( char *path, int flags, mode_t mode )   +*/
+/*+               substitute for open() when called with 3 arguments        +*/
+/*+               generates openBeginID, openEndID                          +*/
+/*+               record Open (openBeginID)                                 +*/
+/*+                                                                         +*/
+/*****************************************************************************/
+int 
+HDFtrace3OPEN( const char *path, int flags, mode_t mode )
 {
-    struct open_args openArgs;
-    int fd;
-    int id;
+   struct open_args openArgs;
+   int fd;
+   int id;
 
-    if ( IOtracingEnabled ) {
-        strcpy( openArgs.filename, path );
-        openArgs.flags = flags;
-        openArgs.mode = (int) mode;
+   if ( IOtracingEnabled ) 
+   {
+      strcpy( openArgs.filename, path );
+      openArgs.flags = flags;
+      openArgs.mode = (int) mode;
 
-        HDFtraceIOEvent( openBeginID, (char *)&openArgs, sizeof(openArgs) );
-    }
+      HDFtraceIOEvent( openBeginID, (char *)&openArgs, sizeof(openArgs) );
+   }
 
-    fd = open( path, flags, mode );
-    id = set_c_mappedID( fd );
+   fd = open( path, flags, mode );
+   id = set_c_mappedID( fd );
 
-    if ( IOtracingEnabled ) {
-        HDFtraceIOEvent( openEndID, (char *) &id, int_SIZE );
-    }
+   if ( IOtracingEnabled ) 
+   {
+      HDFtraceIOEvent( openEndID, (char *) &id, int_SIZE );
+   }
 
-    return( fd );
+   return( fd );
 }
 
-/*+	Routine:  int HDFtraceCLOSE( int fd )	                             +*/
-/*+		  substitute for close()              			     +*/
-/*+               generates closeBeginID, closeEndID 		             +*/
-/*+		  record Close (closeBeginID)                                +*/
-/*+									     +*/
-int HDFtraceCLOSE( int fd )
+/*****************************************************************************/
+/*+	Routine:  int HDFtraceCLOSE( int fd )	                            +*/
+/*+		  substitute for close()              			    +*/
+/*+               generates closeBeginID, closeEndID 		            +*/
+/*+		  record Close (closeBeginID)                               +*/
+/*+									    +*/
+/*****************************************************************************/
+int 
+HDFtraceCLOSE( int fd )
 {
-    int ret;
-    int id;
+   int ret;
+   int id;
 
-    if ( IOtracingEnabled ) {
-	id = c_mappedID( fd );
-        HDFtraceIOEvent( closeBeginID, (void *) &id, int_SIZE );
-    }
+   if ( IOtracingEnabled ) 
+   {
+      id = c_mappedID( fd );
+      HDFtraceIOEvent( closeBeginID, (void *) &id, int_SIZE );
+   }
 
-    ret = close( fd );
+   ret = close( fd );
 
-    if ( IOtracingEnabled ) {
-        HDFtraceIOEvent( closeEndID, (void *) 0, 0 );
-    }
+   if ( IOtracingEnabled ) 
+   {
+      HDFtraceIOEvent( closeEndID, (void *) 0, 0 );
+   }
 
-    return( ret );
+   return( ret );
 }
 
-/******************************************************************************/
-/*+	Read routines	            			                     +*/
-/*+     -------------			            	                     +*/
-/*+	                                                                     +*/
-/*+	Routine:  int HDFtraceREAD( int fd, char *buf, int nbyte )           +*/
-/*+		  substitute for read()                                      +*/
-/*+               generates readBeginID, readEndID                           +*/
-/*+	          record Read (readBeginID)                                  +*/
-/*+                      Number Variables = 1                                +*/
-/*+			 Cause = -1                                          +*/
-/*+									     +*/
-ssize_t HDFtraceREAD( int fd, void *buf, size_t nbyte )
+/*****************************************************************************/
+/*+	Read routines	            			                    +*/
+/*+     -------------			            	                    +*/
+/*+	                                                                    +*/
+/*+	Routine:  int HDFtraceREAD( int fd, char *buf, int nbyte )          +*/
+/*+		  substitute for read()                                     +*/
+/*+               generates readBeginID, readEndID                          +*/
+/*+	          record Read (readBeginID)                                 +*/
+/*+                      Number Variables = 1                               +*/
+/*+			 Cause = -1                                         +*/
+/*+									    +*/
+/*****************************************************************************/
+ssize_t 
+HDFtraceREAD( int fd, void *buf, size_t nbyte )
 {
-    struct read_write_args readArgs;  
-    ssize_t ret;
-    int bytes;
-    CLOCK t1, t2, incDur;
-
-    if ( IOtracingEnabled ) {
-        readArgs.fileID = c_mappedID( fd );
-        readArgs.numVariables = 1;
-        readArgs.cause = -1;   
-
-        HDFtraceIOEvent( readBeginID, (void *) &readArgs, sizeof(readArgs) );
-    }
-
-    t1 = getClock();
-    ret = read( fd, buf, nbyte );
-    t2 = getClock();
-    incDur = clockSubtract(t2,t1);
-    ReadTotals += clockToSeconds( incDur );
-
-    if ( IOtracingEnabled ) {
-        if ( ret > 0 ) {
-           bytes = (int)ret;
-	} else { 
-           bytes = 0;
-	} 
-        HDFtraceIOEvent( readEndID, (void *) &bytes, int_SIZE );
-    }
-
-    return( ret );
+   struct read_write_args readArgs;  
+   ssize_t ret;
+   int bytes;
+   CLOCK t1, t2, incDur;
+
+   if ( IOtracingEnabled ) 
+   {
+      readArgs.fileID = c_mappedID( fd );
+      readArgs.numVariables = 1;
+      readArgs.cause = -1;   
+
+      HDFtraceIOEvent( readBeginID, (void *) &readArgs, sizeof(readArgs) );
+   }
+
+   t1 = getClock();
+   ret = read( fd, buf, nbyte );
+   t2 = getClock();
+   incDur = clockSubtract(t2,t1);
+   ReadTotals += clockToSeconds( incDur );
+
+   if ( IOtracingEnabled ) 
+   {
+      if ( ret > 0 ) 
+      {
+         bytes = (int)ret;
+      } 
+      else 
+      { 
+         bytes = 0;
+      } 
+      HDFtraceIOEvent( readEndID, (void *) &bytes, int_SIZE );
+   }
+
+   return( ret );
 }
-       
-/*+	Routine:  int HDFtraceFREAD( char *ptr, int size, int nitems,        +*/
-/*+			          FILE *stream)                              +*/
-/*+		  substitute for fread()                                     +*/
-/*+               generates freadBeginID, freadEndID                         +*/
-/*+	          record Read (freadBeginID)                                 +*/
-/*+                      Number Variables = nitems                           +*/
-/*+			 Cause = -1                                          +*/
-/*+									     +*/
-size_t HDFtraceFREAD( void *ptr, size_t size, size_t nitems, FILE *stream )
+        
+/*****************************************************************************/
+/*+	Routine:  int HDFtraceFREAD( char *ptr, int size, int nitems,       +*/
+/*+			          FILE *stream)                             +*/
+/*+		  substitute for fread()                                    +*/
+/*+               generates freadBeginID, freadEndID                        +*/
+/*+	          record Read (freadBeginID)                                +*/
+/*+                      Number Variables = nitems                          +*/
+/*+			 Cause = -1                                         +*/
+/*+									    +*/
+/*****************************************************************************/
+size_t 
+HDFtraceFREAD( void *ptr, size_t size, size_t nitems, FILE *stream )
 {
-    struct read_write_args readArgs;  
-    size_t ret;
-    int nbytes;
-    int fd = fileno( stream );
-	CLOCK t1, t2, incDur;
-
-    if ( IOtracingEnabled ) {
-        readArgs.fileID = c_mappedID( fd );
-        readArgs.numVariables = (int)nitems;
-        readArgs.cause = -1;
-        HDFtraceIOEvent( freadBeginID, (void *) &readArgs, sizeof(readArgs) );
-    }
-
-    t1 = getClock();
-    ret = fread( ptr, size, nitems, stream );
-    t2 = getClock();
-    incDur = clockSubtract(t2,t1);
-    ReadTotals += clockToSeconds( incDur );
-
-    if ( IOtracingEnabled ) {
-        if ( ret > 0 ) {
-           nbytes = (int)(ret * size) ;
-	} else {
-           nbytes = 0;
-	}
-        HDFtraceIOEvent( freadEndID, (void *) &nbytes, int_SIZE );
-    }
-
-    return( ret );
+   struct read_write_args readArgs;  
+   size_t ret;
+   int nbytes;
+   int fd = fileno( stream );
+   CLOCK t1, t2, incDur;
+
+   if ( IOtracingEnabled ) 
+   {
+      readArgs.fileID = c_mappedID( fd );
+      readArgs.numVariables = (int)nitems;
+      readArgs.cause = -1;
+      HDFtraceIOEvent( freadBeginID, (void *) &readArgs, sizeof(readArgs) );
+   }
+
+   t1 = getClock();
+   ret = fread( ptr, size, nitems, stream );
+   t2 = getClock();
+   incDur = clockSubtract(t2,t1);
+   ReadTotals += clockToSeconds( incDur );
+
+   if ( IOtracingEnabled ) 
+   {
+      if ( ret > 0 ) 
+      {
+         nbytes = (int)(ret * size) ;
+      } 
+      else 
+      {
+         nbytes = 0;
+      }
+      HDFtraceIOEvent( freadEndID, (void *) &nbytes, int_SIZE );
+   }
+
+   return( ret );
 }
 
        
-/******************************************************************************/
-/*+	Seek routines            			                     +*/
-/*+     -------------			            	                     +*/
-/*+	                                                                     +*/
-/*+	Routine:  off_t HDFtraceLSEEK( int fd, off_t offset, int whence )    +*/
-/*+		  substitute for lseek()                                     +*/
-/*+               generates lseekBeginID, lseekEndID                         +*/
-/*+	          record Seek (lseekBeginID)                                 +*/
+/*****************************************************************************/
+/*+	Seek routines            			                    +*/
+/*+     -------------			            	                    +*/
+/*+	                                                                    +*/
+/*+	Routine:  off_t HDFtraceLSEEK( int fd, off_t offset, int whence )   +*/
+/*+		  substitute for lseek()                                    +*/
+/*+               generates lseekBeginID, lseekEndID                        +*/
+/*+	          record Seek (lseekBeginID)                                +*/
 /*+									     +*/
-off_t HDFtraceLSEEK( int fd, off_t offset, int whence )
+/*****************************************************************************/
+off_t 
+HDFtraceLSEEK( int fd, off_t offset, int whence )
 {
-    struct seek_args seekArgs;
-    off_t ret;
-    long  arg;
+   struct seek_args seekArgs;
+   off_t ret;
+   long  arg;
 
-    if ( IOtracingEnabled ) {
-        seekArgs.fileID = c_mappedID( fd );
-        seekArgs.offset = (int) offset;
-        seekArgs.whence = whence;
+   if ( IOtracingEnabled ) 
+   {
+      seekArgs.fileID = c_mappedID( fd );
+      seekArgs.offset = (int) offset;
+      seekArgs.whence = whence;
 
-        HDFtraceIOEvent( lseekBeginID, (void *) &seekArgs, sizeof(seekArgs) );
-    }
+      HDFtraceIOEvent( lseekBeginID, (void *) &seekArgs, sizeof(seekArgs) );
+   }
 
-    ret = lseek( fd, offset, whence );
+   ret = lseek( fd, offset, whence );
 
-    if ( IOtracingEnabled ) {
-	arg = (long) ret;
-        HDFtraceIOEvent( lseekEndID, (void *)&arg, long_SIZE );
-    }
+   if ( IOtracingEnabled ) 
+   {
+      arg = (long) ret;
+      HDFtraceIOEvent( lseekEndID, (void *)&arg, long_SIZE );
+   }
 
-    return( ret );
+   return( ret );
 }
 
-/*+ routine:  int HDF traceFSEEK( FILE *stream, long offset, int whence )    +*/
-/*+		  substitute for fseek()                                     +*/
-/*+               generates fseekBeginID, fseekEndID                         +*/
-/*+	          record Seek (fseekBeginID)                                 +*/
-/*+									     +*/
-int HDFtraceFSEEK( FILE *stream, long offset, int whence )
+/*****************************************************************************/
+/*+ routine:  int HDF traceFSEEK( FILE *stream, long offset, int whence )   +*/
+/*+		  substitute for fseek()                                    +*/
+/*+               generates fseekBeginID, fseekEndID                        +*/
+/*+	          record Seek (fseekBeginID)                                +*/
+/*+									    +*/
+/*****************************************************************************/
+int 
+HDFtraceFSEEK( FILE *stream, long offset, int whence )
 {
-    struct seek_args seekArgs;
-    int ret;
-    long arg;
-    int fd = fileno( stream );
+   struct seek_args seekArgs;
+   int ret;
+   long arg;
+   int fd = fileno( stream );
 
-    if ( IOtracingEnabled ) {
-        seekArgs.fileID = c_mappedID( fd );;
-        seekArgs.offset = (int) offset;
-        seekArgs.whence = whence;
+   if ( IOtracingEnabled ) 
+   {
+      seekArgs.fileID = c_mappedID( fd );;
+      seekArgs.offset = (int) offset;
+      seekArgs.whence = whence;
 
-        HDFtraceIOEvent( fseekBeginID, (void *) &seekArgs, sizeof(seekArgs) );
-    }
+      HDFtraceIOEvent( fseekBeginID, (void *) &seekArgs, sizeof(seekArgs) );
+   }
 
-    ret = fseek( stream, offset, whence );
+   ret = fseek( stream, offset, whence );
 
-    if ( IOtracingEnabled ) {
-	arg = ftell( stream );
-        HDFtraceIOEvent( fseekEndID, (void *)&arg, long_SIZE );
-    }
+   if ( IOtracingEnabled ) 
+   {
+      arg = ftell( stream );
+      HDFtraceIOEvent( fseekEndID, (void *)&arg, long_SIZE );
+   }
 
-    return( ret );
+   return( ret );
 }
 
 #ifdef fpos_t
+/*****************************************************************************/
 /*+ Routine:  int HDFtraceFSETPOS( FILE *stream, const fpos_t *position )   +*/
-/*+		  substitute for fsetpos()                                   +*/
-/*+               generates fsetposBeginID, fsetposEndID                     +*/
-/*+	          record Seek (fsetposBeginID)                               +*/
-/*+									     +*/
-int HDFtraceFSETPOS( FILE stream, const fpos_t *position )
+/*+		  substitute for fsetpos()                                  +*/
+/*+               generates fsetposBeginID, fsetposEndID                    +*/
+/*+	          record Seek (fsetposBeginID)                              +*/
+/*+									    +*/
+/*****************************************************************************/
+int 
+HDFtraceFSETPOS( FILE stream, const fpos_t *position )
 {
-    struct seek_args seekArgs;
-    int ret;
-    long arg;
-    int fd = fileno( stream );
+   struct seek_args seekArgs;
+   int ret;
+   long arg;
+   int fd = fileno( stream );
 
-    if ( IOtracingEnabled ) {
-        seekArgs.fileID = c_mappedID( fd );;
-        seekArgs.offset = (int) *position;
-        seekArgs.whence = SEEK_SET;
+   if ( IOtracingEnabled ) 
+   {
+      seekArgs.fileID = c_mappedID( fd );;
+      seekArgs.offset = (int) *position;
+      seekArgs.whence = SEEK_SET;
 
-        HDFtraceIOEvent( fsetposBeginID, (void *) &seekArgs, sizeof(seekArgs) );
-    }
+      HDFtraceIOEvent( fsetposBeginID, (void *) &seekArgs, sizeof(seekArgs) );
+   }
 
-    ret = fsetpos( stream, position );
+   ret = fsetpos( stream, position );
 
-    if ( IOtracingEnabled ) {
-	arg = (long) *position;
-        HDFtraceIOEvent( fsetposEndID, (void *)&arg, long_SIZE );
-    }
+   if ( IOtracingEnabled ) 
+   {
+      arg = (long) *position;
+      HDFtraceIOEvent( fsetposEndID, (void *)&arg, long_SIZE );
+   }
 
-    return( ret );
+   return( ret );
 }
 #endif /* fpos_t */
 
-/*+	Routine:  void HDFtraceREWIND ( FILE *stream )                       +*/
-/*+		  substitute for rewind()                                    +*/
-/*+               generates rewindBeginID, rewindEndID                       +*/
-/*+	          record Seek (rewindBeginID)                                +*/
-/*+                    	 Offset = 0                                          +*/
-/*+			 Whence = SEEK_SET                                   +*/
-/*+									     +*/
+/*****************************************************************************/
+/*+	Routine:  void HDFtraceREWIND ( FILE *stream )                      +*/
+/*+		  substitute for rewind()                                   +*/
+/*+               generates rewindBeginID, rewindEndID                      +*/
+/*+	          record Seek (rewindBeginID)                               +*/
+/*+                    	 Offset = 0                                         +*/
+/*+			 Whence = SEEK_SET                                  +*/
+/*+									    +*/
+/*****************************************************************************/
 void HDFtraceREWIND( FILE *stream )
 {
-    struct seek_args seekArgs;
-    long arg;
-    int fd = fileno( stream );
+   struct seek_args seekArgs;
+   long arg;
+   int fd = fileno( stream );
 
-    if ( IOtracingEnabled ) {
-        seekArgs.fileID = c_mappedID( fd );
-        seekArgs.offset = 0;
-        seekArgs.whence = SEEK_SET;
+   if ( IOtracingEnabled ) 
+   {
+      seekArgs.fileID = c_mappedID( fd );
+      seekArgs.offset = 0;
+      seekArgs.whence = SEEK_SET;
 
-        HDFtraceIOEvent( rewindBeginID, (void *) &seekArgs, sizeof(seekArgs) );
-    }
+      HDFtraceIOEvent( rewindBeginID, (void *) &seekArgs, sizeof(seekArgs) );
+   }
 
-    rewind( stream );
+   rewind( stream );
 
-    if ( IOtracingEnabled ) {
-	arg = 0;
-        HDFtraceIOEvent( rewindEndID, (void *)&arg, long_SIZE );
-    }
+   if ( IOtracingEnabled ) 
+   {
+      arg = 0;
+      HDFtraceIOEvent( rewindEndID, (void *)&arg, long_SIZE );
+   }
 
-    return;
+   return;
 }
 
-/******************************************************************************/
-/*+	Write routines            			                     +*/
-/*+     --------------			            	                     +*/
-/*+	                                                                     +*/
-/*+  Routine:  int HDFtraceWRITE( int fd, char *buf, int nbyte )             +*/
-/*+		  substitute for write()                                     +*/
-/*+               generates writeBeginID, writeEndID                         +*/
-/*+	          record Write (writeBeginID)                                +*/
-/*+                    	 Number Variables = 1                                +*/
-/*+			 Cause = -1                                          +*/
-/*+									     +*/
+/*****************************************************************************/
+/*+	Write routines            			                    +*/
+/*+     --------------			            	                    +*/
+/*+	                                                                    +*/
+/*+  Routine:  int HDFtraceWRITE( int fd, char *buf, int nbyte )            +*/
+/*+		  substitute for write()                                    +*/
+/*+               generates writeBeginID, writeEndID                        +*/
+/*+	          record Write (writeBeginID)                               +*/
+/*+                    	 Number Variables = 1                               +*/
+/*+			 Cause = -1                                         +*/
+/*+									    +*/
+/*****************************************************************************/
 ssize_t HDFtraceWRITE( int fd, const void *buf, size_t nbyte )
 {
-    struct read_write_args writeArgs;
-    ssize_t ret;
-    int bytes;
-    CLOCK t1, t2, incDur;
-
-    if ( IOtracingEnabled ) {
-        writeArgs.fileID = c_mappedID( fd );
-        writeArgs.numVariables = 1;
-        writeArgs.cause = -1;
-
-        HDFtraceIOEvent( writeBeginID, (void *) &writeArgs, sizeof(writeArgs) );
-    }
-
-    t1 = getClock();
-    ret = write( fd, buf, nbyte );
-    t2 = getClock();
-    incDur = clockSubtract(t2,t1);
-    WriteTotals += clockToSeconds( incDur );
-
-    if ( IOtracingEnabled ) {
-        if ( ret > 0 ) {
-           bytes =  (int)ret;
-	} else {
-	   bytes = 0;
-	}
-        HDFtraceIOEvent( writeEndID, (void *) &bytes, int_SIZE );
-    }
-    return( ret );
+   struct read_write_args writeArgs;
+   ssize_t ret;
+   int bytes;
+   CLOCK t1, t2, incDur;
+
+   if ( IOtracingEnabled ) 
+   {
+      writeArgs.fileID = c_mappedID( fd );
+      writeArgs.numVariables = 1;
+      writeArgs.cause = -1;
+
+      HDFtraceIOEvent( writeBeginID, (void *) &writeArgs, sizeof(writeArgs) );
+   }
+
+   t1 = getClock();
+   ret = write( fd, buf, nbyte );
+   t2 = getClock();
+   incDur = clockSubtract(t2,t1);
+   WriteTotals += clockToSeconds( incDur );
+
+   if ( IOtracingEnabled ) 
+   {
+      if ( ret > 0 ) 
+      {
+         bytes =  (int)ret;
+      } 
+      else 
+      {
+         bytes = 0;
+      }
+      HDFtraceIOEvent( writeEndID, (void *) &bytes, int_SIZE );
+   }
+   return( ret );
 }  
 
-/*+  Routine:  size_t HDFtraceFWRITE( const char *ptr, int size, int nitems, +*/
-/*+                                FILE *stream )                            +*/
-/*+		  substitute for fwrite()                                    +*/
-/*+               generates fwriteBeginID, fwriteEndID                       +*/
-/*+	          record Write (fwriteBeginID)                               +*/
-/*+                    	 Number Variables = nitems                           +*/
-/*+			 Cause = -1                                          +*/
-/*+									     +*/
-size_t HDFtraceFWRITE(const void *ptr,size_t size,size_t nitems,FILE *stream )
+/*****************************************************************************/
+/*+  Routine:  size_t HDFtraceFWRITE( const char *ptr, int size, int nitems,+*/
+/*+                                FILE *stream )                           +*/
+/*+		  substitute for fwrite()                                   +*/
+/*+               generates fwriteBeginID, fwriteEndID                      +*/
+/*+	          record Write (fwriteBeginID)                              +*/
+/*+                    	 Number Variables = nitems                          +*/
+/*+			 Cause = -1                                         +*/
+/*+									    +*/
+/*****************************************************************************/
+size_t 
+HDFtraceFWRITE(const void *ptr,size_t size,size_t nitems,FILE *stream )
 
 {
-    struct read_write_args writeArgs;
-    size_t ret;
-    int nbytes;
-    int fd = fileno( stream );
-    CLOCK t1, t2, incDur;
-
-    if ( IOtracingEnabled ) {
-        writeArgs.fileID = c_mappedID( fd );
-        writeArgs.numVariables = (int)nitems;
-        writeArgs.cause = -1;
-
-      HDFtraceIOEvent( fwriteBeginID, (void *) &writeArgs, sizeof(writeArgs) );
-    }
-
-    t1 = getClock();
-    ret = fwrite( ptr, size, nitems, stream );
-    t2 = getClock();
-    incDur = clockSubtract(t2,t1);
-    WriteTotals += clockToSeconds( incDur );
-
-
-    if ( IOtracingEnabled ) {
-        if ( ret > 0 ) {
-           nbytes = (int)(ret * size) ;
-	} else {
-           nbytes = 0;
-	} 
-        HDFtraceIOEvent( fwriteEndID, (void *) &nbytes, int_SIZE );
-    }
-
-    return( ret );
+   struct read_write_args writeArgs;
+   size_t ret;
+   int nbytes;
+   int fd = fileno( stream );
+   CLOCK t1, t2, incDur;
+
+   if ( IOtracingEnabled ) 
+   {
+      writeArgs.fileID = c_mappedID( fd );
+      writeArgs.numVariables = (int)nitems;
+      writeArgs.cause = -1;
+
+      HDFtraceIOEvent(fwriteBeginID, (void *)&writeArgs, sizeof(writeArgs));
+   }
+
+   t1 = getClock();
+   ret = fwrite( ptr, size, nitems, stream );
+   t2 = getClock();
+   incDur = clockSubtract(t2,t1);
+   WriteTotals += clockToSeconds( incDur );
+
+
+   if ( IOtracingEnabled ) 
+   {
+      if ( ret > 0 ) 
+      {
+         nbytes = (int)(ret * size) ;
+      } 
+      else 
+      {
+         nbytes = 0;
+      } 
+      HDFtraceIOEvent( fwriteEndID, (void *) &nbytes, int_SIZE );
+   }
+
+   return( ret );
 }
 
-/*+  Routine:  int HDFtracePUTS( char *s )                                   +*/
-/*+		  substitute for puts()                                      +*/
-/*+               generates fwriteBeginID, fwriteEndID                       +*/
-/*+	          record Write (fwriteBeginID)                               +*/
-/*+                    	 Number Variables = 1                                +*/
-/*+			 Cause = -1                                          +*/
-/*+									     +*/
-int HDFtracePUTS( char *s )
+/*****************************************************************************/
+/*+  Routine:  int HDFtracePUTS( char *s )                                  +*/
+/*+		  substitute for puts()                                     +*/
+/*+               generates fwriteBeginID, fwriteEndID                      +*/
+/*+	          record Write (fwriteBeginID)                              +*/
+/*+                    	 Number Variables = 1                               +*/
+/*+			 Cause = -1                                         +*/
+/*+									    +*/
+/*****************************************************************************/
+int 
+HDFtracePUTS( char *s )
 {
-    struct read_write_args writeArgs;
-    int ret;
-    int fd = fileno( stdout );
+   struct read_write_args writeArgs;
+   int ret;
+   int fd = fileno( stdout );
 
-    if ( IOtracingEnabled ) {
-        writeArgs.fileID = c_mappedID( fd );
-        writeArgs.numVariables = 1;
-        writeArgs.cause = -1;
+   if ( IOtracingEnabled ) 
+   {
+      writeArgs.fileID = c_mappedID( fd );
+      writeArgs.numVariables = 1;
+      writeArgs.cause = -1;
 
-        HDFtraceIOEvent( fwriteBeginID, (void *) &writeArgs, sizeof(writeArgs) );
-    }
+      HDFtraceIOEvent( fwriteBeginID, (void *) &writeArgs, sizeof(writeArgs) );
+   }
 
-    ret = puts( s );
+   ret = puts( s );
 
-    if ( IOtracingEnabled ) {
-        HDFtraceIOEvent( fwriteEndID, (void *) &ret, int_SIZE );
-    }
+   if ( IOtracingEnabled ) 
+   {
+      HDFtraceIOEvent( fwriteEndID, (void *) &ret, int_SIZE );
+   }
 
-    return( ret );
+   return( ret );
 }
        
-/*+	Routine:  int HDFtraceFPUTC( int c, FILE *stream )                   +*/
-/*+		  substitute for fputc()                                     +*/
-/*+               generates fwriteBeginID, fwriteEndID                       +*/
-/*+	          record Write (fwriteBeginID)                               +*/
-/*+                    	 Number Variables = 1                                +*/
-/*+			 Cause = -1                                          +*/
-/*+									     +*/
-int HDFtraceFPUTC( int c, FILE *stream )
+/*****************************************************************************/
+/*+	Routine:  int HDFtraceFPUTC( int c, FILE *stream )                  +*/
+/*+		  substitute for fputc()                                    +*/
+/*+               generates fwriteBeginID, fwriteEndID                      +*/
+/*+	          record Write (fwriteBeginID)                              +*/
+/*+                    	 Number Variables = 1                               +*/
+/*+			 Cause = -1                                         +*/
+/*+									    +*/
+/*****************************************************************************/
+int 
+HDFtraceFPUTC( int c, FILE *stream )
 {
-    struct read_write_args writeArgs;
-    int ret; 
-    int nbytes = char_SIZE;
-    int fd = fileno( stream );
+   struct read_write_args writeArgs;
+   int ret; 
+   int nbytes = char_SIZE;
+   int fd = fileno( stream );
 
-    if ( IOtracingEnabled ) {
-        writeArgs.fileID = c_mappedID( fd );
-        writeArgs.numVariables = 1;
-        writeArgs.cause = -1;
+   if ( IOtracingEnabled ) 
+   {
+      writeArgs.fileID = c_mappedID( fd );
+      writeArgs.numVariables = 1;
+      writeArgs.cause = -1;
 
-        HDFtraceIOEvent( fwriteBeginID, (void *) &writeArgs, sizeof(writeArgs) );
-    }
+      HDFtraceIOEvent( fwriteBeginID, (void *) &writeArgs, sizeof(writeArgs) );
+   }
 
-    ret = fputc( c, stream );
+   ret = fputc( c, stream );
 
-    if ( IOtracingEnabled ) {
-	if ( ret == EOF ) {
-	    nbytes = 0;
-            HDFtraceIOEvent( fwriteEndID, (void *) &nbytes, int_SIZE );
-	}
-    }
+   if ( IOtracingEnabled ) 
+   {
+      if ( ret == EOF ) 
+      {
+         nbytes = 0;
+         HDFtraceIOEvent( fwriteEndID, (void *) &nbytes, int_SIZE );
+      }
+   }
 
     return( ret );
 }
-/*+  Routine:  int HDFtraceFPUTS( char *s, FILE *stream )                    +*/
-/*+		  substitute for fputs()                                     +*/
-/*+               generates fwriteBeginID, fwriteEndID                       +*/
-/*+	          record Write (fwriteBeginID)                               +*/
-/*+                    	 Number Variables = 1                                +*/
-/*+			 Cause = -1                                          +*/
-/*+									     +*/
+/*****************************************************************************/
+/*+  Routine:  int HDFtraceFPUTS( char *s, FILE *stream )                   +*/
+/*+		  substitute for fputs()                                    +*/
+/*+               generates fwriteBeginID, fwriteEndID                      +*/
+/*+	          record Write (fwriteBeginID)                              +*/
+/*+                    	 Number Variables = 1                               +*/
+/*+			 Cause = -1                                         +*/
+/*+									    +*/
+/*****************************************************************************/
 int HDFtraceFPUTS( const char *s, FILE *stream )
 {
     struct read_write_args writeArgs;
@@ -1059,178 +1201,362 @@ void PabloHDFTrace( int ID )
            exit (-1);
 	}
 }
-#ifdef HAVE_PARALLEL
-/*======================================================================* 
-// Pass call through to regular MPIO entry except in case of Real Time	* 
-// tracing.  								* 
-// Note: The regular MPIO entry may or may not be instrumented.		*
-//======================================================================*/
-int HDF_MPI_File_open( MPI_Comm comm, char *filename, int amode, 
-                                    MPI_Info info, MPI_File *fh )
+#ifdef H5_HAVE_PARALLEL
+#include "MPIO_Trace.h"
+#include "MPIO_EventArgs.h"
+#include "MPIO_Data.h"
+
+/* Global variable declarations and definitions. */
+static int HDFlocalNode = 0;
+int HDFmyNode;
+int myHDFid = 3;
+/* Function prototypes */
+int HDF_get_mode( int );
+int HDF_get_source( int );
+int HDF_get_comm( MPI_Comm );
+int HDF_get_Datatype( MPI_Datatype );
+int HDF_get_DataRep( char* );
+int HDF_get_Bytes( MPI_Datatype, int );
+int HDF_MPI_Get_count( MPI_Status *, MPI_Datatype, int *, int );
+/************************************************************************/
+/* MPI_Get_count isn't always implemented correctly and may cause the 	*/
+/* program to fail.  This is a kluge to allow the program to complete.  */
+/************************************************************************/
+int HDF_MPI_Get_count( MPI_Status* status, 
+                      MPI_Datatype t, 
+                      int* result, 
+                      int input  )
 {
-   	int returnVal;
-   	HDFsetInfo dataPtr;
-   	int dataLen;
-   
-        if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-           returnVal = MPI_File_open( comm, filename, amode, info, fh );
-        } else {
-	   dataLen = sizeof( HDFsetInfo );
-	   dataPtr.setID = (long)fh;
-	   dataPtr.setName = (char *)malloc( strlen(filename) + 1);
-	   strcpy( dataPtr.setName , filename );
-           HDFtraceEvent_RT( HDFmpiOpenID, &dataPtr, dataLen );
-           returnVal = PMPI_File_open( comm, filename, amode, info, fh );
-           HDFtraceEvent_RT( -HDFmpiOpenID, &dataPtr, dataLen );
-        }
-   	return returnVal;
+#ifdef LAM_MPI
+   *result = input;
+#else
+   MPI_Get_count( status, t, result );
+#endif
+   return;
 }
 
-   
+/* Get the mode at the file openning */
+int HDF_get_mode( int amode )
+{
+   if( amode == MPI_MODE_RDONLY || amode == MPI_MODE_RDWR ||
+       amode == MPI_MODE_WRONLY || amode == MPI_MODE_CREATE ||
+       amode == MPI_MODE_EXCL || amode == MPI_MODE_DELETE_ON_CLOSE ||
+       amode == MPI_MODE_UNIQUE_OPEN || 
+       /* amode == MPI_MODE_SEQUENTIAL || */
+       amode == MPI_MODE_APPEND )
+      return amode;
+   else
+      return PABLO_MPI_MODE_NULL;
+}
 
-/*======================================================================* 
-// Pass call through to regular MPIO entry except in case of Real Time	* 
-// tracing.  								* 
-// Note: The regular MPIO entry may or may not be instrumented.		*
-//======================================================================*/
-int HDF_MPI_File_close( MPI_File *fh )
+/* Get the node number */
+int HDF_get_source( int source )
 {
-   	int returnVal;
-   	HDFsetInfo dataPtr;
-   	int dataLen;
+   if ( source == MPI_ANY_SOURCE ) {
+      return PABLO_MPI_ANYSOURCE;
+   }
    
-        if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-           returnVal = MPI_File_close( fh );
-        } else {
-	   dataLen = sizeof( HDFsetInfo );
-	   dataPtr.setID = (long)fh;
-	   dataPtr.setName = NULL;
-           HDFtraceEvent_RT( HDFmpiCloseID, &dataPtr, dataLen );
-           returnVal = PMPI_File_close( fh );
-           HDFtraceEvent_RT( -HDFmpiCloseID, &dataPtr, dataLen );
-	   free( dataPtr.setName );
-        }
-   	return returnVal;
+   if ( source == MPI_PROC_NULL ) {
+      return PABLO_MPI_PROCNULL;
+   }
+   
+   else {
+      return  source;
+   }
 }
 
-/*======================================================================* 
-// Pass call through to regular MPIO entry except in case of Real Time	* 
-// tracing.  								* 
-// Note: The regular MPIO entry may or may not be instrumented.		*
-//======================================================================*/
-int HDF_MPI_File_delete( char *filename, MPI_Info info )
+/* get the communicator ID                            */
+/* this is dummy for compatability with MPIO Traceing */
+int HDF_get_comm( MPI_Comm in_comm )
 {
-   	int returnVal;
-   	HDFsetInfo dataPtr;
-   	int dataLen;
+   return 0;
+}
+/* Get the MPI_Datatype (mapped to a integer) */
+int HDF_get_Datatype( MPI_Datatype datatype )
+{
+   /*  elementary  datatypes (C) */
+   if ( datatype ==  MPI_CHAR )
+      return PABLO_MPI_CHAR;
+   else if ( datatype ==  MPI_SHORT )
+      return PABLO_MPI_SHORT; 
+   else if ( datatype == MPI_INT )
+      return PABLO_MPI_INT;
+   else if ( datatype ==  MPI_LONG ) 
+      return PABLO_MPI_LONG;  
+   else if ( datatype ==  MPI_UNSIGNED_CHAR )
+      return PABLO_MPI_UNSIGNED_CHAR; 
+   else if ( datatype ==  MPI_UNSIGNED_SHORT )
+      return PABLO_MPI_UNSIGNED_SHORT;
+   else if ( datatype ==  MPI_UNSIGNED )
+      return PABLO_MPI_UNSIGNED;  
+   else if ( datatype ==  MPI_UNSIGNED_LONG )
+      return PABLO_MPI_UNSIGNED_LONG;
+  else if ( datatype ==  MPI_FLOAT )
+     return PABLO_MPI_FLOAT;  
+   else if ( datatype ==  MPI_DOUBLE )
+      return PABLO_MPI_DOUBLE; 
+   else if ( datatype ==  MPI_LONG_DOUBLE )
+      return PABLO_MPI_LONG_DOUBLE; 
    
-        if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-   	   returnVal = MPI_File_delete( filename, info );
-        } else {
-	   dataLen = sizeof( HDFsetInfo );
-	   dataPtr.setID = 0;
-	   dataPtr.setName = (char *)malloc( sizeof(filename) );
-	   strcpy( dataPtr.setName , filename );
-           HDFtraceEvent_RT( HDFmpiDeleteID, &dataPtr, dataLen );
-   	   returnVal = PMPI_File_delete( filename, info );
-           HDFtraceEvent_RT( -HDFmpiDeleteID, &dataPtr, dataLen );
-	   free( dataPtr.setName );
-        }
-   	return returnVal;
+   /* elementary  datatypes (FORTRAN) */
+#ifdef MPI_INTEGER
+   else if ( datatype ==  MPI_INTEGER )	
+      return PABLO_MPI_INTEGER;   
+#endif
+#ifdef MPI_REAL       	
+   else if ( datatype ==  MPI_REAL )
+      return PABLO_MPI_REAL; 	
+#endif
+#ifdef MPI_DOUBLE_PRECISION
+   else if ( datatype ==  MPI_DOUBLE_PRECISION )
+      return PABLO_MPI_DOUBLE_PRECISION; 
+#endif
+#ifdef MPI_COMPLEX
+   else if ( datatype ==  MPI_COMPLEX )   
+      return PABLO_MPI_COMPLEX; 
+#endif
+#ifdef MPI_DOUBLE_COMPLEX		
+   else if ( datatype ==  MPI_DOUBLE_COMPLEX )	
+      return PABLO_MPI_DOUBLE_COMPLEX; 	
+#endif
+#ifdef MPI_LOGICAL
+   else if ( datatype ==  MPI_LOGICAL )	
+      return PABLO_MPI_LOGICAL;
+#endif
+#ifdef MPI_CHARACTER
+   else if ( datatype ==  MPI_CHARACTER )	
+      return PABLO_MPI_CHARACTER;
+#endif 	
+      
+   /*  other  datatypes (C, Fortran).*/
+   else if ( datatype ==  MPI_BYTE )
+      return PABLO_MPI_BYTE;         
+   else if ( datatype ==  MPI_PACKED )
+      return PABLO_MPI_PACKED;  
+   else if ( datatype ==  MPI_LB )
+      return PABLO_MPI_LB;         
+   else if ( datatype ==  MPI_UB )
+      return PABLO_MPI_UB;  
+   
+   
+   /*  reduction  datatypes (C).	*/
+   else if ( datatype ==  MPI_FLOAT_INT )
+      return PABLO_MPI_FLOAT_INT; 	
+   else if ( datatype ==  MPI_DOUBLE_INT )
+      return PABLO_MPI_DOUBLE_INT; 	
+   else if ( datatype ==  MPI_LONG_INT )
+      return PABLO_MPI_LONG_INT; 	
+   else if ( datatype ==  MPI_2INT )
+      return PABLO_MPI_2INT; 		
+   else if ( datatype ==  MPI_SHORT_INT )
+      return PABLO_MPI_SHORT_INT; 	
+   else if ( datatype ==  MPI_LONG_DOUBLE_INT )
+      return PABLO_MPI_LONG_DOUBLE_INT;
+   
+   /* Reduction datatypes (FORTRAN) */
+#ifdef MPI_2REAL
+   else if ( datatype ==  MPI_2REAL )
+      return PABLO_MPI_2REAL; 	
+#endif
+#ifdef MPI_2DOUBLE_PRECISION	
+   else if ( datatype ==  MPI_2DOUBLE_PRECISION )
+      return PABLO_MPI_2DOUBLE_PRECISION;
+#endif
+#ifdef MPI_2INTEGER 		
+   else if ( datatype ==  MPI_2INTEGER )
+      return PABLO_MPI_2INTEGER; 		
+#endif
+
+#ifdef MPI_2COMPLEX
+   else if ( datatype ==  MPI_2COMPLEX )
+      return PABLO_MPI_2COMPLEX; 
+#endif
+#ifdef 	MPI_2DOUBLE_COMPLEX
+   else if ( datatype ==  MPI_2DOUBLE_COMPLEX )
+      return PABLO_MPI_2DOUBLE_COMPLEX; 
+#endif		
+   
+/*  optional  datatypes (C).*/
+#ifdef MPI_LONG_LONG_INT
+   else if ( datatype ==  MPI_LONG_LONG_INT )
+      return PABLO_MPI_LONG_LONG_INT;
+#endif
+   else if ( datatype ==  MPI_DATATYPE_NULL ) 	
+      return PABLO_MPI_DATATYPE_NULL; 		
+   else
+      return PABLO_MPI_USER_DEF;  
 }
 
-/*======================================================================* 
-// Pass call through to regular MPIO entry except in case of Real Time	* 
-// tracing.  								* 
-// Note: The regular MPIO entry may or may not be instrumented.		*
-//======================================================================*/
-int HDF_MPI_File_set_size( MPI_File fh, MPI_Offset size )
+/* data representations */
+int HDF_get_DataRep( char* datarep )
 {
-   	int returnVal;
-   	HDFsetInfo dataPtr;
-   	int dataLen;
-   
-        if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-   	   returnVal = MPI_File_set_size( fh, size );
-        } else {
-	   dataLen = 0;
-           HDFtraceEvent_RT( HDFmpiSetSizeID,&dataPtr,dataLen );
-   	   returnVal = PMPI_File_set_size( fh, size );
-           HDFtraceEvent_RT( -HDFmpiSetSizeID, &dataPtr, dataLen );
-        }
-   	return returnVal;
+   if ( !strcmp( datarep, "native" ) )
+      return PABLO_MPI_NATIVE;
+   else if ( !strcmp( datarep, "internal" ) )
+      return PABLO_MPI_INTERNAL;
+   else if ( !strcmp( datarep, "external32" ) )
+      return PABLO_MPI_EXTERNAL32;
+   else
+      return (-1);
 }
 
+/*****************************************************************************/
+/* The routines below are there to bypass the MPI I/O Tracing.  When MPI I/O */
+/* tracing is done with a nonstandard MPI I/O implementation, problems can   */
+/* occur in linking and in data recording.				     */
+/* For each of the MPI I/O routines MPI_File_xxx used in HDF, there are two  */
+/* entries: HDF_MPI_File_xxx and PabloMPI_File_xxx.	Macros replace the   */
+/* MPI_File_xxx call with HDF_MPI_File_xxx.  	                             */
+/* If SUMMARY Tracing is used                                                */
+/* HDF_MPI_File_xxx routine will record entry data in a table, call the      */
+/* IF RUNTIME Tracing is used						     */
+/* HDF_MPI_File_xxx routine calls PabloMPI_File_xxx.  This routine writes    */
+/* data to the trace file, calls the standard MPI_File_xxx routine, then     */
+/* records exit data to a trace file.					     */
+/* The PabloMPI_File_xxx functionality could have been incorporated into the */
+/* HDF_MPI_File_xxx routine, but was not done so for expediency.	     */
+/*****************************************************************************/
+int PabloMPI_File_open( MPI_Comm comm,
+                   char *filename,
+                   int amode,
+                   MPI_Info info,
+                   MPI_File *fh ) ;
+
+int PabloMPI_File_close( MPI_File *fh ) ;
+
+int PabloMPI_File_set_size( MPI_File fh, MPI_Offset size ) ;
+
+int PabloMPI_File_get_size( MPI_File fh, MPI_Offset *size ) ;
+
+int PabloMPI_File_set_view( MPI_File fh,
+                       MPI_Offset disp,
+                       MPI_Datatype etype,
+                       MPI_Datatype filetype,
+                       char *datarep,
+                       MPI_Info info ) ;
+
+int PabloMPI_File_get_view( MPI_File fh,
+                       MPI_Offset *disp,
+                       MPI_Datatype *etype,
+                       MPI_Datatype *filetype,
+                       char *datarep ) ;
+
+int PabloMPI_File_read_at( MPI_File fh,
+                      MPI_Offset offset,
+                      void *buf,
+                      int count,
+                      MPI_Datatype datatype,
+                      MPI_Status *status ) ;
+
+int PabloMPI_File_read_at_all( MPI_File fh,
+                          MPI_Offset offset,
+                          void *buf,
+                          int count,
+                          MPI_Datatype datatype,
+                          MPI_Status *status ) ;
+
+int PabloMPI_File_write_at( MPI_File fh,
+                       MPI_Offset offset,
+                       void *buf,
+                       int count,
+                       MPI_Datatype datatype,
+                       MPI_Status *status ) ;
+
+int PabloMPI_File_write_at_all( MPI_File fh,
+                           MPI_Offset offset,
+                           void *buf,
+                           int count,
+                           MPI_Datatype datatype,
+                           MPI_Status *status ) ;
+
+int 
+PabloMPI_File_sync( MPI_File fh ) ; 
+
 /*======================================================================* 
 // Pass call through to regular MPIO entry except in case of Real Time	* 
 // tracing.  								* 
 // Note: The regular MPIO entry may or may not be instrumented.		*
 //======================================================================*/
-int HDF_MPI_File_preallocate( MPI_File fh, MPI_Offset size)
+int HDF_MPI_File_open( MPI_Comm comm, char *filename, int amode, 
+                                    MPI_Info info, MPI_File *fh )
 {
-   	int returnVal;
-   	HDFsetInfo dataPtr;
-   	int dataLen;
+   int returnVal;
+   HDFsetInfo dataPtr;
+   int dataLen;
    
-        if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-   	   returnVal = MPI_File_preallocate( fh, size);
-        } else {
-	   dataLen = 0;
-           HDFtraceEvent_RT( HDFmpiPreallocateID,
-                             &dataPtr,dataLen );
-   	   returnVal = PMPI_File_preallocate( fh, size);
-           HDFtraceEvent_RT( -HDFmpiPreallocateID, 
-                             &dataPtr, dataLen );
-        }
-   	return returnVal;
+   if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) 
+   {
+      returnVal = PabloMPI_File_open( comm, filename, amode, info, fh );
+   } 
+   else 
+   {
+      dataLen = sizeof( HDFsetInfo );
+      dataPtr.setID = 0;
+      dataPtr.setName = (char *)malloc( strlen(filename) + 1);
+      strcpy( dataPtr.setName , filename );
+      HDFtraceEvent_RT( HDFmpiOpenID, &dataPtr, dataLen );
+      returnVal = MPI_File_open( comm, filename, amode, info, fh );
+      dataPtr.setID = (long)fh;
+      HDFtraceEvent_RT( -HDFmpiOpenID, &dataPtr, dataLen );
+   }
+   return returnVal;
 }
 
+   
+
 /*======================================================================* 
 // Pass call through to regular MPIO entry except in case of Real Time	* 
 // tracing.  								* 
 // Note: The regular MPIO entry may or may not be instrumented.		*
 //======================================================================*/
-int HDF_MPI_File_get_size( MPI_File fh, MPI_Offset *size )
+int HDF_MPI_File_close( MPI_File *fh )
 {
    	int returnVal;
    	HDFsetInfo dataPtr;
    	int dataLen;
-
-        if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-           returnVal = MPI_File_get_size( fh, size);
-	} else {
-	   dataLen = 0;
-           HDFtraceEvent_RT( HDFmpiGetSizeID,
-                             &dataPtr,dataLen );
-           returnVal = PMPI_File_get_size( fh, size);
-           HDFtraceEvent_RT( -HDFmpiGetSizeID,
-                             &dataPtr,dataLen );
-	}
-   	return returnVal;
+   
+   if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) 
+   {
+      returnVal = PabloMPI_File_close( fh );
+   } 
+   else 
+   {
+      dataLen = sizeof( HDFsetInfo );
+      dataPtr.setID = (long)fh;
+      dataPtr.setName = NULL;
+      HDFtraceEvent_RT( HDFmpiCloseID, &dataPtr, dataLen );
+      returnVal = MPI_File_close( fh );
+      HDFtraceEvent_RT( -HDFmpiCloseID, &dataPtr, dataLen );
+      free( dataPtr.setName );
+   }
+   return returnVal;
 }
 
+
 /*======================================================================* 
 // Pass call through to regular MPIO entry except in case of Real Time	* 
 // tracing.  								* 
 // Note: The regular MPIO entry may or may not be instrumented.		*
 //======================================================================*/
-int HDF_MPI_File_get_group( MPI_File fh, MPI_Group *group )
+int HDF_MPI_File_set_size( MPI_File fh, MPI_Offset size )
 {
-   	int returnVal;
-   	HDFsetInfo dataPtr;
-   	int dataLen;
+   int returnVal;
+   HDFsetInfo dataPtr;
+   int dataLen;
    
-        if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-   	   returnVal = MPI_File_get_group( fh, group);
-	} else {
-	   dataLen = 0;
-           HDFtraceEvent_RT( HDFmpiGetGroupID,
-                             &dataPtr,dataLen );
-   	   returnVal = PMPI_File_get_group( fh, group);
-           HDFtraceEvent_RT( -HDFmpiGetGroupID,
-                             &dataPtr,dataLen );
-	}
-   	return returnVal;
+   if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) 
+   {
+      returnVal = PabloMPI_File_set_size( fh, size );
+   } 
+   else 
+   {
+      dataLen = 1;
+      dataPtr.setID = (long)fh;
+      HDFtraceEvent_RT( HDFmpiSetSizeID,&dataPtr,dataLen );
+      returnVal = MPI_File_set_size( fh, size );
+      HDFtraceEvent_RT( -HDFmpiSetSizeID, &dataPtr, dataLen );
+   }
+   return returnVal;
 }
 
 /*======================================================================* 
@@ -1238,20 +1564,21 @@ int HDF_MPI_File_get_group( MPI_File fh, MPI_Group *group )
 // tracing.  								* 
 // Note: The regular MPIO entry may or may not be instrumented.		*
 //======================================================================*/
-int HDF_MPI_File_get_amode( MPI_File fh, int *amode )
+int HDF_MPI_File_get_size( MPI_File fh, MPI_Offset *size )
 {
    	int returnVal;
    	HDFsetInfo dataPtr;
    	int dataLen;
 
         if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-   	   returnVal = MPI_File_get_amode( fh, amode);
+           returnVal = PabloMPI_File_get_size( fh, size);
 	} else {
-	   dataLen = 0;
-           HDFtraceEvent_RT( HDFmpiGetAmodeID,
+	   dataLen = 1;
+           dataPtr.setID = (long)fh;
+           HDFtraceEvent_RT( HDFmpiGetSizeID,
                              &dataPtr,dataLen );
-   	   returnVal = PMPI_File_get_amode( fh, amode);
-           HDFtraceEvent_RT( -HDFmpiGetAmodeID,
+           returnVal = MPI_File_get_size( fh, size);
+           HDFtraceEvent_RT( -HDFmpiGetSizeID,
                              &dataPtr,dataLen );
 	}
    	return returnVal;
@@ -1270,13 +1597,14 @@ int HDF_MPI_File_set_view( MPI_File fh, MPI_Offset disp, MPI_Datatype etype,
    	int dataLen;
 
         if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-   	   returnVal = MPI_File_set_view( fh, disp, etype, filetype, 
+   	   returnVal = PabloMPI_File_set_view( fh, disp, etype, filetype, 
                                                       datarep, info );
 	} else {
-	   dataLen = 0;
+	   dataLen = 1;
+           dataPtr.setID = (long)fh;
            HDFtraceEvent_RT( HDFmpiSetViewID,
                              &dataPtr,dataLen );
-   	   returnVal = PMPI_File_set_view( fh, disp, etype, filetype, 
+   	   returnVal = MPI_File_set_view( fh, disp, etype, filetype, 
                                                       datarep, info );
            HDFtraceEvent_RT( -HDFmpiSetViewID,
                              &dataPtr,dataLen );
@@ -1292,23 +1620,26 @@ int HDF_MPI_File_set_view( MPI_File fh, MPI_Offset disp, MPI_Datatype etype,
 int HDF_MPI_File_get_view( MPI_File fh, MPI_Offset *disp, MPI_Datatype *etype, 
                            MPI_Datatype *filetype, char *datarep )
 {
-   	int returnVal;
-   	HDFsetInfo dataPtr;
-   	int dataLen;
-
-        if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-   	   returnVal = MPI_File_get_view(fh, disp, etype, filetype, datarep);
-	} else {
-	   dataLen = 0;
-           HDFtraceEvent_RT( HDFmpiSetViewID,
-                             &dataPtr,dataLen );
-   	   returnVal = PMPI_File_get_view(fh, disp, etype, filetype, datarep);
-           HDFtraceEvent_RT( -HDFmpiSetViewID,
+   int returnVal;
+   HDFsetInfo dataPtr;
+   int dataLen;
+
+   if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) 
+   {
+      returnVal = PabloMPI_File_get_view(fh, disp, etype, filetype, datarep);
+   } 
+   else 
+   {
+      dataLen = 1;
+      dataPtr.setID = (long)fh;
+      HDFtraceEvent_RT( HDFmpiSetViewID,
                              &dataPtr,dataLen );
-     	   returnVal = PMPI_File_get_view(fh, disp, etype, filetype, datarep);
+      returnVal = MPI_File_get_view(fh, disp, etype, filetype, datarep);
+      HDFtraceEvent_RT( -HDFmpiSetViewID, &dataPtr,dataLen );
+      returnVal = MPI_File_get_view(fh, disp, etype, filetype, datarep);
 
-	}
-   	return returnVal;
+   }
+   return returnVal;
 }
 
 /*======================================================================* 
@@ -1322,16 +1653,28 @@ int HDF_MPI_File_read_at( MPI_File fh, MPI_Offset offset, void *buf,
    	int returnVal;
    	HDFsetInfo dataPtr;
    	int dataLen;
+        int rCount;
 
         if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-   	   returnVal = MPI_File_read_at( fh, offset, buf, count, datatype, 
+   	   returnVal = PabloMPI_File_read_at( fh, offset, buf, count, datatype, 
 	                                                            status );
 	} else {
-	   dataLen = 0;
+	   dataLen = sizeof(dataPtr);
+           dataPtr.setID = (long)fh;
+           dataPtr.numBytes = HDF_get_Bytes( datatype, count );
            HDFtraceEvent_RT( HDFmpiReadAtID,
                              &dataPtr,dataLen );
-   	   returnVal = PMPI_File_read_at( fh, offset, buf, count, datatype, 
+   	   returnVal = MPI_File_read_at( fh, offset, buf, count, datatype, 
 	                                                            status );
+           HDF_MPI_Get_count(status,datatype,&rCount,count);
+           if ( rCount < 0 || rCount > count ) 
+           {
+              dataPtr.numBytes = -1;
+           }
+           else
+           {
+              dataPtr.numBytes = HDF_get_Bytes( datatype, rCount );
+           }
            HDFtraceEvent_RT( -HDFmpiReadAtID,
                              &dataPtr,dataLen );
 	}
@@ -1350,16 +1693,28 @@ int HDF_MPI_File_read_at_all( MPI_File fh, MPI_Offset offset, void *buf,
    	int returnVal;
    	HDFsetInfo dataPtr;
    	int dataLen;
+        int rCount;
 
         if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-   	   returnVal = MPI_File_read_at_all( fh, offset, buf, 
+   	   returnVal = PabloMPI_File_read_at_all( fh, offset, buf, 
 				      count, datatype, status );
 	} else {
-	   dataLen = 0;
+	   dataLen = sizeof(dataPtr);
+           dataPtr.setID = (long)fh;
+           dataPtr.numBytes = HDF_get_Bytes( datatype, count );
            HDFtraceEvent_RT( HDFmpiReadAtAllID,
                              &dataPtr,dataLen );
-   	   returnVal = PMPI_File_read_at_all( fh, offset, buf, 
+   	   returnVal = MPI_File_read_at_all( fh, offset, buf, 
 				      count, datatype, status );
+           HDF_MPI_Get_count(status,datatype,&rCount,count);
+           if ( rCount < 0 || rCount > count ) 
+           {
+              dataPtr.numBytes = -1;
+           }
+           else
+           {
+              dataPtr.numBytes = HDF_get_Bytes( datatype, rCount );
+           }
            HDFtraceEvent_RT( -HDFmpiReadAtAllID,
                              &dataPtr,dataLen );
 	}
@@ -1375,23 +1730,36 @@ int HDF_MPI_File_write_at( MPI_File fh, MPI_Offset offset, void *buf,
                       int count, MPI_Datatype datatype, MPI_Status *status )
 {
    
-   	int returnVal;
-   	HDFsetInfo dataPtr;
-   	int dataLen;
-
-        if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-   	   returnVal = MPI_File_write_at( fh, offset, buf, count, datatype, 
-	                                                           status );
-	} else {
-	   dataLen = 0;
-           HDFtraceEvent_RT( HDFmpiWriteAtID,
-                             &dataPtr,dataLen );
-   	   returnVal = PMPI_File_write_at( fh, offset, buf, count, datatype, 
-	                                                            status );
-           HDFtraceEvent_RT( -HDFmpiWriteAtID,
-                             &dataPtr,dataLen );
-	}
-   	return returnVal;
+   int returnVal;
+   HDFsetInfo dataPtr;
+   int dataLen;
+   int rCount;
+
+   if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) 
+   {
+      returnVal = PabloMPI_File_write_at( fh, offset, buf, count, datatype, 
+                                                              status );
+   } 
+   else 
+   {
+      dataLen = sizeof(dataPtr);
+      dataPtr.setID = (long)fh;
+      dataPtr.numBytes = HDF_get_Bytes( datatype, count );
+      HDFtraceEvent_RT( HDFmpiWriteAtID, &dataPtr,dataLen );
+      returnVal = MPI_File_write_at( fh, offset, buf, count, datatype, 
+                                                               status );
+      HDF_MPI_Get_count(status,datatype,&rCount,count);
+      if ( rCount < 0 || rCount > count ) 
+      {
+         dataPtr.numBytes = -1;
+      }
+      else
+      {
+         dataPtr.numBytes = HDF_get_Bytes( datatype, rCount );
+      }
+      HDFtraceEvent_RT( -HDFmpiWriteAtID, &dataPtr,dataLen );
+   }
+   return returnVal;
 }
 
 /*======================================================================* 
@@ -1405,16 +1773,28 @@ int HDF_MPI_File_write_at_all( MPI_File fh, MPI_Offset offset, void *buf,
    	int returnVal;
    	HDFsetInfo dataPtr;
    	int dataLen;
+        int numBytes;
 
         if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-   	   returnVal = MPI_File_write_at_all( fh, offset, buf, 
+   	   returnVal = PabloMPI_File_write_at_all( fh, offset, buf, 
 	 	 	       		count, datatype, status );
 	} else {
-	   dataLen = 0;
+	   dataLen = sizeof(dataPtr);
+           dataPtr.setID = (long)fh;
+           dataPtr.numBytes = HDF_get_Bytes( datatype, count );
            HDFtraceEvent_RT( HDFmpiWriteAtAllID,
                              &dataPtr,dataLen );
-   	   returnVal = PMPI_File_write_at_all( fh, offset, buf, 
+   	   returnVal = MPI_File_write_at_all( fh, offset, buf, 
 	 			       count, datatype, status );
+           if ( returnVal == MPI_SUCCESS ) 
+           {
+              numBytes = HDF_get_Bytes( datatype, count );
+           }
+           else
+           {
+              numBytes = -1;
+           }
+           dataPtr.numBytes = numBytes;
            HDFtraceEvent_RT( -HDFmpiWriteAtAllID,
                              &dataPtr,dataLen );
 	}
@@ -1426,317 +1806,530 @@ int HDF_MPI_File_write_at_all( MPI_File fh, MPI_Offset offset, void *buf,
 // tracing.  								* 
 // Note: The regular MPIO entry may or may not be instrumented.		*
 //======================================================================*/
-int HDF_MPI_File_iread_at( MPI_File fh, MPI_Offset offset, void *buf,
-   int count, MPI_Datatype datatype, MPIO_Request *request )
-{
-   return MPI_File_iread_at( fh, offset, buf, count, datatype, request );
-}
-
-/*======================================================================* 
-// Pass call through to regular MPIO entry except in case of Real Time	* 
-// tracing.  								* 
-// Note: The regular MPIO entry may or may not be instrumented.		*
-//======================================================================*/
-int HDF_MPI_File_iwrite_at( MPI_File fh, MPI_Offset offset, void *buf, 
-		int count, MPI_Datatype datatype, MPIO_Request *request)
-{
-   return MPI_File_iwrite_at( fh, offset, buf, count, datatype, request );
-}
-
-/*======================================================================* 
-// Pass call through to regular MPIO entry except in case of Real Time	* 
-// tracing.  								* 
-// Note: The regular MPIO entry may or may not be instrumented.		*
-//======================================================================*/
-int HDF_MPI_File_read( MPI_File fh, void *buf, int count, 
-                       MPI_Datatype datatype, MPI_Status *status)
+int HDF_MPI_File_sync( MPI_File fh )
 {
    	int returnVal;
    	HDFsetInfo dataPtr;
    	int dataLen;
 
-        if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-   	   returnVal = MPI_File_read( fh, buf, count, datatype, status );
+        if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) { 
+   	   returnVal = PabloMPI_File_sync ( fh );
 	} else {
-	   dataLen = 0;
-           HDFtraceEvent_RT( HDFmpiReadID,
+	   dataLen = 1;
+           dataPtr.setID = (long)fh;
+           HDFtraceEvent_RT( HDFmpiSyncID,
                              &dataPtr,dataLen );
-   	   returnVal = PMPI_File_read( fh, buf, count, datatype, status );
-           HDFtraceEvent_RT( -HDFmpiReadID,
+   	   returnVal = MPI_File_sync ( fh );
+           HDFtraceEvent_RT( -HDFmpiSyncID,
                              &dataPtr,dataLen );
-	}
+	} 
    	return returnVal;
 }
 
-/*======================================================================* 
-// Pass call through to regular MPIO entry except in case of Real Time	* 
-// tracing.  								* 
-// Note: The regular MPIO entry may or may not be instrumented.		*
-//======================================================================*/
-int HDF_MPI_File_read_all( MPI_File fh, void *buf, int count, 
-                           MPI_Datatype datatype, MPI_Status *status)
+int HDF_get_Bytes( MPI_Datatype datatype, int count )
 {
-   	int returnVal;
-   	HDFsetInfo dataPtr;
-   	int dataLen;
-
-        if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-   	   returnVal = MPI_File_read_all( fh, buf, count, datatype, status );
-	} else {
-	   dataLen = 0;
-           HDFtraceEvent_RT( HDFmpiReadAllID,
-                             &dataPtr,dataLen );
-   	   returnVal = PMPI_File_read_all( fh, buf, count, datatype, status );
-           HDFtraceEvent_RT( -HDFmpiReadAllID,
-                             &dataPtr,dataLen );
-	}
-   	return returnVal;
+   int nm_bytes;
+   
+   MPI_Type_size( datatype, &nm_bytes );
+   return( nm_bytes * count );
 }
 
-/*======================================================================* 
-// Pass call through to regular MPIO entry except in case of Real Time	* 
-// tracing.  								* 
-// Note: The regular MPIO entry may or may not be instrumented.		*
-//======================================================================*/
-int HDF_MPI_File_write( MPI_File fh, void *buf, int count, 
-                        MPI_Datatype datatype, MPI_Status *status )
+int 
+PabloMPI_File_open( MPI_Comm comm,
+                    char *filename,
+                    int amode,
+                    MPI_Info info,
+                    MPI_File *fh )
 {
-   	int returnVal;
-   	HDFsetInfo dataPtr;
-   	int dataLen;
-
-        if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-           returnVal = MPI_File_write( fh, buf, count, datatype, status );
-	} else {
-	   dataLen = 0;
-           HDFtraceEvent_RT( HDFmpiWriteID,
-                             &dataPtr,dataLen );
-           returnVal = PMPI_File_write( fh, buf, count, datatype, status );
-           HDFtraceEvent_RT( -HDFmpiWriteID,
-                             &dataPtr,dataLen );
-	}
-   	return returnVal;
+   int returnVal;
+   
+   struct mpiOpenBeginArgs mpiOpenBeginArguments;
+   struct mpiOpenEndArgs mpiOpenEndArguments;
+   
+#ifdef DEBUG
+   fprintf( debugFile, "MPI_File_open\n" );
+   fflush( debugFile );
+#endif /* DEBUG */
+   
+   MPI_Comm_rank( comm, &HDFlocalNode );
+   MPI_Comm_rank( MPI_COMM_WORLD, &HDFmyNode );
+
+   mpiOpenBeginArguments.localNode = HDF_get_source( HDFlocalNode );
+   mpiOpenBeginArguments.globalNode = HDFmyNode;
+   mpiOpenBeginArguments.communicatorID = HDF_get_comm( comm );
+   mpiOpenBeginArguments.mode = amode;
+   strcpy( mpiOpenBeginArguments.fileName, filename );
+   
+   /* Generate entry record */
+   traceIOEvent( mpiOpenBeginID, (char *) &mpiOpenBeginArguments, 
+                 sizeof( mpiOpenBeginArguments ) );
+   
+   returnVal = MPI_File_open( comm, filename, amode, info, fh );
+   
+   mpiOpenEndArguments.localNode = HDF_get_source( HDFlocalNode );
+   mpiOpenEndArguments.globalNode = HDFmyNode;
+   /* the fileID is mapped to the fp's address */
+   myHDFid++;
+   mpiOpenEndArguments.fileID = myHDFid;
+   
+   /* Generate exit record */
+   traceIOEvent( mpiOpenEndID, (char *) &mpiOpenEndArguments, 
+                 sizeof( mpiOpenEndArguments ) );
+   
+   return returnVal;
 }
 
-/*======================================================================* 
-// Pass call through to regular MPIO entry except in case of Real Time	* 
-// tracing.  								* 
-// Note: The regular MPIO entry may or may not be instrumented.		*
-//======================================================================*/
-int HDF_MPI_File_write_all( MPI_File fh, void *buf, int count, 
-                            MPI_Datatype datatype, MPI_Status *status )
+int 
+PabloMPI_File_close( MPI_File *fh )
 {
-   	int returnVal;
-   	HDFsetInfo dataPtr;
-   	int dataLen;
-
-        if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-   	   returnVal =MPI_File_write_all( fh, buf, count, datatype, status );
-	} else {
-	   dataLen = 0;
-           HDFtraceEvent_RT( HDFmpiWriteAllID,
-                             &dataPtr,dataLen );
-   	   returnVal = PMPI_File_write_all( fh, buf, count, datatype, status );
-           HDFtraceEvent_RT( -HDFmpiWriteAllID,
-                             &dataPtr,dataLen );
-	}
-   	return returnVal;
+   int returnVal;
+   
+   struct mpiCloseBeginArgs mpiCloseBeginArguments;
+   struct mpiCloseEndArgs mpiCloseEndArguments;
+   
+#ifdef DEBUG
+   fprintf( debugFile, "MPI_File_close\n" );
+   fflush( debugFile );
+#endif /* DEBUG */
+   
+   mpiCloseBeginArguments.localNode = HDFlocalNode;
+   mpiCloseBeginArguments.globalNode = HDFmyNode;
+   mpiCloseBeginArguments.fileID = myHDFid;
+   
+   /* Generate entry record */
+   traceIOEvent( mpiCloseBeginID, (char *) &mpiCloseBeginArguments, 
+		 sizeof( mpiCloseBeginArguments ) );
+   
+   returnVal = MPI_File_close( fh );
+   
+   mpiCloseEndArguments.localNode = HDFlocalNode;
+   mpiCloseEndArguments.globalNode = HDFmyNode;
+   mpiCloseEndArguments.fileID = myHDFid;
+   
+   /* Generate exit record */
+   traceIOEvent( mpiCloseEndID, (char *) &mpiCloseEndArguments, 
+	      sizeof( mpiCloseEndArguments ) );
+   
+   return returnVal;
 }
 
-/*======================================================================* 
-// Pass call through to regular MPIO entry except in case of Real Time	* 
-// tracing.  								* 
-// Note: The regular MPIO entry may or may not be instrumented.		*
-//======================================================================*/
-int HDF_MPI_File_iread( MPI_File fh, void *buf, int count, 
-                        MPI_Datatype datatype, MPIO_Request *request )
+int 
+PabloMPI_File_set_size( MPI_File fh, MPI_Offset size )
 {
-	return MPI_File_iread( fh, buf, count, datatype, request );
+   int returnVal;
+   
+   struct mpiSetSizeBeginArgs mpiSetSizeBeginArguments;
+   struct mpiSetSizeEndArgs mpiSetSizeEndArguments;
+   
+#ifdef DEBUG
+   fprintf( debugFile, "MPI_File_set_size\n" );
+   fflush( debugFile );
+#endif /* DEBUG */
+   
+   mpiSetSizeBeginArguments.localNode = HDFlocalNode;
+   mpiSetSizeBeginArguments.globalNode = HDFmyNode;
+   /* mpiSetSizeBeginArguments.fileID = (long) (&fh); */
+   mpiSetSizeBeginArguments.fileID = myHDFid;
+   
+   mpiSetSizeBeginArguments.fileSize = (long) size;
+   
+   /* Generate entry record */
+   traceIOEvent( mpiSetSizeBeginID, (char *) &mpiSetSizeBeginArguments, 
+		 sizeof( mpiSetSizeBeginArguments ) );
+   
+   returnVal = MPI_File_set_size( fh, size );
+   
+   mpiSetSizeEndArguments.localNode = HDFlocalNode;
+   mpiSetSizeEndArguments.globalNode = HDFmyNode;
+   /* mpiSetSizeEndArguments.fileID = (long) ( &fh ); */
+   mpiSetSizeEndArguments.fileID = myHDFid;
+      
+   /* Generate entry record */
+   traceIOEvent( mpiSetSizeEndID, (char *) &mpiSetSizeEndArguments, 
+		 sizeof( mpiSetSizeEndArguments ) );
+   
+   return returnVal; 
 }
 
-/*======================================================================* 
-// Pass call through to regular MPIO entry except in case of Real Time	* 
-// tracing.  								* 
-// Note: The regular MPIO entry may or may not be instrumented.		*
-//======================================================================*/
-int HDF_MPI_File_iwrite( MPI_File fh, void *buf, int count, 
-	                 MPI_Datatype datatype, MPIO_Request *request )
+int 
+PabloMPI_File_get_size( MPI_File fh, MPI_Offset *size )
 {
-   return MPI_File_iwrite( fh, buf, count, datatype, request );
+   int returnVal;
+  
+   struct mpiGetSizeBeginArgs mpiGetSizeBeginArguments;
+   struct mpiGetSizeEndArgs mpiGetSizeEndArguments;
+   
+#ifdef DEBUG
+   fprintf( debugFile, "MPI_File_get_size\n" );
+   fflush( debugFile );
+#endif /* DEBUG */
+   
+   mpiGetSizeBeginArguments.localNode = HDFlocalNode;
+   mpiGetSizeBeginArguments.globalNode = HDFmyNode;
+   /* mpiGetSizeBeginArguments.fileID = (long) (&fh); */
+   mpiGetSizeBeginArguments.fileID = myHDFid;
+   
+   /* Generate entry record */
+   traceIOEvent( mpiGetSizeBeginID, (char *) &mpiGetSizeBeginArguments, 
+		 sizeof( mpiGetSizeBeginArguments ) );
+   
+   returnVal = MPI_File_get_size( fh, size);
+   
+   mpiGetSizeEndArguments.localNode = HDFlocalNode;
+   mpiGetSizeEndArguments.globalNode = HDFmyNode;
+   /* mpiGetSizeEndArguments.fileID = (long) ( &fh ); */
+   mpiGetSizeEndArguments.fileID = myHDFid;
+   
+   mpiGetSizeEndArguments.fileSize = (long) (*size);
+   
+   /* Generate entry record */
+   traceIOEvent( mpiGetSizeEndID, (char *) &mpiGetSizeEndArguments, 
+		 sizeof( mpiGetSizeEndArguments ) );
+   
+   return returnVal;
 }
 
-/*======================================================================* 
-// Pass call through to regular MPIO entry except in case of Real Time	* 
-// tracing.  								* 
-// Note: The regular MPIO entry may or may not be instrumented.		*
-//======================================================================*/
-int HDF_MPI_File_seek( MPI_File fh, MPI_Offset offset, int whence )
+int 
+PabloMPI_File_set_view( MPI_File fh,
+                        MPI_Offset disp,
+                        MPI_Datatype etype,
+                        MPI_Datatype filetype,
+                        char *datarep,
+                        MPI_Info info )
 {
+   int returnVal;
    
-   	int returnVal;
-   	HDFsetInfo dataPtr;
-   	int dataLen;
-
-        if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-   	   returnVal = MPI_File_seek( fh, offset, whence );
-	} else {
-	   dataLen = 0;
-           HDFtraceEvent_RT( HDFmpiSeekID,
-                             &dataPtr,dataLen );
-   	   returnVal = PMPI_File_seek( fh, offset, whence );
-           HDFtraceEvent_RT( -HDFmpiSeekID,
-                             &dataPtr,dataLen );
-	}
-   	return returnVal;
+   struct mpiSetViewBeginArgs mpiSetViewBeginArguments;
+   struct mpiSetViewEndArgs mpiSetViewEndArguments;
+   
+#ifdef DEBUG
+   fprintf( debugFile, "MPI_File_set_view\n" );
+   fflush( debugFile );
+#endif /* DEBUG */
+   
+   mpiSetViewBeginArguments.localNode = HDFlocalNode;
+   mpiSetViewBeginArguments.globalNode = HDFmyNode;
+   /* mpiSetViewBeginArguments.fileID = (long) ( &fh ); */
+   mpiSetViewBeginArguments.fileID = myHDFid;
+   
+   mpiSetViewBeginArguments.disp = (long) ( disp );
+   mpiSetViewBeginArguments.etype = HDF_get_Datatype( etype );
+   mpiSetViewBeginArguments.fileType = HDF_get_Datatype( filetype );
+   mpiSetViewBeginArguments.dataRep = HDF_get_DataRep( datarep );
+   
+   /* Generate entry record */
+   traceIOEvent( mpiSetViewBeginID, (char *) &mpiSetViewBeginArguments, 
+		 sizeof( mpiSetViewBeginArguments ) );
+   
+   returnVal = MPI_File_set_view( fh, disp, etype, filetype, 
+                                                    datarep, info );
+   
+   mpiSetViewEndArguments.localNode = HDFlocalNode;
+   mpiSetViewEndArguments.globalNode = HDFmyNode;
+   /* mpiSetViewEndArguments.fileID = (long) ( &fh ); */
+   mpiSetViewEndArguments.fileID = myHDFid;
+   
+   /* Generate entry record */
+   traceIOEvent( mpiSetViewEndID, (char *) &mpiSetViewEndArguments, 
+		 sizeof( mpiSetViewEndArguments ) );
+   
+   return returnVal;
 }
 
-/*======================================================================* 
-// Pass call through to regular MPIO entry except in case of Real Time	* 
-// tracing.  								* 
-// Note: The regular MPIO entry may or may not be instrumented.		*
-//======================================================================*/
-int HDF_MPI_File_get_position( MPI_File fh, MPI_Offset *offset )
+int 
+PabloMPI_File_get_view( MPI_File fh,
+                        MPI_Offset *disp,
+                        MPI_Datatype *etype,
+                        MPI_Datatype *filetype,
+                        char *datarep )
 {
+   int returnVal;
    
-   	int returnVal;
-   	HDFsetInfo dataPtr;
-   	int dataLen;
+   struct mpiGetViewBeginArgs mpiGetViewBeginArguments;
+   struct mpiGetViewEndArgs mpiGetViewEndArguments;
 
-        if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-   	   returnVal = MPI_File_get_position( fh, offset );
-	} else {
-	   dataLen = 0;
-           HDFtraceEvent_RT( HDFmpiGetPositionID,
-                             &dataPtr,dataLen );
-   	   returnVal = PMPI_File_get_position( fh, offset );
-           HDFtraceEvent_RT( -HDFmpiGetPositionID,
-                             &dataPtr,dataLen );
-	}
-   	return returnVal;
+#ifdef DEBUG
+   fprintf( debugFile, "MPI_File_get_view\n" );
+   fflush( debugFile );
+#endif /* DEBUG */
+   
+   mpiGetViewBeginArguments.localNode = HDFlocalNode;
+   mpiGetViewBeginArguments.globalNode = HDFmyNode;
+   /* mpiGetViewBeginArguments.fileID = (long) ( &fh ); */
+   mpiGetViewBeginArguments.fileID = myHDFid;
+     
+   /* Generate entry record */
+   traceIOEvent( mpiGetViewBeginID, (char *) &mpiGetViewBeginArguments, 
+		 sizeof( mpiGetViewBeginArguments ) );
+   
+   returnVal = MPI_File_get_view( fh, disp, etype, filetype, datarep );
+   
+   mpiGetViewEndArguments.localNode = HDFlocalNode;
+   mpiGetViewEndArguments.globalNode = HDFmyNode;
+   /* mpiGetViewEndArguments.fileID = (long) ( &fh ); */
+   mpiGetViewEndArguments.fileID = myHDFid;
+   
+   mpiGetViewEndArguments.disp = (long) ( *disp );
+   mpiGetViewEndArguments.etype = HDF_get_Datatype( *etype );
+   mpiGetViewEndArguments.fileType = HDF_get_Datatype( *filetype );
+   mpiGetViewEndArguments.dataRep = HDF_get_DataRep( datarep );
+   
+   /* Generate entry record */
+   traceIOEvent( mpiGetViewEndID, (char *) &mpiGetViewEndArguments, 
+		 sizeof( mpiGetViewEndArguments ) );
+   
+   return returnVal;  
 }
 
-/*======================================================================* 
-// Pass call through to regular MPIO entry except in case of Real Time	* 
-// tracing.  								* 
-// Note: The regular MPIO entry may or may not be instrumented.		*
-//======================================================================*/
-int HDF_MPI_File_get_byte_offset( MPI_File fh, MPI_Offset offset, 
-                                             MPI_Offset *disp )
+int 
+PabloMPI_File_read_at( MPI_File fh,
+                       MPI_Offset offset,
+                       void *buf,
+                       int count,
+                       MPI_Datatype datatype,
+                       MPI_Status *status )
 {
-   	int returnVal;
-   	HDFsetInfo dataPtr;
-   	int dataLen;
-
-        if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-   	   returnVal = MPI_File_get_byte_offset( fh, offset, disp );
-	} else {
-	   dataLen = 0;
-           HDFtraceEvent_RT( HDFmpiGetByteOffsetID,
-                             &dataPtr,dataLen );
-   	   returnVal = PMPI_File_get_byte_offset( fh, offset, disp );
-           HDFtraceEvent_RT( -HDFmpiGetByteOffsetID,
-                             &dataPtr,dataLen );
-	}
-   	return returnVal;
+   int returnVal, bcount;
+   
+   struct mpiReadAtBeginArgs mpiReadAtBeginArguments;
+   struct mpiReadAtEndArgs mpiReadAtEndArguments;
+   
+#ifdef DEBUG
+   fprintf( debugFile, "MPI_File_read_at\n" );
+   fflush( debugFile );
+#endif /* DEBUG */
+   
+   mpiReadAtBeginArguments.localNode = HDFlocalNode;
+   mpiReadAtBeginArguments.globalNode = HDFmyNode;
+   /* mpiReadAtBeginArguments.fileID = (long) ( &fh ); */
+   mpiReadAtBeginArguments.fileID = myHDFid;
+   
+   mpiReadAtBeginArguments.offset = (long) ( offset );
+   mpiReadAtBeginArguments.count = count;
+   mpiReadAtBeginArguments.dataType = HDF_get_Datatype( datatype );
+   mpiReadAtBeginArguments.numBytes = HDF_get_Bytes( datatype, count );
+    
+  
+   /* Generate entry record */
+   traceIOEvent( mpiReadAtBeginID, (char *) &mpiReadAtBeginArguments, 
+		 sizeof( mpiReadAtBeginArguments ) );
+   
+   returnVal = MPI_File_read_at( fh, offset, buf, count, datatype, status );
+   
+   mpiReadAtEndArguments.localNode = HDFlocalNode;
+   mpiReadAtEndArguments.globalNode = HDFmyNode;
+   /* mpiReadAtEndArguments.fileID = (long) ( &fh ); */
+   mpiReadAtEndArguments.fileID = myHDFid;
+   
+   HDF_MPI_Get_count( status, datatype, &bcount, count );
+   mpiReadAtEndArguments.rCount = bcount;
+   mpiReadAtEndArguments.numBytes = HDF_get_Bytes( datatype, bcount );
+      
+   /* Generate entry record */
+   traceIOEvent( mpiReadAtEndID, (char *) &mpiReadAtEndArguments, 
+		 sizeof( mpiReadAtEndArguments ) );
+   
+   return returnVal;
 }
 
-/*======================================================================* 
-// Pass call through to regular MPIO entry except in case of Real Time	* 
-// tracing.  								* 
-// Note: The regular MPIO entry may or may not be instrumented.		*
-//======================================================================*/
-int HDF_MPI_File_get_type_extent( MPI_File fh, MPI_Datatype datatype, 
-                                               MPI_Aint *extent )
+int 
+PabloMPI_File_read_at_all( MPI_File fh,
+                           MPI_Offset offset,
+                           void *buf,
+                           int count,
+                           MPI_Datatype datatype,
+                           MPI_Status *status )
 {
+   int returnVal, bcount;
    
-   	int returnVal;
-   	HDFsetInfo dataPtr;
-   	int dataLen;
-
-        if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-   	   returnVal = MPI_File_get_type_extent( fh, datatype, extent );
-	} else {
-	   dataLen = 0;
-           HDFtraceEvent_RT( HDFmpiGetTypeExtentID,
-                             &dataPtr,dataLen );
-   	   returnVal = PMPI_File_get_type_extent( fh, datatype, extent );
-           HDFtraceEvent_RT( -HDFmpiGetTypeExtentID,
-                             &dataPtr,dataLen );
-	}
-   	return returnVal;
+   struct mpiReadAtAllBeginArgs mpiReadAtAllBeginArguments;
+   struct mpiReadAtAllEndArgs mpiReadAtAllEndArguments;
+   
+#ifdef DEBUG
+   fprintf( debugFile, "MPI_File_read_at_all\n" );
+   fflush( debugFile );
+#endif /* DEBUG */
+   
+   mpiReadAtAllBeginArguments.localNode = HDFlocalNode;
+   mpiReadAtAllBeginArguments.globalNode = HDFmyNode;
+   /* mpiReadAtAllBeginArguments.fileID = (long) ( &fh ); */
+   mpiReadAtAllBeginArguments.fileID = myHDFid;
+   
+   mpiReadAtAllBeginArguments.offset = (long) ( offset );
+   mpiReadAtAllBeginArguments.count = count;
+   mpiReadAtAllBeginArguments.dataType = HDF_get_Datatype( datatype );
+   mpiReadAtAllBeginArguments.numBytes = HDF_get_Bytes( datatype, count );
+   
+   /* Generate entry record */
+   traceIOEvent( mpiReadAtAllBeginID, (char *) &mpiReadAtAllBeginArguments, 
+		 sizeof( mpiReadAtAllBeginArguments ) );
+   
+   returnVal = MPI_File_read_at_all( fh, offset, buf, 
+				      count, datatype, status );
+   
+   mpiReadAtAllEndArguments.localNode = HDFlocalNode;
+   mpiReadAtAllEndArguments.globalNode = HDFmyNode;
+   /* mpiReadAtAllEndArguments.fileID = (long) ( &fh ); */
+   mpiReadAtAllEndArguments.fileID = myHDFid;
+   
+   HDF_MPI_Get_count( status, datatype, &bcount, count );
+   mpiReadAtAllEndArguments.rCount = bcount;
+   mpiReadAtAllEndArguments.numBytes = HDF_get_Bytes( datatype, bcount );
+   
+   /* Generate entry record */
+   traceIOEvent( mpiReadAtAllEndID, (char *) &mpiReadAtAllEndArguments, 
+		 sizeof( mpiReadAtAllEndArguments ) );
+   
+   return returnVal;
 }
 
-/*======================================================================* 
-// Pass call through to regular MPIO entry except in case of Real Time	* 
-// tracing.  								* 
-// Note: The regular MPIO entry may or may not be instrumented.		*
-//======================================================================*/
-int HDF_MPI_File_set_atomicity( MPI_File fh, int flag )
+int 
+PabloMPI_File_write_at( MPI_File fh,
+                        MPI_Offset offset,
+                        void *buf,
+                        int count,
+                        MPI_Datatype datatype,
+                        MPI_Status *status )
 {
-   	int returnVal;
-   	HDFsetInfo dataPtr;
-   	int dataLen;
-
-        if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-   	   returnVal = MPI_File_set_atomicity( fh, flag );
-	} else {
-	   dataLen = 0;
-           HDFtraceEvent_RT( HDFmpiSetAtomicityID,
-                             &dataPtr,dataLen );
-   	   returnVal = PMPI_File_set_atomicity( fh, flag );
-           HDFtraceEvent_RT( -HDFmpiSetAtomicityID,
-                             &dataPtr,dataLen );
-	}
-   	return returnVal;
+   int returnVal, bcount;
+   
+   struct mpiWriteAtBeginArgs mpiWriteAtBeginArguments;
+   struct mpiWriteAtEndArgs mpiWriteAtEndArguments;
+   
+#ifdef DEBUG
+   fprintf( debugFile, "MPI_File_write_at\n" );
+   fflush( debugFile );
+#endif /* DEBUG */
+   
+   mpiWriteAtBeginArguments.localNode = HDFlocalNode;
+   mpiWriteAtBeginArguments.globalNode = HDFmyNode;
+   /* mpiWriteAtBeginArguments.fileID = (long) ( &fh ); */
+   mpiWriteAtBeginArguments.fileID = myHDFid;
+   
+   mpiWriteAtBeginArguments.offset = (long) ( offset );
+   mpiWriteAtBeginArguments.count = count;
+   mpiWriteAtBeginArguments.dataType = HDF_get_Datatype( datatype );
+   mpiWriteAtBeginArguments.numBytes = HDF_get_Bytes( datatype, count );
+   
+   /* Generate entry record */
+   traceIOEvent( mpiWriteAtBeginID, (char *) &mpiWriteAtBeginArguments, 
+		 sizeof( mpiWriteAtBeginArguments ) );
+  
+   returnVal = MPI_File_write_at( fh, offset, buf, count, 
+                                            datatype, status );
+   
+   mpiWriteAtEndArguments.localNode = HDFlocalNode;
+   mpiWriteAtEndArguments.globalNode = HDFmyNode;
+   /* mpiWriteAtEndArguments.fileID = (long) ( &fh ); */
+   mpiWriteAtEndArguments.fileID = myHDFid;
+   
+   HDF_MPI_Get_count( status, datatype, &bcount, count );
+   mpiWriteAtEndArguments.wCount = bcount;
+   mpiWriteAtEndArguments.numBytes = HDF_get_Bytes( datatype, bcount );
+   
+   /* Generate entry record */
+   traceIOEvent( mpiWriteAtEndID, (char *) &mpiWriteAtEndArguments, 
+		 sizeof( mpiWriteAtEndArguments ) );
+   
+   return returnVal;  
 }
 
-/*======================================================================* 
-// Pass call through to regular MPIO entry except in case of Real Time	* 
-// tracing.  								* 
-// Note: The regular MPIO entry may or may not be instrumented.		*
-//======================================================================*/
-int HDF_MPI_File_get_atomicity( MPI_File fh, int *flag )
+int 
+PabloMPI_File_write_at_all( MPI_File fh,
+                            MPI_Offset offset,
+                            void *buf,
+                            int count,
+                            MPI_Datatype datatype,
+                            MPI_Status *status )
 {
+   int returnVal, bcount;
+   int numBytes;
    
-   	int returnVal;
-   	HDFsetInfo dataPtr;
-   	int dataLen;
-
-        if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-   	   returnVal = MPI_File_get_atomicity( fh, flag );
-	} else {
-	   dataLen = 0;
-           HDFtraceEvent_RT( HDFmpiGetAtomicityID,
-                             &dataPtr,dataLen );
-   	   returnVal = PMPI_File_get_atomicity( fh, flag );
-           HDFtraceEvent_RT( -HDFmpiGetAtomicityID,
-                             &dataPtr,dataLen );
-	}
-   	return returnVal;
+   struct mpiWriteAtAllBeginArgs mpiWriteAtAllBeginArguments;
+   struct mpiWriteAtAllEndArgs mpiWriteAtAllEndArguments;
+   
+#ifdef DEBUG
+   fprintf( debugFile, "MPI_File_write_at\n" );
+   fflush( debugFile );
+#endif /* DEBUG */
+   
+   mpiWriteAtAllBeginArguments.localNode = HDFlocalNode;
+   mpiWriteAtAllBeginArguments.globalNode = HDFmyNode;
+   /* mpiWriteAtAllBeginArguments.fileID = (long) ( &fh ); */
+   mpiWriteAtAllBeginArguments.fileID = myHDFid;
+   
+   mpiWriteAtAllBeginArguments.offset = (long) ( offset );
+   mpiWriteAtAllBeginArguments.count = count;
+   mpiWriteAtAllBeginArguments.dataType = HDF_get_Datatype( datatype );
+   mpiWriteAtAllBeginArguments.numBytes = HDF_get_Bytes( datatype, count );
+      
+   /* Generate entry record */
+   traceIOEvent( mpiWriteAtAllBeginID, (char *) &mpiWriteAtAllBeginArguments, 
+		 sizeof( mpiWriteAtAllBeginArguments ) );
+   
+   returnVal = MPI_File_write_at_all( fh, offset, buf, 
+				       count, datatype, status );
+   
+   mpiWriteAtAllEndArguments.localNode = HDFlocalNode;
+   mpiWriteAtAllEndArguments.globalNode = HDFmyNode;
+   /* mpiWriteAtAllEndArguments.fileID = (long) ( &fh ); */
+   mpiWriteAtAllEndArguments.fileID = myHDFid;
+   
+   if ( returnVal == MPI_SUCCESS ) 
+   {
+      bcount = count;
+      numBytes = HDF_get_Bytes( datatype, count );
+   }
+   else
+   {
+      bcount = -1;
+      numBytes = -1;
+   }
+   mpiWriteAtAllEndArguments.wCount = bcount;
+   mpiWriteAtAllEndArguments.numBytes = numBytes;
+
+   /* Generate entry record */
+   traceIOEvent( mpiWriteAtAllEndID, (char *) &mpiWriteAtAllEndArguments, 
+		 sizeof( mpiWriteAtAllEndArguments ) );
+   
+   return returnVal;  
 }
 
-/*======================================================================* 
-// Pass call through to regular MPIO entry except in case of Real Time	* 
-// tracing.  								* 
-// Note: The regular MPIO entry may or may not be instrumented.		*
-//======================================================================*/
-int HDF_MPI_File_sync( MPI_File fh )
+int 
+PabloMPI_File_sync( MPI_File fh ) 
 {
-   	int returnVal;
-   	HDFsetInfo dataPtr;
-   	int dataLen;
-
-        if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) { 
-   	   returnVal = MPI_File_sync ( fh );
-	} else {
-	   dataLen = 0;
-           HDFtraceEvent_RT( HDFmpiSyncID,
-                             &dataPtr,dataLen );
-   	   returnVal = PMPI_File_sync ( fh );
-           HDFtraceEvent_RT( -HDFmpiSyncID,
-                             &dataPtr,dataLen );
-	} 
-   	return returnVal;
+   int returnVal;
+   
+   struct mpiSyncBeginArgs mpiSyncBeginArguments;
+   struct mpiSyncEndArgs mpiSyncEndArguments;
+   
+#ifdef DEBUG
+   fprintf( debugFile, "MPI_File_sync\n" );
+   fflush( debugFile );
+#endif /* DEBUG */
+   
+   mpiSyncBeginArguments.localNode = HDFlocalNode;
+   mpiSyncBeginArguments.globalNode = HDFmyNode;
+   /* mpiSyncBeginArguments.fileID = (long) ( &fh ); */
+   mpiSyncBeginArguments.fileID = myHDFid;
+      
+   /* Generate entry record */
+   traceIOEvent( mpiSyncBeginID, 
+		 (char *) &mpiSyncBeginArguments, 
+		 sizeof( mpiSyncBeginArguments ) );
+   
+   returnVal = MPI_File_sync ( fh );
+   
+   mpiSyncEndArguments.localNode = HDFlocalNode;
+   mpiSyncEndArguments.globalNode = HDFmyNode;
+   /* mpiSyncEndArguments.fileID = (long) ( &fh ); */
+   mpiSyncEndArguments.fileID = myHDFid;
+   
+   /* Generate entry record */
+   traceIOEvent( mpiSyncEndID, (char *) &mpiSyncEndArguments, 
+		 sizeof( mpiSyncEndArguments ) );
+   
+   return returnVal;
 }
 
-#endif /* HAVE_PARALLEL */
+#endif /* H5_HAVE_PARALLEL */
diff --git a/pablo/PabloHDF_RT.c b/pablo/PabloHDF_RT.c
index 1ccdad5..6de90d2 100644
--- a/pablo/PabloHDF_RT.c
+++ b/pablo/PabloHDF_RT.c
@@ -142,8 +142,8 @@
 
 #include "HDFrecord_RT.h"
 
-#ifdef HAVE_PARALLEL
-#include "mpio.h"
+#ifdef H5_HAVE_PARALLEL
+#include "mpi.h"
 #include "MPIO_EventArgs.h"
 #endif
 
@@ -230,7 +230,7 @@ extern char *hdfRecordPointer;
 //======================================================================*/
 void HDFinitTrace_RT( char *fileName, int OUTSW )
 {
-#ifdef  HAVE_PARALLEL
+#ifdef  H5_HAVE_PARALLEL
 	int myNode;
 #endif
 	int error;
@@ -241,7 +241,7 @@ void HDFinitTrace_RT( char *fileName, int OUTSW )
 	   exit(-1);
 	}
 	FileName = ( char * ) malloc ( strlen( fileName ) + 10 );
-#ifdef  HAVE_PARALLEL
+#ifdef  H5_HAVE_PARALLEL
 	/*==============================================================*
 	// Here the library was built to linked with the MPI and MPIO	*
 	// libraries.  However, the use may chose not to run with MPI.	*
@@ -259,11 +259,11 @@ void HDFinitTrace_RT( char *fileName, int OUTSW )
 	}
 #else
 	/*==============================================================*
-	// In the non-parallel case, set the trace file name and 	*
+      case, set the trace file name and 	*
 	// initialize the trace library.				*
 	//==============================================================*/
 	strcpy( FileName, fileName ) ;
-#endif	/* HAVE_PARALLEL */
+#endif	/* H5_HAVE_PARALLEL */
         setTraceFileName(FileName);
         basicLibraryInit( );         
 }
@@ -280,7 +280,6 @@ void HDFendTrace_RT( int OUTSW )
 	int j, numSetIDs;
 	HDFnode_t *P;
 	char **Names;
-/*	char* mapFile;*/
 
 	HDFfinalTimeStamp();
 	/*==============================================================*
@@ -391,27 +390,40 @@ int initHDFProcTrace_RT( void )
 //======================================================================*/
 void HDFtraceEvent_RT( int eventType, char *dataPtr, unsigned dataLen ) 
 {
-	CLOCK	seconds;
+   CLOCK	seconds;
 
-	seconds = getClock();
+   seconds = getClock();
 
-	if ( isBeginIOEvent ( eventType ) || eventType == ID_malloc ) {
-	   BeginIOEventRecord ( eventType, seconds, dataPtr ) ;
-	} else if ( isEndIOEvent( eventType )  || eventType == -ID_malloc) {
-	   EndIOEventRecord ( eventType, seconds, dataPtr );
-	} else if ( isBeginHDFEvent( eventType ) ) { 
-	   BeginHDFEventRecord ( eventType , seconds ) ;
-	} else if ( isEndHDFEvent( eventType ) ) {
-	   EndHDFEventRecord ( seconds, dataPtr );
-#ifdef  HAVE_PARALLEL
-	} else if ( isBeginMPIOEvent( eventType ) ) { 
-	   BeginMPIOEventRecord ( eventType, seconds, dataPtr, dataLen ) ;
-	} else if ( isEndMPIOEvent( eventType ) ) {
-	   EndMPIOEventRecord ( eventType, seconds, dataPtr, dataLen );
-#endif  /* HAVE_PARALLEL */
-	} else {
-	   fprintf(stderr,"eventType %d, dataLen = %u\n",eventType,dataLen);
-	} 
+   if ( isBeginIOEvent ( eventType ) || eventType == ID_malloc ) 
+   {
+      BeginIOEventRecord ( eventType, seconds, dataPtr ) ;
+   } 
+   else if ( isEndIOEvent( eventType )  || eventType == -ID_malloc) 
+   {
+      EndIOEventRecord ( eventType, seconds, dataPtr );
+   } 
+   else if ( isBeginHDFEvent( eventType ) ) 
+   { 
+      BeginHDFEventRecord ( eventType , seconds ) ;
+   } 
+   else if ( isEndHDFEvent( eventType ) ) 
+   {
+      EndHDFEventRecord ( seconds, dataPtr );
+#ifdef  H5_HAVE_PARALLEL
+   } 
+   else if ( isBeginMPIOEvent( eventType ) ) 
+   { 
+      BeginMPIOEventRecord ( eventType, seconds, dataPtr, dataLen ) ;
+   } 
+   else if ( isEndMPIOEvent( eventType ) ) 
+   {
+      EndMPIOEventRecord ( eventType, seconds, dataPtr, dataLen );
+#endif  /* H5_HAVE_PARALLEL */
+   } 
+   else 
+   {
+      fprintf(stderr,"eventType %d, dataLen = %u\n",eventType,dataLen);
+   } 
 }
 /*======================================================================* 
 // BeginIOEventRecord:                                               	*
@@ -420,41 +432,48 @@ void HDFtraceEvent_RT( int eventType, char *dataPtr, unsigned dataLen )
 //======================================================================*/ 
 void BeginIOEventRecord ( int eventType, CLOCK seconds, void *dataPtr  )
 {
-	char *name;
-	/*==============================================================*
-	// save the time value temporarily in top of stack		*
-	// When the end record is received, the duration can be 	*
-	// computed.							*
-	//==============================================================*/
-	CallStack->lastIOtime = seconds;
-	/*==============================================================*
-	// get the ID or name of the file accessed from the structure	*
-	// passed as dataPtr.  						*
-	//==============================================================*/
-	switch ( eventType )
-	{
-		case fopenBeginID:
-		case openBeginID:
-		   name = (char *)(dataPtr) + 2*sizeof(int);
-  	   	   strcpy( openName, name );
-		   break;
-		case fcloseBeginID:
-		case closeBeginID:
-	   	   CallStack->record.hdfID = *( long *)dataPtr;
-		   break;
-		case readBeginID:
-		case freadBeginID:
-		case writeBeginID:
-		case fwriteBeginID:
-		case lseekBeginID:
-		case fseekBeginID:
-		case fsetposBeginID:
-		case rewindBeginID:
-	   	   CallStack->record.hdfID = *(int *)dataPtr;
-		   break;
-		default:
-		   break;
-	}
+   char *name;
+   /*===================================================================*
+   // save the time value temporarily in top of stack			*
+   // When the end record is received, the duration can be computed.	*
+   //===================================================================*/
+   CallStack->lastIOtime = seconds;
+   /*===================================================================*
+   // get the ID or name of the file accessed from the structure	*
+   // passed as dataPtr.  						*
+   //===================================================================*/
+   switch ( eventType )
+   {
+      case fopenBeginID:
+      case openBeginID:
+      {
+         name = (char *)(dataPtr) + 2*sizeof(int);
+         strcpy( openName, name );
+	 break;
+      }
+      case fcloseBeginID:
+      case closeBeginID:
+      {
+         CallStack->record.hdfID = *( long *)dataPtr;
+	 break;
+      }
+      case readBeginID:
+      case freadBeginID:
+      case writeBeginID:
+      case fwriteBeginID:
+      case lseekBeginID:
+      case fseekBeginID:
+      case fsetposBeginID:
+      case rewindBeginID:
+      {
+         CallStack->record.hdfID = *(int *)dataPtr;
+	 break;
+      }
+      default:
+      {
+         break;
+      }
+   }
 }
 /*======================================================================* 
 // EndIOEventRecord:							*
@@ -465,44 +484,50 @@ void BeginIOEventRecord ( int eventType, CLOCK seconds, void *dataPtr  )
 //======================================================================*/ 
 void EndIOEventRecord ( int eventType, CLOCK secs, void *dataPtr )
 {
-	CLOCK incDur;
-	int i, Field, ByteField, bytes;
-
-	incDur = clockSubtract(secs,CallStack->lastIOtime) ;
-	Field = getHDFFieldIndex( eventType ) ;
-        CallStack->record.times[Field] 
-            = clockAdd ( CallStack->record.times[Field] , incDur ) ;
-        ++CallStack->record.counts[Field];
-	ByteField = getHDFByteFieldIndex( Field ) ;
-	switch ( eventType ) 
-	{
-		case readEndID:
-		case freadEndID:
-		case writeEndID:
-		case fwriteEndID:
-		case -ID_malloc:
-	   	   bytes = *((int *)dataPtr);
-	      	   CallStack->record.bytes[ByteField] += bytes;
-	           /*====================================================
-		   // update histogram					*
-	           //===================================================*/
-                   i = -1;
-                   while ( bytes >= BktLim[i+1] ) ++i  ;
-                   if ( i >= 0 ) ++CallStack->record.Hists[ByteField][i];
-		   break;
-		case fopenEndID:
-		case openEndID:
-		   openInfo.setName = openName;
-		   openInfo.setID = (int)(*((long *)dataPtr));
-		   CallStack->record.hdfID = openInfo.setID;
-	           HDFrecordFileName ( &openInfo );
-		   break;
-		default:
-		   break;
-	}
+   CLOCK incDur;
+   int i, Field, ByteField, bytes;
+   
+   incDur = clockSubtract(secs,CallStack->lastIOtime) ;
+   Field = getHDFFieldIndex( eventType ) ;
+   CallStack->record.times[Field] 
+   = clockAdd ( CallStack->record.times[Field] , incDur ) ;
+   ++CallStack->record.counts[Field];
+   ByteField = getHDFByteFieldIndex( Field ) ;
+   switch ( eventType ) 
+   {
+      case readEndID:
+      case freadEndID:
+      case writeEndID:
+      case fwriteEndID:
+      case -ID_malloc:
+      {
+         bytes = *((int *)dataPtr);
+         CallStack->record.bytes[ByteField] += bytes;
+         /*======================================================
+         // update histogram					*
+         //=====================================================*/
+         i = -1;
+         while ( bytes >= BktLim[i+1] ) ++i  ;
+         if ( i >= 0 ) ++CallStack->record.Hists[ByteField][i];
+         break;
+      }
+      case fopenEndID:
+      case openEndID:
+      {
+         openInfo.setName = openName;
+         openInfo.setID = (int)(*((long *)dataPtr));
+         CallStack->record.hdfID = openInfo.setID;
+         HDFrecordFileName ( &openInfo );
+         break;
+      }
+      default:
+      {
+         break;
+      }
+   }
 			
 }
-#ifdef HAVE_PARALLEL
+#ifdef H5_HAVE_PARALLEL
 /*======================================================================*
 // BeginMPIOEventRecord:                                               	*
 //  This routine simply records the time in the record on the top of 	*
@@ -510,141 +535,97 @@ void EndIOEventRecord ( int eventType, CLOCK secs, void *dataPtr )
 //======================================================================*/ 
 void BeginMPIOEventRecord( int eventType, 
 	                   CLOCK seconds, 
-	                   void *dataPtr,
+	                   void *data,
 	                   int dataLen )
 {
-	/*==============================================================*
-	// save the time value temporarily in top of stack		*
-	// When the end record is received, the duration can be 	*
-	// computed.							*
-	//==============================================================*/
-	CallStack->lastIOtime = seconds;
-	/*==============================================================*
-	// get useful info from the structure pointed to by dataPtr.	*
-	// in most cases, this is the file ID.  For mpiOpen, it is the	*
-	// name of the file.  For mpiDelete, no information is of any	*
-	// use.								*
-	//==============================================================*/
-        if ( dataLen == 0 ) return;
-	switch ( eventType ) 
-	{
-	   case HDFmpiGetSizeID:
-	      CallStack->record.hdfID 
-		 = ((struct mpiGetSizeBeginArgs *)dataPtr)->fileID;
-	      break;
-	   case HDFmpiGetGroupID:
-	      CallStack->record.hdfID 
-		 = ((struct mpiGetGroupBeginArgs *)dataPtr)->fileID;
-	      break;
-	   case HDFmpiGetAmodeID:
-	      CallStack->record.hdfID 
-		 = ((struct mpiGetAmodeBeginArgs *)dataPtr)->fileID;
-	      break;
-	   case HDFmpiGetViewID:
-	      CallStack->record.hdfID 
-		 = ((struct mpiGetViewBeginArgs *)dataPtr)->fileID;
-	      break;
-	   case HDFmpiGetPositionID:
-	      CallStack->record.hdfID 
-		 = ((struct mpiGetPositionBeginArgs *)dataPtr)->fileID;
-	      break;
-	   case HDFmpiGetByteOffsetID:
-	      CallStack->record.hdfID 
-		 = ((struct mpiGetByteOffsetBeginArgs *)dataPtr)->fileID;
-	      break;
-	   case HDFmpiGetTypeExtentID:
-	      CallStack->record.hdfID 
-		 = ((struct mpiGetTypeExtentBeginArgs *)dataPtr)->fileID;
-	      break;
-	   case HDFmpiGetAtomicityID:
-	      CallStack->record.hdfID 
-		 = ((struct mpiGetAtomicityBeginArgs *)dataPtr)->fileID;
-	      break;
-	   case HDFmpiOpenID:
-	      strcpy( openName,
-		     ((struct mpiOpenBeginArgs *)dataPtr)->fileName);
-	      break;
-	   case HDFmpiCloseID:
-	      CallStack->record.hdfID 
-		 = ((struct mpiCloseBeginArgs *)dataPtr)->fileID;
-	      break;
-	   case HDFmpiDeleteID:
-	      break;
-	   case HDFmpiSetSizeID:
-	      CallStack->record.hdfID 
-		 = ((struct mpiSetSizeBeginArgs *)dataPtr)->fileID;
-	      break;
-	   case HDFmpiPreallocateID:
-	      CallStack->record.hdfID 
-		 = ((struct mpiPreallocateBeginArgs *)dataPtr)->fileID;
-	      break;
-	   case HDFmpiSetViewID:
-	      CallStack->record.hdfID 
-		 = ((struct mpiSetViewBeginArgs *)dataPtr)->fileID;
-	      break;
-	   case HDFmpiReadAtID:
-	      CallStack->record.hdfID 
-		 = ((struct mpiReadAtBeginArgs *)dataPtr)->fileID;
-	      break;
-	   case HDFmpiReadAtAllID:
-	      CallStack->record.hdfID 
-		 = ((struct mpiReadAtAllBeginArgs *)dataPtr)->fileID;
-	      break;
-	   case HDFmpiWriteAtID:
-	      CallStack->record.hdfID 
-		 = ((struct mpiWriteAtBeginArgs *)dataPtr)->fileID;
-	      break;
-	   case HDFmpiWriteAtAllID:
-	      CallStack->record.hdfID 
-		 = ((struct mpiWriteAtAllBeginArgs *)dataPtr)->fileID;
-	      break;
-	   case HDFmpiIreadAtID:
-	      CallStack->record.hdfID 
-		 = ((struct mpiIreadAtBeginArgs *)dataPtr)->fileID;
-	      break;
-	   case HDFmpiIwriteAtID:
-	      CallStack->record.hdfID 
-		 = ((struct mpiIwriteAtBeginArgs *)dataPtr)->fileID;
-	      break;
-	   case HDFmpiReadID:
-	      CallStack->record.hdfID 
-		 = ((struct mpiReadBeginArgs *)dataPtr)->fileID;
-	      break;
-	   case HDFmpiReadAllID:
-	      CallStack->record.hdfID 
-		 = ((struct mpiReadAllBeginArgs *)dataPtr)->fileID;
-	      break;
-	   case HDFmpiWriteID:
-	      CallStack->record.hdfID 
-		 = ((struct mpiWriteBeginArgs *)dataPtr)->fileID;
-	      break;
-	   case HDFmpiWriteAllID:
-	      CallStack->record.hdfID 
-		 = ((struct mpiWriteAllBeginArgs *)dataPtr)->fileID;
-	      break;
-	   case HDFmpiIreadID:
-	      CallStack->record.hdfID 
-		 = ((struct mpiIreadBeginArgs *)dataPtr)->fileID;
-	      break;
-	   case HDFmpiIwriteID:
-	      CallStack->record.hdfID 
-		 = ((struct mpiIwriteBeginArgs *)dataPtr)->fileID;
-	      break;
-	   case HDFmpiSeekID:
-	      CallStack->record.hdfID 
-		 = ((struct mpiSeekBeginArgs *)dataPtr)->fileID;
-	      break;
-	   case HDFmpiSetAtomicityID:
-	      CallStack->record.hdfID 
-		 = ((struct mpiSetAtomicityBeginArgs *)dataPtr)->fileID;
-	      break;
-	   case HDFmpiSyncID:
-	      CallStack->record.hdfID 
-		 = ((struct mpiSyncBeginArgs *)dataPtr)->fileID;
-	      break;
-	   default:
-	      break;
-	}
+   HDFsetInfo *dataPtr;
+   dataPtr = (HDFsetInfo *)data;
+   /*==============================================================*
+   // save the time value temporarily in top of stack		*
+   // When the end record is received, the duration can be 	*
+   // computed.							*
+   //==============================================================*/
+   CallStack->lastIOtime = seconds;
+   /*==============================================================*
+   // get useful info from the structure pointed to by dataPtr.	*
+      cases, this is the file ID.  For mpiOpen, it is the	*
+   // name of the file.  For mpiDelete, no information is of any	*
+   // use.								*
+   //==============================================================*/
+   if ( dataLen == 0 ) return;
+   CallStack->record.hdfID = dataPtr->setID; 
+   switch ( eventType ) 
+   {
+      case HDFmpiOpenID:
+      {
+         strcpy( openName, dataPtr->setName );
+         break;
+      }
+      case HDFmpiReadAtID:
+      {
+         CallStack->record.bytes[MPIOreadBytesReq] += dataPtr->numBytes;
+         break;
+      }
+      case HDFmpiReadAtAllID:
+      {
+         CallStack->record.bytes[MPIOreadAllBytesReq] += dataPtr->numBytes;
+         break;
+      }
+      case HDFmpiWriteAtID:
+      {
+         CallStack->record.bytes[MPIOwriteBytesReq] += dataPtr->numBytes;
+         break;
+      }
+      case HDFmpiWriteAtAllID:
+      {
+         CallStack->record.bytes[MPIOwriteAllBytesReq] += dataPtr->numBytes;
+         break;
+      }
+      case HDFmpiIreadAtID:
+      {
+         CallStack->record.bytes[MPIOiReadBytesReq] += dataPtr->numBytes;
+         break;
+      }
+      case HDFmpiIwriteAtID:
+      {
+         CallStack->record.bytes[MPIOiWriteBytesReq] += dataPtr->numBytes;
+         break;
+      }
+      case HDFmpiReadID:
+      {
+         CallStack->record.bytes[MPIOreadBytesReq] += dataPtr->numBytes;
+         break;
+      }
+      case HDFmpiReadAllID:
+      {
+         CallStack->record.bytes[MPIOreadAllBytesReq] += dataPtr->numBytes;
+         break;
+      }
+      case HDFmpiWriteID:
+      {
+         CallStack->record.bytes[MPIOwriteBytesReq] += dataPtr->numBytes;
+         break;
+      }
+      case HDFmpiWriteAllID:
+      {
+         CallStack->record.bytes[MPIOwriteAllBytesReq] += dataPtr->numBytes;
+         break;
+      }
+      case HDFmpiIreadID:
+      {
+         CallStack->record.bytes[MPIOiReadBytesReq] += dataPtr->numBytes;
+         break;
+      }
+      case HDFmpiIwriteID:
+      {
+         CallStack->record.bytes[MPIOiWriteBytesReq] += dataPtr->numBytes;
+         break;
+      }
+      default:
+      {
+         break;
+      }
+   }
 }
 /*======================================================================*
 // EndMPIOEventRecord:							*
@@ -654,27 +635,136 @@ void BeginMPIOEventRecord( int eventType,
 //======================================================================*/ 
 void EndMPIOEventRecord ( int eventType, 
 	                  CLOCK secs, 
-	                  void *dataPtr,
+	                  void *data,
 	                  int dataLen )
 {
-	CLOCK incDur;
+   CLOCK incDur;
 
-	incDur = clockSubtract(secs,CallStack->lastIOtime) ;
-        CallStack->record.times[MPI] 
-           = clockAdd ( CallStack->record.times[MPI], incDur );
-        ++CallStack->record.counts[MPI];
-	if ( eventType == -HDFmpiOpenID && dataLen != 0 ) {
-	   /*===========================================================*
-	   // complete the file information for the case of a file 	*
-	   // open and record the information.				*
-	   //===========================================================*/
-	   openInfo.setName = openName;
-	   openInfo.setID = ((struct mpiOpenEndArgs *)dataPtr)->fileID;
-	   CallStack->record.hdfID = openInfo.setID;
-	   HDFrecordFileName ( &openInfo );
-	}
+   HDFsetInfo* dataPtr;
+   incDur = clockSubtract(secs,CallStack->lastIOtime) ;
+   CallStack->record.times[MPI] 
+          = clockAdd ( CallStack->record.times[MPI], incDur );
+   ++CallStack->record.counts[MPI];
+   if ( dataLen == 0 ) 
+   {
+      return;
+   }
+   dataPtr = (HDFsetInfo *)data;
+   switch ( eventType ) 
+   {
+      case -HDFmpiOpenID:
+      {
+         /*===========================================================*
+         // open and record the information.			      *
+         //===========================================================*/
+	 openInfo.setName = openName;
+	 openInfo.setID = dataPtr->setID;
+	 CallStack->record.hdfID = openInfo.setID;
+	 HDFrecordFileName ( &openInfo );
+         break;
+      }
+      case -HDFmpiReadAtID:
+      {
+         ++CallStack->record.counts[MPIOread] ;
+         CallStack->record.times[MPIOread] 
+          = clockAdd ( CallStack->record.times[MPIOread], incDur );
+         CallStack->record.bytes[MPIOreadBytesTrans] += dataPtr->numBytes; 
+         break;
+      }
+      case -HDFmpiReadAtAllID:
+      {
+         ++CallStack->record.counts[MPIOreadAll] ;
+         CallStack->record.times[MPIOreadAll] 
+          = clockAdd ( CallStack->record.times[MPIOreadAll], incDur );
+         CallStack->record.bytes[MPIOreadAllBytesTrans] += dataPtr->numBytes;
+         break;
+      }
+      case -HDFmpiWriteAtID:
+      {
+         ++CallStack->record.counts[MPIOwrite] ;
+         CallStack->record.times[MPIOwrite] 
+          = clockAdd ( CallStack->record.times[MPIOwrite], incDur );
+         CallStack->record.bytes[MPIOwriteBytesTrans] += dataPtr->numBytes;
+         break;
+      }
+      case -HDFmpiWriteAtAllID:
+      {
+         ++CallStack->record.counts[MPIOwriteAll] ;
+         CallStack->record.times[MPIOwriteAll] 
+          = clockAdd ( CallStack->record.times[MPIOwriteAll], incDur );
+         CallStack->record.bytes[MPIOwriteAllBytesTrans] += dataPtr->numBytes;
+         break;
+      }
+      case -HDFmpiIreadAtID:
+      {
+         ++CallStack->record.counts[MPIOiRead] ;
+         CallStack->record.times[MPIOiRead] 
+             = clockAdd ( CallStack->record.times[MPIOiRead], incDur );
+         break;
+      }
+      case -HDFmpiIwriteAtID:
+      {
+         ++CallStack->record.counts[MPIOiWrite] ;
+         CallStack->record.times[MPIOiWrite] 
+             = clockAdd ( CallStack->record.times[MPIOiWrite], incDur );
+         break;
+      }
+      case -HDFmpiReadID:
+      {
+         ++CallStack->record.counts[MPIOread] ;
+         CallStack->record.times[MPIOread] 
+          = clockAdd ( CallStack->record.times[MPIOread], incDur );
+         CallStack->record.bytes[MPIOreadBytesTrans] += dataPtr->numBytes;
+         break;
+      }
+      case -HDFmpiReadAllID:
+      {
+         ++CallStack->record.counts[MPIOreadAll] ;
+         CallStack->record.times[MPIOreadAll] 
+          = clockAdd ( CallStack->record.times[MPIOreadAll], incDur );
+         CallStack->record.bytes[MPIOreadAllBytesTrans] += dataPtr->numBytes;
+         break;
+      }
+      case -HDFmpiWriteID:
+      {
+         ++CallStack->record.counts[MPIOwrite] ;
+         CallStack->record.times[MPIOwrite] 
+          = clockAdd ( CallStack->record.times[MPIOwrite], incDur );
+         CallStack->record.bytes[MPIOwriteBytesTrans] += dataPtr->numBytes;
+         break;
+      }
+      case -HDFmpiWriteAllID:
+      {
+         ++CallStack->record.counts[MPIOwriteAll] ;
+         CallStack->record.times[MPIOwriteAll] 
+          = clockAdd ( CallStack->record.times[MPIOwriteAll], incDur );
+         CallStack->record.bytes[MPIOwriteAllBytesTrans] += dataPtr->numBytes;
+         break;
+      }
+      case -HDFmpiIreadID:
+      {
+         ++CallStack->record.counts[MPIOiRead] ;
+         CallStack->record.times[MPIOiRead] 
+          = clockAdd ( CallStack->record.times[MPIOiRead], incDur );
+         break;
+      }
+      case -HDFmpiIwriteID:
+      {
+         ++CallStack->record.counts[MPIOiWrite] ;
+         CallStack->record.times[MPIOiWrite] 
+          = clockAdd ( CallStack->record.times[MPIOiWrite], incDur );
+         break;
+      }
+      default:
+      {
+         ++CallStack->record.counts[MPIOother] ;
+         CallStack->record.times[MPIOother] 
+          = clockAdd ( CallStack->record.times[MPIOiWrite], incDur );
+         break;
+      }
+   }
 }
-#endif /* HAVE_PARALLEL */
+#endif /* H5_HAVE_PARALLEL */
 /*======================================================================*
 //   BeginHDFEventRecord:						* 
 // 	This function puts a trace record on the stack corresponding to	*
@@ -1015,8 +1105,8 @@ void HDFSummarySDDF( HDFnode_t *P, int procIndex )
 	                 + nTallyFields*sizeof(int) 	 /* count array */
 	                 + sizeof(int)			 /* array len   */
 	                 + nByteFields*sizeof(int) 	 /* bytes array */
-	                 + nByteFields*sizeof(int)	 /* array lens  */
-	                 + nByteFields*nBkts*sizeof(int) /* byte hist   */
+	                 + nHistFields*sizeof(int)     	 /* array lens  */
+	                 + nHistFields*nBkts*sizeof(int) /* byte hist   */
 	                 + sizeof(int)                   /* nodeID      */
 	                 + sizeof(int) ;                 /* Name len    */
 	Header.packetTag = HDF_SUMMARY_FAMILY +
@@ -1137,7 +1227,7 @@ void HDFrecordSum ( HDFrec_t *S, HDFrec_t *T )
         for ( j = 0; j < nByteFields; ++j ) {
            S->bytes[j] += T->bytes[j] ;
         }
-        for ( j = 0; j < nByteFields; ++j ) {
+        for ( j = 0; j < nHistFields; ++j ) {
            for ( i = 0; i < nBkts; ++i ) {
               S->Hists[j][i] += T->Hists[j][i] ;
            }
@@ -1149,105 +1239,137 @@ void HDFrecordSum ( HDFrec_t *S, HDFrec_t *T )
 //======================================================================*/
 int getHDFFieldIndex( int eventID )
 {
-	int result = -1;
-	switch ( eventID )
-	{
-	        case ID_malloc:
-	        case -ID_malloc:
-			result = Malloc;
-			break;
-		case openBeginID:
-		case openEndID:
-		case fopenBeginID:
-		case fopenEndID:
-			result = Open;
-			break;
-		case closeBeginID:
-		case closeEndID:
-		case fcloseBeginID:
-		case fcloseEndID:
-			result = Close;
-			break;
-		case readBeginID:
-		case readEndID:
-		case freadBeginID:
-		case freadEndID:
-			result = Read;
-			break;
-		case lseekBeginID:
-		case lseekEndID:
-		case fseekBeginID:
-		case fseekEndID:
-			result = Seek;
-			break;
-		case writeBeginID:
-		case writeEndID:
-		case fwriteBeginID:
-		case fwriteEndID:
-			result = Write;
-			break;
-		case fflushBeginID:
-		case fflushEndID:
-		case flushBeginID:
-		case flushEndID:
-			result = Misc;
-			break;
-		case rewindBeginID:
-		case rewindEndID:
-		case fsetposBeginID:
-		case fsetposEndID:
-			result = Misc;
-			break;
+   int result = -1;
+   switch ( eventID )
+   {
+      case ID_malloc:
+      case -ID_malloc:
+      {
+         result = Malloc;
+         break;
+      }
+      case openBeginID:
+      case openEndID:
+      case fopenBeginID:
+      case fopenEndID:
+      {
+         result = Open;
+         break;
+      }
+      case closeBeginID:
+      case closeEndID:
+      case fcloseBeginID:
+      case fcloseEndID:
+      {
+         result = Close;
+         break;
+      }
+      case readBeginID:
+      case readEndID:
+      case freadBeginID:
+      case freadEndID:
+      {
+         result = Read;
+         break;
+      }
+      case lseekBeginID:
+      case lseekEndID:
+      case fseekBeginID:
+      case fseekEndID:
+      {
+         result = Seek;
+         break;
+      }
+      case writeBeginID:
+      case writeEndID:
+      case fwriteBeginID:
+      case fwriteEndID:
+      {
+         result = Write;
+         break;
+      }
+      case fflushBeginID:
+      case fflushEndID:
+      case flushBeginID:
+      case flushEndID:
+      {
+         result = Misc;
+         break;
+      }
+      case rewindBeginID:
+      case rewindEndID:
+      case fsetposBeginID:
+      case fsetposEndID:
+      {
+         result = Misc;
+         break;
+      }
 #ifdef	creadBeginID
-		case creadBeginID:
-		case creadEndID:
-		case creadvBeginID:
-		case creadvEndID:
-			result = Read;
- 			break;
-		case cwriteBeginID:
-		case cwriteEndID:
-		case cwritevBeginID:
-		case cwritevEndID:
-			result = Write;
- 			break;
-		case ireadBeginID:
-		case ireadEndID:
-		case ireadvBeginID:
-		case ireadvEndID:
-			result = ARead;
- 			break;
-		case iwriteBeginID:
-		case iwriteEndID:
-		case iwritevBeginID:
-		case iwritevEndID:
-			result = AWrite;
- 			break;
-		case iowaitBeginID:
-		case iowaitEndID:
-			result = Wait;
- 			break;
-		case iodoneBeginID:
-		case iodoneEndID:
-			result = Misc;
- 			break;
-		case gopenBeginID:
-		case gopenEndID:
-			result = Open;
- 			break;
-		case iomodeBeginID:
-		case iomodeEndID:
-		case setiomodeBeginID:
-		case setiomodeEndID:
-		case lsizeBeginID:
-		case lsizeEndID:
-		case forflushBeginID:
-		case forflushEndID:
-			result = Misc;
- 			break;
+      case creadBeginID:
+      case creadEndID:
+      case creadvBeginID:
+      case creadvEndID:
+      {
+         result = Read;
+         break;
+      }
+      case cwriteBeginID:
+      case cwriteEndID:
+      case cwritevBeginID:
+      case cwritevEndID:
+      {
+         result = Write;
+         break;
+      }
+      case ireadBeginID:
+      case ireadEndID:
+      case ireadvBeginID:
+      case ireadvEndID:
+      {
+         result = Aread;
+         break;
+      }
+      case iwriteBeginID:
+      case iwriteEndID:
+      case iwritevBeginID:
+      case iwritevEndID:
+      {
+         result = Awrite;
+         break;
+      }
+      case iowaitBeginID:
+      case iowaitEndID:
+      {
+         result = Wait;
+         break;
+      }
+      case iodoneBeginID:
+      case iodoneEndID:
+      {
+         result = Misc;
+         break;
+      }
+      case gopenBeginID:
+      case gopenEndID:
+      {
+         result = Open;
+         break;
+      }
+      case iomodeBeginID:
+      case iomodeEndID:
+      case setiomodeBeginID:
+      case setiomodeEndID:
+      case lsizeBeginID:
+      case lsizeEndID:
+      case forflushBeginID:
+      case forflushEndID:
+      {
+         result = Misc;
+         break;
+      }
 #endif	
-	}
-	return result;
+   }
+   return result;
 }
 /*======================================================================*
 // This routine determines the field index in the bytes array of the 	*
@@ -1257,29 +1379,91 @@ int getHDFFieldIndex( int eventID )
 //======================================================================*/
 int getHDFByteFieldIndex( int Operation ) 
 {
-	int result;
-	switch ( Operation )
-	{
-		case Malloc:
-	 		result = MallocBytes;
-			break;
-		case Read:
-	 		result = ReadBytes;
-			break;
-		case Write:
-	 		result = WriteBytes;
-			break;
-		case ARead:
-	 		result = AReadBytes;
-			break;
-		case AWrite:
-	 		result = AWriteBytes;
-			break;
-		default:
-			result = -1;
-			break;
-	}
-	return result;
+   int result;
+   switch ( Operation )
+   {
+      case Malloc:
+      {
+         result = MallocBytes;
+         break;
+      }
+      case Read:
+      {
+         result = ReadBytes;
+         break;
+      }
+      case Write:
+      {
+         result = WriteBytes;
+         break;
+      }
+      case Aread:
+      {
+         result = AreadBytes;
+         break;
+      }
+      case Awrite:
+      {
+         result = AwriteBytes;
+         break;
+      }
+      case MPIOread:
+      {
+         result = MPIOreadBytesReq;
+         break;
+      }
+      case MPIOwrite:
+      {
+         result = MPIOwriteBytesReq;
+         break;
+      }
+      case MPIOreadAll:
+      {
+         result = MPIOreadAllBytesReq;
+         break;
+      }
+      case MPIOwriteAll:
+      {
+         result = MPIOwriteAllBytesReq;
+         break;
+      }
+      case MPIOiRead:
+      {
+         result = MPIOiReadBytesReq;
+         break;
+      }
+      case MPIOiWrite:
+      {
+         result = MPIOiWriteBytesReq;
+         break;
+      }
+      case MPIOreadTrans:
+      {
+         result = MPIOreadBytesTrans;
+         break;
+      }
+      case MPIOwriteTrans:
+      {
+         result = MPIOwriteBytesTrans;
+         break;
+      }
+      case MPIOreadAllTrans:
+      {
+         result = MPIOreadAllBytesTrans;
+         break;
+      }
+      case MPIOwriteAllTrans:
+      {
+         result = MPIOwriteAllBytesTrans;
+         break;
+      }
+      default:
+      {
+         result = -1;
+         break;
+      }
+   }
+   return result;
 }
 /*======================================================================*
 // This routine writes the SDDF packet descriptors for the HDF summary	*
@@ -1365,12 +1549,12 @@ void _hdfDescriptorRT( char *recordName, char *recordDescription,
                      "Write Histogram",
 	             "Historgram of size Write Requests",
 		     INTEGER, 1 );
-    WRITE_HDF_FIELD( "ARead Histogram",
-                     "ARead Histogram",
+    WRITE_HDF_FIELD( "Aread Histogram",
+                     "Aread Histogram",
 	             "Historgram of size Asynch Read Requests",
 		     INTEGER, 1 );
-    WRITE_HDF_FIELD( "AWrite Histogram",
-                     "AWrite Histogram",
+    WRITE_HDF_FIELD( "Awrite Histogram",
+                     "Awrite Histogram",
 	             "Historgram of size Asynch Write Requests",
 		     INTEGER, 1 );
     WRITE_HDF_FIELD( "Processor Number", 
diff --git a/pablo/PabloHDF_SDDF.c b/pablo/PabloHDF_SDDF.c
index 859047d..bf42112 100644
--- a/pablo/PabloHDF_SDDF.c
+++ b/pablo/PabloHDF_SDDF.c
@@ -57,14 +57,14 @@
 //======================================================================*/
 #include <stdio.h>
 
-#ifdef HAVE_PARALLEL
+#ifdef H5_HAVE_PARALLEL
 #include "mpi.h"
 #endif
 
 #include "H5config.h"
-#undef HAVE_PABLO
+#undef H5_HAVE_PABLO
 #include "H5private.h" 
-#define HAVE_PABLO
+#define H5_HAVE_PABLO
 #include "ProcIDs.h"
 
 #include "SystemDepend.h"
@@ -105,7 +105,7 @@ void endIOTrace( void );
 
 #define returnRecord(x)    return x;
 
-#ifdef HAVE_MPIOTRACE
+#ifdef H5_HAVE_MPIOTRACE
 	int initMPIOTrace( char *, int );
 	void endMPIOTrace( void ) ;
 #else
@@ -233,7 +233,7 @@ void HDFinitTrace_SDDF( char *traceFileName, int OUTSW )
         // set traceFileName and set IO tracing switches.  If MPIO 	*
 	// tracing is available, MPIO tracing will also be initialized. *
 	//==============================================================*/
-#ifdef HAVE_PARALLEL
+#ifdef H5_HAVE_PARALLEL
 	/*===============================================================
 	// The code is built to handle parallel processing using MPI.	*	
 	// However, the code may or may not be run using MPI and there  *
@@ -254,13 +254,13 @@ void HDFinitTrace_SDDF( char *traceFileName, int OUTSW )
 	   //===========================================================*/
            MPI_Comm_rank( MPI_COMM_WORLD, &myNode );
 	   setTraceProcessorNumber( myNode );
-#ifdef HAVE_MPIOTRACE
+#ifdef H5_HAVE_MPIOTRACE
 	   /*============================================================
 	   // MPIO Tracing is supported in the Pablo Library.  Let the  *
 	   // MPIO initialization be performed and handle the naming of *
 	   // trace files.						*
 	   //===========================================================*/
-           initMPIOTrace( traceFileName, RUNTIME_TRACE ); 
+           initMPIOTrace( traceFileName, SUPPRESS_MPIO_TRACE ); 
 #else 
 	   /*============================================================
 	   // MPIO tracing is not supported.				*
@@ -296,7 +296,7 @@ void HDFinitTrace_SDDF( char *traceFileName, int OUTSW )
     	disableLifetimeSummaries();
         disableTimeWindowSummaries();
 	disableFileRegionSummaries();
-#endif /* HAVE_PARALLEL */
+#endif /* H5_HAVE_PARALLEL */
 	/*===============================================================
 	// complete HDF initiailization.				*
 	//==============================================================*/
@@ -826,4 +826,4 @@ void _hdfMiscDescriptor( void )
     putBytes( recordBuffer, (unsigned) recordLength );
 }
 
-/*#endif */ /* HAVE_PABLO */ 
+/*#endif */ /* H5_HAVE_PABLO */ 
diff --git a/pablo/ProcTrace.h b/pablo/ProcTrace.h
index 405f0e6..ef8c16b 100644
--- a/pablo/ProcTrace.h
+++ b/pablo/ProcTrace.h
@@ -97,6 +97,7 @@ NO_TRACE,
 NUM_HDF_IDS
 } ;
 
+#define SUPPRESS_MPIO_TRACE 2
 #define ID_HDF_Last_Entry ID_ALLHDF
 
 void HDFinitTrace( const char *, int trace_id, ... );