[svn-r4110]

Purpose:
    feature
Description:
    allows the option of building the library libhdf-inst.a so that it can
    link with either the Pablo Trace Libraries or with the Pablo Performance
    Capture Facility (PCF)
Solution:
    Added code for conditional compilation using the PCF_BUILD flag. When the
    library is made, the user can specify PABLO_BUILD=PCF which will cause the
    -DPCF_BUILD to be passed to the compiler.
Platforms tested:
    Solaris, IRIX64

1 files changed, 241 insertions, 1223 deletions

diff --git a/pablo/PabloHDF.c b/pablo/PabloHDF.c
index d78cf07..aa11d85 100644
--- a/pablo/PabloHDF.c
+++ b/pablo/PabloHDF.c
@@ -112,6 +112,10 @@ int HDFtrace3OPEN( const char *, int, mode_t );
 typedef unsigned int mode_t;
 #endif
 
+#ifdef H5_HAVE_PARALLEL
+#define HAVE_MPIO
+#endif
+
 int OUTPUT_SWITCH = 1;
 int *procTrace;
 extern void preInitIOTrace( void ); 
@@ -126,11 +130,27 @@ extern void preInitIOTrace( void );
 #define	ID_timeStamp		9999
 #define	DUMMY_HDF		10000
 
-#ifdef H5_HAVE_PARALLEL
-#include "mpi.h"
-int HDF_get_Bytes( MPI_Datatype datatype, int count );
-#endif /* H5_HAVE_PARALLEL*/
+extern char HDFprocNames[][40] = {
+"noName",
+"noName",
+"noName",
+"noName",
+"noName",
+#include "HDFentryNames.h"
+"HDF_LAST_ENTRY"
+};
+
+void startHDFtraceEvent (int );
+void endHDFtraceEvent (int , int , char *, int );
+
+#ifdef TRACELIB_BUILD
+#undef PCF_BUILD
+#endif 
 
+#ifdef PCF_BUILD
+void hdfCaptureInit( const char* name, int captureType );
+void hdfCaptureEnd( void );
+#else
 void HDFinitTrace_RT ( const char *, int );
 void HDFinitTrace_SDDF ( const char *, int );
 void hinittracex_ ( char [], int *, int[], int *,unsigned * );
@@ -138,17 +158,13 @@ void hdfendtrace_ ( void ) ;
 void HDFendTrace_RT (int);
 void HDFendTrace_SDDF(int);
 void HDFfinalTimeStamp( void );
-void startHDFtraceEvent (int );
-int computeProcMask (int eventID);
-int computePacketTag(int eventID);
-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;
+#endif
+
 /*======================================================================*
 // NAME									*
 //     HDFinitTrace -- initialize HDF tracing				*
@@ -164,6 +180,7 @@ double ReadTotals = 0.0;
 // RETURNS								*
 //     None.								*
 //======================================================================*/
+#ifndef PCF_BUILD 
 /*======================================================================*
 // fortran to C interface.                                              *
 // This is called from hdfinittracef_                                   *
@@ -249,9 +266,12 @@ hinittracex_( char *file,
       exit (-1);
    }
 }
-void HDFinitTrace( const char *traceFileName, int id_flag, ... )
+#endif /* PCF_BUILD */
+void
+HDFinitTrace( const char *traceFileName, int id_flag, ... )
 {
-   int i, nIDs;
+   int i; 
+   int nIDs;
    va_list ap;
 
    /*===================================================================*
@@ -280,7 +300,7 @@ void HDFinitTrace( const char *traceFileName, int id_flag, ... )
    //===================================================================*/
    nIDs = 0;
    va_start( ap, id_flag );
-   while ( id_flag > NO_TRACE ) 
+   while ( id_flag > LAST_TRACE_TYPE ) 
    {
       procTrace[id_flag] = 1;
       ++nIDs;
@@ -298,6 +318,9 @@ void HDFinitTrace( const char *traceFileName, int id_flag, ... )
          procTrace[i] = 1;      
       }
    }
+#ifdef PCF_BUILD
+   hdfCaptureInit( traceFileName, OUTPUT_SWITCH );
+#else
    suppressMPIOtrace = TRUE;
    if ( OUTPUT_SWITCH == RUNTIME_TRACE 
                         || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) 
@@ -324,6 +347,7 @@ void HDFinitTrace( const char *traceFileName, int id_flag, ... )
        fprintf(stderr," Exiting Program.     <<\n");
        exit (-1);
    }
