mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2025-04-12 17:31:09 +08:00
Code Issues Packages Projects Releases Wiki Activity

[svn-r3619]

Browse Source 
Purpose:
    These changes allow the user to determine bytes requested and bytes
    received by MPI I/O calls.
Description:
    User wished to know if the number of bytes requested in MPI I/O calls was
    save as the number actually received.
Solution:
    Added additional fields to the HDFrecord structure for bytes requested and
    bytes received.  Other files reflect these changes.
Platforms tested:
    Solaris
    IRIX64 parallel
This commit is contained in:
Dan Wells 2001-03-13 13:28:03 -05:00
parent 6c915a1fa6
commit a5d53d6dac
7 changed files with 837 additions and 853 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
pablo/HDFTrace.h
View File

@ -132,6 +132,7 @@ extern char *hdfRecordPointer;
#define FAMILY_HDFPROCNAME 0300
typedef struct {
long numBytes;
long setID;
char *setName;
} HDFsetInfo ;

11
pablo/HDFmpioProtos.h
View File

@ -55,13 +55,6 @@ 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,
@ -70,10 +63,6 @@ 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 );

67
pablo/HDFrecord_RT.h
View File

@ -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. *

49
pablo/Makefile.in
View File

@ -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
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 PabloHDFff.o
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

614
pablo/PabloHDF.c
View File

