diff options
| -rw-r--r-- | pablo/Makefile.in | 2 | ||||
| -rw-r--r-- | pablo/PabloHDF.c | 40 | ||||
| -rw-r--r-- | pablo/PabloHDF_MPIO.c | 44 | ||||
| -rw-r--r-- | pablo/PabloHDF_RT.c | 367 | ||||
| -rw-r--r-- | pablo/PabloHDF_SDDF.c | 934 | ||||
| -rw-r--r-- | pablo/ProcTrace.h | 2 |
6 files changed, 671 insertions, 718 deletions
diff --git a/pablo/Makefile.in b/pablo/Makefile.in index d4cc451..5b7c9ea 100644 --- a/pablo/Makefile.in +++ b/pablo/Makefile.in @@ -164,7 +164,7 @@ PABLO_CLEAN=HDFentryNames.h HDFidList.h ProcMasks.h HDFentries.txt \ HDFentries.txt: $(top_srcdir)/src/*.c grep "FUNC_ENTER[_INIT ]*(" $(top_srcdir)/src/*.c | \ - sed "s/.*FUNC_ENTER[_INIT ]*(//;s/[,)].*//" | sort -u > $@ + sed "s/.*FUNC_ENTER[_INIT ]*( *//;s/[,)].*//" | sort -u > $@ HDFentryNames.h: HDFentries.txt sed "s/.*/\"&\",/" $? > $@ diff --git a/pablo/PabloHDF.c b/pablo/PabloHDF.c index fd4f2b8..4c8357a 100644 --- a/pablo/PabloHDF.c +++ b/pablo/PabloHDF.c @@ -151,12 +151,12 @@ void endHDFtraceEvent (int , int , char *, int ); void hdfCaptureInit( const char* name, int captureType ); void hdfCaptureEnd( void ); #else -void HDFinitTrace_RT ( const char *, int ); -void HDFinitTrace_SDDF ( const char *, int ); +void HDFinitTrace_RT ( const char * ); +void HDFinitTrace_SDDF ( const char * ); void hinittracex_ ( char [], int *, int[], int *,unsigned * ); void hdfendtrace_ ( void ) ; -void HDFendTrace_RT (int); -void HDFendTrace_SDDF(int); +void HDFendTrace_RT (void ); +void HDFendTrace_SDDF( void ); void HDFfinalTimeStamp( void ); void HDFtraceEvent_RT ( int , HDFsetInfo *, unsigned ); void HDFtraceIOEvent( int , void *, unsigned ); @@ -246,13 +246,13 @@ hinittracex_( char *file, if ( OUTPUT_SWITCH == RUNTIME_TRACE || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) { - HDFinitTrace_SDDF( traceFileName, OUTPUT_SWITCH ); + HDFinitTrace_SDDF( traceFileName ); IOtracingEnabled = 1; } else if ( OUTPUT_SWITCH == SUMMARY_TRACE || OUTPUT_SWITCH == MPI_SUMMARY_TRACE ) { - HDFinitTrace_RT( traceFileName, OUTPUT_SWITCH ); + HDFinitTrace_RT( traceFileName ); IOtracingEnabled = 1; } else if ( OUTPUT_SWITCH == NO_TRACE ) @@ -328,13 +328,13 @@ HDFinitTrace( const char *traceFileName, int id_flag, ... ) if ( OUTPUT_SWITCH == RUNTIME_TRACE || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) { - HDFinitTrace_SDDF( traceFileName, OUTPUT_SWITCH ); + HDFinitTrace_SDDF( traceFileName ); IOtracingEnabled = 1; } else if ( OUTPUT_SWITCH == SUMMARY_TRACE || OUTPUT_SWITCH == MPI_SUMMARY_TRACE ) { - HDFinitTrace_RT( traceFileName, OUTPUT_SWITCH ); + HDFinitTrace_RT( traceFileName ); IOtracingEnabled = 1; } else if ( OUTPUT_SWITCH == NO_TRACE ) @@ -370,14 +370,14 @@ void HDFendTrace(void) hdfCaptureEnd(); #else if ( OUTPUT_SWITCH == RUNTIME_TRACE - || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) + || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) { - HDFendTrace_SDDF( OUTPUT_SWITCH ); + HDFendTrace_SDDF( ); } else if ( OUTPUT_SWITCH == SUMMARY_TRACE - || OUTPUT_SWITCH == MPI_SUMMARY_TRACE ) + || OUTPUT_SWITCH == MPI_SUMMARY_TRACE ) { - HDFendTrace_RT( OUTPUT_SWITCH ); + HDFendTrace_RT(); } #endif /* PCF_BUILD */ } @@ -773,7 +773,6 @@ HDFtraceREAD( int fd, void *buf, size_t nbyte ) #else struct read_write_args readArgs; int bytes; - CLOCK t1, t2, incDur; if ( IOtracingEnabled ) { @@ -784,10 +783,7 @@ HDFtraceREAD( int fd, void *buf, size_t nbyte ) HDFtraceIOEvent( readBeginID, (void *) &readArgs, sizeof(readArgs) ); } - t1 = getClock(); ret = read( fd, buf, nbyte ); - t2 = getClock(); - incDur = clockSubtract(t2,t1); if ( IOtracingEnabled ) { @@ -826,7 +822,6 @@ HDFtraceFREAD( void *ptr, size_t size, size_t nitems, FILE *stream ) struct read_write_args readArgs; int nbytes; int fd = fileno( stream ); - CLOCK t1, t2, incDur; if ( IOtracingEnabled ) { @@ -836,10 +831,7 @@ HDFtraceFREAD( void *ptr, size_t size, size_t nitems, FILE *stream ) HDFtraceIOEvent( freadBeginID, (void *) &readArgs, sizeof(readArgs) ); } - t1 = getClock(); ret = fread( ptr, size, nitems, stream ); - t2 = getClock(); - incDur = clockSubtract(t2,t1); if ( IOtracingEnabled ) { @@ -1039,7 +1031,6 @@ HDFtraceWRITE( int fd, const void *buf, size_t nbyte ) #else struct read_write_args writeArgs; int bytes; - CLOCK t1, t2, incDur; if ( IOtracingEnabled ) { @@ -1050,10 +1041,7 @@ HDFtraceWRITE( int fd, const void *buf, size_t nbyte ) HDFtraceIOEvent( writeBeginID, (void *) &writeArgs, sizeof(writeArgs) ); } - t1 = getClock(); ret = write( fd, buf, nbyte ); - t2 = getClock(); - incDur = clockSubtract(t2,t1); if ( IOtracingEnabled ) { @@ -1092,7 +1080,6 @@ HDFtraceFWRITE(const void *ptr,size_t size,size_t nitems,FILE *stream ) struct read_write_args writeArgs; int nbytes; int fd = fileno( stream ); - CLOCK t1, t2, incDur; if ( IOtracingEnabled ) { @@ -1103,10 +1090,7 @@ HDFtraceFWRITE(const void *ptr,size_t size,size_t nitems,FILE *stream ) HDFtraceIOEvent(fwriteBeginID, (void *)&writeArgs, sizeof(writeArgs)); } - t1 = getClock(); ret = fwrite( ptr, size, nitems, stream ); - t2 = getClock(); - incDur = clockSubtract(t2,t1); if ( IOtracingEnabled ) { diff --git a/pablo/PabloHDF_MPIO.c b/pablo/PabloHDF_MPIO.c index 0eee178..13ed41a 100644 --- a/pablo/PabloHDF_MPIO.c +++ b/pablo/PabloHDF_MPIO.c @@ -821,10 +821,10 @@ PabloMPI_File_open( MPI_Comm comm, struct mpiOpenBeginArgs mpiOpenBeginArguments; struct mpiOpenEndArgs mpiOpenEndArguments; -#ifdef DEBUG +#ifdef PABLODEBUG fprintf( debugFile, "PabloMPI_File_open\n" ); fflush( debugFile ); -#endif /* DEBUG */ +#endif /* PABLODEBUG */ MPI_Comm_rank( comm, &HDFlocalNode ); MPI_Comm_rank( MPI_COMM_WORLD, &HDFmyNode ); @@ -864,10 +864,10 @@ PabloMPI_File_close( MPI_File *fh ) struct mpiCloseBeginArgs mpiCloseBeginArguments; struct mpiCloseEndArgs mpiCloseEndArguments; -#ifdef DEBUG +#ifdef PABLODEBUG fprintf( debugFile, "MPI_File_close\n" ); fflush( debugFile ); -#endif /* DEBUG */ +#endif /* PABLODEBUG */ mpiCloseBeginArguments.localNode = HDFlocalNode; mpiCloseBeginArguments.globalNode = HDFmyNode; @@ -900,10 +900,10 @@ PabloMPI_File_set_size( MPI_File fh, MPI_Offset size ) struct mpiSetSizeBeginArgs mpiSetSizeBeginArguments; struct mpiSetSizeEndArgs mpiSetSizeEndArguments; -#ifdef DEBUG +#ifdef PABLODEBUG fprintf( debugFile, "MPI_File_set_size\n" ); fflush( debugFile ); -#endif /* DEBUG */ +#endif /* PABLODEBUG */ mpiSetSizeBeginArguments.localNode = HDFlocalNode; mpiSetSizeBeginArguments.globalNode = HDFmyNode; @@ -939,10 +939,10 @@ PabloMPI_File_get_size( MPI_File fh, MPI_Offset *size ) struct mpiGetSizeBeginArgs mpiGetSizeBeginArguments; struct mpiGetSizeEndArgs mpiGetSizeEndArguments; -#ifdef DEBUG +#ifdef PABLODEBUG fprintf( debugFile, "MPI_File_get_size\n" ); fflush( debugFile ); -#endif /* DEBUG */ +#endif /* PABLODEBUG */ mpiGetSizeBeginArguments.localNode = HDFlocalNode; mpiGetSizeBeginArguments.globalNode = HDFmyNode; @@ -984,10 +984,10 @@ PabloMPI_File_set_view( MPI_File fh, struct mpiSetViewBeginArgs mpiSetViewBeginArguments; struct mpiSetViewEndArgs mpiSetViewEndArguments; -#ifdef DEBUG +#ifdef PABLODEBUG fprintf( debugFile, "MPI_File_set_view\n" ); fflush( debugFile ); -#endif /* DEBUG */ +#endif /* PABLODEBUG */ mpiSetViewBeginArguments.localNode = HDFlocalNode; mpiSetViewBeginArguments.globalNode = HDFmyNode; @@ -1036,10 +1036,10 @@ PabloMPI_File_get_view( MPI_File fh, struct mpiGetViewBeginArgs mpiGetViewBeginArguments; struct mpiGetViewEndArgs mpiGetViewEndArguments; -#ifdef DEBUG +#ifdef PABLODEBUG fprintf( debugFile, "MPI_File_get_view\n" ); fflush( debugFile ); -#endif /* DEBUG */ +#endif /* PABLODEBUG */ mpiGetViewBeginArguments.localNode = HDFlocalNode; mpiGetViewBeginArguments.globalNode = HDFmyNode; @@ -1083,10 +1083,10 @@ PabloMPI_File_read_at( MPI_File fh, struct mpiReadAtBeginArgs mpiReadAtBeginArguments; struct mpiReadAtEndArgs mpiReadAtEndArguments; -#ifdef DEBUG +#ifdef PABLODEBUG fprintf( debugFile, "MPI_File_read_at\n" ); fflush( debugFile ); -#endif /* DEBUG */ +#endif /* PABLODEBUG */ mpiReadAtBeginArguments.localNode = HDFlocalNode; mpiReadAtBeginArguments.globalNode = HDFmyNode; @@ -1143,10 +1143,10 @@ PabloMPI_File_read_at_all( MPI_File fh, struct mpiReadAtAllBeginArgs mpiReadAtAllBeginArguments; struct mpiReadAtAllEndArgs mpiReadAtAllEndArguments; -#ifdef DEBUG +#ifdef PABLODEBUG fprintf( debugFile, "MPI_File_read_at_all\n" ); fflush( debugFile ); -#endif /* DEBUG */ +#endif /* PABLODEBUG */ mpiReadAtAllBeginArguments.localNode = HDFlocalNode; mpiReadAtAllBeginArguments.globalNode = HDFmyNode; @@ -1208,10 +1208,10 @@ PabloMPI_File_write_at( MPI_File fh, struct mpiWriteAtBeginArgs mpiWriteAtBeginArguments; struct mpiWriteAtEndArgs mpiWriteAtEndArguments; -#ifdef DEBUG +#ifdef PABLODEBUG fprintf( debugFile, "MPI_File_write_at\n" ); fflush( debugFile ); -#endif /* DEBUG */ +#endif /* PABLODEBUG */ mpiWriteAtBeginArguments.localNode = HDFlocalNode; mpiWriteAtBeginArguments.globalNode = HDFmyNode; @@ -1266,10 +1266,10 @@ PabloMPI_File_write_at_all( MPI_File fh, struct mpiWriteAtAllBeginArgs mpiWriteAtAllBeginArguments; struct mpiWriteAtAllEndArgs mpiWriteAtAllEndArguments; -#ifdef DEBUG +#ifdef PABLODEBUG fprintf( debugFile, "MPI_File_write_at\n" ); fflush( debugFile ); -#endif /* DEBUG */ +#endif /* PABLODEBUG */ mpiWriteAtAllBeginArguments.localNode = HDFlocalNode; mpiWriteAtAllBeginArguments.globalNode = HDFmyNode; @@ -1326,10 +1326,10 @@ PabloMPI_File_sync( MPI_File fh ) struct mpiSyncBeginArgs mpiSyncBeginArguments; struct mpiSyncEndArgs mpiSyncEndArguments; -#ifdef DEBUG +#ifdef PABLODEBUG fprintf( debugFile, "MPI_File_sync\n" ); fflush( debugFile ); -#endif /* DEBUG */ +#endif /* PABLODEBUG */ mpiSyncBeginArguments.localNode = HDFlocalNode; mpiSyncBeginArguments.globalNode = HDFmyNode; diff --git a/pablo/PabloHDF_RT.c b/pablo/PabloHDF_RT.c index c1289a4..d15c47b 100644 --- a/pablo/PabloHDF_RT.c +++ b/pablo/PabloHDF_RT.c @@ -143,7 +143,7 @@ #include "HDFrecord_RT.h" -#ifdef H5_HAVE_PARALLEL +#ifdef H5_HAVE_MPIOTRACE #include "mpi.h" #include "MPIO_EventArgs.h" #endif @@ -184,7 +184,7 @@ fileRec_t *HDFfileList; // Internal Function prototypes * //======================================================================*/ void HDFinitTrace_RT( char *, int ); -void HDFendTrace_RT( int ); +void HDFendTrace_RT(); int initproctracert_( void ); int initHDFProcTrace_RT( void ); void HDFtraceEvent_RT( int , char *, unsigned ) ; @@ -223,51 +223,32 @@ extern char HDFprocNames[][40]; // NAME * // HDFinitTrace_RT-- initialize HDF real-time tracing * // USAGE * -// VOID HDFinitTrace_RT( fileName, OUTSW ) * +// VOID HDFinitTrace_RT( fileName ) * // * // char *fileName; IN: name of output file * -// int OUTSW ; IN: Type of tracing * // RETURNS * // None. * //======================================================================*/ void HDFinitTrace_RT( char *fileName, int OUTSW ) { -#ifdef H5_HAVE_PARALLEL - int myNode; -#endif - int error; - TRgetClock( &epoch ); - error = initHDFProcTrace_RT() ; - if ( error != SUCCESS ) { - fprintf (stderr,"Unable to Initialize properly. Exiting program\n"); - exit(-1); - } - FileName = ( char * ) malloc ( strlen( fileName ) + 10 ); -#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. * - // A check is made to see if MPI has been initialized. If so, * - // a trace file is assigned to the current node with the number * - // of the node as a suffix; if not, only one file is opened * - // and it is not given a suffix. * - //==============================================================*/ - if ( OUTSW == MPI_SUMMARY_TRACE ) { - MPI_Comm_rank( MPI_COMM_WORLD, &myNode ); - setTraceProcessorNumber( myNode ); - sprintf(FileName,"%s.nd%d",fileName,myNode); - } else { - strcpy( FileName, fileName ) ; - } -#else - /*==============================================================* - case, set the trace file name and * - // initialize the trace library. * - //==============================================================*/ - strcpy( FileName, fileName ) ; -#endif /* H5_HAVE_PARALLEL */ - setTraceFileName(FileName); - basicLibraryInit( ); + int error; + TRgetClock( &epoch ); + error = initHDFProcTrace_RT() ; + if ( error != SUCCESS ) + { + fprintf (stderr,"Unable to Initialize properly. Exiting program\n"); + exit(-1); + } + FileName = ( char * ) malloc ( strlen( fileName ) + 10 ); + /*===================================================================* + // Here the library was built to linked with the MPI and MPIO * + // libraries. However, the use may chose not to run with MPI. * + // A check is made to see if MPI has been initialized. If so, * + // a trace file is assigned to the current node with the number * + // of the node as a suffix; if not, only one file is opened * + // and it is not given a suffix. * + //===================================================================*/ + IOtraceInit( fileName, OUTSW ); } /*======================================================================* // NAME * @@ -277,37 +258,37 @@ void HDFinitTrace_RT( char *fileName, int OUTSW ) // RETURNS * // None. * //======================================================================*/ -void HDFendTrace_RT( int OUTSW ) +void HDFendTrace_RT( ) { - int j, numSetIDs; - HDFnode_t *P; - char **Names; + int j, numSetIDs; + HDFnode_t *P; + char **Names; - HDFfinalTimeStamp(); - /*==============================================================* - // Assing pablo ids to named identifiers and tag records * - //==============================================================*/ - HDFassignPabloIDs( &numSetIDs, &Names ); - /*==============================================================* - // Create a file name for the File map file. * - // Disable for now. * - //==============================================================*/ + HDFfinalTimeStamp(); + /*===================================================================* + // Assing pablo ids to named identifiers and tag records * + //===================================================================*/ + HDFassignPabloIDs( &numSetIDs, &Names ); + /*===================================================================* + // Create a file name for the File map file. * + // Disable for now. * + //===================================================================*/ /* mapFile = (char *)malloc( strlen(FileName) + 4 ); - strcpy(mapFile,FileName); - strcat(mapFile,".map"); */ - /*==============================================================* - // print the file mappings. * - //==============================================================*/ + strcpy(mapFile,FileName); + strcat(mapFile,".map"); */ + /*===================================================================* + // print the file mappings. * + //===================================================================*/ /* printFileMappingsRT( mapFile, Names, numSetIDs ); */ - /*==============================================================* - // Print SDDF summary records * - //==============================================================*/ - writeHDFRecDescrptrsRT(); - writeHDFNamePacketsRT( Names, numSetIDs ); + /*===================================================================* + // Print SDDF summary records * + //===================================================================*/ + writeHDFRecDescrptrsRT(); + writeHDFNamePacketsRT( Names, numSetIDs ); for ( j = 0; j < NumHDFProcs; ++j ) { - HDFSummarySDDF( HDFQueues[j], j ); - } - endTracing(); + HDFSummarySDDF( HDFQueues[j], j ); + } + endTracing(); } /*======================================================================* // initHFDProcTrace_RT * @@ -318,71 +299,80 @@ void HDFendTrace_RT( int OUTSW ) int initproctracert_( void ) { - return initHDFProcTrace_RT(); + return initHDFProcTrace_RT(); } int initHDFProcTrace_RT( void ) - { - int i, j, size; - int numProcs = NumHDFProcs; + int i; + int j; + int size; + int numProcs = NumHDFProcs; - if ( traceProcessorNumber == -1 ) { - traceProcessorNumber = TRgetDefaultProcessor(); - } - /*==============================================================* - // Initialize InitNode used for node initialization. * - //==============================================================*/ - InitNode.ptr = NULL; - InitNode.eventID = 0; - InitNode.lastIOtime = zeroClock; - InitNode.record.nCalls = 0; - InitNode.record.lastCall = zeroClock; - InitNode.record.incDur = zeroClock; - InitNode.record.excDur = zeroClock; - InitNode.record.hdfID = 0; - InitNode.record.xRef = 0; - for ( j = 0; j < nTallyFields; ++j ) { + if ( traceProcessorNumber == -1 ) + { + traceProcessorNumber = TRgetDefaultProcessor(); + } + /*===================================================================* + // Initialize InitNode used for node initialization. * + //===================================================================*/ + InitNode.ptr = NULL; + InitNode.eventID = 0; + InitNode.lastIOtime = zeroClock; + InitNode.record.nCalls = 0; + InitNode.record.lastCall = zeroClock; + InitNode.record.incDur = zeroClock; + InitNode.record.excDur = zeroClock; + InitNode.record.hdfID = 0; + InitNode.record.xRef = 0; + for ( j = 0; j < nTallyFields; ++j ) + { InitNode.record.times[j] = zeroClock; - } - for ( j = 0; j < nTallyFields; ++j ) { + } + for ( j = 0; j < nTallyFields; ++j ) + { InitNode.record.counts[j] = 0; - } - for ( j = 0; j < nByteFields; ++j ) { + } + for ( j = 0; j < nByteFields; ++j ) + { InitNode.record.bytes[j] = 0; - } - for ( i = 0; i < nByteFields; ++i ) { - for ( j = 0; j < nBkts; ++j ) { - InitNode.record.Hists[i][j] = 0; - } - } - /*==============================================================* - // initialize linked list used to keep track of named hdf * - // identifiers. * - //==============================================================*/ - HDFfileList = NULL; - /*==============================================================* - // Allocate a one dimensional array of pointers to queues of * - // HDFnodes. There is one queue for each thread and one for * - // each HDF procedure. Each queue will be a list of summary * - // records distinquished by file type and * - //==============================================================*/ - size = (int)(numProcs*sizeof( HDFnode_t * )); - HDFQueues = (HDFnode_t **)malloc( size ); - if ( HDFQueues == NULL ) { - fprintf(stderr,"Failed to allocate HDFQueues in initHDFProcTrace\n"); - return FAILURE; - } - for ( j = 0; j < numProcs; ++j ) { - HDFQueues[j] = NULL; - } - /*==============================================================* - // Initialize call stack to a dummy node and TagQueue to NULL * - //==============================================================*/ - CallStack = (HDFnode_t *)malloc( sizeof(HDFnode_t) ); - *CallStack = InitNode; - TagQueue = NULL ; - return SUCCESS; + } + for ( i = 0; i < nByteFields; ++i ) + { + for ( j = 0; j < nBkts; ++j ) + { + InitNode.record.Hists[i][j] = 0; + } + } + /*===================================================================* + // initialize linked list used to keep track of named hdf * + // identifiers. * + //===================================================================*/ + HDFfileList = NULL; + /*===================================================================* + // Allocate a one dimensional array of pointers to queues of * + // HDFnodes. There is one queue for each thread and one for * + // each HDF procedure. Each queue will be a list of summary * + // records distinquished by file type and * + //===================================================================*/ + size = (int)(numProcs*sizeof( HDFnode_t * )); + HDFQueues = (HDFnode_t **)malloc( size ); + if ( HDFQueues == NULL ) + { + fprintf(stderr,"Failed to allocate HDFQueues in initHDFProcTrace\n"); + return FAILURE; + } + for ( j = 0; j < numProcs; ++j ) + { + HDFQueues[j] = NULL; + } + /*===================================================================* + // Initialize call stack to a dummy node and TagQueue to NULL * + //===================================================================*/ + CallStack = (HDFnode_t *)malloc( sizeof(HDFnode_t) ); + *CallStack = InitNode; + TagQueue = NULL ; + return SUCCESS; } /*======================================================================* // This is called from the HDF and I/O routines when real-time summary * @@ -411,7 +401,7 @@ void HDFtraceEvent_RT( int eventType, char *dataPtr, unsigned dataLen ) else if ( isEndHDFEvent( eventType ) ) { EndHDFEventRecord ( seconds, dataPtr ); -#ifdef H5_HAVE_PARALLEL +#ifdef H5_HAVE_MPIOTRACE } else if ( isBeginMPIOEvent( eventType ) ) { @@ -420,7 +410,7 @@ void HDFtraceEvent_RT( int eventType, char *dataPtr, unsigned dataLen ) else if ( isEndMPIOEvent( eventType ) ) { EndMPIOEventRecord ( eventType, seconds, dataPtr, dataLen ); -#endif /* H5_HAVE_PARALLEL */ +#endif /* H5_HAVE_MPIOTRACE */ } else { @@ -529,7 +519,7 @@ void EndIOEventRecord ( int eventType, CLOCK secs, void *dataPtr ) } } -#ifdef H5_HAVE_PARALLEL +#ifdef H5_HAVE_MPIOTRACE /*======================================================================* // BeginMPIOEventRecord: * // This routine simply records the time in the record on the top of * @@ -542,18 +532,18 @@ void BeginMPIOEventRecord( int eventType, { 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. * - //==============================================================*/ + /*===================================================================* + // 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 * + /*===================================================================* + // get useful info from the structure pointed to by dataPtr. * + // Form 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; CallStack->record.hdfID = dataPtr->setID; switch ( eventType ) @@ -766,7 +756,7 @@ void EndMPIOEventRecord ( int eventType, } } } -#endif /* H5_HAVE_PARALLEL */ +#endif /* H5_HAVE_MPIOTRACE */ /*======================================================================* // BeginHDFEventRecord: * // This function puts a trace record on the stack corresponding to * @@ -1087,17 +1077,18 @@ void HDFSummarySDDF( HDFnode_t *P, int procIndex ) char buff[1024]; char *Packet; HDFnode_t *Q; - struct { - int packetLen, - packetType, - packetTag, - eventID; - double Seconds, - IncDur, - ExcDur; - long HDFid, - XREFid; - } Header; + struct + { + int packetLen; + int packetType; + int packetTag; + int eventID; + double Seconds; + double IncDur; + double ExcDur; + long HDFid; + long XREFid; + } Header; Header.packetLen = sizeof(Header) + sizeof(int) /* n Calls */ @@ -1109,8 +1100,7 @@ void HDFSummarySDDF( HDFnode_t *P, int procIndex ) + nByteFields*sizeof(int) /* bytes array */ + nHistFields*sizeof(int) /* array lens */ + nHistFields*nBkts*sizeof(int) /* byte hist */ - + sizeof(int) /* nodeID */ - + sizeof(int) ; /* Name len */ + + sizeof(int); /* nodeID */ Header.packetTag = HDF_SUMMARY_FAMILY + ( procIndex + 1 )*8 + RECORD_TRACE ; Header.packetType = PKT_DATA; @@ -1186,7 +1176,8 @@ void HDFSummarySDDF( HDFnode_t *P, int procIndex ) // copy length of historgram arrays and arrays to Packet. * //===========================================================*/ arrayLen = nBkts; - for ( i = 0; i < nByteFields; ++i ) { + for ( i = 0; i < nHistFields; ++i ) + { memcpy( Packet, &arrayLen, sizeof(int) ); Packet += sizeof(int); memcpy( Packet, P->record.Hists[i], nBkts*sizeof(int) ); @@ -1194,9 +1185,9 @@ void HDFSummarySDDF( HDFnode_t *P, int procIndex ) } memcpy( Packet, &nodeID, sizeof(int) ); Packet += sizeof(int); - arrayLen = 0; /* name length */ - memcpy( Packet, &arrayLen, sizeof(int) ); - putBytes( buff, Header.packetLen ); + arrayLen = Packet-buff; + memcpy(buff,&arrayLen,sizeof(int)); + putBytes( buff, Packet-buff ); P = Q; } } @@ -1205,7 +1196,7 @@ void HDFSummarySDDF( HDFnode_t *P, int procIndex ) //======================================================================*/ void HDFnodeInit ( HDFnode_t *S ) { - *S = InitNode; + *S = InitNode; } /*======================================================================* // Compute IO totals, exclusive durations of the input record T * @@ -1213,27 +1204,34 @@ void HDFnodeInit ( HDFnode_t *S ) //======================================================================*/ void HDFrecordSum ( HDFrec_t *S, HDFrec_t *T ) { - int i, j; + int i; + int j; - S->nCalls += T->nCalls; - if ( clockCompare ( S->lastCall, T->lastCall ) < 0 ) { - S->lastCall = T->lastCall ; - } - S->incDur = clockAdd ( S->incDur, T->incDur ); - for ( j = 0; j < nTallyFields; ++j ) { - S->times[j] = clockAdd( S->times[j] , T->times[j] ) ; - } - for ( j = 0; j < nTallyFields; ++j ) { - S->counts[j] += T->counts[j] ; - } - for ( j = 0; j < nByteFields; ++j ) { - S->bytes[j] += T->bytes[j] ; - } - for ( j = 0; j < nHistFields; ++j ) { - for ( i = 0; i < nBkts; ++i ) { - S->Hists[j][i] += T->Hists[j][i] ; - } - } + S->nCalls += T->nCalls; + if ( clockCompare ( S->lastCall, T->lastCall ) < 0 ) + { + S->lastCall = T->lastCall ; + } + S->incDur = clockAdd ( S->incDur, T->incDur ); + for ( j = 0; j < nTallyFields; ++j ) + { + S->times[j] = clockAdd( S->times[j] , T->times[j] ) ; + } + for ( j = 0; j < nTallyFields; ++j ) + { + S->counts[j] += T->counts[j] ; + } + for ( j = 0; j < nByteFields; ++j ) + { + S->bytes[j] += T->bytes[j] ; + } + for ( j = 0; j < nHistFields; ++j ) + { + for ( i = 0; i < nBkts; ++i ) + { + S->Hists[j][i] += T->Hists[j][i] ; + } + } } /*======================================================================* // Return the field index corresponding to an IO event ID. The fields * @@ -1498,7 +1496,7 @@ void _hdfDescriptorRT( char *recordName, char *recordDescription, /*==================================================================* // The record field count * //==================================================================*/ - sddfWriteInteger( &hdfRecordPointer, 17 ); + sddfWriteInteger( &hdfRecordPointer, 16 ); WRITE_HDF_FIELD( "Event Identifier", "Event ID", "Corresponding Event", @@ -1563,10 +1561,6 @@ void _hdfDescriptorRT( char *recordName, char *recordDescription, "Node", "Processor number", INTEGER, 0 ); - WRITE_HDF_FIELD( "HDF Name", - "HDF Name", - "Name of File,Data Set or Dim accessed", - CHARACTER, 1 ); /*=================================================================== // The entire record descriptor packet has been written. * // Compute and update the record length. * @@ -1586,17 +1580,6 @@ void _hdfDescriptorRT( char *recordName, char *recordDescription, //======================================================================*/ void writeHDFRecDescrptrsRT( void ) { -/* - char HDFprocNames[][40] = { - "noName", - "noName", - "noName", - "noName", - "noName", -# include "HDFentryNames.h" - "HDF_Last_Entry" - }; -*/ int j, FAMILY; char BUF1[256], BUF2[256] ; _hdfNameDescriptor(); /* Descriptor for named identifiers */ @@ -1646,10 +1629,10 @@ void _hdfNameDescriptor( void ) static char recordBuffer[ 4096 ]; int recordLength; -#ifdef DEBUG +#ifdef PABLODEBUG fprintf( debugFile, "_hdfExitTraceDescriptor entered\n" ); fflush( debugFile ); -#endif /* DEBUG */ +#endif /* PABLODEBUG */ hdfRecordPointer = recordBuffer; /********************************************************************/ /* Allow space at the beginning of the record for the packet */ diff --git a/pablo/PabloHDF_SDDF.c b/pablo/PabloHDF_SDDF.c index 4858086..c46878f 100644 --- a/pablo/PabloHDF_SDDF.c +++ b/pablo/PabloHDF_SDDF.c @@ -69,7 +69,7 @@ #include "TraceParam.h" #include "Trace.h" #include "HDFTrace.h" -void HDFendTrace_SDDF(int); +void HDFendTrace_SDDF(void); void startHDFtraceEvent(int eventID); void endHDFtraceEvent(int , int , char *, int ); int preInitHDFProcTrace( void ); @@ -113,7 +113,7 @@ extern char HDFprocNames[][40]; /*======================================================================* // Prototypes of functions in this file. * //======================================================================*/ -void HDFinitTrace_SDDF( char *, int ); +void HDFinitTrace_SDDF( char * ); /*======================================================================* // Each procedure being traced has associated with it a distinct pair * // of entry and exit event IDs. This code maintains a vector of such * @@ -176,22 +176,24 @@ struct procTraceRecordData { /*======================================================================* // misc Record Data packets: * //======================================================================*/ -struct miscTraceRecordData { - int packetLength; /* bytes in packet */ - int packetType; /* == PKT_DATA */ - int packetTag; /* FAMILY_MISC | RECORD_TRACE */ - int eventID; /* ID of corresponding event */ - double seconds; /* floating-point timestamp */ - double duration; /* floating-point operation duration */ - unsigned long bytes; /* number of bytes requested */ - int nodeNumber; /* occurred on which node */ +struct miscTraceRecordData +{ + int packetLength; /* bytes in packet */ + int packetType; /* == PKT_DATA */ + int packetTag; /* FAMILY_MISC | RECORD_TRACE */ + int eventID; /* ID of corresponding event */ + double seconds; /* floating-point timestamp */ + double duration; /* floating-point operation duration */ + unsigned long bytes; /* number of bytes requested */ + int nodeNumber; /* occurred on which node */ }; #define miscTraceLen 5*sizeof(int) + 2*sizeof(double) +sizeof(long) /*======================================================================* // The procEntries array specifies the event IDs of procedure entry * // events. * //======================================================================*/ -int procEntries[] = { +int procEntries[] = +{ 0, 0, 0, 0, 0, #include "HDFidList.h" ID_HDF_Last_Entry @@ -201,105 +203,46 @@ ID_HDF_Last_Entry // was called. * //======================================================================*/ int *procEntryCalled; -/*======================================================================* -// The HDFProcNames array holds the names of the HDF entries. * -//======================================================================*/ -/*static char HDFprocNames[][40] = { -"noName", -"noName", -"noName", -"noName", -"noName", -#include "HDFentryNames.h" -"HDF_LAST_ENTRY" -};*/ /*======================================================================= // NAME * // HDFinitTrace_SDDF -- initalize HDF tracing with SDDF records * // USAGE * -// HDFinitTrace_SDDF( traceFileName, procTraceMask ) * +// HDFinitTrace_SDDF( traceFileName ) * // PARAMETERS * // char *traceFileName -- name of trace file to hold output * -// uint32 prcoTraceMask -- mask indicating classes of HDF procs to * -// be traced * // RETURNS * // None * //======================================================================*/ -void HDFinitTrace_SDDF( char *traceFileName, int OUTSW ) +void HDFinitTrace_SDDF( char *traceFileName ) { - /*=============================================================== - // set traceFileName and set IO tracing switches. If MPIO * - // tracing is available, MPIO tracing will also be initialized. * - //==============================================================*/ -#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 * - // may or may not be support for MPIO tracing in the Pablo * - // Trace libraries. The type of initialization performed * - // depends on these factors. * - //==============================================================*/ - int myNode; - char *buff; - /*=============================================================== - // Determine if MPI is running the program. * - //==============================================================*/ - if ( OUTSW == MPI_RUNTIME_TRACE ) { - /*============================================================ - // in the parallel case, initialize MPI-IO tracing. This * - // will initialize the traceFileName and set the I/O tracing * - // switches. * - //===========================================================*/ - MPI_Comm_rank( MPI_COMM_WORLD, &myNode ); - setTraceProcessorNumber( myNode ); + /*==================================================================== + // set traceFileName and set IO tracing switches. If MPIO * + // tracing is available, MPIO tracing will also be initialized. * + //===================================================================*/ #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, SUPPRESS_MPIO_TRACE ); + int myNode; + char *buff; + /*==================================================================== + // in the parallel case, initialize MPI-IO tracing. This * + // will initialize the traceFileName and set the I/O tracing * + // switches. * + //===================================================================*/ + /*==================================================================== + // MPIO Tracing is supported in the Pablo Library. Let the * + // MPIO initialization be performed and handle the naming of * + // trace files. * + //===================================================================*/ + initMPIOTrace( traceFileName, SUPPRESS_MPIO_TRACE ); + MPI_Comm_rank( MPI_COMM_WORLD, &myNode ); + setTraceProcessorNumber( myNode ); #else - /*============================================================ - // MPIO tracing is not supported. * - // Set up the trace file names depending on the number of * - // current node. * - //===========================================================*/ - buff = (char *)malloc( strlen(traceFileName)+12); - sprintf( buff, "%s.nd%.4d\0",traceFileName,myNode); - setTraceFileName( buff ); - free( buff ); + IOtraceInit( traceFileName, RUNTIME_TRACE ); #endif - } else { - /*============================================================ - // The HDF library was built to run with MPI, but the * - // application is being run in serial mode. Initialization * - // is done as in the serial case. * - //===========================================================*/ - setTraceFileName(traceFileName); - initIOTrace(); - enableIOdetail(); - disableLifetimeSummaries(); - disableTimeWindowSummaries(); - disableFileRegionSummaries(); - } -#else - /*=============================================================== - // in the non-parallel case, set the trace file name and the * - // I/O tracing switches. * - //==============================================================*/ - setTraceFileName(traceFileName); - initIOTrace(); - enableIOdetail(); - disableLifetimeSummaries(); - disableTimeWindowSummaries(); - disableFileRegionSummaries(); -#endif /* H5_HAVE_PARALLEL */ - /*=============================================================== - // complete HDF initiailization. * - //==============================================================*/ - preInitHDFProcTrace(); - initHDFProcTrace( sizeof(procEntries)/sizeof(int), procEntries ); + /*==================================================================== + // complete HDF initiailization. * + //===================================================================*/ + preInitHDFProcTrace(); + initHDFProcTrace( sizeof(procEntries)/sizeof(int), procEntries ); } /*======================================================================= // NAME * @@ -309,23 +252,22 @@ void HDFinitTrace_SDDF( char *traceFileName, int OUTSW ) // RETURNS * // None. * //======================================================================*/ -void HDFendTrace_SDDF(int OUTSW) +void HDFendTrace_SDDF() { - HDFfinalTimeStamp(); - if ( OUTSW == MPI_RUNTIME_TRACE ) { - /*============================================================ - // termintate MPI-IO tracing in the parallel case. This * - // will terminate the I/O tracing and close tracing as well. * - //===========================================================*/ - endMPIOTrace(); - } else { - /*============================================================ - // terminate tracing * - //===========================================================*/ - endIOTrace(); - endTracing(); - exit(1); - } + HDFfinalTimeStamp(); +#ifdef H5_HAVE_MPIORACE + /*==================================================================== + // termintate MPI-IO tracing in the parallel case. This * + // will terminate the I/O tracing and close tracing as well. * + //===================================================================*/ + endMPIOTrace(); +#else + /*==================================================================== + // terminate tracing * + //===================================================================*/ + endIOTrace(); + endTracing(); +#endif } /*======================================================================= // NAME * @@ -347,57 +289,65 @@ void HDFendTrace_SDDF(int OUTSW) //======================================================================*/ int initHDFProcTrace( int numProcs, int *procEntryID ) { - int procIndex, IX, ID; - - if (( numProcs <= 0 ) || ( procEntryID == (int *) 0 ) ) - return FAILURE; - /*=============================================================== - // Allocate space to store a copy of the procedure entry-exit * - // event ID matchings and also the procedure entry stacks. * - //==============================================================*/ - procEvents = (PROC_EVENTS *) TRgetBuffer( - (numProcs+4)*sizeof(PROC_EVENTS) ); - - if ( procEvents == (PROC_EVENTS *) 0 ) - TRfailure( "cannot allocate procedure events matching" ); - - procEntryCalled = ( int *)malloc( numProcs*sizeof(int) ); - if ( procEvents == NULL ) - TRfailure( "cannot allocate procedure Called indicators" ); - /*=============================================================== - // Initialize the procedure events matching from the arguments * - // passed. Configure the trace record-generating function for * - // these events. Initialize the flags indicating whether or * - // not the procedure was called. * - //==============================================================*/ - for ( procIndex = 0; procIndex < numProcs; procIndex++ ) { - - IX = procEntryID[ procIndex ]; - ID = HDFIXtoEventID( IX ); - procEvents[ procIndex ].entryID = ID; - procEvents[ procIndex ].exitID = -ID; - - setEventRecordFunction( ID, HDFprocEventRecord ); - setEventRecordFunction( -ID, HDFprocEventRecord ); - procEntryCalled[ procIndex ] = 0; - - } - - /*=============================================================== - // Initialize the procedure events for malloc. * - // Configure the trace record-generating function for this * - // event. * - //==============================================================*/ - procEvents[ numProcs ].entryID = ID_malloc; - procEvents[ numProcs ].exitID = -ID_malloc; - setEventRecordFunction( ID_malloc, miscEventRecord ); - setEventRecordFunction( -ID_malloc, miscEventRecord ); - procEvents[ numProcs+1 ].entryID = ID_free; - procEvents[ numProcs+1 ].exitID = -ID_free; - setEventRecordFunction( ID_free, miscEventRecord ); - setEventRecordFunction( -ID_free, miscEventRecord ); - - return SUCCESS; + int procIndex; + int IX; + int ID; + + if (( numProcs <= 0 ) || ( procEntryID == (int *) 0 ) ) + { + return FAILURE; + } + /*==================================================================== + // Allocate space to store a copy of the procedure entry-exit * + // event ID matchings and also the procedure entry stacks. * + //===================================================================*/ + procEvents = (PROC_EVENTS *)TRgetBuffer((numProcs+4)*sizeof(PROC_EVENTS)); + + if ( procEvents == (PROC_EVENTS *) 0 ) + { + TRfailure( "cannot allocate procedure events matching" ); + } + + procEntryCalled = ( int *)malloc( numProcs*sizeof(int) ); + if ( procEvents == NULL ) + { + TRfailure( "cannot allocate procedure Called indicators" ); + } + /*==================================================================== + // Initialize the procedure events matching from the arguments * + // passed. Configure the trace record-generating function for * + // these events. Initialize the flags indicating whether or * + // not the procedure was called. * + //===================================================================*/ + for ( procIndex = 0; procIndex < numProcs; procIndex++ ) + { + + IX = procEntryID[ procIndex ]; + ID = HDFIXtoEventID( IX ); + procEvents[ procIndex ].entryID = ID; + procEvents[ procIndex ].exitID = -ID; + + setEventRecordFunction( ID, HDFprocEventRecord ); + setEventRecordFunction( -ID, HDFprocEventRecord ); + procEntryCalled[ procIndex ] = 0; + + } + + /*==================================================================== + // Initialize the procedure events for malloc. * + // Configure the trace record-generating function for this * + // event. * + //===================================================================*/ + procEvents[ numProcs ].entryID = ID_malloc; + procEvents[ numProcs ].exitID = -ID_malloc; + setEventRecordFunction( ID_malloc, miscEventRecord ); + setEventRecordFunction( -ID_malloc, miscEventRecord ); + procEvents[ numProcs+1 ].entryID = ID_free; + procEvents[ numProcs+1 ].exitID = -ID_free; + setEventRecordFunction( ID_free, miscEventRecord ); + setEventRecordFunction( -ID_free, miscEventRecord ); + + return SUCCESS; } /*======================================================================= // NAME * @@ -414,19 +364,21 @@ int initHDFProcTrace( int numProcs, int *procEntryID ) /=======================================================================*/ int preInitHDFProcTrace( void ) { - static int preInitDone = FALSE; - - if ( preInitDone == TRUE ) - return SUCCESS; - /*=============================================================== - // Give the instrumentation library a pointer to the functions * - // in which we output the specialized record descriptors for * - // procedure entry/exit. * - //==============================================================*/ - setRecordDescriptor( writeHDFProcRecordDescriptors ); - - preInitDone = TRUE; - return SUCCESS; + static int preInitDone = FALSE; + + if ( preInitDone == TRUE ) + { + return SUCCESS; + } + /*==================================================================== + // Give the instrumentation library a pointer to the functions * + // in which we output the specialized record descriptors for * + // procedure entry/exit. * + //===================================================================*/ + setRecordDescriptor( writeHDFProcRecordDescriptors ); + + preInitDone = TRUE; + return SUCCESS; } /*======================================================================= // NAME * @@ -443,18 +395,18 @@ int preInitHDFProcTrace( void ) /=======================================================================*/ int writeHDFProcRecordDescriptors( void ) { -#ifdef DEBUG - fprintf( debugFile, "writeHDFProcRecordDescriptors\n" ); - fflush( debugFile ); -#endif /* DEBUG */ - - _hdfMiscDescriptor(); - -#ifdef DEBUG - fprintf( debugFile, "writeHDFProcRecordDescriptors done\n" ); - fflush( debugFile ); -#endif /* DEBUG */ - return SUCCESS; +#ifdef PABLODEBUG + fprintf( debugFile, "writeHDFProcRecordDescriptors\n" ); + fflush( debugFile ); +#endif /* PABLODEBUG */ + + _hdfMiscDescriptor(); + +#ifdef PABLODEBUG + fprintf( debugFile, "writeHDFProcRecordDescriptors done\n" ); + fflush( debugFile ); +#endif /* PABLODEBUG */ + return SUCCESS; } /*======================================================================= // NAME * @@ -476,166 +428,182 @@ int writeHDFProcRecordDescriptors( void ) // pointer to trace record for this event * //======================================================================*/ TR_RECORD * -HDFprocEventRecord( int recordType, TR_EVENT *eventPointer, CLOCK timeStamp, - HDFsetInfo *dataPointer, unsigned dataLength ) +HDFprocEventRecord( int recordType, + TR_EVENT *eventPointer, + CLOCK timeStamp, + HDFsetInfo *dataPointer, + unsigned dataLength ) { - static TR_RECORD traceRecord; - static void *recordBuffer = NULL; - static int bufferLength = 0; - struct procTraceRecordData *TraceRecordHeader; - int procIndex; - int recordFamily; - char *namePtr; + static TR_RECORD traceRecord; + static void *recordBuffer = NULL; + static int bufferLength = 0; + struct procTraceRecordData *TraceRecordHeader; + int procIndex; + int recordFamily; + char *namePtr; - #ifdef DEBUG - fprintf( debugFile, "HDFprocEventRecord\n" ); - fflush( debugFile ); - #endif /* DEBUG */ - - /*==============================================================* - // Find the index in the tables for the procedure corresponding * - // to this eventID. * - //==============================================================*/ - procIndex = findHDFProcEvent( eventPointer->eventID ); - if ( procIndex < 0 ) { - return nullRecordFunction( recordType, eventPointer, +#ifdef PABLODEBUG + fprintf( debugFile, "HDFprocEventRecord\n" ); + fflush( debugFile ); +#endif /* PABLODEBUG */ + + /*==============================================================* + // Find the index in the tables for the procedure corresponding * + // to this eventID. * + //==============================================================*/ + procIndex = findHDFProcEvent( eventPointer->eventID ); + if ( procIndex < 0 ) + { + return nullRecordFunction( recordType, eventPointer, timeStamp, (char *)dataPointer, dataLength ); - } - /*==============================================================* - // Produce a packet for the name of the procedure if one has * - // not already been produced. * - //==============================================================*/ - if ( procEntryCalled[procIndex] == 0 ) { - createHDFTraceDescriptor( procIndex ); - procEntryCalled[procIndex] = 1; - } - /*==============================================================* - // Determine whether this is a procedure entry or a procedure * - // exit family event by lookup in the procedure event ID * - // matching. * - //==============================================================*/ - recordFamily = HDF_FAMILY + ( procIndex + 1)*8; - /*==============================================================* - // The time stamp stored in the event descriptor will be used * - // unless one is specified in the timeStamp parameter. * - //==============================================================*/ - if ( clockCompare( timeStamp, noSuchClock ) == 0 ) { - timeStamp = eventPointer->eventLast; - } - /*==============================================================* - // Determine how many bytes of storage will be needed for the * - // contents of the trace record. * - //==============================================================*/ - traceRecord.recordLength = sizeof *TraceRecordHeader; - if ( dataPointer != NULL && dataPointer->setName != NULL ) { - traceRecord.recordLength += strlen( dataPointer->setName ); - } - /*==============================================================* - // If there is a previously-allocated buffer and its size will * - // hold this record, re-use the buffer. Otherwise, deallocate * - // the buffer (if allocated) and allocate a bigger one. * - //==============================================================*/ - if ( bufferLength < traceRecord.recordLength ) { - - if ( recordBuffer != NULL ) { - TRfreeBuffer( recordBuffer ); - } - - recordBuffer = (char *)TRgetBuffer( traceRecord.recordLength ); - - if ( recordBuffer == NULL ) { - TRfailure( "cannot allocate storage for trace record" ); - } - bufferLength = traceRecord.recordLength; - } - - traceRecord.recordContents = recordBuffer; - /*==============================================================* - // Load the trace record fields into the allocated buffer * - //==============================================================*/ - TraceRecordHeader = (struct procTraceRecordData *)recordBuffer; - TraceRecordHeader->packetLength = traceRecord.recordLength; - TraceRecordHeader->packetType = PKT_DATA; - TraceRecordHeader->packetTag = recordFamily | recordType; - TraceRecordHeader->seconds = clockToSeconds( timeStamp ); - TraceRecordHeader->eventID = eventPointer->eventID; - TraceRecordHeader->nodeNumber = TRgetNode(); - - if ( dataPointer != 0 ) { - TraceRecordHeader->setID = dataPointer->setID; - if (dataPointer->setName != NULL ) { - TraceRecordHeader->nameLen = (int)strlen( dataPointer->setName ); - /*================================================* - // copy name directly into the end of the buffer. * - //================================================*/ - namePtr = (char *)TraceRecordHeader + procTraceRecLen; - memcpy(namePtr, dataPointer->setName, TraceRecordHeader->nameLen); - } else { - TraceRecordHeader->nameLen = 0; - } - } else { - TraceRecordHeader->setID = 0; - TraceRecordHeader->nameLen = 0; - } - -#ifdef DEBUG - fprintf( debugFile, "HDFprocEventRecord done\n" ); - fflush( debugFile ); -#endif /* DEBUG */ - returnRecord(&traceRecord); + } + /*===================================================================* + // Produce a packet for the name of the procedure if one has * + // not already been produced. * + //===================================================================*/ + if ( procEntryCalled[procIndex] == 0 ) { + createHDFTraceDescriptor( procIndex ); + procEntryCalled[procIndex] = 1; + } + /*===================================================================* + // Determine whether this is a procedure entry or a procedure * + // exit family event by lookup in the procedure event ID * + // matching. * + //===================================================================*/ + recordFamily = HDF_FAMILY + ( procIndex + 1)*8; + /*===================================================================* + // The time stamp stored in the event descriptor will be used * + // unless one is specified in the timeStamp parameter. * + //===================================================================*/ + if ( clockCompare( timeStamp, noSuchClock ) == 0 ) { + timeStamp = eventPointer->eventLast; + } + /*===================================================================* + // Determine how many bytes of storage will be needed for the * + // contents of the trace record. * + //===================================================================*/ + traceRecord.recordLength = sizeof *TraceRecordHeader; + if ( dataPointer != NULL && dataPointer->setName != NULL ) + { + traceRecord.recordLength += strlen( dataPointer->setName ); + } + /*===================================================================* + // If there is a previously-allocated buffer and its size will * + // hold this record, re-use the buffer. Otherwise, deallocate * + // the buffer (if allocated) and allocate a bigger one. * + //===================================================================*/ + if ( bufferLength < traceRecord.recordLength ) + { + + if ( recordBuffer != NULL ) + { + TRfreeBuffer( recordBuffer ); + } + + recordBuffer = (char *)TRgetBuffer( traceRecord.recordLength ); + + if ( recordBuffer == NULL ) + { + TRfailure( "cannot allocate storage for trace record" ); + } + bufferLength = traceRecord.recordLength; + } + + traceRecord.recordContents = recordBuffer; + /*===================================================================* + // Load the trace record fields into the allocated buffer * + //===================================================================*/ + TraceRecordHeader = (struct procTraceRecordData *)recordBuffer; + TraceRecordHeader->packetLength = traceRecord.recordLength; + TraceRecordHeader->packetType = PKT_DATA; + TraceRecordHeader->packetTag = recordFamily | recordType; + TraceRecordHeader->seconds = clockToSeconds( timeStamp ); + TraceRecordHeader->eventID = eventPointer->eventID; + TraceRecordHeader->nodeNumber = TRgetNode(); + + if ( dataPointer != 0 ) + { + TraceRecordHeader->setID = dataPointer->setID; + if (dataPointer->setName != NULL ) + { + TraceRecordHeader->nameLen = (int)strlen( dataPointer->setName ); + /*==============================================================* + // copy name directly into the end of the buffer. * + //==============================================================*/ + namePtr = (char *)TraceRecordHeader + procTraceRecLen; + memcpy(namePtr, dataPointer->setName, TraceRecordHeader->nameLen); + } + else + { + TraceRecordHeader->nameLen = 0; + } + } + else + { + TraceRecordHeader->setID = 0; + TraceRecordHeader->nameLen = 0; + } +#ifdef PABLODEBUG + fprintf( debugFile, "HDFprocEventRecord done\n" ); + fflush( debugFile ); +#endif /* PABLODEBUG */ + returnRecord(&traceRecord); } /*======================================================================* // Internal Routine: miscEventRecord * // Called for misc start and end events. * //======================================================================*/ TR_RECORD *miscEventRecord( int recordType, - TR_EVENT *eventPointer, - CLOCK timeStamp, - void *dataPointer, - unsigned dataLength ) + TR_EVENT *eventPointer, + CLOCK timeStamp, + void *dataPointer, + unsigned dataLength ) { - static TR_RECORD traceRecord; - static struct miscTraceRecordData miscRecord; - static int initialized = FALSE; - int eventID; - - if ( clockCompare( timeStamp, noSuchClock ) == 0 ) { - timeStamp = eventPointer->eventLast; - } - - eventID = eventPointer->eventID; - if ( ! initialized ) { - miscRecord.packetLength = sizeof( miscRecord ); - miscRecord.packetType = PKT_DATA; - miscRecord.packetTag = FAMILY_MISC | RECORD_TRACE; - miscRecord.nodeNumber = traceProcessorNumber; - - traceRecord.recordLength = miscRecord.packetLength; - traceRecord.recordContents = (char *) &miscRecord; - initialized = TRUE; - } - - switch ( eventID ) { - case ID_malloc: - case ID_free: - miscRecord.seconds = clockToSeconds( timeStamp ) ; - miscRecord.eventID = eventID ; - break; - case -ID_malloc: - case -ID_free: - miscRecord.bytes = *(int *)dataPointer; - miscRecord.duration = clockToSeconds( timeStamp) - - miscRecord.seconds; - return &traceRecord; /* generate trace record */ - default: - fprintf( stderr, "miscEventRecord: unknown eventID %d\n", eventID ); - break; - } - /*==================================================================* - // If we get here then no trace record generated. Normally we * - // should get here if this is an entry call. * - //==================================================================*/ - return( nullRecordFunction( recordType, eventPointer, timeStamp, + static TR_RECORD traceRecord; + static struct miscTraceRecordData miscRecord; + static int initialized = FALSE; + int eventID; + + if ( clockCompare( timeStamp, noSuchClock ) == 0 ) + { + timeStamp = eventPointer->eventLast; + } + + eventID = eventPointer->eventID; + if ( ! initialized ) + { + miscRecord.packetLength = sizeof( miscRecord ); + miscRecord.packetType = PKT_DATA; + miscRecord.packetTag = FAMILY_MISC | RECORD_TRACE; + miscRecord.nodeNumber = traceProcessorNumber; + + traceRecord.recordLength = miscRecord.packetLength; + traceRecord.recordContents = (char *) &miscRecord; + initialized = TRUE; + } + + switch ( eventID ) + { + case ID_malloc: + case ID_free: + miscRecord.seconds = clockToSeconds( timeStamp ) ; + miscRecord.eventID = eventID ; + break; + case -ID_malloc: + case -ID_free: + miscRecord.bytes = *(int *)dataPointer; + miscRecord.duration = clockToSeconds( timeStamp) + - miscRecord.seconds; + return &traceRecord; /* generate trace record */ + default: + fprintf( stderr, "miscEventRecord: unknown eventID %d\n", eventID ); + break; + } + /*===================================================================* + // If we get here then no trace record generated. Normally we * + // should get here if this is an entry call. * + //===================================================================*/ + return( nullRecordFunction( recordType, eventPointer, timeStamp, dataPointer, dataLength ) ); } /*======================================================================* @@ -653,33 +621,39 @@ TR_RECORD *miscEventRecord( int recordType, //======================================================================*/ int findHDFProcEvent( int eventID ) { - int procIndex; - -#ifdef DEBUG - fprintf( debugFile, "findHDFProcEvent\n" ); - fflush( debugFile ); -#endif /* DEBUG */ - if ( isBeginHDFEvent(eventID) ) { - procIndex = eventID - BEGIN_HDF; - } else if ( isEndHDFEvent( eventID ) ) { - procIndex = -eventID - BEGIN_HDF; - } else { - procIndex = -1 ; - } - return procIndex; + int procIndex; + +#ifdef PABLODEBUG + fprintf( debugFile, "findHDFProcEvent\n" ); + fflush( debugFile ); +#endif /* PABLODEBUG */ + if ( isBeginHDFEvent(eventID) ) + { + procIndex = eventID - BEGIN_HDF; + } + else if ( isEndHDFEvent( eventID ) ) + { + procIndex = -eventID - BEGIN_HDF; + } + else + { + procIndex = -1 ; + } + return procIndex; } void createHDFTraceDescriptor( int Inx ) { - char BUF1[256], BUF2[256] ; - int FAMILY; - strcpy( BUF2, "HDF "); - strcat( BUF2, HDFprocNames[Inx] ); - strcat( BUF2, " Procedure"); - strcpy( BUF1, BUF2 ); - strcat( BUF1, " Trace"); - - FAMILY = HDF_FAMILY + (Inx + 1)*8; - _hdfTraceDescriptor( BUF1, BUF2, FAMILY ); + char BUF1[256]; + char BUF2[256] ; + int FAMILY; + strcpy( BUF2, "HDF "); + strcat( BUF2, HDFprocNames[Inx] ); + strcat( BUF2, " Procedure"); + strcpy( BUF1, BUF2 ); + strcat( BUF1, " Trace"); + + FAMILY = HDF_FAMILY + (Inx + 1)*8; + _hdfTraceDescriptor( BUF1, BUF2, FAMILY ); } /*======================================================================* // NAME * @@ -695,61 +669,68 @@ void _hdfTraceDescriptor( char *recordName, char *recordDescription, int recordFamily ) { - static char recordBuffer[ 4096 ]; - int recordLength; + static char recordBuffer[ 4096 ]; + int recordLength; + + hdfRecordPointer = recordBuffer; + /*==================================================================== + // Allow space at the beginning of the record for the packet * + //length which will be computed after the packet is complete. * + //===================================================================*/ + sddfWriteInteger( &hdfRecordPointer, 0 ); + /*==================================================================== + // The record type, tag, and name * + //===================================================================*/ + sddfWriteInteger( &hdfRecordPointer, PKT_DESCRIPTOR ); + sddfWriteInteger( &hdfRecordPointer, ( recordFamily | RECORD_TRACE ) ); + sddfWriteString( &hdfRecordPointer, recordName ); + /*==================================================================== + // The record attribute count and string pair * + //===================================================================*/ + sddfWriteInteger( &hdfRecordPointer, 1 ); + sddfWriteString( &hdfRecordPointer, "description" ); + sddfWriteString( &hdfRecordPointer, recordDescription ); + /*===================================================================* + // The record field count * + //===================================================================*/ + sddfWriteInteger( &hdfRecordPointer, 5); + /*===================================================================* + // Create fields * + //===================================================================*/ + WRITE_HDF_FIELD( "Event Identifier", + "Event ID", + "Event Identifier Number", + INTEGER, + 0 ); + WRITE_HDF_FIELD( "Seconds", + "Seconds", + "Floating Point Timestamp", + DOUBLE, + 0 ); + WRITE_HDF_FIELD2( "HDF ID", + "HDF ID", + "File, Data Set or Dim Identifier number", + "0", + "No HDF ID specified", + LONG, + 0 ); + WRITE_HDF_FIELD( "Processor Number", + "Node", + "Processor number", + INTEGER, + 0 ); + WRITE_HDF_FIELD( "HDF Name", + "HDF Name", + "Name of File, Data Set or Dim", + CHARACTER, + 1 ); + + recordLength = (int)(hdfRecordPointer - recordBuffer); - hdfRecordPointer = recordBuffer; - /*=================================================================== - // Allow space at the beginning of the record for the packet * - //length which will be computed after the packet is complete. * - //==================================================================*/ - sddfWriteInteger( &hdfRecordPointer, 0 ); - /*=================================================================== - // The record type, tag, and name * - //==================================================================*/ - sddfWriteInteger( &hdfRecordPointer, PKT_DESCRIPTOR ); - sddfWriteInteger( &hdfRecordPointer, ( recordFamily | RECORD_TRACE ) ); - sddfWriteString( &hdfRecordPointer, recordName ); - /*=================================================================== - // The record attribute count and string pair * - //==================================================================*/ - sddfWriteInteger( &hdfRecordPointer, 1 ); - sddfWriteString( &hdfRecordPointer, "description" ); - sddfWriteString( &hdfRecordPointer, recordDescription ); - /*==================================================================* - // The record field count * - //==================================================================*/ - sddfWriteInteger( &hdfRecordPointer, 5); - /*==================================================================* - // Create fields * - //==================================================================*/ - WRITE_HDF_FIELD( "Event Identifier", - "Event ID", - "Event Identifier Number", - INTEGER, 0 ); - WRITE_HDF_FIELD( "Seconds", - "Seconds", - "Floating Point Timestamp", - DOUBLE, 0 ); - WRITE_HDF_FIELD2( "HDF ID", - "HDF ID", "File, Data Set or Dim Identifier number", - "0", "No HDF ID specified", - LONG, 0 ); - WRITE_HDF_FIELD( "Processor Number", - "Node", - "Processor number", - INTEGER, 0 ); - WRITE_HDF_FIELD( "HDF Name", - "HDF Name", "Name of File, Data Set or Dim", - CHARACTER, 1 ); - - - recordLength = (int)(hdfRecordPointer - recordBuffer); - - hdfRecordPointer = recordBuffer; - sddfWriteInteger( &hdfRecordPointer, recordLength ); - - putBytes( recordBuffer, (unsigned) recordLength ); + hdfRecordPointer = recordBuffer; + sddfWriteInteger( &hdfRecordPointer, recordLength ); + + putBytes( recordBuffer, (unsigned) recordLength ); } /*======================================================================* // NAME * @@ -766,62 +747,67 @@ void _hdfMiscDescriptor( void ) static char recordBuffer[ 4096 ]; int recordLength; -#ifdef DEBUG - fprintf( debugFile, "_hdfMiscDescriptor entered\n" ); - fflush( debugFile ); -#endif /* DEBUG */ - hdfRecordPointer = recordBuffer; - /*==================================================================* - // Allow space at the beginning of the record for the packet * - //length which will be computed after the packet is complete. * - //==================================================================*/ - sddfWriteInteger( &hdfRecordPointer, 0 ); - /*==================================================================* - // The record type, tag, and name * - //==================================================================*/ - sddfWriteInteger( &hdfRecordPointer, PKT_DESCRIPTOR ); - sddfWriteInteger( &hdfRecordPointer, ( FAMILY_MISC | RECORD_TRACE ) ); - sddfWriteString( &hdfRecordPointer, "Misc Trace" ); - /*==================================================================* - // The record attribute count and string pair * - //==================================================================*/ - sddfWriteInteger( &hdfRecordPointer, 1 ); - sddfWriteString( &hdfRecordPointer, "description" ); - sddfWriteString( &hdfRecordPointer, "Misc Trace Record" ); - /*==================================================================* - // The record field count * - //==================================================================*/ - sddfWriteInteger( &hdfRecordPointer, 5); - /*==================================================================* - // Create fields * - //==================================================================*/ - WRITE_HDF_FIELD( "Event Identifier", - "Event ID", - "Event Identifier Number", - INTEGER, 0 ); - WRITE_HDF_FIELD( "Seconds", - "Seconds", - "Floating Point Timestamp", - DOUBLE, 0 ); - WRITE_HDF_FIELD( "Duration", - "Duration", - "Operation Duration", - DOUBLE, 0 ); - WRITE_HDF_FIELD( "Bytes", - "Bytes", - "Bytes Requested", - LONG, 0 ); - WRITE_HDF_FIELD( "Processor Number", - "Node", - "Processor number", - INTEGER, 0 ); - - recordLength = (int)(hdfRecordPointer - recordBuffer); - - hdfRecordPointer = recordBuffer; - sddfWriteInteger( &hdfRecordPointer, recordLength ); - - putBytes( recordBuffer, (unsigned) recordLength ); +#ifdef PABLODEBUG + fprintf( debugFile, "_hdfMiscDescriptor entered\n" ); + fflush( debugFile ); +#endif /* PABLODEBUG */ + hdfRecordPointer = recordBuffer; + /*===================================================================* + // Allow space at the beginning of the record for the packet * + //length which will be computed after the packet is complete. * + //===================================================================*/ + sddfWriteInteger( &hdfRecordPointer, 0 ); + /*===================================================================* + // The record type, tag, and name * + //===================================================================*/ + sddfWriteInteger( &hdfRecordPointer, PKT_DESCRIPTOR ); + sddfWriteInteger( &hdfRecordPointer, ( FAMILY_MISC | RECORD_TRACE ) ); + sddfWriteString( &hdfRecordPointer, "Misc Trace" ); + /*===================================================================* + // The record attribute count and string pair * + //===================================================================*/ + sddfWriteInteger( &hdfRecordPointer, 1 ); + sddfWriteString( &hdfRecordPointer, "description" ); + sddfWriteString( &hdfRecordPointer, "Misc Trace Record" ); + /*===================================================================* + // The record field count * + //===================================================================*/ + sddfWriteInteger( &hdfRecordPointer, 5); + /*===================================================================* + // Create fields * + //===================================================================*/ + WRITE_HDF_FIELD( "Event Identifier", + "Event ID", + "Event Identifier Number", + INTEGER, + 0 ); + WRITE_HDF_FIELD( "Seconds", + "Seconds", + "Floating Point Timestamp", + DOUBLE, + 0 ); + WRITE_HDF_FIELD( "Duration", + "Duration", + "Operation Duration", + DOUBLE, + 0 ); + WRITE_HDF_FIELD( "Bytes", + "Bytes", + "Bytes Requested", + LONG, + 0 ); + WRITE_HDF_FIELD( "Processor Number", + "Node", + "Processor number", + INTEGER, + 0 ); + + recordLength = (int)(hdfRecordPointer - recordBuffer); + + hdfRecordPointer = recordBuffer; + sddfWriteInteger( &hdfRecordPointer, recordLength ); + + putBytes( recordBuffer, (unsigned) recordLength ); } #endif /* PCF_BUILD */ diff --git a/pablo/ProcTrace.h b/pablo/ProcTrace.h index f4650d5..6ff2911 100644 --- a/pablo/ProcTrace.h +++ b/pablo/ProcTrace.h @@ -99,7 +99,7 @@ LAST_TRACE_TYPE=MPI_SUMMARY_TRACE, NUM_HDF_IDS } ; -#define SUPPRESS_MPIO_TRACE 2 +#define SUPPRESS_MPIO_TRACE 6 #define ID_HDF_Last_Entry ID_ALLHDF void HDFinitTrace( const char *, int trace_id, ... ); |