+#endif /* PCF_BUILD */
 }
 /*======================================================================*
 // NAME									*
@@ -339,6 +363,9 @@ void hdfendtrace_( void )
 }
 void HDFendTrace(void)
 {
+#ifdef PCF_BUILD
+   hdfCaptureEnd();
+#else
    if ( OUTPUT_SWITCH == RUNTIME_TRACE 
 	                     || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) 
    {
@@ -349,9 +376,13 @@ void HDFendTrace(void)
    {
       HDFendTrace_RT( OUTPUT_SWITCH );
    }
+#endif /* PCF_BUILD */
 }
 void startHDFtraceEvent(int eventID)
 {
+#ifdef PCF_BUILD
+   traceHDFentryEvent( eventID ) ;
+#else
    if ( OUTPUT_SWITCH == RUNTIME_TRACE 
 	                     || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) 
    {
@@ -361,9 +392,13 @@ void startHDFtraceEvent(int eventID)
    {
       HDFtraceEvent_RT( eventID, NULL, 0 ) ;
    } 
+#endif /* PCF_BUILD */
 }
 void endHDFtraceEvent(int eventID, int setID, char *setName, int IDtype )
 {
+#ifdef PCF_BUILD
+   traceHDFexitEvent( eventID );
+#else
    HDFsetInfo info;
    info.setID = setID;
    info.setName = setName;
@@ -383,7 +418,43 @@ void endHDFtraceEvent(int eventID, int setID, char *setName, int IDtype )
       fprintf(stderr,"invalid OUTPUT_SWITCH %d, IDtype = %d\n",
                                                   OUTPUT_SWITCH, IDtype ) ;
    }
+#endif /* PCF_BUILD */
+}
+#ifdef PCF_BUILD
+void
+hdfCaptureInit( const char* name, int captureType )
+{
+   int procNum;
+   HDF_get_NodeNum( &procNum );
+   basePerformanceInit( name, procNum );
+   genericBaseInit( captureType, procNum );
+   unixIObaseInit( captureType, procNum );
+#ifdef HAVE_MPIO
+   mpiIObaseInit( captureType, procNum );
+#endif
+   hdfBaseInit( captureType,
+                procNum,
+                ID_HDF_Last_Entry,
+                HDFprocNames );
 }
+void
+hdfCaptureEnd( void )
+{
+   int i;
+   timeStamp();
+   for ( i = 0; i < NUM_HDF_IDS; ++i )
+   {
+      procTrace[i] = 0;
+   }
+   hdfBaseEnd();
+#ifdef HAVE_MPIO
+   mpiIObaseEnd();
+#endif
+   unixIObaseEnd();
+   genericBaseEnd();
+   basePerformanceEnd();
+}
+#endif /* PCF_BUILD */
 /*****************************************************************************/
 /* The HDFtraceXXXX routines are substitutes for the standard I/O routines.  */
 /* When libhdf5-inst.a is compiled, macros in HDFTrace.h substitute the name */
@@ -401,9 +472,13 @@ void endHDFtraceEvent(int eventID, int setID, char *setName, int IDtype )
 /*+			Mode = -1                                           +*/
 /*+									    +*/
 /*****************************************************************************/
-FILE*HDFtraceFOPEN( const char *filename, const char *type )
+FILE*
+HDFtraceFOPEN( const char *filename, const char *type )
 {
    FILE *fp;
+#ifdef PCF_BUILD
+   fp = (FILE *)traceFOPEN( filename, type );
+#else
    int fd, id;
    int flags = 0;
    struct open_args openArgs;
@@ -471,7 +546,7 @@ FILE*HDFtraceFOPEN( const char *filename, const char *type )
    {
      HDFtraceIOEvent( fopenEndID, (void *) &id, int_SIZE );   
    }
-
+#endif /* PCF_BUILD */
    return( fp );
 }
 
