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