summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorDan Wells <dwells@cs.uiuc.edu>2001-04-30 19:26:25 (GMT)
committerDan Wells <dwells@cs.uiuc.edu>2001-04-30 19:26:25 (GMT)
commitdc8e89d465711256c7022df017a354a2c4fa61e9 (patch)
treeed4863f47c40dc56661c441031576462f3267c83
parent4f19d133e7366489b1bf27624042c26343f51d3b (diff)
downloadhdf5-dc8e89d465711256c7022df017a354a2c4fa61e9.zip
hdf5-dc8e89d465711256c7022df017a354a2c4fa61e9.tar.gz
hdf5-dc8e89d465711256c7022df017a354a2c4fa61e9.tar.bz2
[svn-r3874]
Purpose: feature Description: This brings the development version up to date with the release version. It now supports Pablo tracing of MPI-I/O calls from MPI-I/O versions which are not totally compliant with the standars. Solution: Added entries to bypass the current MPI-I/O tracing in the Pablo Trace Library. Platforms tested: IRIX64/Solaris/IBM SP2
Diffstat
-rw-r--r--pablo/HDFTrace.h33
-rw-r--r--pablo/HDFmpioProtos.h38
-rw-r--r--pablo/PabloHDF.c2227
-rw-r--r--pablo/PabloHDF_SDDF.c2
-rw-r--r--pablo/ProcTrace.h1
5 files changed, 1564 insertions, 737 deletions
diff --git a/pablo/HDFTrace.h b/pablo/HDFTrace.h
index 264291c..a8e2a47 100644
--- a/pablo/HDFTrace.h
+++ b/pablo/HDFTrace.h
@@ -131,6 +131,39 @@ extern char *hdfRecordPointer;
#define FAMILY_MISC 0270
#define FAMILY_HDFPROCNAME 0300
+#define mpiOpenBeginID 900800
+#define mpiOpenEndID 900801
+
+#define mpiCloseBeginID 900802
+#define mpiCloseEndID 900803
+
+#define mpiSetSizeBeginID 900806
+#define mpiSetSizeEndID 900807
+
+#define mpiGetSizeBeginID 900810
+#define mpiGetSizeEndID 900811
+
+#define mpiSetViewBeginID 900816
+#define mpiSetViewEndID 900817
+
+#define mpiGetViewBeginID 900818
+#define mpiGetViewEndID 900819
+
+#define mpiReadAtBeginID 900820
+#define mpiReadAtEndID 900821
+
+#define mpiReadAtAllBeginID 900822
+#define mpiReadAtAllEndID 900823
+
+#define mpiWriteAtBeginID 900824
+#define mpiWriteAtEndID 900825
+
+#define mpiWriteAtAllBeginID 900826
+#define mpiWriteAtAllEndID 900827
+
+#define mpiSyncBeginID 900856
+#define mpiSyncEndID 900857
+
typedef struct {
long numBytes;
long setID;
diff --git a/pablo/HDFmpioProtos.h b/pablo/HDFmpioProtos.h
index 01da37b..5a08c4e 100644
--- a/pablo/HDFmpioProtos.h
+++ b/pablo/HDFmpioProtos.h
@@ -1,31 +1,13 @@
#define MPI_File_open HDF_MPI_File_open
#define MPI_File_close HDF_MPI_File_close
-#define MPI_File_delete HDF_MPI_File_delete
#define MPI_File_set_size HDF_MPI_File_set_size
-#define MPI_File_preallocate HDF_MPI_File_preallocate
#define MPI_File_get_size HDF_MPI_File_get_size
-#define MPI_File_get_group HDF_MPI_File_get_group
-#define MPI_File_get_amode HDF_MPI_File_get_amode
#define MPI_File_set_view HDF_MPI_File_set_view
#define MPI_File_get_view HDF_MPI_File_get_view
#define MPI_File_read_at HDF_MPI_File_read_at
#define MPI_File_read_at_all HDF_MPI_File_read_at_all
#define MPI_File_write_at HDF_MPI_File_write_at
#define MPI_File_write_at_all HDF_MPI_File_write_at_all
-#define MPI_File_iread_at HDF_MPI_File_iread_at
-#define MPI_File_iwrite_at HDF_MPI_File_iwrite_at
-#define MPI_File_read HDF_MPI_File_read
-#define MPI_File_read_all HDF_MPI_File_read_all
-#define MPI_File_write HDF_MPI_File_write
-#define MPI_File_write_all HDF_MPI_File_write_all
-#define MPI_File_iread HDF_MPI_File_iread
-#define MPI_File_iwrite HDF_MPI_File_iwrite
-#define MPI_File_seek HDF_MPI_File_seek
-#define MPI_File_get_position HDF_MPI_File_get_position
-#define MPI_File_get_byte_offset HDF_MPI_File_get_byte_offset
-#define MPI_File_get_type_extent HDF_MPI_File_get_type_extent
-#define MPI_File_set_atomicity HDF_MPI_File_set_atomicity
-#define MPI_File_get_atomicity HDF_MPI_File_get_atomicity
#define MPI_File_sync HDF_MPI_File_sync
int HDF_MPI_File_open( MPI_Comm comm, char *filename, int amode,
@@ -33,10 +15,7 @@ int HDF_MPI_File_open( MPI_Comm comm, char *filename, int amode,
int HDF_MPI_File_close( MPI_File *fh );
int HDF_MPI_File_delete( char *filename, MPI_Info info );
int HDF_MPI_File_set_size( MPI_File fh, MPI_Offset size );
-int HDF_MPI_File_preallocate( MPI_File fh, MPI_Offset size);
int HDF_MPI_File_get_size( MPI_File fh, MPI_Offset *size );
-int HDF_MPI_File_get_group( MPI_File fh, MPI_Group *group );
-int HDF_MPI_File_get_amode( MPI_File fh, int *amode );
int HDF_MPI_File_set_view( MPI_File fh, MPI_Offset disp, MPI_Datatype etype,
MPI_Datatype filetype, char *datarep,
MPI_Info info );
@@ -55,21 +34,4 @@ int HDF_MPI_File_write_at( MPI_File fh, MPI_Offset offset, void *buf,
int HDF_MPI_File_write_at_all( MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype,
MPI_Status *status );
-int HDF_MPI_File_read( MPI_File fh, void *buf, int count,
- MPI_Datatype datatype, MPI_Status *status );
-int HDF_MPI_File_read_all( MPI_File fh, void *buf, int count,
- MPI_Datatype datatype, MPI_Status *status );
-int HDF_MPI_File_write( MPI_File fh, void *buf, int count,
- MPI_Datatype datatype, MPI_Status *status );
-int HDF_MPI_File_write_all( MPI_File fh, void *buf, int count,
- MPI_Datatype datatype, MPI_Status *status );
-int HDF_MPI_File_seek( MPI_File fh,
- MPI_Offset offset, int whence ) ;
-int HDF_MPI_File_get_position( MPI_File fh, MPI_Offset *offset );
-int HDF_MPI_File_get_byte_offset( MPI_File fh, MPI_Offset offset,
- MPI_Offset *disp) ;
-int HDF_MPI_File_get_type_extent( MPI_File fh, MPI_Datatype datatype,
- MPI_Aint *extent );
-int HDF_MPI_File_set_atomicity( MPI_File fh, int flag );
-int HDF_MPI_File_get_atomicity( MPI_File fh, int *flag );
int HDF_MPI_File_sync( MPI_File fh );
diff --git a/pablo/PabloHDF.c b/pablo/PabloHDF.c
index 9c43897..b890b07 100644
--- a/pablo/PabloHDF.c
+++ b/pablo/PabloHDF.c
@@ -145,6 +145,7 @@ void endHDFtraceEvent (int , int , char *, int );
void HDFtraceEvent_RT ( int , HDFsetInfo *, unsigned );
void HDFtraceIOEvent( int , void *, unsigned );
extern int IOtracingEnabled;
+extern int suppressMPIOtrace;
char *hdfRecordPointer;
double WriteTotals = 0.0;
double ReadTotals = 0.0;
@@ -167,132 +168,162 @@ double ReadTotals = 0.0;
// fortran to C interface. *
// This is called from hdfinittracef_ *
//======================================================================*/
-void hinittracex_( char *file, int *len, int flags[], int *nflags,
- unsigned *out_sw )
+void
+hinittracex_( char *file,
+ int *len,
+ int flags[],
+ int *nflags,
+ unsigned *out_sw )
{
- char *traceFileName;
- int i;
- traceFileName = (char *)malloc(*len+1);
- for ( i = 0; i < *len; ++i ) {
- traceFileName[i] = file[i];
- }
- traceFileName[*len+1] = 0;
- /*==============================================================*
- // Allocate space for trace indicators. *
- //==============================================================*/
- procTrace = ( int * ) malloc( NUM_HDF_IDS*sizeof(int) );
- if ( procTrace == NULL ) {
- fprintf(stderr,">> Error: Unable to allocate procTrace ");
- fprintf(stderr,"array in program HDFinitTrace. <<<\n");
- fprintf(stderr,">>> Exiting program! <<<\n");
- exit (-1);
- }
- /*==============================================================*
- // Initialize to 0. *
- //==============================================================*/
- for ( i = 0; i <= NUM_HDF_IDS; ++i ) {
- procTrace[i] = 0;
- }
- /*==============================================================*
- // Read in the flags indicating which procedures to trace. *
- // The last parameter passed is an indicator of the type of *
- // tracing to do. This indicator has a value larger than any *
- // of the flags. *
- //==============================================================*/
- for ( i = 0; i < *nflags; ++i ) {
- procTrace[flags[i]] = 1;
- }
- OUTPUT_SWITCH = *out_sw;
- /*==============================================================*
- // if no flags were passed, the default is to trace all of the *
- // procedures. *
- //==============================================================*/
- if ( *nflags == 0 || procTrace[ID_ALLHDF] ) {
- for ( i = 0; i < NUM_HDF_IDS; ++i ) {
- procTrace[i] = 1;
- }
- }
- if ( OUTPUT_SWITCH == RUNTIME_TRACE
- || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) {
- HDFinitTrace_SDDF( traceFileName, OUTPUT_SWITCH );
- IOtracingEnabled = 1;
- } else if ( OUTPUT_SWITCH == SUMMARY_TRACE
- || OUTPUT_SWITCH == MPI_SUMMARY_TRACE ) {
- HDFinitTrace_RT( traceFileName, OUTPUT_SWITCH );
- IOtracingEnabled = 1;
- } else if ( OUTPUT_SWITCH == NO_TRACE ) {
- IOtracingEnabled = 0;
- } else {
- fprintf(stderr,">> Error in HDFinitTrace: the third argument ");
- fprintf(stderr,"must have a value between %4d<<\n",RUNTIME_TRACE);
- fprintf(stderr,">> and %4d, inclusive.",NO_TRACE);
- fprintf(stderr," The value received was %4u.", OUTPUT_SWITCH);
- fprintf(stderr," Exiting Program. <<\n");
- exit (-1);
- }
+ char *traceFileName;
+ int i;
+ traceFileName = (char *)malloc(*len+1);
+ for ( i = 0; i < *len; ++i )
+ {
+ traceFileName[i] = file[i];
+ }
+ traceFileName[*len+1] = 0;
+ /*===================================================================*
+ // Allocate space for trace indicators. *
+ //===================================================================*/
+ procTrace = ( int * ) malloc( NUM_HDF_IDS*sizeof(int) );
+ if ( procTrace == NULL )
+ {
+ fprintf(stderr,">> Error: Unable to allocate procTrace ");
+ fprintf(stderr,"array in program HDFinitTrace. <<<\n");
+ fprintf(stderr,">>> Exiting program! <<<\n");
+ exit (-1);
+ }
+ /*===================================================================*
+ // Initialize to 0. *
+ //===================================================================*/
+ for ( i = 0; i <= NUM_HDF_IDS; ++i )
+ {
+ procTrace[i] = 0;
+ }
+ /*===================================================================*
+ // Read in the flags indicating which procedures to trace. *
+ // The last parameter passed is an indicator of the type of *
+ // tracing to do. This indicator has a value larger than any *
+ // of the flags. *
+ //===================================================================*/
+ for ( i = 0; i < *nflags; ++i )
+ {
+ procTrace[flags[i]] = 1;
+ }
+ OUTPUT_SWITCH = *out_sw;
+ /*===================================================================*
+ // if no flags were passed, the default is to trace all of the *
+ // procedures. *
+ //===================================================================*/
+ if ( *nflags == 0 || procTrace[ID_ALLHDF] )
+ {
+ for ( i = 0; i < NUM_HDF_IDS; ++i )
+ {
+ procTrace[i] = 1;
+ }
+ }
+ if ( OUTPUT_SWITCH == RUNTIME_TRACE
+ || OUTPUT_SWITCH == MPI_RUNTIME_TRACE )
+ {
+ HDFinitTrace_SDDF( traceFileName, OUTPUT_SWITCH );
+ IOtracingEnabled = 1;
+ }
+ else if ( OUTPUT_SWITCH == SUMMARY_TRACE
+ || OUTPUT_SWITCH == MPI_SUMMARY_TRACE )
+ {
+ HDFinitTrace_RT( traceFileName, OUTPUT_SWITCH );
+ IOtracingEnabled = 1;
+ }
+ else if ( OUTPUT_SWITCH == NO_TRACE )
+ {
+ IOtracingEnabled = 0;
+ }
+ else
+ {
+ fprintf(stderr,">> Error in HDFinitTrace: the third argument ");
+ fprintf(stderr,"must have a value between %4d<<\n",RUNTIME_TRACE);
+ fprintf(stderr,">> and %4d, inclusive.",NO_TRACE);
+ fprintf(stderr," The value received was %4u.", OUTPUT_SWITCH);
+ fprintf(stderr," Exiting Program. <<\n");
+ exit (-1);
+ }
}
void HDFinitTrace( const char *traceFileName, int id_flag, ... )
{
- int i, nIDs;
- va_list ap;
-
- /*==============================================================*
- // Allocate space for trace indicators. *
- //==============================================================*/
- procTrace = ( int * ) malloc( NUM_HDF_IDS*sizeof(int) );
- if ( procTrace == NULL ) {
- fprintf(stderr,">> Error: Unable to allocate procTrace ");
- fprintf(stderr,"array in program HDFinitTrace. <<<\n");
- fprintf(stderr,">>> Exiting program! <<<\n");
- exit (-1);
- }
- /*==============================================================*
- // Initialize to 0. *
- //==============================================================*/
- for ( i = 0; i < NUM_HDF_IDS; ++i ) {
- procTrace[i] = 0;
- }
- /*==============================================================*
- // Read in the flags indicating which procedures to trace. *
- // The last parameter passed is an indicator of the type of *
- // tracing to do. This indicator has a value larger than any *
- // of the flags. *
- //==============================================================*/
- nIDs = 0;
- va_start( ap, id_flag );
- while ( id_flag > NO_TRACE ) {
- procTrace[id_flag] = 1;
- ++nIDs;
- id_flag = va_arg ( ap, int );
- }
- OUTPUT_SWITCH = id_flag;
- /*==============================================================*
- // if no flags were passed, the default is to trace all of the *
- // procedures. *
- //==============================================================*/
- if ( nIDs == 0 || procTrace[ID_ALLHDF] ) {
- for ( i = 0; i < NUM_HDF_IDS; ++i ) {
- procTrace[i] = 1;
- }
- }
- if ( OUTPUT_SWITCH == RUNTIME_TRACE
- || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) {
- HDFinitTrace_SDDF( traceFileName, OUTPUT_SWITCH );
- IOtracingEnabled = 1;
- } else if ( OUTPUT_SWITCH == SUMMARY_TRACE
- || OUTPUT_SWITCH == MPI_SUMMARY_TRACE ) {
- HDFinitTrace_RT( traceFileName, OUTPUT_SWITCH );
- IOtracingEnabled = 1;
- } else if ( OUTPUT_SWITCH == NO_TRACE ) {
- IOtracingEnabled = 0;
- } else {
- fprintf(stderr,">> Error in HDFinitTrace: the third argument ");
- fprintf(stderr,"must have a value between %4d<<\n",RUNTIME_TRACE);
- fprintf(stderr,">> and %4d, inclusive.",NO_TRACE);
- fprintf(stderr," The value received was %4u.", OUTPUT_SWITCH);
- fprintf(stderr," Exiting Program. <<\n");
- exit (-1);
- }
+ int i, nIDs;
+ va_list ap;
+
+ /*===================================================================*
+ // Allocate space for trace indicators. *
+ //===================================================================*/
+ procTrace = ( int * ) malloc( NUM_HDF_IDS*sizeof(int) );
+ if ( procTrace == NULL )
+ {
+ fprintf(stderr,">> Error: Unable to allocate procTrace ");
+ fprintf(stderr,"array in program HDFinitTrace. <<<\n");
+ fprintf(stderr,">>> Exiting program! <<<\n");
+ exit (-1);
+ }
+ /*===================================================================*
+ // Initialize to 0. *
+ //===================================================================*/
+ for ( i = 0; i < NUM_HDF_IDS; ++i )
+ {
+ procTrace[i] = 0;
+ }
+ /*===================================================================*
+ // Read in the flags indicating which procedures to trace. *
+ // The last parameter passed is an indicator of the type of *
+ // tracing to do. This indicator has a value larger than any *
+ // of the flags. *
+ //===================================================================*/
+ nIDs = 0;
+ va_start( ap, id_flag );
+ while ( id_flag > NO_TRACE )
+ {
+ procTrace[id_flag] = 1;
+ ++nIDs;
+ id_flag = va_arg ( ap, int );
+ }
+ OUTPUT_SWITCH = id_flag;
+ /*===================================================================*
+ // if no flags were passed, the default is to trace all of the *
+ // procedures. *
+ //===================================================================*/
+ if ( nIDs == 0 || procTrace[ID_ALLHDF] )
+ {
+ for ( i = 0; i < NUM_HDF_IDS; ++i )
+ {
+ procTrace[i] = 1;
+ }
+ }
+ suppressMPIOtrace = TRUE;
+ if ( OUTPUT_SWITCH == RUNTIME_TRACE
+ || OUTPUT_SWITCH == MPI_RUNTIME_TRACE )
+ {
+ HDFinitTrace_SDDF( traceFileName, OUTPUT_SWITCH );
+ IOtracingEnabled = 1;
+ }
+ else if ( OUTPUT_SWITCH == SUMMARY_TRACE
+ || OUTPUT_SWITCH == MPI_SUMMARY_TRACE )
+ {
+ HDFinitTrace_RT( traceFileName, OUTPUT_SWITCH );
+ IOtracingEnabled = 1;
+ }
+ else if ( OUTPUT_SWITCH == NO_TRACE )
+ {
+ IOtracingEnabled = 0;
+ }
+ else
+ {
+ fprintf(stderr,">> Error in HDFinitTrace: the third argument ");
+ fprintf(stderr,"must have a value between %4d<<\n",RUNTIME_TRACE);
+ fprintf(stderr,">> and %4d, inclusive.",NO_TRACE);
+ fprintf(stderr," The value received was %4u.", OUTPUT_SWITCH);
+ fprintf(stderr," Exiting Program. <<\n");
+ exit (-1);
+ }
}
/*======================================================================*
// NAME *
@@ -304,124 +335,155 @@ void HDFinitTrace( const char *traceFileName, int id_flag, ... )
//======================================================================*/
void hdfendtrace_( void )
{
- HDFendTrace ();
+ HDFendTrace ();
}
void HDFendTrace(void)
{
- if ( OUTPUT_SWITCH == RUNTIME_TRACE
- || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) {
- HDFendTrace_SDDF( OUTPUT_SWITCH );
- } else if ( OUTPUT_SWITCH == SUMMARY_TRACE
- || OUTPUT_SWITCH == MPI_SUMMARY_TRACE ) {
- HDFendTrace_RT( OUTPUT_SWITCH );
- }
+ if ( OUTPUT_SWITCH == RUNTIME_TRACE
+ || OUTPUT_SWITCH == MPI_RUNTIME_TRACE )
+ {
+ HDFendTrace_SDDF( OUTPUT_SWITCH );
+ }
+ else if ( OUTPUT_SWITCH == SUMMARY_TRACE
+ || OUTPUT_SWITCH == MPI_SUMMARY_TRACE )
+ {
+ HDFendTrace_RT( OUTPUT_SWITCH );
+ }
}
void startHDFtraceEvent(int eventID)
{
- if ( OUTPUT_SWITCH == RUNTIME_TRACE
- || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) {
- traceEvent( eventID, NULL, 0 ) ;
- } else {
- HDFtraceEvent_RT( eventID, NULL, 0 ) ;
- }
+ if ( OUTPUT_SWITCH == RUNTIME_TRACE
+ || OUTPUT_SWITCH == MPI_RUNTIME_TRACE )
+ {
+ traceEvent( eventID, NULL, 0 ) ;
+ }
+ else
+ {
+ HDFtraceEvent_RT( eventID, NULL, 0 ) ;
+ }
}
void endHDFtraceEvent(int eventID, int setID, char *setName, int IDtype )
{
- HDFsetInfo info;
- info.setID = setID;
- info.setName = setName;
- if ( OUTPUT_SWITCH == RUNTIME_TRACE
- || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) {
- traceEvent( eventID, (char *)&info, 0 ) ;
- } else if ( OUTPUT_SWITCH == SUMMARY_TRACE
- || OUTPUT_SWITCH == MPI_SUMMARY_TRACE ) {
- HDFtraceEvent_RT( eventID, &info, 0 ) ;
- } else if ( OUTPUT_SWITCH != NO_TRACE ) {
- fprintf(stderr,"endHDFtraceEvent: ");
- fprintf(stderr,"invalid OUTPUT_SWITCH %d, IDtype = %d\n",
+ HDFsetInfo info;
+ info.setID = setID;
+ info.setName = setName;
+ if ( OUTPUT_SWITCH == RUNTIME_TRACE
+ || OUTPUT_SWITCH == MPI_RUNTIME_TRACE )
+ {
+ traceEvent( eventID, (char *)&info, 0 ) ;
+ }
+ else if ( OUTPUT_SWITCH == SUMMARY_TRACE
+ || OUTPUT_SWITCH == MPI_SUMMARY_TRACE )
+ {
+ HDFtraceEvent_RT( eventID, &info, 0 ) ;
+ }
+ else if ( OUTPUT_SWITCH != NO_TRACE )
+ {
+ fprintf(stderr,"endHDFtraceEvent: ");
+ fprintf(stderr,"invalid OUTPUT_SWITCH %d, IDtype = %d\n",
OUTPUT_SWITCH, IDtype ) ;
- }
+ }
}
-/******************************************************************************/
-
-/*+ Open routines +*/
-/*+ ------------- +*/
-/*+ +*/
-/*+ Routine: FILE *HDFtraceFOPEN( const char *filename, const char *type ) +*/
-/*+ substitute for fopen() +*/
-/*+ generates fopenBeginID, fopenEndID +*/
-/*+ record Open (fopenBegin) +*/
-/*+ Mode = -1 +*/
-/*+ +*/
-FILE *HDFtraceFOPEN( const char *filename, const char *type )
+/*****************************************************************************/
+/* The HDFtraceXXXX routines are substitutes for the standard I/O routines. */
+/* When libhdf5-inst.a is compiled, macros in HDFTrace.h substitute the name */
+/* HDFtraceWrite for write, HDFtraceRead for Read, etc. These routines are */
+/* then called when standard I/O is done. */
+/*****************************************************************************/
+/*****************************************************************************/
+/*+ Open routines +*/
+/*+ ------------- +*/
+/*+ +*/
+/*+ Routine: FILE *HDFtraceFOPEN( const char *filename, const char *type ) +*/
+/*+ substitute for fopen() +*/
+/*+ generates fopenBeginID, fopenEndID +*/
+/*+ record Open (fopenBegin) +*/
+/*+ Mode = -1 +*/
+/*+ +*/
+/*****************************************************************************/
+FILE*HDFtraceFOPEN( const char *filename, const char *type )
{
- FILE *fp;
- int fd, id;
- int flags = 0;
- struct open_args openArgs;
- size_t typeLen;
+ FILE *fp;
+ int fd, id;
+ int flags = 0;
+ struct open_args openArgs;
+ size_t typeLen;
- if ( IOtracingEnabled ) {
- strcpy( openArgs.filename, filename );
+ if ( IOtracingEnabled )
+ {
+ strcpy( openArgs.filename, filename );
- /* check for 'b' - usually if 2 chars, second is '+' */
- typeLen = strlen( type );
- if ( ( typeLen == 2 ) && ( type [1] == 'b' ) ) {
- typeLen = 1;
- }
+ /* check for 'b' - usually if 2 chars, second is '+' */
+ typeLen = strlen( type );
+ if ( ( typeLen == 2 ) && ( type [1] == 'b' ) )
+ {
+ typeLen = 1;
+ }
- if ( typeLen == 1 ) {
- switch( type[0] ) {
- case 'r':
- flags = flags | O_RDONLY;
- break;
- case 'w':
- flags = O_TRUNC | O_CREAT | O_WRONLY;
- break;
- case 'a':
- flags = flags | O_APPEND | O_CREAT | O_WRONLY;
- break;
- }
- } else {
- switch( type[0] ) {
- case 'r':
- flags = O_RDWR;
- break;
- case 'w':
- flags = O_TRUNC | O_CREAT | O_RDWR;
- break;
- case 'a':
- flags = O_APPEND | O_CREAT | O_RDWR;
- break;
- }
- }
- openArgs.flags = flags;
- openArgs.mode= -1;
+ if ( typeLen == 1 )
+ {
+ switch( type[0] )
+ {
+ case 'r':
+ flags = flags | O_RDONLY;
+ break;
+ case 'w':
+ flags = O_TRUNC | O_CREAT | O_WRONLY;
+ break;
+ case 'a':
+ flags = flags | O_APPEND | O_CREAT | O_WRONLY;
+ break;
+ }
+ }
+ else
+ {
+ switch( type[0] )
+ {
+ case 'r':
+ flags = O_RDWR;
+ break;
+ case 'w':
+ flags = O_TRUNC | O_CREAT | O_RDWR;
+ break;
+ case 'a':
+ flags = O_APPEND | O_CREAT | O_RDWR;
+ break;
+ }
+ }
+ openArgs.flags = flags;
+ openArgs.mode= -1;
- HDFtraceIOEvent( fopenBeginID, (void *)&openArgs, sizeof(openArgs) );
- }
+ HDFtraceIOEvent( fopenBeginID, (void *)&openArgs, sizeof(openArgs) );
+ }
- fp = fopen( filename, type );
- if ( fp != NULL ) {
- fd = fileno( fp );
- id = set_c_mappedID( fd );
- } else {
- id = -1;
- }
+ fp = fopen( filename, type );
+ if ( fp != NULL )
+ {
+ fd = fileno( fp );
+ id = set_c_mappedID( fd );
+ }
+ else
+ {
+ id = -1;
+ }
- if ( IOtracingEnabled ) {
- HDFtraceIOEvent( fopenEndID, (void *) &id, int_SIZE );
- }
+ if ( IOtracingEnabled )
+ {
+ HDFtraceIOEvent( fopenEndID, (void *) &id, int_SIZE );
+ }
- return( fp );
+ return( fp );
}
-/*+ Routine: int HDFtraceCREAT( const char *path, mode_t mode ) +*/
-/*+ substitute for creat() +*/
-/*+ generates openBeginID, openEndID +*/
-/*+ record Open (openBeginID) +*/
-/*+ +*/
-int HDFtraceCREAT( const char *path, mode_t mode )
+/*****************************************************************************/
+/*+ Routine: int HDFtraceCREAT( const char *path, mode_t mode ) +*/
+/*+ substitute for creat() +*/
+/*+ generates openBeginID, openEndID +*/
+/*+ record Open (openBeginID) +*/
+/*+ +*/
+/*****************************************************************************/
+int
+HDFtraceCREAT( const char *path, mode_t mode )
{
struct open_args openArgs;
int fd;
@@ -445,504 +507,583 @@ int HDFtraceCREAT( const char *path, mode_t mode )
return( fd );
}
-/******************************************************************************/
-
-/*+ Flush routines +*/
-/*+ -------------- +*/
-/*+ +*/
-/*+ Routine: int HDFtraceFFLUSH( FILE *stream ) +*/
-/*+ substitute for fflush() +*/
-/*+ generates fflushBeginID, fflushEndID +*/
-/*+ record Flush (fflushBeginID) +*/
-/*+ +*/
+/*****************************************************************************/
+/*+ Flush routines +*/
+/*+ -------------- +*/
+/*+ +*/
+/*+ Routine: int HDFtraceFFLUSH( FILE *stream ) +*/
+/*+ substitute for fflush() +*/
+/*+ generates fflushBeginID, fflushEndID +*/
+/*+ record Flush (fflushBeginID) +*/
+/*+ +*/
+/*****************************************************************************/
int HDFtraceFFLUSH( FILE *stream )
{
- int ret;
- int id;
- int fd;
+ int ret;
+ int id;
+ int fd;
- if ( IOtracingEnabled ) {
- /*
- * If stream is NULL, all files open for write are flushed.
- * We show this with a -2 in the trace record as too much overhead
- * to try and tell what files those are and generate individual
- * trace records.
- */
- if ( stream == NULL ) {
- id = -2;
- } else {
- fd = fileno( stream );
- id = c_mappedID( fd );
- HDFtraceIOEvent( fflushBeginID, (void *) 0, int_SIZE );
- }
- }
+ if ( IOtracingEnabled )
+ {
+ /*
+ * If stream is NULL, all files open for write are flushed.
+ * We show this with a -2 in the trace record as too much overhead
+ * to try and tell what files those are and generate individual
+ * trace records.
+ */
+ if ( stream == NULL )
+ {
+ id = -2;
+ }
+ else
+ {
+ fd = fileno( stream );
+ id = c_mappedID( fd );
+ HDFtraceIOEvent( fflushBeginID, (void *) 0, int_SIZE );
+ }
+ }
- ret = fflush( stream );
+ ret = fflush( stream );
- if ( IOtracingEnabled ) {
- HDFtraceIOEvent( fflushEndID, (void *) &id, 0 );
- }
+ if ( IOtracingEnabled )
+ {
+ HDFtraceIOEvent( fflushEndID, (void *) &id, 0 );
+ }
- /*
- * Note that if fflush called on stream open for reading, the file pointer
- * is moved to EOF if it isn't there already. We don't account for that
- * in our file positioning information.
- */
+ /*
+ * Note that if fflush called on stream open for reading, the file pointer
+ * is moved to EOF if it isn't there already. We don't account for that
+ * in our file positioning information.
+ */
- return( ret );
+ return( ret );
}
-/******************************************************************************/
-/*+ Close routines +*/
-/*+ -------------- +*/
-/*+ +*/
-/*+ Routine: int HDFtraceFCLOSE( FILE *stream ) +*/
-/*+ substitute for fclose() +*/
-/*+ generates fcloseBeginID, fcloseEndID +*/
-/*+ record Close (fcloseBeginID) +*/
-/*+ +*/
-int HDFtraceFCLOSE( FILE *stream )
+/*****************************************************************************/
+/*+ Close routines +*/
+/*+ -------------- +*/
+/*+ +*/
+/*+ Routine: int HDFtraceFCLOSE( FILE *stream ) +*/
+/*+ substitute for fclose() +*/
+/*+ generates fcloseBeginID, fcloseEndID +*/
+/*+ record Close (fcloseBeginID) +*/
+/*+ +*/
+/*****************************************************************************/
+int
+HDFtraceFCLOSE( FILE *stream )
{
- int ret;
- int id;
- int fd = fileno( stream );
+ int ret;
+ int id;
+ int fd = fileno( stream );
- if ( IOtracingEnabled ) {
- id = c_mappedID( fd );
- HDFtraceIOEvent( fcloseBeginID, (void *) &id, int_SIZE );
- }
+ if ( IOtracingEnabled )
+ {
+ id = c_mappedID( fd );
+ HDFtraceIOEvent( fcloseBeginID, (void *) &id, int_SIZE );
+ }
- ret = fclose( stream );
+ ret = fclose( stream );
- if ( IOtracingEnabled ) {
- HDFtraceIOEvent( fcloseEndID, (void *) 0, 0 );
- }
+ if ( IOtracingEnabled )
+ {
+ HDFtraceIOEvent( fcloseEndID, (void *) 0, 0 );
+ }
- return( ret );
+ return( ret );
}
-/*+ Routine: int HDFtrace3OPEN( char *path, int flags, mode_t mode ) +*/
-/*+ substitute for open() when called with 3 arguments +*/
-/*+ generates openBeginID, openEndID +*/
-/*+ record Open (openBeginID) +*/
-/*+ +*/
-int HDFtrace3OPEN( const char *path, int flags, mode_t mode )
+/*****************************************************************************/
+/*+ Routine: int HDFtrace3OPEN( char *path, int flags, mode_t mode ) +*/
+/*+ substitute for open() when called with 3 arguments +*/
+/*+ generates openBeginID, openEndID +*/
+/*+ record Open (openBeginID) +*/
+/*+ +*/
+/*****************************************************************************/
+int
+HDFtrace3OPEN( const char *path, int flags, mode_t mode )
{
- struct open_args openArgs;
- int fd;
- int id;
+ struct open_args openArgs;
+ int fd;
+ int id;
- if ( IOtracingEnabled ) {
- strcpy( openArgs.filename, path );
- openArgs.flags = flags;
- openArgs.mode = (int) mode;
+ if ( IOtracingEnabled )
+ {
+ strcpy( openArgs.filename, path );
+ openArgs.flags = flags;
+ openArgs.mode = (int) mode;
- HDFtraceIOEvent( openBeginID, (char *)&openArgs, sizeof(openArgs) );
- }
+ HDFtraceIOEvent( openBeginID, (char *)&openArgs, sizeof(openArgs) );
+ }
- fd = open( path, flags, mode );
- id = set_c_mappedID( fd );
+ fd = open( path, flags, mode );
+ id = set_c_mappedID( fd );
- if ( IOtracingEnabled ) {
- HDFtraceIOEvent( openEndID, (char *) &id, int_SIZE );
- }
+ if ( IOtracingEnabled )
+ {
+ HDFtraceIOEvent( openEndID, (char *) &id, int_SIZE );
+ }
- return( fd );
+ return( fd );
}
-/*+ Routine: int HDFtraceCLOSE( int fd ) +*/
-/*+ substitute for close() +*/
-/*+ generates closeBeginID, closeEndID +*/
-/*+ record Close (closeBeginID) +*/
-/*+ +*/
-int HDFtraceCLOSE( int fd )
+/*****************************************************************************/
+/*+ Routine: int HDFtraceCLOSE( int fd ) +*/
+/*+ substitute for close() +*/
+/*+ generates closeBeginID, closeEndID +*/
+/*+ record Close (closeBeginID) +*/
+/*+ +*/
+/*****************************************************************************/
+int
+HDFtraceCLOSE( int fd )
{
- int ret;
- int id;
+ int ret;
+ int id;
- if ( IOtracingEnabled ) {
- id = c_mappedID( fd );
- HDFtraceIOEvent( closeBeginID, (void *) &id, int_SIZE );
- }
+ if ( IOtracingEnabled )
+ {
+ id = c_mappedID( fd );
+ HDFtraceIOEvent( closeBeginID, (void *) &id, int_SIZE );
+ }
- ret = close( fd );
+ ret = close( fd );
- if ( IOtracingEnabled ) {
- HDFtraceIOEvent( closeEndID, (void *) 0, 0 );
- }
+ if ( IOtracingEnabled )
+ {
+ HDFtraceIOEvent( closeEndID, (void *) 0, 0 );
+ }
- return( ret );
+ return( ret );
}
-/******************************************************************************/
-/*+ Read routines +*/
-/*+ ------------- +*/
-/*+ +*/
-/*+ Routine: int HDFtraceREAD( int fd, char *buf, int nbyte ) +*/
-/*+ substitute for read() +*/
-/*+ generates readBeginID, readEndID +*/
-/*+ record Read (readBeginID) +*/
-/*+ Number Variables = 1 +*/
-/*+ Cause = -1 +*/
-/*+ +*/
-ssize_t HDFtraceREAD( int fd, void *buf, size_t nbyte )
+/*****************************************************************************/
+/*+ Read routines +*/
+/*+ ------------- +*/
+/*+ +*/
+/*+ Routine: int HDFtraceREAD( int fd, char *buf, int nbyte ) +*/
+/*+ substitute for read() +*/
+/*+ generates readBeginID, readEndID +*/
+/*+ record Read (readBeginID) +*/
+/*+ Number Variables = 1 +*/
+/*+ Cause = -1 +*/
+/*+ +*/
+/*****************************************************************************/
+ssize_t
+HDFtraceREAD( int fd, void *buf, size_t nbyte )
{
- struct read_write_args readArgs;
- ssize_t ret;
- int bytes;
- CLOCK t1, t2, incDur;
+ struct read_write_args readArgs;
+ ssize_t ret;
+ int bytes;
+ CLOCK t1, t2, incDur;
- if ( IOtracingEnabled ) {
- readArgs.fileID = c_mappedID( fd );
- readArgs.numVariables = 1;
- readArgs.cause = -1;
+ if ( IOtracingEnabled )
+ {
+ readArgs.fileID = c_mappedID( fd );
+ readArgs.numVariables = 1;
+ readArgs.cause = -1;
- HDFtraceIOEvent( readBeginID, (void *) &readArgs, sizeof(readArgs) );
- }
+ HDFtraceIOEvent( readBeginID, (void *) &readArgs, sizeof(readArgs) );
+ }
- t1 = getClock();
- ret = read( fd, buf, nbyte );
- t2 = getClock();
- incDur = clockSubtract(t2,t1);
- ReadTotals += clockToSeconds( incDur );
+ t1 = getClock();
+ ret = read( fd, buf, nbyte );
+ t2 = getClock();
+ incDur = clockSubtract(t2,t1);
+ ReadTotals += clockToSeconds( incDur );
- if ( IOtracingEnabled ) {
- if ( ret > 0 ) {
- bytes = (int)ret;
- } else {
- bytes = 0;
- }
- HDFtraceIOEvent( readEndID, (void *) &bytes, int_SIZE );
- }
+ if ( IOtracingEnabled )
+ {
+ if ( ret > 0 )
+ {
+ bytes = (int)ret;
+ }
+ else
+ {
+ bytes = 0;
+ }
+ HDFtraceIOEvent( readEndID, (void *) &bytes, int_SIZE );
+ }
- return( ret );
+ return( ret );
}
-
-/*+ Routine: int HDFtraceFREAD( char *ptr, int size, int nitems, +*/
-/*+ FILE *stream) +*/
-/*+ substitute for fread() +*/
-/*+ generates freadBeginID, freadEndID +*/
-/*+ record Read (freadBeginID) +*/
-/*+ Number Variables = nitems +*/
-/*+ Cause = -1 +*/
-/*+ +*/
-size_t HDFtraceFREAD( void *ptr, size_t size, size_t nitems, FILE *stream )
+
+/*****************************************************************************/
+/*+ Routine: int HDFtraceFREAD( char *ptr, int size, int nitems, +*/
+/*+ FILE *stream) +*/
+/*+ substitute for fread() +*/
+/*+ generates freadBeginID, freadEndID +*/
+/*+ record Read (freadBeginID) +*/
+/*+ Number Variables = nitems +*/
+/*+ Cause = -1 +*/
+/*+ +*/
+/*****************************************************************************/
+size_t
+HDFtraceFREAD( void *ptr, size_t size, size_t nitems, FILE *stream )
{
- struct read_write_args readArgs;
- size_t ret;
- int nbytes;
- int fd = fileno( stream );
- CLOCK t1, t2, incDur;
+ struct read_write_args readArgs;
+ size_t ret;
+ int nbytes;
+ int fd = fileno( stream );
+ CLOCK t1, t2, incDur;
- if ( IOtracingEnabled ) {
- readArgs.fileID = c_mappedID( fd );
- readArgs.numVariables = (int)nitems;
- readArgs.cause = -1;
- HDFtraceIOEvent( freadBeginID, (void *) &readArgs, sizeof(readArgs) );
- }
+ if ( IOtracingEnabled )
+ {
+ readArgs.fileID = c_mappedID( fd );
+ readArgs.numVariables = (int)nitems;
+ readArgs.cause = -1;
+ HDFtraceIOEvent( freadBeginID, (void *) &readArgs, sizeof(readArgs) );
+ }
- t1 = getClock();
- ret = fread( ptr, size, nitems, stream );
- t2 = getClock();
- incDur = clockSubtract(t2,t1);
- ReadTotals += clockToSeconds( incDur );
+ t1 = getClock();
+ ret = fread( ptr, size, nitems, stream );
+ t2 = getClock();
+ incDur = clockSubtract(t2,t1);
+ ReadTotals += clockToSeconds( incDur );
- if ( IOtracingEnabled ) {
- if ( ret > 0 ) {
- nbytes = (int)(ret * size) ;
- } else {
- nbytes = 0;
- }
- HDFtraceIOEvent( freadEndID, (void *) &nbytes, int_SIZE );
- }
+ if ( IOtracingEnabled )
+ {
+ if ( ret > 0 )
+ {
+ nbytes = (int)(ret * size) ;
+ }
+ else
+ {
+ nbytes = 0;
+ }
+ HDFtraceIOEvent( freadEndID, (void *) &nbytes, int_SIZE );
+ }
- return( ret );
+ return( ret );
}
-/******************************************************************************/
-/*+ Seek routines +*/
-/*+ ------------- +*/
-/*+ +*/
-/*+ Routine: off_t HDFtraceLSEEK( int fd, off_t offset, int whence ) +*/
-/*+ substitute for lseek() +*/
-/*+ generates lseekBeginID, lseekEndID +*/
-/*+ record Seek (lseekBeginID) +*/
+/*****************************************************************************/
+/*+ Seek routines +*/
+/*+ ------------- +*/
+/*+ +*/
+/*+ Routine: off_t HDFtraceLSEEK( int fd, off_t offset, int whence ) +*/
+/*+ substitute for lseek() +*/
+/*+ generates lseekBeginID, lseekEndID +*/
+/*+ record Seek (lseekBeginID) +*/
/*+ +*/
-off_t HDFtraceLSEEK( int fd, off_t offset, int whence )
+/*****************************************************************************/
+off_t
+HDFtraceLSEEK( int fd, off_t offset, int whence )
{
- struct seek_args seekArgs;
- off_t ret;
- long arg;
+ struct seek_args seekArgs;
+ off_t ret;
+ long arg;
- if ( IOtracingEnabled ) {
- seekArgs.fileID = c_mappedID( fd );
- seekArgs.offset = (int) offset;
- seekArgs.whence = whence;
+ if ( IOtracingEnabled )
+ {
+ seekArgs.fileID = c_mappedID( fd );
+ seekArgs.offset = (int) offset;
+ seekArgs.whence = whence;
- HDFtraceIOEvent( lseekBeginID, (void *) &seekArgs, sizeof(seekArgs) );
- }
+ HDFtraceIOEvent( lseekBeginID, (void *) &seekArgs, sizeof(seekArgs) );
+ }
- ret = lseek( fd, offset, whence );
+ ret = lseek( fd, offset, whence );
- if ( IOtracingEnabled ) {
- arg = (long) ret;
- HDFtraceIOEvent( lseekEndID, (void *)&arg, long_SIZE );
- }
+ if ( IOtracingEnabled )
+ {
+ arg = (long) ret;
+ HDFtraceIOEvent( lseekEndID, (void *)&arg, long_SIZE );
+ }
- return( ret );
+ return( ret );
}
-/*+ routine: int HDF traceFSEEK( FILE *stream, long offset, int whence ) +*/
-/*+ substitute for fseek() +*/
-/*+ generates fseekBeginID, fseekEndID +*/
-/*+ record Seek (fseekBeginID) +*/
-/*+ +*/
-int HDFtraceFSEEK( FILE *stream, long offset, int whence )
+/*****************************************************************************/
+/*+ routine: int HDF traceFSEEK( FILE *stream, long offset, int whence ) +*/
+/*+ substitute for fseek() +*/
+/*+ generates fseekBeginID, fseekEndID +*/
+/*+ record Seek (fseekBeginID) +*/
+/*+ +*/
+/*****************************************************************************/
+int
+HDFtraceFSEEK( FILE *stream, long offset, int whence )
{
- struct seek_args seekArgs;
- int ret;
- long arg;
- int fd = fileno( stream );
+ struct seek_args seekArgs;
+ int ret;
+ long arg;
+ int fd = fileno( stream );
- if ( IOtracingEnabled ) {
- seekArgs.fileID = c_mappedID( fd );;
- seekArgs.offset = (int) offset;
- seekArgs.whence = whence;
+ if ( IOtracingEnabled )
+ {
+ seekArgs.fileID = c_mappedID( fd );;
+ seekArgs.offset = (int) offset;
+ seekArgs.whence = whence;
- HDFtraceIOEvent( fseekBeginID, (void *) &seekArgs, sizeof(seekArgs) );
- }
+ HDFtraceIOEvent( fseekBeginID, (void *) &seekArgs, sizeof(seekArgs) );
+ }
- ret = fseek( stream, offset, whence );
+ ret = fseek( stream, offset, whence );
- if ( IOtracingEnabled ) {
- arg = ftell( stream );
- HDFtraceIOEvent( fseekEndID, (void *)&arg, long_SIZE );
- }
+ if ( IOtracingEnabled )
+ {
+ arg = ftell( stream );
+ HDFtraceIOEvent( fseekEndID, (void *)&arg, long_SIZE );
+ }
- return( ret );
+ return( ret );
}
#ifdef fpos_t
+/*****************************************************************************/
/*+ Routine: int HDFtraceFSETPOS( FILE *stream, const fpos_t *position ) +*/
-/*+ substitute for fsetpos() +*/
-/*+ generates fsetposBeginID, fsetposEndID +*/
-/*+ record Seek (fsetposBeginID) +*/
-/*+ +*/
-int HDFtraceFSETPOS( FILE stream, const fpos_t *position )
+/*+ substitute for fsetpos() +*/
+/*+ generates fsetposBeginID, fsetposEndID +*/
+/*+ record Seek (fsetposBeginID) +*/
+/*+ +*/
+/*****************************************************************************/
+int
+HDFtraceFSETPOS( FILE stream, const fpos_t *position )
{
- struct seek_args seekArgs;
- int ret;
- long arg;
- int fd = fileno( stream );
+ struct seek_args seekArgs;
+ int ret;
+ long arg;
+ int fd = fileno( stream );
- if ( IOtracingEnabled ) {
- seekArgs.fileID = c_mappedID( fd );;
- seekArgs.offset = (int) *position;
- seekArgs.whence = SEEK_SET;
+ if ( IOtracingEnabled )
+ {
+ seekArgs.fileID = c_mappedID( fd );;
+ seekArgs.offset = (int) *position;
+ seekArgs.whence = SEEK_SET;
- HDFtraceIOEvent( fsetposBeginID, (void *) &seekArgs, sizeof(seekArgs) );
- }
+ HDFtraceIOEvent( fsetposBeginID, (void *) &seekArgs, sizeof(seekArgs) );
+ }
- ret = fsetpos( stream, position );
+ ret = fsetpos( stream, position );
- if ( IOtracingEnabled ) {
- arg = (long) *position;
- HDFtraceIOEvent( fsetposEndID, (void *)&arg, long_SIZE );
- }
+ if ( IOtracingEnabled )
+ {
+ arg = (long) *position;
+ HDFtraceIOEvent( fsetposEndID, (void *)&arg, long_SIZE );
+ }
- return( ret );
+ return( ret );
}
#endif /* fpos_t */
-/*+ Routine: void HDFtraceREWIND ( FILE *stream ) +*/
-/*+ substitute for rewind() +*/
-/*+ generates rewindBeginID, rewindEndID +*/
-/*+ record Seek (rewindBeginID) +*/
-/*+ Offset = 0 +*/
-/*+ Whence = SEEK_SET +*/
-/*+ +*/
+/*****************************************************************************/
+/*+ Routine: void HDFtraceREWIND ( FILE *stream ) +*/
+/*+ substitute for rewind() +*/
+/*+ generates rewindBeginID, rewindEndID +*/
+/*+ record Seek (rewindBeginID) +*/
+/*+ Offset = 0 +*/
+/*+ Whence = SEEK_SET +*/
+/*+ +*/
+/*****************************************************************************/
void HDFtraceREWIND( FILE *stream )
{
- struct seek_args seekArgs;
- long arg;
- int fd = fileno( stream );
+ struct seek_args seekArgs;
+ long arg;
+ int fd = fileno( stream );
- if ( IOtracingEnabled ) {
- seekArgs.fileID = c_mappedID( fd );
- seekArgs.offset = 0;
- seekArgs.whence = SEEK_SET;
+ if ( IOtracingEnabled )
+ {
+ seekArgs.fileID = c_mappedID( fd );
+ seekArgs.offset = 0;
+ seekArgs.whence = SEEK_SET;
- HDFtraceIOEvent( rewindBeginID, (void *) &seekArgs, sizeof(seekArgs) );
- }
+ HDFtraceIOEvent( rewindBeginID, (void *) &seekArgs, sizeof(seekArgs) );
+ }
- rewind( stream );
+ rewind( stream );
- if ( IOtracingEnabled ) {
- arg = 0;
- HDFtraceIOEvent( rewindEndID, (void *)&arg, long_SIZE );
- }
+ if ( IOtracingEnabled )
+ {
+ arg = 0;
+ HDFtraceIOEvent( rewindEndID, (void *)&arg, long_SIZE );
+ }
- return;
+ return;
}
-/******************************************************************************/
-/*+ Write routines +*/
-/*+ -------------- +*/
-/*+ +*/
-/*+ Routine: int HDFtraceWRITE( int fd, char *buf, int nbyte ) +*/
-/*+ substitute for write() +*/
-/*+ generates writeBeginID, writeEndID +*/
-/*+ record Write (writeBeginID) +*/
-/*+ Number Variables = 1 +*/
-/*+ Cause = -1 +*/
-/*+ +*/
+/*****************************************************************************/
+/*+ Write routines +*/
+/*+ -------------- +*/
+/*+ +*/
+/*+ Routine: int HDFtraceWRITE( int fd, char *buf, int nbyte ) +*/
+/*+ substitute for write() +*/
+/*+ generates writeBeginID, writeEndID +*/
+/*+ record Write (writeBeginID) +*/
+/*+ Number Variables = 1 +*/
+/*+ Cause = -1 +*/
+/*+ +*/
+/*****************************************************************************/
ssize_t HDFtraceWRITE( int fd, const void *buf, size_t nbyte )
{
- struct read_write_args writeArgs;
- ssize_t ret;
- int bytes;
- CLOCK t1, t2, incDur;
+ struct read_write_args writeArgs;
+ ssize_t ret;
+ int bytes;
+ CLOCK t1, t2, incDur;
- if ( IOtracingEnabled ) {
- writeArgs.fileID = c_mappedID( fd );
- writeArgs.numVariables = 1;
- writeArgs.cause = -1;
+ if ( IOtracingEnabled )
+ {
+ writeArgs.fileID = c_mappedID( fd );
+ writeArgs.numVariables = 1;
+ writeArgs.cause = -1;
- HDFtraceIOEvent( writeBeginID, (void *) &writeArgs, sizeof(writeArgs) );
- }
+ HDFtraceIOEvent( writeBeginID, (void *) &writeArgs, sizeof(writeArgs) );
+ }
- t1 = getClock();
- ret = write( fd, buf, nbyte );
- t2 = getClock();
- incDur = clockSubtract(t2,t1);
- WriteTotals += clockToSeconds( incDur );
+ t1 = getClock();
+ ret = write( fd, buf, nbyte );
+ t2 = getClock();
+ incDur = clockSubtract(t2,t1);
+ WriteTotals += clockToSeconds( incDur );
- if ( IOtracingEnabled ) {
- if ( ret > 0 ) {
- bytes = (int)ret;
- } else {
- bytes = 0;
- }
- HDFtraceIOEvent( writeEndID, (void *) &bytes, int_SIZE );
- }
- return( ret );
+ if ( IOtracingEnabled )
+ {
+ if ( ret > 0 )
+ {
+ bytes = (int)ret;
+ }
+ else
+ {
+ bytes = 0;
+ }
+ HDFtraceIOEvent( writeEndID, (void *) &bytes, int_SIZE );
+ }
+ return( ret );
}
-/*+ Routine: size_t HDFtraceFWRITE( const char *ptr, int size, int nitems, +*/
-/*+ FILE *stream ) +*/
-/*+ substitute for fwrite() +*/
-/*+ generates fwriteBeginID, fwriteEndID +*/
-/*+ record Write (fwriteBeginID) +*/
-/*+ Number Variables = nitems +*/
-/*+ Cause = -1 +*/
-/*+ +*/
-size_t HDFtraceFWRITE(const void *ptr,size_t size,size_t nitems,FILE *stream )
+/*****************************************************************************/
+/*+ Routine: size_t HDFtraceFWRITE( const char *ptr, int size, int nitems,+*/
+/*+ FILE *stream ) +*/
+/*+ substitute for fwrite() +*/
+/*+ generates fwriteBeginID, fwriteEndID +*/
+/*+ record Write (fwriteBeginID) +*/
+/*+ Number Variables = nitems +*/
+/*+ Cause = -1 +*/
+/*+ +*/
+/*****************************************************************************/
+size_t
+HDFtraceFWRITE(const void *ptr,size_t size,size_t nitems,FILE *stream )
{
- struct read_write_args writeArgs;
- size_t ret;
- int nbytes;
- int fd = fileno( stream );
- CLOCK t1, t2, incDur;
+ struct read_write_args writeArgs;
+ size_t ret;
+ int nbytes;
+ int fd = fileno( stream );
+ CLOCK t1, t2, incDur;
- if ( IOtracingEnabled ) {
- writeArgs.fileID = c_mappedID( fd );
- writeArgs.numVariables = (int)nitems;
- writeArgs.cause = -1;
+ if ( IOtracingEnabled )
+ {
+ writeArgs.fileID = c_mappedID( fd );
+ writeArgs.numVariables = (int)nitems;
+ writeArgs.cause = -1;
- HDFtraceIOEvent( fwriteBeginID, (void *) &writeArgs, sizeof(writeArgs) );
- }
+ HDFtraceIOEvent(fwriteBeginID, (void *)&writeArgs, sizeof(writeArgs));
+ }
- t1 = getClock();
- ret = fwrite( ptr, size, nitems, stream );
- t2 = getClock();
- incDur = clockSubtract(t2,t1);
- WriteTotals += clockToSeconds( incDur );
+ t1 = getClock();
+ ret = fwrite( ptr, size, nitems, stream );
+ t2 = getClock();
+ incDur = clockSubtract(t2,t1);
+ WriteTotals += clockToSeconds( incDur );
- if ( IOtracingEnabled ) {
- if ( ret > 0 ) {
- nbytes = (int)(ret * size) ;
- } else {
- nbytes = 0;
- }
- HDFtraceIOEvent( fwriteEndID, (void *) &nbytes, int_SIZE );
- }
+ if ( IOtracingEnabled )
+ {
+ if ( ret > 0 )
+ {
+ nbytes = (int)(ret * size) ;
+ }
+ else
+ {
+ nbytes = 0;
+ }
+ HDFtraceIOEvent( fwriteEndID, (void *) &nbytes, int_SIZE );
+ }
- return( ret );
+ return( ret );
}
-/*+ Routine: int HDFtracePUTS( char *s ) +*/
-/*+ substitute for puts() +*/
-/*+ generates fwriteBeginID, fwriteEndID +*/
-/*+ record Write (fwriteBeginID) +*/
-/*+ Number Variables = 1 +*/
-/*+ Cause = -1 +*/
-/*+ +*/
-int HDFtracePUTS( char *s )
+/*****************************************************************************/
+/*+ Routine: int HDFtracePUTS( char *s ) +*/
+/*+ substitute for puts() +*/
+/*+ generates fwriteBeginID, fwriteEndID +*/
+/*+ record Write (fwriteBeginID) +*/
+/*+ Number Variables = 1 +*/
+/*+ Cause = -1 +*/
+/*+ +*/
+/*****************************************************************************/
+int
+HDFtracePUTS( char *s )
{
- struct read_write_args writeArgs;
- int ret;
- int fd = fileno( stdout );
+ struct read_write_args writeArgs;
+ int ret;
+ int fd = fileno( stdout );
- if ( IOtracingEnabled ) {
- writeArgs.fileID = c_mappedID( fd );
- writeArgs.numVariables = 1;
- writeArgs.cause = -1;
+ if ( IOtracingEnabled )
+ {
+ writeArgs.fileID = c_mappedID( fd );
+ writeArgs.numVariables = 1;
+ writeArgs.cause = -1;
- HDFtraceIOEvent( fwriteBeginID, (void *) &writeArgs, sizeof(writeArgs) );
- }
+ HDFtraceIOEvent( fwriteBeginID, (void *) &writeArgs, sizeof(writeArgs) );
+ }
- ret = puts( s );
+ ret = puts( s );
- if ( IOtracingEnabled ) {
- HDFtraceIOEvent( fwriteEndID, (void *) &ret, int_SIZE );
- }
+ if ( IOtracingEnabled )
+ {
+ HDFtraceIOEvent( fwriteEndID, (void *) &ret, int_SIZE );
+ }
- return( ret );
+ return( ret );
}
-/*+ Routine: int HDFtraceFPUTC( int c, FILE *stream ) +*/
-/*+ substitute for fputc() +*/
-/*+ generates fwriteBeginID, fwriteEndID +*/
-/*+ record Write (fwriteBeginID) +*/
-/*+ Number Variables = 1 +*/
-/*+ Cause = -1 +*/
-/*+ +*/
-int HDFtraceFPUTC( int c, FILE *stream )
+/*****************************************************************************/
+/*+ Routine: int HDFtraceFPUTC( int c, FILE *stream ) +*/
+/*+ substitute for fputc() +*/
+/*+ generates fwriteBeginID, fwriteEndID +*/
+/*+ record Write (fwriteBeginID) +*/
+/*+ Number Variables = 1 +*/
+/*+ Cause = -1 +*/
+/*+ +*/
+/*****************************************************************************/
+int
+HDFtraceFPUTC( int c, FILE *stream )
{
- struct read_write_args writeArgs;
- int ret;
- int nbytes = char_SIZE;
- int fd = fileno( stream );
+ struct read_write_args writeArgs;
+ int ret;
+ int nbytes = char_SIZE;
+ int fd = fileno( stream );
- if ( IOtracingEnabled ) {
- writeArgs.fileID = c_mappedID( fd );
- writeArgs.numVariables = 1;
- writeArgs.cause = -1;
+ if ( IOtracingEnabled )
+ {
+ writeArgs.fileID = c_mappedID( fd );
+ writeArgs.numVariables = 1;
+ writeArgs.cause = -1;
- HDFtraceIOEvent( fwriteBeginID, (void *) &writeArgs, sizeof(writeArgs) );
- }
+ HDFtraceIOEvent( fwriteBeginID, (void *) &writeArgs, sizeof(writeArgs) );
+ }
- ret = fputc( c, stream );
+ ret = fputc( c, stream );
- if ( IOtracingEnabled ) {
- if ( ret == EOF ) {
- nbytes = 0;
- HDFtraceIOEvent( fwriteEndID, (void *) &nbytes, int_SIZE );
- }
- }
+ if ( IOtracingEnabled )
+ {
+ if ( ret == EOF )
+ {
+ nbytes = 0;
+ HDFtraceIOEvent( fwriteEndID, (void *) &nbytes, int_SIZE );
+ }
+ }
return( ret );
}
-/*+ Routine: int HDFtraceFPUTS( char *s, FILE *stream ) +*/
-/*+ substitute for fputs() +*/
-/*+ generates fwriteBeginID, fwriteEndID +*/
-/*+ record Write (fwriteBeginID) +*/
-/*+ Number Variables = 1 +*/
-/*+ Cause = -1 +*/
-/*+ +*/
+/*****************************************************************************/
+/*+ Routine: int HDFtraceFPUTS( char *s, FILE *stream ) +*/
+/*+ substitute for fputs() +*/
+/*+ generates fwriteBeginID, fwriteEndID +*/
+/*+ record Write (fwriteBeginID) +*/
+/*+ Number Variables = 1 +*/
+/*+ Cause = -1 +*/
+/*+ +*/
+/*****************************************************************************/
int HDFtraceFPUTS( const char *s, FILE *stream )
{
struct read_write_args writeArgs;
@@ -1061,6 +1202,276 @@ void PabloHDFTrace( int ID )
}
}
#ifdef H5_HAVE_PARALLEL
+#include "MPIO_Trace.h"
+#include "MPIO_EventArgs.h"
+#include "MPIO_Data.h"
+
+/* Global variable declarations and definitions. */
+static int HDFlocalNode = 0;
+int HDFmyNode;
+int myHDFid = 3;
+/* Function prototypes */
+int HDF_get_mode( int );
+int HDF_get_source( int );
+int HDF_get_comm( MPI_Comm );
+int HDF_get_Datatype( MPI_Datatype );
+int HDF_get_DataRep( char* );
+int HDF_get_Bytes( MPI_Datatype, int );
+int HDF_MPI_Get_count( MPI_Status *, MPI_Datatype, int *, int );
+/************************************************************************/
+/* MPI_Get_count isn't always implemented correctly and may cause the */
+/* program to fail. This is a kluge to allow the program to complete. */
+/************************************************************************/
+int HDF_MPI_Get_count( MPI_Status* status,
+ MPI_Datatype t,
+ int* result,
+ int input )
+{
+#ifdef LAM_MPI
+ *result = input;
+#else
+ MPI_Get_count( status, t, result );
+#endif
+ return;
+}
+
+/* Get the mode at the file openning */
+int HDF_get_mode( int amode )
+{
+ if( amode == MPI_MODE_RDONLY || amode == MPI_MODE_RDWR ||
+ amode == MPI_MODE_WRONLY || amode == MPI_MODE_CREATE ||
+ amode == MPI_MODE_EXCL || amode == MPI_MODE_DELETE_ON_CLOSE ||
+ amode == MPI_MODE_UNIQUE_OPEN ||
+ /* amode == MPI_MODE_SEQUENTIAL || */
+ amode == MPI_MODE_APPEND )
+ return amode;
+ else
+ return PABLO_MPI_MODE_NULL;
+}
+
+/* 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. *
@@ -1084,7 +1495,7 @@ int HDF_MPI_File_open( MPI_Comm comm, char *filename, int amode,
dataPtr.setName = (char *)malloc( strlen(filename) + 1);
strcpy( dataPtr.setName , filename );
HDFtraceEvent_RT( HDFmpiOpenID, &dataPtr, dataLen );
- returnVal = PMPI_File_open( comm, filename, amode, info, fh );
+ returnVal = MPI_File_open( comm, filename, amode, info, fh );
dataPtr.setID = (long)fh;
HDFtraceEvent_RT( -HDFmpiOpenID, &dataPtr, dataLen );
}
@@ -1114,41 +1525,13 @@ int HDF_MPI_File_close( MPI_File *fh )
dataPtr.setID = (long)fh;
dataPtr.setName = NULL;
HDFtraceEvent_RT( HDFmpiCloseID, &dataPtr, dataLen );
- returnVal = PMPI_File_close( fh );
+ 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_delete( char *filename, MPI_Info info )
-{
- int returnVal;
- HDFsetInfo dataPtr;
- int dataLen;
-
- if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE )
- {
- returnVal = PabloMPI_File_delete( filename, info );
- }
- else
- {
- dataLen = sizeof( HDFsetInfo );
- dataPtr.setID = 0;
- dataPtr.setName = (char *)malloc( sizeof(filename) );
- strcpy( dataPtr.setName , filename );
- HDFtraceEvent_RT( HDFmpiDeleteID, &dataPtr, dataLen );
- returnVal = PMPI_File_delete( filename, info );
- HDFtraceEvent_RT( -HDFmpiDeleteID, &dataPtr, dataLen );
- free( dataPtr.setName );
- }
- return returnVal;
-}
/*======================================================================*
// Pass call through to regular MPIO entry except in case of Real Time *
@@ -1170,7 +1553,7 @@ int HDF_MPI_File_set_size( MPI_File fh, MPI_Offset size )
dataLen = 1;
dataPtr.setID = (long)fh;
HDFtraceEvent_RT( HDFmpiSetSizeID,&dataPtr,dataLen );
- returnVal = PMPI_File_set_size( fh, size );
+ returnVal = MPI_File_set_size( fh, size );
HDFtraceEvent_RT( -HDFmpiSetSizeID, &dataPtr, dataLen );
}
return returnVal;
@@ -1194,7 +1577,7 @@ int HDF_MPI_File_get_size( MPI_File fh, MPI_Offset *size )
dataPtr.setID = (long)fh;
HDFtraceEvent_RT( HDFmpiGetSizeID,
&dataPtr,dataLen );
- returnVal = PMPI_File_get_size( fh, size);
+ returnVal = MPI_File_get_size( fh, size);
HDFtraceEvent_RT( -HDFmpiGetSizeID,
&dataPtr,dataLen );
}
@@ -1206,56 +1589,6 @@ int HDF_MPI_File_get_size( MPI_File fh, MPI_Offset *size )
// tracing. *
// Note: The regular MPIO entry may or may not be instrumented. *
//======================================================================*/
-int HDF_MPI_File_get_group( MPI_File fh, MPI_Group *group )
-{
- int returnVal;
- HDFsetInfo dataPtr;
- int dataLen;
-
- if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
- returnVal = PabloMPI_File_get_group( fh, group);
- } else {
- dataLen = 1;
- dataPtr.setID = (long)fh;
- HDFtraceEvent_RT( HDFmpiGetGroupID,
- &dataPtr,dataLen );
- returnVal = PMPI_File_get_group( fh, group);
- HDFtraceEvent_RT( -HDFmpiGetGroupID,
- &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_amode( MPI_File fh, int *amode )
-{
- int returnVal;
- HDFsetInfo dataPtr;
- int dataLen;
-
- if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
- returnVal = PabloMPI_File_get_amode( fh, amode);
- } else {
- dataLen = 1;
- dataPtr.setID = (long)fh;
- HDFtraceEvent_RT( HDFmpiGetAmodeID,
- &dataPtr,dataLen );
- returnVal = PMPI_File_get_amode( fh, amode);
- HDFtraceEvent_RT( -HDFmpiGetAmodeID,
- &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 )
{
@@ -1271,7 +1604,7 @@ int HDF_MPI_File_set_view( MPI_File fh, MPI_Offset disp, MPI_Datatype etype,
dataPtr.setID = (long)fh;
HDFtraceEvent_RT( HDFmpiSetViewID,
&dataPtr,dataLen );
- returnVal = PMPI_File_set_view( fh, disp, etype, filetype,
+ returnVal = MPI_File_set_view( fh, disp, etype, filetype,
datarep, info );
HDFtraceEvent_RT( -HDFmpiSetViewID,
&dataPtr,dataLen );
@@ -1301,9 +1634,9 @@ int HDF_MPI_File_get_view( MPI_File fh, MPI_Offset *disp, MPI_Datatype *etype,
dataPtr.setID = (long)fh;
HDFtraceEvent_RT( HDFmpiSetViewID,
&dataPtr,dataLen );
- returnVal = PMPI_File_get_view(fh, disp, etype, filetype, datarep);
+ returnVal = MPI_File_get_view(fh, disp, etype, filetype, datarep);
HDFtraceEvent_RT( -HDFmpiSetViewID, &dataPtr,dataLen );
- returnVal = PMPI_File_get_view(fh, disp, etype, filetype, datarep);
+ returnVal = MPI_File_get_view(fh, disp, etype, filetype, datarep);
}
return returnVal;
@@ -1331,9 +1664,9 @@ int HDF_MPI_File_read_at( MPI_File fh, MPI_Offset offset, void *buf,
dataPtr.numBytes = HDF_get_Bytes( datatype, count );
HDFtraceEvent_RT( HDFmpiReadAtID,
&dataPtr,dataLen );
- returnVal = PMPI_File_read_at( fh, offset, buf, count, datatype,
+ returnVal = MPI_File_read_at( fh, offset, buf, count, datatype,
status );
- MPI_Get_count(status,datatype,&rCount);
+ HDF_MPI_Get_count(status,datatype,&rCount,count);
if ( rCount < 0 || rCount > count )
{
dataPtr.numBytes = -1;
@@ -1371,9 +1704,9 @@ int HDF_MPI_File_read_at_all( MPI_File fh, MPI_Offset offset, void *buf,
dataPtr.numBytes = HDF_get_Bytes( datatype, count );
HDFtraceEvent_RT( HDFmpiReadAtAllID,
&dataPtr,dataLen );
- returnVal = PMPI_File_read_at_all( fh, offset, buf,
+ returnVal = MPI_File_read_at_all( fh, offset, buf,
count, datatype, status );
- MPI_Get_count(status,datatype,&rCount);
+ HDF_MPI_Get_count(status,datatype,&rCount,count);
if ( rCount < 0 || rCount > count )
{
dataPtr.numBytes = -1;
@@ -1413,9 +1746,9 @@ int HDF_MPI_File_write_at( MPI_File fh, MPI_Offset offset, void *buf,
dataPtr.setID = (long)fh;
dataPtr.numBytes = HDF_get_Bytes( datatype, count );
HDFtraceEvent_RT( HDFmpiWriteAtID, &dataPtr,dataLen );
- returnVal = PMPI_File_write_at( fh, offset, buf, count, datatype,
+ returnVal = MPI_File_write_at( fh, offset, buf, count, datatype,
status );
- MPI_Get_count(status,datatype,&rCount);
+ HDF_MPI_Get_count(status,datatype,&rCount,count);
if ( rCount < 0 || rCount > count )
{
dataPtr.numBytes = -1;
@@ -1440,7 +1773,7 @@ int HDF_MPI_File_write_at_all( MPI_File fh, MPI_Offset offset, void *buf,
int returnVal;
HDFsetInfo dataPtr;
int dataLen;
- int rCount;
+ int numBytes;
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = PabloMPI_File_write_at_all( fh, offset, buf,
@@ -1451,17 +1784,17 @@ int HDF_MPI_File_write_at_all( MPI_File fh, MPI_Offset offset, void *buf,
dataPtr.numBytes = HDF_get_Bytes( datatype, count );
HDFtraceEvent_RT( HDFmpiWriteAtAllID,
&dataPtr,dataLen );
- returnVal = PMPI_File_write_at_all( fh, offset, buf,
+ returnVal = MPI_File_write_at_all( fh, offset, buf,
count, datatype, status );
- MPI_Get_count(status,datatype,&rCount);
- if ( rCount < 0 || rCount > count )
+ if ( returnVal == MPI_SUCCESS )
{
- dataPtr.numBytes = -1;
+ numBytes = HDF_get_Bytes( datatype, count );
}
else
{
- dataPtr.numBytes = HDF_get_Bytes( datatype, rCount );
+ numBytes = -1;
}
+ dataPtr.numBytes = numBytes;
HDFtraceEvent_RT( -HDFmpiWriteAtAllID,
&dataPtr,dataLen );
}
@@ -1486,7 +1819,7 @@ int HDF_MPI_File_sync( MPI_File fh )
dataPtr.setID = (long)fh;
HDFtraceEvent_RT( HDFmpiSyncID,
&dataPtr,dataLen );
- returnVal = PMPI_File_sync ( fh );
+ returnVal = MPI_File_sync ( fh );
HDFtraceEvent_RT( -HDFmpiSyncID,
&dataPtr,dataLen );
}
@@ -1501,4 +1834,502 @@ int HDF_get_Bytes( MPI_Datatype datatype, int count )
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 */
+ traceIOEvent( mpiOpenBeginID, (char *) &mpiOpenBeginArguments,
+ sizeof( mpiOpenBeginArguments ) );
+
+ returnVal = MPI_File_open( comm, filename, amode, info, fh );
+
+ mpiOpenEndArguments.localNode = HDF_get_source( HDFlocalNode );
+ mpiOpenEndArguments.globalNode = HDFmyNode;
+ /* the fileID is mapped to the fp's address */
+ myHDFid++;
+ mpiOpenEndArguments.fileID = myHDFid;
+
+ /* Generate exit record */
+ traceIOEvent( mpiOpenEndID, (char *) &mpiOpenEndArguments,
+ sizeof( mpiOpenEndArguments ) );
+
+ return returnVal;
+}
+
+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 */
+ traceIOEvent( mpiCloseBeginID, (char *) &mpiCloseBeginArguments,
+ sizeof( mpiCloseBeginArguments ) );
+
+ returnVal = MPI_File_close( fh );
+
+ mpiCloseEndArguments.localNode = HDFlocalNode;
+ mpiCloseEndArguments.globalNode = HDFmyNode;
+ mpiCloseEndArguments.fileID = myHDFid;
+
+ /* Generate exit record */
+ traceIOEvent( mpiCloseEndID, (char *) &mpiCloseEndArguments,
+ sizeof( mpiCloseEndArguments ) );
+
+ return returnVal;
+}
+
+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 */
+ traceIOEvent( mpiSetSizeBeginID, (char *) &mpiSetSizeBeginArguments,
+ sizeof( mpiSetSizeBeginArguments ) );
+
+ returnVal = MPI_File_set_size( fh, size );
+
+ mpiSetSizeEndArguments.localNode = HDFlocalNode;
+ mpiSetSizeEndArguments.globalNode = HDFmyNode;
+ /* mpiSetSizeEndArguments.fileID = (long) ( &fh ); */
+ mpiSetSizeEndArguments.fileID = myHDFid;
+
+ /* Generate entry record */
+ traceIOEvent( mpiSetSizeEndID, (char *) &mpiSetSizeEndArguments,
+ sizeof( mpiSetSizeEndArguments ) );
+
+ return returnVal;
+}
+
+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 */
+ traceIOEvent( mpiGetSizeBeginID, (char *) &mpiGetSizeBeginArguments,
+ sizeof( mpiGetSizeBeginArguments ) );
+
+ returnVal = MPI_File_get_size( fh, size);
+
+ mpiGetSizeEndArguments.localNode = HDFlocalNode;
+ mpiGetSizeEndArguments.globalNode = HDFmyNode;
+ /* mpiGetSizeEndArguments.fileID = (long) ( &fh ); */
+ mpiGetSizeEndArguments.fileID = myHDFid;
+
+ mpiGetSizeEndArguments.fileSize = (long) (*size);
+
+ /* Generate entry record */
+ traceIOEvent( mpiGetSizeEndID, (char *) &mpiGetSizeEndArguments,
+ sizeof( mpiGetSizeEndArguments ) );
+
+ return returnVal;
+}
+
+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 */
+ traceIOEvent( mpiSetViewBeginID, (char *) &mpiSetViewBeginArguments,
+ sizeof( mpiSetViewBeginArguments ) );
+
+ returnVal = MPI_File_set_view( fh, disp, etype, filetype,
+ datarep, info );
+
+ mpiSetViewEndArguments.localNode = HDFlocalNode;
+ mpiSetViewEndArguments.globalNode = HDFmyNode;
+ /* mpiSetViewEndArguments.fileID = (long) ( &fh ); */
+ mpiSetViewEndArguments.fileID = myHDFid;
+
+ /* Generate entry record */
+ traceIOEvent( mpiSetViewEndID, (char *) &mpiSetViewEndArguments,
+ sizeof( mpiSetViewEndArguments ) );
+
+ return returnVal;
+}
+
+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 */
+ traceIOEvent( mpiGetViewBeginID, (char *) &mpiGetViewBeginArguments,
+ sizeof( mpiGetViewBeginArguments ) );
+
+ returnVal = MPI_File_get_view( fh, disp, etype, filetype, datarep );
+
+ mpiGetViewEndArguments.localNode = HDFlocalNode;
+ mpiGetViewEndArguments.globalNode = HDFmyNode;
+ /* mpiGetViewEndArguments.fileID = (long) ( &fh ); */
+ mpiGetViewEndArguments.fileID = myHDFid;
+
+ mpiGetViewEndArguments.disp = (long) ( *disp );
+ mpiGetViewEndArguments.etype = HDF_get_Datatype( *etype );
+ mpiGetViewEndArguments.fileType = HDF_get_Datatype( *filetype );
+ mpiGetViewEndArguments.dataRep = HDF_get_DataRep( datarep );
+
+ /* Generate entry record */
+ traceIOEvent( mpiGetViewEndID, (char *) &mpiGetViewEndArguments,
+ sizeof( mpiGetViewEndArguments ) );
+
+ return returnVal;
+}
+
+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 */
+ traceIOEvent( mpiReadAtBeginID, (char *) &mpiReadAtBeginArguments,
+ sizeof( mpiReadAtBeginArguments ) );
+
+ returnVal = MPI_File_read_at( fh, offset, buf, count, datatype, status );
+
+ mpiReadAtEndArguments.localNode = HDFlocalNode;
+ mpiReadAtEndArguments.globalNode = HDFmyNode;
+ /* mpiReadAtEndArguments.fileID = (long) ( &fh ); */
+ mpiReadAtEndArguments.fileID = myHDFid;
+
+ HDF_MPI_Get_count( status, datatype, &bcount, count );
+ mpiReadAtEndArguments.rCount = bcount;
+ mpiReadAtEndArguments.numBytes = HDF_get_Bytes( datatype, bcount );
+
+ /* Generate entry record */
+ traceIOEvent( mpiReadAtEndID, (char *) &mpiReadAtEndArguments,
+ sizeof( mpiReadAtEndArguments ) );
+
+ return returnVal;
+}
+
+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 */
+ traceIOEvent( mpiReadAtAllBeginID, (char *) &mpiReadAtAllBeginArguments,
+ sizeof( mpiReadAtAllBeginArguments ) );
+
+ returnVal = MPI_File_read_at_all( fh, offset, buf,
+ count, datatype, status );
+
+ mpiReadAtAllEndArguments.localNode = HDFlocalNode;
+ mpiReadAtAllEndArguments.globalNode = HDFmyNode;
+ /* mpiReadAtAllEndArguments.fileID = (long) ( &fh ); */
+ mpiReadAtAllEndArguments.fileID = myHDFid;
+
+ HDF_MPI_Get_count( status, datatype, &bcount, count );
+ mpiReadAtAllEndArguments.rCount = bcount;
+ mpiReadAtAllEndArguments.numBytes = HDF_get_Bytes( datatype, bcount );
+
+ /* Generate entry record */
+ traceIOEvent( mpiReadAtAllEndID, (char *) &mpiReadAtAllEndArguments,
+ sizeof( mpiReadAtAllEndArguments ) );
+
+ return returnVal;
+}
+
+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 */
+ traceIOEvent( mpiWriteAtBeginID, (char *) &mpiWriteAtBeginArguments,
+ sizeof( mpiWriteAtBeginArguments ) );
+
+ returnVal = MPI_File_write_at( fh, offset, buf, count,
+ datatype, status );
+
+ mpiWriteAtEndArguments.localNode = HDFlocalNode;
+ mpiWriteAtEndArguments.globalNode = HDFmyNode;
+ /* mpiWriteAtEndArguments.fileID = (long) ( &fh ); */
+ mpiWriteAtEndArguments.fileID = myHDFid;
+
+ HDF_MPI_Get_count( status, datatype, &bcount, count );
+ mpiWriteAtEndArguments.wCount = bcount;
+ mpiWriteAtEndArguments.numBytes = HDF_get_Bytes( datatype, bcount );
+
+ /* Generate entry record */
+ traceIOEvent( mpiWriteAtEndID, (char *) &mpiWriteAtEndArguments,
+ sizeof( mpiWriteAtEndArguments ) );
+
+ return returnVal;
+}
+
+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 */
+ traceIOEvent( mpiWriteAtAllBeginID, (char *) &mpiWriteAtAllBeginArguments,
+ sizeof( mpiWriteAtAllBeginArguments ) );
+
+ returnVal = MPI_File_write_at_all( fh, offset, buf,
+ count, datatype, status );
+
+ mpiWriteAtAllEndArguments.localNode = HDFlocalNode;
+ mpiWriteAtAllEndArguments.globalNode = HDFmyNode;
+ /* mpiWriteAtAllEndArguments.fileID = (long) ( &fh ); */
+ mpiWriteAtAllEndArguments.fileID = myHDFid;
+
+ if ( returnVal == MPI_SUCCESS )
+ {
+ bcount = count;
+ numBytes = HDF_get_Bytes( datatype, count );
+ }
+ else
+ {
+ bcount = -1;
+ numBytes = -1;
+ }
+ mpiWriteAtAllEndArguments.wCount = bcount;
+ mpiWriteAtAllEndArguments.numBytes = numBytes;
+
+ /* Generate entry record */
+ traceIOEvent( mpiWriteAtAllEndID, (char *) &mpiWriteAtAllEndArguments,
+ sizeof( mpiWriteAtAllEndArguments ) );
+
+ return returnVal;
+}
+
+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 */
+ traceIOEvent( mpiSyncBeginID,
+ (char *) &mpiSyncBeginArguments,
+ sizeof( mpiSyncBeginArguments ) );
+
+ returnVal = MPI_File_sync ( fh );
+
+ mpiSyncEndArguments.localNode = HDFlocalNode;
+ mpiSyncEndArguments.globalNode = HDFmyNode;
+ /* mpiSyncEndArguments.fileID = (long) ( &fh ); */
+ mpiSyncEndArguments.fileID = myHDFid;
+
+ /* Generate entry record */
+ traceIOEvent( mpiSyncEndID, (char *) &mpiSyncEndArguments,
+ sizeof( mpiSyncEndArguments ) );
+
+ return returnVal;
+}
+
#endif /* H5_HAVE_PARALLEL */
diff --git a/pablo/PabloHDF_SDDF.c b/pablo/PabloHDF_SDDF.c
index d5468c6..bf42112 100644
--- a/pablo/PabloHDF_SDDF.c
+++ b/pablo/PabloHDF_SDDF.c
@@ -260,7 +260,7 @@ void HDFinitTrace_SDDF( char *traceFileName, int OUTSW )
// MPIO initialization be performed and handle the naming of *
// trace files. *
//===========================================================*/
- initMPIOTrace( traceFileName, RUNTIME_TRACE );
+ initMPIOTrace( traceFileName, SUPPRESS_MPIO_TRACE );
#else
/*============================================================
// MPIO tracing is not supported. *
diff --git a/pablo/ProcTrace.h b/pablo/ProcTrace.h
index 405f0e6..ef8c16b 100644
--- a/pablo/ProcTrace.h
+++ b/pablo/ProcTrace.h
@@ -97,6 +97,7 @@ NO_TRACE,
NUM_HDF_IDS
} ;
+#define SUPPRESS_MPIO_TRACE 2
#define ID_HDF_Last_Entry ID_ALLHDF
void HDFinitTrace( const char *, int trace_id, ... );
generated by cgit v0.12 at 2024-11-09 14:28:19 (GMT)