@@ -485,8 +560,11 @@ FILE*HDFtraceFOPEN( const char *filename, const char *type )
 int 
 HDFtraceCREAT( const char *path, mode_t mode )
 {
-    struct open_args openArgs;
     int fd;
+#ifdef PCF_BUILD
+    fd = traceCREAT( path, mode );
+#else
+    struct open_args openArgs;
     int id;
 
     if ( IOtracingEnabled ) {
@@ -503,7 +581,7 @@ HDFtraceCREAT( const char *path, mode_t mode )
     if ( IOtracingEnabled ) {
         HDFtraceIOEvent( openEndID, (void *) &id, int_SIZE );
     }
-
+#endif /* PCF_BUILD */
     return( fd );
 }
 
@@ -517,9 +595,13 @@ HDFtraceCREAT( const char *path, mode_t mode )
 /*+	          record Flush (fflushBeginID)                              +*/
 /*+		   							    +*/
 /*****************************************************************************/
-int HDFtraceFFLUSH( FILE *stream )
+int 
+HDFtraceFFLUSH( FILE *stream )
 {
    int ret;
+#ifdef PCF_BUILD
+    ret = traceFFLUSH( stream );
+#else
    int id;
    int fd;
 
@@ -555,7 +637,7 @@ int HDFtraceFFLUSH( FILE *stream )
     * is moved to EOF if it isn't there already.  We don't account for that
     * in our file positioning information.
     */
-
+#endif /* PCF_BUILD */
    return( ret );
 }
 
@@ -573,6 +655,9 @@ int
 HDFtraceFCLOSE( FILE *stream )
 {
    int ret;
+#ifdef PCF_BUILD
+    ret = traceFCLOSE( stream );
+#else
    int id;
    int fd = fileno( stream );
 
@@ -588,6 +673,7 @@ HDFtraceFCLOSE( FILE *stream )
    {
       HDFtraceIOEvent( fcloseEndID, (void *) 0, 0 );
    }
+#endif /* PCF_BUILD */
 
    return( ret );
 }
@@ -602,8 +688,11 @@ HDFtraceFCLOSE( FILE *stream )
 int 
 HDFtrace3OPEN( const char *path, int flags, mode_t mode )
 {
-   struct open_args openArgs;
    int fd;
+#ifdef PCF_BUILD
+   fd = trace3OPEN( path, flags, mode );
+#else
+   struct open_args openArgs;
    int id;
 
    if ( IOtracingEnabled ) 
@@ -622,6 +711,7 @@ HDFtrace3OPEN( const char *path, int flags, mode_t mode )
    {
       HDFtraceIOEvent( openEndID, (char *) &id, int_SIZE );
    }
+#endif /* PCF_BUILD */
 
    return( fd );
 }
@@ -637,6 +727,9 @@ int
 HDFtraceCLOSE( int fd )
 {
    int ret;
+#ifdef PCF_BUILD
+   ret = traceCLOSE( fd );
+#else
    int id;
 
    if ( IOtracingEnabled ) 
@@ -651,6 +744,7 @@ HDFtraceCLOSE( int fd )
    {
       HDFtraceIOEvent( closeEndID, (void *) 0, 0 );
    }
+#endif /* PCF_BUILD */
 
    return( ret );
 }
@@ -670,8 +764,11 @@ HDFtraceCLOSE( int fd )
 ssize_t 
 HDFtraceREAD( int fd, void *buf, size_t nbyte )
 {
-   struct read_write_args readArgs;  
    ssize_t ret;
+#ifdef PCF_BUILD
+    ret = traceREAD( fd, buf, nbyte );
+#else
+   struct read_write_args readArgs;  
    int bytes;
    CLOCK t1, t2, incDur;
 
@@ -688,7 +785,6 @@ HDFtraceREAD( int fd, void *buf, size_t nbyte )
    ret = read( fd, buf, nbyte );
    t2 = getClock();
    incDur = clockSubtract(t2,t1);
-   ReadTotals += clockToSeconds( incDur );
 
    if ( IOtracingEnabled ) 
    {
@@ -702,6 +798,7 @@ HDFtraceREAD( int fd, void *buf, size_t nbyte )
       } 
       HDFtraceIOEvent( readEndID, (void *) &bytes, int_SIZE );
    }
+#endif /* PCF_BUILD */
 
    return( ret );
 }
@@ -719,8 +816,11 @@ HDFtraceREAD( int fd, void *buf, size_t nbyte )
 size_t 
 HDFtraceFREAD( void *ptr, size_t size, size_t nitems, FILE *stream )
 {
-   struct read_write_args readArgs;  
    size_t ret;
+#ifdef PCF_BUILD
+   ret = traceFREAD( ptr, size, nitems, stream );
+#else
+   struct read_write_args readArgs;  
    int nbytes;
    int fd = fileno( stream );
    CLOCK t1, t2, incDur;
@@ -737,7 +837,6 @@ HDFtraceFREAD( void *ptr, size_t size, size_t nitems, FILE *stream )
    ret = fread( ptr, size, nitems, stream );
    t2 = getClock();
    incDur = clockSubtract(t2,t1);
-   ReadTotals += clockToSeconds( incDur );
 
    if ( IOtracingEnabled ) 
    {
@@ -751,11 +850,10 @@ HDFtraceFREAD( void *ptr, size_t size, size_t nitems, FILE *stream )
       }
       HDFtraceIOEvent( freadEndID, (void *) &nbytes, int_SIZE );
    }
+#endif /* PCF_BUILD */
 
    return( ret );
 }
-
-       
 /*****************************************************************************/
 /*+	Seek routines            			                    +*/
 /*+     -------------			            	                    +*/
@@ -769,8 +867,11 @@ HDFtraceFREAD( void *ptr, size_t size, size_t nitems, FILE *stream )
 off_t 
 HDFtraceLSEEK( int fd, off_t offset, int whence )
 {
-   struct seek_args seekArgs;
    off_t ret;
+#ifdef PCF_BUILD
+   ret = traceLSEEK( fd, offset, whence );
+#else
+   struct seek_args seekArgs;
    long  arg;
 
    if ( IOtracingEnabled ) 
@@ -789,6 +890,7 @@ HDFtraceLSEEK( int fd, off_t offset, int whence )
       arg = (long) ret;
       HDFtraceIOEvent( lseekEndID, (void *)&arg, long_SIZE );
    }
+#endif /* PCF_BUILD */
 
    return( ret );
 }
@@ -803,8 +905,11 @@ HDFtraceLSEEK( int fd, off_t offset, int whence )
 int 
 HDFtraceFSEEK( FILE *stream, long offset, int whence )
 {
-   struct seek_args seekArgs;
    int ret;
+#ifdef PCF_BUILD
+   ret = traceFSEEK( stream, offset, whence );
+#else
+   struct seek_args seekArgs;
    long arg;
    int fd = fileno( stream );
 
@@ -824,6 +929,7 @@ HDFtraceFSEEK( FILE *stream, long offset, int whence )
       arg = ftell( stream );
       HDFtraceIOEvent( fseekEndID, (void *)&arg, long_SIZE );
    }