@ -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 );
@ -207,7 +208,7 @@ void hinittracex_( char *file, int *len, int flags[], int *nflags,
// procedures. *
//==============================================================*/
if ( *nflags == 0 || procTrace[ID_ALLHDF] ) {
for ( i = ID_HDF_Last_Entry + 1; i < NUM_HDF_IDS; ++i ) {
for ( i = 0; i < NUM_HDF_IDS; ++i ) {
procTrace[i] = 1;
}
}
@ -270,7 +271,7 @@ void HDFinitTrace( const char *traceFileName, int id_flag, ... )
// procedures. *
//==============================================================*/
if ( nIDs == 0 || procTrace[ID_ALLHDF] ) {
for ( i = ID_HDF_Last_Entry + 1; i < NUM_HDF_IDS; ++i ) {
for ( i = 0; i < NUM_HDF_IDS; ++i ) {
procTrace[i] = 1;
}
}
@ -1059,7 +1060,7 @@ void PabloHDFTrace( int ID )
exit (-1);
}
}
#ifdef HAVE_PARALLEL
#ifdef H5_HAVE_PARALLEL
/*======================================================================*
// Pass call through to regular MPIO entry except in case of Real Time *
// tracing. *
@ -1068,22 +1069,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 = PMPI_File_open( comm, filename, amode, info, fh );
dataPtr.setID = (long)fh;
HDFtraceEvent_RT( -HDFmpiOpenID, &dataPtr, dataLen );
}
return returnVal;
}
@ -1099,18 +1104,21 @@ 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;
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 = PMPI_File_close( fh );
HDFtraceEvent_RT( -HDFmpiCloseID, &dataPtr, dataLen );
free( dataPtr.setName );
}
return returnVal;
}
/*======================================================================*
@ -1120,23 +1128,26 @@ int HDF_MPI_File_close( MPI_File *fh )
//======================================================================*/
int HDF_MPI_File_delete( char *filename, MPI_Info info )
{
int returnVal;
HDFsetInfo dataPtr;
int dataLen;
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_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;
}
/*======================================================================*
@ -1146,43 +1157,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;
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;
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 = PMPI_File_set_size( fh, size );
HDFtraceEvent_RT( -HDFmpiSetSizeID, &dataPtr, dataLen );
}
return returnVal;
}
/*======================================================================*
@ -1197,9 +1188,10 @@ 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);
@ -1221,9 +1213,10 @@ int HDF_MPI_File_get_group( MPI_File fh, MPI_Group *group )
int dataLen;
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = MPI_File_get_group( fh, group);
returnVal = PabloMPI_File_get_group( fh, group);
} else {
dataLen = 0;
dataLen = 1;
dataPtr.setID = (long)fh;
HDFtraceEvent_RT( HDFmpiGetGroupID,
&dataPtr,dataLen );
returnVal = PMPI_File_get_group( fh, group);
@ -1245,9 +1238,10 @@ int HDF_MPI_File_get_amode( MPI_File fh, int *amode )
int dataLen;
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = MPI_File_get_amode( fh, amode);
returnVal = PabloMPI_File_get_amode( fh, amode);
} else {
dataLen = 0;
dataLen = 1;
dataPtr.setID = (long)fh;
HDFtraceEvent_RT( HDFmpiGetAmodeID,
&dataPtr,dataLen );
returnVal = PMPI_File_get_amode( fh, amode);
@ -1270,10 +1264,11 @@ 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,
@ -1292,23 +1287,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;
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,
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 = PMPI_File_get_view(fh, disp, etype, filetype, datarep);
HDFtraceEvent_RT( -HDFmpiSetViewID, &dataPtr,dataLen );
returnVal = PMPI_File_get_view(fh, disp, etype, filetype, datarep);
}
return returnVal;
}
return returnVal;
}
/*======================================================================*
@ -1322,16 +1320,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,
status );
MPI_Get_count(status,datatype,&rCount);
if ( rCount < 0 || rCount > count )
{
dataPtr.numBytes = -1;
}
else
{
dataPtr.numBytes = HDF_get_Bytes( datatype, rCount );
}
HDFtraceEvent_RT( -HDFmpiReadAtID,
&dataPtr,dataLen );
}
@ -1350,16 +1360,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,
count, datatype, status );
MPI_Get_count(status,datatype,&rCount);
if ( rCount < 0 || rCount > count )
{
dataPtr.numBytes = -1;
}
else
{
dataPtr.numBytes = HDF_get_Bytes( datatype, rCount );
}
HDFtraceEvent_RT( -HDFmpiReadAtAllID,
&dataPtr,dataLen );
}
@ -1375,23 +1397,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;
int returnVal;
HDFsetInfo dataPtr;
int dataLen;
int rCount;
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;
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 = PMPI_File_write_at( fh, offset, buf, count, datatype,
status );
MPI_Get_count(status,datatype,&rCount);
if ( rCount < 0 || rCount > count )
{
dataPtr.numBytes = -1;
}
else
{
dataPtr.numBytes = HDF_get_Bytes( datatype, rCount );
}
HDFtraceEvent_RT( -HDFmpiWriteAtID, &dataPtr,dataLen );
}
return returnVal;
}
/*======================================================================*
@ -1405,316 +1440,34 @@ int HDF_MPI_File_write_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_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,
count, datatype, status );
MPI_Get_count(status,datatype,&rCount);
if ( rCount < 0 || rCount > count )
{
dataPtr.numBytes = -1;
}
else
{
dataPtr.numBytes = HDF_get_Bytes( datatype, rCount );
}
HDFtraceEvent_RT( -HDFmpiWriteAtAllID,
&dataPtr,dataLen );
}
return returnVal;
}
/*======================================================================*
// Pass call through to regular MPIO entry except in case of Real Time *
// tracing. *
// Note: The regular MPIO entry may or may not be instrumented. *
//======================================================================*/
int HDF_MPI_File_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 returnVal;
HDFsetInfo dataPtr;
int dataLen;
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = MPI_File_read( fh, buf, count, datatype, status );
} else {
dataLen = 0;
HDFtraceEvent_RT( HDFmpiReadID,
&dataPtr,dataLen );
returnVal = PMPI_File_read( fh, buf, count, datatype, status );
HDFtraceEvent_RT( -HDFmpiReadID,
&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 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;
}
/*======================================================================*
// 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 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;
}
/*======================================================================*
// 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 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;
}
/*======================================================================*
// 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 )
{
return MPI_File_iread( fh, 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( MPI_File fh, void *buf, int count,
MPI_Datatype datatype, MPIO_Request *request )
{
return MPI_File_iwrite( fh, 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_seek( MPI_File fh, MPI_Offset offset, int whence )
{
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;
}
/*======================================================================*
// 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 returnVal;
HDFsetInfo dataPtr;
int dataLen;
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;
}
/*======================================================================*
// 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 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;
}
/*======================================================================*
// 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 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;
}
/*======================================================================*
// 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 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;
}
/*======================================================================*
// 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 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;
}
/*======================================================================*
// Pass call through to regular MPIO entry except in case of Real Time *
// tracing. *
@ -1727,9 +1480,10 @@ int HDF_MPI_File_sync( MPI_File fh )
int dataLen;
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = MPI_File_sync ( fh );
returnVal = PabloMPI_File_sync ( fh );
} else {
dataLen = 0;
dataLen = 1;
dataPtr.setID = (long)fh;
HDFtraceEvent_RT( HDFmpiSyncID,
&dataPtr,dataLen );
returnVal = PMPI_File_sync ( fh );
@ -1739,4 +1493,12 @@ int HDF_MPI_File_sync( MPI_File fh )
return returnVal;
}
#endif /* HAVE_PARALLEL */
int HDF_get_Bytes( MPI_Datatype datatype, int count )
{
int nm_bytes;
MPI_Type_size( datatype, &nm_bytes );
return( nm_bytes * count );
}
#endif /* H5_HAVE_PARALLEL */

932
pablo/PabloHDF_RT.c
View File

File diff suppressed because it is too large Load Diff

16
pablo/PabloHDF_SDDF.c
View File

@ -57,14 +57,14 @@
//======================================================================*/
#include <stdio.h>
#ifdef HAVE_PARALLEL
#ifdef H5_HAVE_PARALLEL
#include "mpi.h"
#endif
#include "H5config.h"
#undef HAVE_PABLO
#undef H5_HAVE_PABLO
#include "H5private.h"
#define HAVE_PABLO
#define H5_HAVE_PABLO
#include "ProcIDs.h"
#include "SystemDepend.h"
@ -105,7 +105,7 @@ void endIOTrace( void );
#define returnRecord(x) return x;
#ifdef HAVE_MPIOTRACE
#ifdef H5_HAVE_MPIOTRACE
int initMPIOTrace( char *, int );
void endMPIOTrace( void ) ;
#else
@ -233,7 +233,7 @@ void HDFinitTrace_SDDF( char *traceFileName, int OUTSW )
// set traceFileName and set IO tracing switches. If MPIO *
// tracing is available, MPIO tracing will also be initialized. *
//==============================================================*/
#ifdef HAVE_PARALLEL
#ifdef H5_HAVE_PARALLEL
/*===============================================================
// The code is built to handle parallel processing using MPI. *
// However, the code may or may not be run using MPI and there *
@ -254,7 +254,7 @@ 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 *
@ -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 */