[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, 1364 insertions, 0 deletions

diff --git a/pablo/PabloHDF_MPIO.c b/pablo/PabloHDF_MPIO.c
new file mode 100644
index 0000000..0eee178
--- /dev/null
+++ b/pablo/PabloHDF_MPIO.c
@@ -0,0 +1,1364 @@
+/*
+ * This file is an extension to NCSA HDF to enable the use of the
+ * Pablo trace library.
+ *
+ * Developed by: The TAPESTRY Parallel Computing Laboratory
+ *		 University of Illinois at Urbana-Champaign
+ *		 Department of Computer Science
+ *		 1304 W. Springfield Avenue
+ *		 Urbana, IL	61801
+ *
+ * Copyright (c) 1995
+ * The University of Illinois Board of Trustees.
+ *      All Rights Reserved.
+ *
+ * PABLO is a registered trademark of
+ * The Board of Trustees of the University of Illinois
+ * registered in the U.S. Patent and Trademark Office.
+ *
+ * Author: George Xin Zhou (xzhou@cs.uiuc.edu)
+ * Contributing Author: Jonathan M. Reid (jreid@cs.uiuc.edu)
+ *
+ * Project Manager and Principal Investigator:
+ *	Daniel A. Reed (reed@cs.uiuc.edu)
+ *
+ * Funded by: National Aeronautics and Space Administration under NASA
+ * Contracts NAG-1-613 and USRA 5555-22 and by the Advanced Research
+ * Projects Agency under ARPA contracts DAVT63-91-C-0029 and
+ * DABT63-93-C-0040.
+ *
+ */
+/*======================================================================*
+// File:  PabloHDF_MPIO.c						*
+// Purpose: support use of Pablo trace library to analyze MPIO calls	*
+// within HDF calls 							*
+// Most of the code is conditionally compiled dependent on the compiler *
+// flag HAVE_H5_PARALLEL which is set in the Makefile in thie hdf/pablo *
+// directory.								*
+// Contents
+//    HDF_get_NodeNum                					*
+// 
+//    HDF_get_mode         				*
+//   returns the node number						*
+// 
+//    HDF_get_source        					*
+// 
+//    HDF_get_comm
+// 
+//    HDF_get_Datatype
+// 
+//    HDF_get_DataRep
+// 
+// int HDF_get_Bytes
+// 
+// int PabloMPI_File_open
+//                       
+// int PabloMPI_File_close
+// 
+// int PabloMPI_File_set_size
+// 
+// int PabloMPI_File_get_size
+// 
+// int PabloMPI_File_set_view
+// 
+// int PabloMPI_File_get_view
+// 
+// int PabloMPI_File_read_at
+// 
+// int PabloMPI_File_read_at_all
+// 
+// int PabloMPI_File_write_at
+// 
+// int PabloMPI_File_write_at_all
+// 
+// int PabloMPI_File_sync
+// 
+// int HDF_MPI_File_open
+// 
+// int HDF_MPI_File_close
+// 
+// int HDF_MPI_File_set_size
+// 
+// int HDF_MPI_File_get_size
+// 
+// int HDF_MPI_File_set_view
+// 
+// int HDF_MPI_File_get_view
+// 
+// int HDF_MPI_File_read_at
+// 
+// int HDF_MPI_File_read_at_all
+// 
+// int HDF_MPI_File_write_at
+//
+// int HDF_MPI_File_write_at_all
+// 
+// int HDF_MPI_File_sync
+// 
+//======================================================================*/
+#ifdef H5_HAVE_PARALLEL
+#include "mpi.h"
+/************************************************************************/
+/* Return the node number.						*/
+/************************************************************************/
+void HDF_get_NodeNum( int* nodeNum )
+{
+   MPI_Comm_rank( MPI_COMM_WORLD, nodeNum );
+}
+#ifdef _BUILD
+#include "HDFTrace.h"
+#include "ProcTrace.h"
+#include "ProcIDs.h"
+#include "MPIO_Trace.h"
+#include "MPIO_EventArgs.h"
+#include "MPIO_Data.h"
+
+extern int OUTPUT_SWITCH;
+/* 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, "PabloMPI_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 = 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 = 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 = 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 /* _BUILD */
+#else /* H5_HAVE_PARALLEL */
+void HDF_get_NodeNum( int* nodeNum )
+{
+   *nodeNum = 0;
+}
+#endif /* H5_HAVE_PARALLEL */