+#endif /* PCF_BUILD */
 
    return( ret );
 }
@@ -839,8 +945,11 @@ HDFtraceFSEEK( FILE *stream, long offset, int whence )
 int 
 HDFtraceFSETPOS( FILE stream, const fpos_t *position )
 {
-   struct seek_args seekArgs;
    int ret;
+#ifdef PCF_BUILD
+   ret = traceFSETPOS( stream, position );
+#else
+   struct seek_args seekArgs;
    long arg;
    int fd = fileno( stream );
 
@@ -860,6 +969,7 @@ HDFtraceFSETPOS( FILE stream, const fpos_t *position )
       arg = (long) *position;
       HDFtraceIOEvent( fsetposEndID, (void *)&arg, long_SIZE );
    }
+#endif /* PCF_BUILD */
 
    return( ret );
 }
@@ -874,10 +984,14 @@ HDFtraceFSETPOS( FILE stream, const fpos_t *position )
 /*+			 Whence = SEEK_SET                                  +*/
 /*+									    +*/
 /*****************************************************************************/
-void HDFtraceREWIND( FILE *stream )
+void 
+HDFtraceREWIND( FILE *stream )
 {
-   struct seek_args seekArgs;
+#ifdef PCF_BUILD
+    traceREWIND( stream );
+#else
    long arg;
+   struct seek_args seekArgs;
    int fd = fileno( stream );
 
    if ( IOtracingEnabled ) 
@@ -896,6 +1010,7 @@ void HDFtraceREWIND( FILE *stream )
       arg = 0;
       HDFtraceIOEvent( rewindEndID, (void *)&arg, long_SIZE );
    }
+#endif /* PCF_BUILD */
 
    return;
 }
@@ -912,10 +1027,14 @@ void HDFtraceREWIND( FILE *stream )
 /*+			 Cause = -1                                         +*/
 /*+									    +*/
 /*****************************************************************************/
-ssize_t HDFtraceWRITE( int fd, const void *buf, size_t nbyte )
+ssize_t 
+HDFtraceWRITE( int fd, const void *buf, size_t nbyte )
 {
-   struct read_write_args writeArgs;
    ssize_t ret;
+#ifdef PCF_BUILD
+   ret = traceWRITE( fd, buf, nbyte );
+#else
+   struct read_write_args writeArgs;
    int bytes;
    CLOCK t1, t2, incDur;
 
@@ -932,7 +1051,6 @@ ssize_t HDFtraceWRITE( int fd, const void *buf, size_t nbyte )
    ret = write( fd, buf, nbyte );
    t2 = getClock();
    incDur = clockSubtract(t2,t1);
-   WriteTotals += clockToSeconds( incDur );
 
    if ( IOtracingEnabled ) 
    {
@@ -946,6 +1064,7 @@ ssize_t HDFtraceWRITE( int fd, const void *buf, size_t nbyte )
       }
       HDFtraceIOEvent( writeEndID, (void *) &bytes, int_SIZE );
    }
+#endif /* PCF_BUILD */
    return( ret );
 }  
 
@@ -963,8 +1082,11 @@ size_t
 HDFtraceFWRITE(const void *ptr,size_t size,size_t nitems,FILE *stream )
 
 {
-   struct read_write_args writeArgs;
    size_t ret;
+#ifdef PCF_BUILD
+   ret = traceFWRITE( ptr, size, nitems, stream );
+#else
+   struct read_write_args writeArgs;
    int nbytes;
    int fd = fileno( stream );
    CLOCK t1, t2, incDur;
@@ -982,8 +1104,6 @@ HDFtraceFWRITE(const void *ptr,size_t size,size_t nitems,FILE *stream )
    ret = fwrite( ptr, size, nitems, stream );
    t2 = getClock();
    incDur = clockSubtract(t2,t1);
-   WriteTotals += clockToSeconds( incDur );
-
 
    if ( IOtracingEnabled ) 
    {
@@ -997,27 +1117,29 @@ HDFtraceFWRITE(const void *ptr,size_t size,size_t nitems,FILE *stream )
       } 
       HDFtraceIOEvent( fwriteEndID, (void *) &nbytes, int_SIZE );
    }
+#endif /* PCF_BUILD */
 
    return( ret );
 }
-
 /*****************************************************************************/
 /*+  Routine:  int HDFtracePUTS( char *s )                                  +*/
-/*+		  substitute for puts()                                     +*/
+/*+               substitute for puts()                                     +*/
 /*+               generates fwriteBeginID, fwriteEndID                      +*/
-/*+	          record Write (fwriteBeginID)                              +*/
-/*+                    	 Number Variables = 1                               +*/
-/*+			 Cause = -1                                         +*/
-/*+									    +*/
+/*+               record Write (fwriteBeginID)                              +*/
+/*+                      Number Variables = 1                               +*/
+/*+                      Cause = -1                                         +*/
+/*+                                                                         +*/
 /*****************************************************************************/
-int 
-HDFtracePUTS( char *s )
+int
+HDFtracePUTS( const char *s )
 {
-   struct read_write_args writeArgs;
    int ret;
    int fd = fileno( stdout );
-
-   if ( IOtracingEnabled ) 
+#ifdef PCF_BUILD
+   tracePUTS( s );
+#else
+   struct read_write_args writeArgs;
+   if ( IOtracingEnabled )
    {
       writeArgs.fileID = c_mappedID( fd );
       writeArgs.numVariables = 1;
@@ -1028,14 +1150,15 @@ HDFtracePUTS( char *s )
 
    ret = puts( s );
 
-   if ( IOtracingEnabled ) 
+   if ( IOtracingEnabled )
    {
       HDFtraceIOEvent( fwriteEndID, (void *) &ret, int_SIZE );
    }
+#endif
 
    return( ret );
 }
-       
+
 /*****************************************************************************/
 /*+	Routine:  int HDFtraceFPUTC( int c, FILE *stream )                  +*/
 /*+		  substitute for fputc()                                    +*/
@@ -1048,8 +1171,11 @@ HDFtracePUTS( char *s )
 int 
 HDFtraceFPUTC( int c, FILE *stream )
 {
-   struct read_write_args writeArgs;
    int ret; 
+#ifdef PCF_BUILD
+    ret = traceFPUTC( c, stream );
+#else
+   struct read_write_args writeArgs;
    int nbytes = char_SIZE;
    int fd = fileno( stream );
 
@@ -1072,72 +1198,92 @@ HDFtraceFPUTC( int c, FILE *stream )
          HDFtraceIOEvent( fwriteEndID, (void *) &nbytes, int_SIZE );
       }
    }
-
-    return( ret );
+#endif /* PCF_BUILD */
+   return( ret );
 }
 /*****************************************************************************/
 /*+  Routine:  int HDFtraceFPUTS( char *s, FILE *stream )                   +*/
-/*+		  substitute for fputs()                                    +*/
+/*+               substitute for fputs()                                    +*/
 /*+               generates fwriteBeginID, fwriteEndID                      +*/
-/*+	          record Write (fwriteBeginID)                              +*/
-/*+                    	 Number Variables = 1                               +*/
-/*+			 Cause = -1                                         +*/
-/*+									    +*/
+/*+               record Write (fwriteBeginID)                              +*/
+/*+                      Number Variables = 1                               +*/
+/*+                      Cause = -1                                         +*/
+/*+                                                                         +*/
 /*****************************************************************************/
 int HDFtraceFPUTS( const char *s, FILE *stream )
 {
-    struct read_write_args writeArgs;
-    int ret;
-    int fd = fileno( stream );
+   int ret;
+   int fd = fileno( stream );
 
-    if ( IOtracingEnabled ) {
-        writeArgs.fileID = c_mappedID( fd );
-        writeArgs.numVariables = 1;
-        writeArgs.cause = -1;
+#ifdef PCF_BUILD
+   ret = traceFPUTS( s, stream );
+#else
+   struct read_write_args writeArgs;
+   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 = fputs( s, stream );
+   ret = fputs( s, stream );
 
-    if ( IOtracingEnabled ) {
-        HDFtraceIOEvent( fwriteEndID, (void *) &ret, int_SIZE );
-    }
+   if ( IOtracingEnabled ) 
+   {
+       HDFtraceIOEvent( fwriteEndID, (void *) &ret, int_SIZE );
+   }
+#endif /* PCF_BUILD */
 
-    return( ret );
+   return( ret );
 }
-void *HDFtraceMALLOC(size_t bytes )
+
+void*
+HDFtraceMALLOC(size_t bytes )
 {
-	void *ptr;
-	int byte_req;
-	byte_req = (int)bytes;
-	if ( IOtracingEnabled ) {
-	   HDFtraceIOEvent ( ID_malloc, NULL, 0 );
-	}
+   void *ptr;
+#ifdef PCF_BUILD
+   ptr = (void *)traceMALLOC( bytes );
+#else
+   int byte_req;
+   byte_req = (int)bytes;
+   if ( IOtracingEnabled ) 
+   {
+      HDFtraceIOEvent ( ID_malloc, NULL, 0 );
+   }
 	
-	ptr = malloc( bytes );
+   ptr = malloc( bytes );
 
-	if ( IOtracingEnabled ) {
-	   HDFtraceIOEvent ( -ID_malloc, &byte_req, sizeof(int) );
-	}
+   if ( IOtracingEnabled ) 
+   {
+      HDFtraceIOEvent ( -ID_malloc, &byte_req, sizeof(int) );
+   }
+#endif /* PCF_BUILD */
 	
-	return ptr ;
+   return ptr ;
 
 }
 	
-void HDFtraceIOEvent( int eventType, void *dataPtr, unsigned dataLen )
+#ifndef PCF_BUILD
+void 
+HDFtraceIOEvent( int eventType, void *dataPtr, unsigned dataLen )
 {
-	if ( OUTPUT_SWITCH == RUNTIME_TRACE 
-	                     || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) {
-           traceEvent( eventType, dataPtr, dataLen );
-        } else {
-           HDFtraceEvent_RT( eventType, (HDFsetInfo *)dataPtr, dataLen );
-        }
+   if ( OUTPUT_SWITCH == RUNTIME_TRACE 
+	              || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) 
+   {
+      traceEvent( eventType, dataPtr, dataLen );
+   } 
+   else 
+   {
+      HDFtraceEvent_RT( eventType, (HDFsetInfo *)dataPtr, dataLen );
+   }
 }
 /*======================================================================*
 // record the final time stamp                                          *
 //======================================================================*/
-void HDFfinalTimeStamp( void )
+void 
+HDFfinalTimeStamp( void )
 {
         CLOCK   currentTime;
         double  seconds;
@@ -1177,7 +1323,8 @@ void HDFfinalTimeStamp( void )
 // the elements of procTrace corresponding to HDF files will be 	*
 // turned on, in which case all HDF procedures will be traced.	*
 //======================================================================*/
-void PabloHDFTrace( int ID ) 
+void 
+PabloHDFTrace( int ID ) 
 {
 	int i;
 	if ( procTrace == NULL ) {
@@ -1201,1133 +1348,4 @@ void PabloHDFTrace( int ID )
            exit (-1);
 	}
 }
-#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 );
-
-/* 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;
-}
-
-/* Get the node number */
-int HDF_get_source( int source )
-{
-   if ( source == MPI_ANY_SOURCE ) {
-      return PABLO_MPI_ANYSOURCE;
-   }
-   
-   if ( source == MPI_PROC_NULL ) {
-      return PABLO_MPI_PROCNULL;
-   }
-   
-   else {
-      return  source;
-   }
-}
-
-/* get the communicator ID                            */
-/* this is dummy for compatability with MPIO Traceing */
-int HDF_get_comm( MPI_Comm in_comm )
-{
-   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; 
-   
-   /* 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;  
-}
-
-/* data representations */
-int HDF_get_DataRep( char* datarep )
-{
-   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_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 = 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_close( MPI_File *fh )
-{
-   	int returnVal;
-   	HDFsetInfo dataPtr;
-   	int dataLen;
-   
-   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_set_size( MPI_File fh, MPI_Offset size )
-{
-   int returnVal;
-   HDFsetInfo dataPtr;
-   int dataLen;
-   
-   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;
-}
-
-/*======================================================================* 
-// 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 returnVal;
-   	HDFsetInfo dataPtr;
-   	int dataLen;
-
-        if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-           returnVal = PabloMPI_File_get_size( fh, size);
-	} else {
-	   dataLen = 1;
-           dataPtr.setID = (long)fh;
-           HDFtraceEvent_RT( HDFmpiGetSizeID,
-                             &dataPtr,dataLen );
-           returnVal = MPI_File_get_size( fh, size);
-           HDFtraceEvent_RT( -HDFmpiGetSizeID,
-                             &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_set_view( MPI_File fh, MPI_Offset disp, MPI_Datatype etype, 
-                           MPI_Datatype filetype, char *datarep, MPI_Info info )
-{
-   	int returnVal;
-   	HDFsetInfo dataPtr;
-   	int dataLen;
-
-        if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-   	   returnVal = PabloMPI_File_set_view( fh, disp, etype, filetype, 
-                                                      datarep, info );
-	} else {
-	   dataLen = 1;
-           dataPtr.setID = (long)fh;
-           HDFtraceEvent_RT( HDFmpiSetViewID,
-                             &dataPtr,dataLen );
-   	   returnVal = MPI_File_set_view( fh, disp, etype, filetype, 
-                                                      datarep, info );
-           HDFtraceEvent_RT( -HDFmpiSetViewID,
-                             &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_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 = PabloMPI_File_get_view(fh, disp, etype, filetype, datarep);
-   } 
-   else 
-   {
-      dataLen = 1;
-      dataPtr.setID = (long)fh;
-      HDFtraceEvent_RT( HDFmpiSetViewID,
-                             &dataPtr,dataLen );
-      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;
-}
-
-/*======================================================================* 
-// 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_at( MPI_File fh, MPI_Offset offset, void *buf,
-		         int count, MPI_Datatype datatype, MPI_Status *status )
-{
-   	int returnVal;
-   	HDFsetInfo dataPtr;
-   	int dataLen;
-        int rCount;
-
-        if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-   	   returnVal = PabloMPI_File_read_at( fh, offset, buf, count, datatype, 
-	                                                            status );
-	} else {
-	   dataLen = sizeof(dataPtr);
-           dataPtr.setID = (long)fh;
-           dataPtr.numBytes = HDF_get_Bytes( datatype, count );
-           HDFtraceEvent_RT( HDFmpiReadAtID,
-                             &dataPtr,dataLen );
-   	   returnVal = MPI_File_read_at( fh, offset, buf, count, datatype, 
-	                                                            status );
-           MPI_Get_count(status,datatype,&rCount);
-           if ( rCount < 0 || rCount > count ) 
-           {
-              dataPtr.numBytes = -1;
-           }
-           else
-           {
-              dataPtr.numBytes = HDF_get_Bytes( datatype, rCount );
-           }
-           HDFtraceEvent_RT( -HDFmpiReadAtID,
-                             &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_at_all( MPI_File fh, MPI_Offset offset, void *buf,
-   			int count, MPI_Datatype datatype, MPI_Status *status )
-{
-   
-   	int returnVal;
-   	HDFsetInfo dataPtr;
-   	int dataLen;
-        int rCount;
-
-        if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-   	   returnVal = PabloMPI_File_read_at_all( fh, offset, buf, 
-				      count, datatype, status );
-	} else {
-	   dataLen = sizeof(dataPtr);
-           dataPtr.setID = (long)fh;
-           dataPtr.numBytes = HDF_get_Bytes( datatype, count );
-           HDFtraceEvent_RT( HDFmpiReadAtAllID,
-                             &dataPtr,dataLen );
-   	   returnVal = MPI_File_read_at_all( fh, offset, buf, 
-				      count, datatype, status );
-           MPI_Get_count(status,datatype,&rCount);
-           if ( rCount < 0 || rCount > count ) 
-           {
-              dataPtr.numBytes = -1;
-           }
-           else
-           {
-              dataPtr.numBytes = HDF_get_Bytes( datatype, rCount );
-           }
-           HDFtraceEvent_RT( -HDFmpiReadAtAllID,
-                             &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_write_at( MPI_File fh, MPI_Offset offset, void *buf,
-                      int count, MPI_Datatype datatype, MPI_Status *status )
-{
-   
-   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 );
-      MPI_Get_count(status,datatype,&rCount);
-      if ( rCount < 0 || rCount > count ) 
-      {
-         dataPtr.numBytes = -1;
-      }
-      else
-      {
-         dataPtr.numBytes = HDF_get_Bytes( datatype, rCount );
-      }
-      HDFtraceEvent_RT( -HDFmpiWriteAtID, &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_write_at_all( MPI_File fh, MPI_Offset offset, void *buf,
-                  int count, MPI_Datatype datatype, MPI_Status *status )
-{
-   	int returnVal;
-   	HDFsetInfo dataPtr;
-   	int dataLen;
-        int numBytes;
-
-        if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
-   	   returnVal = PabloMPI_File_write_at_all( fh, offset, buf, 
-	 	 	       		count, datatype, status );
-	} else {
-	   dataLen = sizeof(dataPtr);
-           dataPtr.setID = (long)fh;
-           dataPtr.numBytes = HDF_get_Bytes( datatype, count );
-           HDFtraceEvent_RT( HDFmpiWriteAtAllID,
-                             &dataPtr,dataLen );
-   	   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 );
-	}
-   	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 returnVal;
-   	HDFsetInfo dataPtr;
-   	int dataLen;
-
-        if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) { 
-   	   returnVal = PabloMPI_File_sync ( fh );
-	} else {
-	   dataLen = 1;
-           dataPtr.setID = (long)fh;
-           HDFtraceEvent_RT( HDFmpiSyncID,
-                             &dataPtr,dataLen );
-   	   returnVal = MPI_File_sync ( fh );
-           HDFtraceEvent_RT( -HDFmpiSyncID,
-                             &dataPtr,dataLen );
-	} 
-   	return returnVal;
-}
-
-int HDF_get_Bytes( MPI_Datatype datatype, int count )
-{
-   int nm_bytes;
-   
-   MPI_Type_size( datatype, &nm_bytes );
-   return( nm_bytes * count );
-}
-
-int 
-PabloMPI_File_open( MPI_Comm comm,
-                    char *filename,
-                    int amode,
-                    MPI_Info info,
-                    MPI_File *fh )
-{
-   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 */
-   HDFtraceIOEvent( 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 */
-   HDFtraceIOEvent( mpiOpenEndID, (char *) &mpiOpenEndArguments, 
-                 sizeof( mpiOpenEndArguments ) );
-   
-   return returnVal;
-}
-
-int 
-PabloMPI_File_close( MPI_File *fh )
-{
-   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 */
-   HDFtraceIOEvent( mpiCloseBeginID, (char *) &mpiCloseBeginArguments, 
-		 sizeof( mpiCloseBeginArguments ) );
-   
-   returnVal = MPI_File_close( fh );
-   
-   mpiCloseEndArguments.localNode = HDFlocalNode;
-   mpiCloseEndArguments.globalNode = HDFmyNode;
-   mpiCloseEndArguments.fileID = myHDFid;
-   
-   /* Generate exit record */
-   HDFtraceIOEvent( mpiCloseEndID, (char *) &mpiCloseEndArguments, 
-	      sizeof( mpiCloseEndArguments ) );
-   
-   return returnVal;
-}
-
-int 
-PabloMPI_File_set_size( MPI_File fh, MPI_Offset size )
-{
-   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 */
-   HDFtraceIOEvent( 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 */
-   HDFtraceIOEvent( mpiSetSizeEndID, (char *) &mpiSetSizeEndArguments, 
-		 sizeof( mpiSetSizeEndArguments ) );
-   
-   return returnVal; 
-}
-
-int 
-PabloMPI_File_get_size( MPI_File fh, MPI_Offset *size )
-{
-   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 */
-   HDFtraceIOEvent( 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 */
-   HDFtraceIOEvent( mpiGetSizeEndID, (char *) &mpiGetSizeEndArguments, 
-		 sizeof( mpiGetSizeEndArguments ) );
-   
-   return returnVal;
-}
-
-int 
-PabloMPI_File_set_view( MPI_File fh,
-                        MPI_Offset disp,
-                        MPI_Datatype etype,
-                        MPI_Datatype filetype,
-                        char *datarep,
-                        MPI_Info info )
-{
-   int 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 */
-   HDFtraceIOEvent( 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 */
-   HDFtraceIOEvent( mpiSetViewEndID, (char *) &mpiSetViewEndArguments, 
-		 sizeof( mpiSetViewEndArguments ) );
-   
-   return returnVal;
-}
-
-int 
-PabloMPI_File_get_view( MPI_File fh,
-                        MPI_Offset *disp,
-                        MPI_Datatype *etype,
-                        MPI_Datatype *filetype,
-                        char *datarep )
-{
-   int returnVal;
-   
-   struct mpiGetViewBeginArgs mpiGetViewBeginArguments;
-   struct mpiGetViewEndArgs mpiGetViewEndArguments;
-
-#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 */
-   HDFtraceIOEvent( 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 */
-   HDFtraceIOEvent( mpiGetViewEndID, (char *) &mpiGetViewEndArguments, 
-		 sizeof( mpiGetViewEndArguments ) );
-   
-   return returnVal;  
-}
-
-int 
-PabloMPI_File_read_at( MPI_File fh,
-                       MPI_Offset offset,
-                       void *buf,
-                       int count,
-                       MPI_Datatype datatype,
-                       MPI_Status *status )
-{
-   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 */
-   HDFtraceIOEvent( 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;
-   
-   MPI_Get_count( status, datatype, &bcount );
-   if ( bcount < 0 || bcount > count ) 
-   {
-      mpiReadAtEndArguments.rCount = -1;
-      mpiReadAtEndArguments.numBytes = -1;
-   }   
-   else
-   {
-      mpiReadAtEndArguments.rCount = bcount;
-      mpiReadAtEndArguments.numBytes = HDF_get_Bytes( datatype, bcount );
-   }   
-   /* Generate entry record */
-   HDFtraceIOEvent( mpiReadAtEndID, (char *) &mpiReadAtEndArguments, 
-		 sizeof( mpiReadAtEndArguments ) );
-   
-   return returnVal;
-}
-
-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;
-   
-   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 */
-   HDFtraceIOEvent( 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;
-   
-   MPI_Get_count( status, datatype, &bcount );
-   if ( bcount < 0 || bcount > count )
-   {
-      mpiReadAtAllEndArguments.rCount = -1;
-      mpiReadAtAllEndArguments.numBytes = -1;
-   }
-   else
-   {
-      mpiReadAtAllEndArguments.rCount = bcount;
-      mpiReadAtAllEndArguments.numBytes = HDF_get_Bytes( datatype, bcount );
-   }
-   
-   /* Generate entry record */
-   HDFtraceIOEvent( mpiReadAtAllEndID, (char *) &mpiReadAtAllEndArguments, 
-		 sizeof( mpiReadAtAllEndArguments ) );
-   
-   return returnVal;
-}
-
-int 
-PabloMPI_File_write_at( MPI_File fh,
-                        MPI_Offset offset,
-                        void *buf,
-                        int count,
-                        MPI_Datatype datatype,
-                        MPI_Status *status )
-{
-   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 */
-   HDFtraceIOEvent( 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;
-   
-   MPI_Get_count( status, datatype, &bcount );
-   mpiWriteAtEndArguments.wCount = bcount;
-   mpiWriteAtEndArguments.numBytes = HDF_get_Bytes( datatype, bcount );
-   
-   /* Generate entry record */
-   HDFtraceIOEvent( mpiWriteAtEndID, (char *) &mpiWriteAtEndArguments, 
-		 sizeof( mpiWriteAtEndArguments ) );
-   
-   return returnVal;  
-}
-
-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;
-   
-   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 */
-   HDFtraceIOEvent( 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 */
-   HDFtraceIOEvent( mpiWriteAtAllEndID, (char *) &mpiWriteAtAllEndArguments, 
-		 sizeof( mpiWriteAtAllEndArguments ) );
-   
-   return returnVal;  
-}
-
-int 
-PabloMPI_File_sync( MPI_File fh ) 
-{
-   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 */
-   HDFtraceIOEvent( 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 */
-   HDFtraceIOEvent( mpiSyncEndID, (char *) &mpiSyncEndArguments, 
-		 sizeof( mpiSyncEndArguments ) );
-   
-   return returnVal;
-}
-
-#endif /* H5_HAVE_PARALLEL */
+#endif /* PCF_BUILD */