diff options
Diffstat (limited to 'pablo/PabloHDF.c')
| -rw-r--r-- | pablo/PabloHDF.c | 2741 |
1 files changed, 1667 insertions, 1074 deletions
diff --git a/pablo/PabloHDF.c b/pablo/PabloHDF.c index 8a61687..b890b07 100644 --- a/pablo/PabloHDF.c +++ b/pablo/PabloHDF.c @@ -126,9 +126,10 @@ extern void preInitIOTrace( void ); #define ID_timeStamp 9999 #define DUMMY_HDF 10000 -#ifdef HAVE_PARALLEL -#include "mpio.h" -#endif /* HAVE_PARALLEL*/ +#ifdef H5_HAVE_PARALLEL +#include "mpi.h" +int HDF_get_Bytes( MPI_Datatype datatype, int count ); +#endif /* H5_HAVE_PARALLEL*/ void HDFinitTrace_RT ( const char *, int ); void HDFinitTrace_SDDF ( const char *, int ); @@ -144,6 +145,7 @@ void endHDFtraceEvent (int , int , char *, int ); void HDFtraceEvent_RT ( int , HDFsetInfo *, unsigned ); void HDFtraceIOEvent( int , void *, unsigned ); extern int IOtracingEnabled; +extern int suppressMPIOtrace; char *hdfRecordPointer; double WriteTotals = 0.0; double ReadTotals = 0.0; @@ -166,132 +168,162 @@ double ReadTotals = 0.0; // fortran to C interface. * // This is called from hdfinittracef_ * //======================================================================*/ -void hinittracex_( char *file, int *len, int flags[], int *nflags, - unsigned *out_sw ) +void +hinittracex_( char *file, + int *len, + int flags[], + int *nflags, + unsigned *out_sw ) { - char *traceFileName; - int i; - traceFileName = (char *)malloc(*len+1); - for ( i = 0; i < *len; ++i ) { - traceFileName[i] = file[i]; - } - traceFileName[*len+1] = 0; - /*==============================================================* - // Allocate space for trace indicators. * - //==============================================================*/ - procTrace = ( int * ) malloc( NUM_HDF_IDS*sizeof(int) ); - if ( procTrace == NULL ) { - fprintf(stderr,">> Error: Unable to allocate procTrace "); - fprintf(stderr,"array in program HDFinitTrace. <<<\n"); - fprintf(stderr,">>> Exiting program! <<<\n"); - exit (-1); - } - /*==============================================================* - // Initialize to 0. * - //==============================================================*/ - for ( i = 0; i <= NUM_HDF_IDS; ++i ) { - procTrace[i] = 0; - } - /*==============================================================* - // Read in the flags indicating which procedures to trace. * - // The last parameter passed is an indicator of the type of * - // tracing to do. This indicator has a value larger than any * - // of the flags. * - //==============================================================*/ - for ( i = 0; i < *nflags; ++i ) { - procTrace[flags[i]] = 1; - } - OUTPUT_SWITCH = *out_sw; - /*==============================================================* - // if no flags were passed, the default is to trace all of the * - // procedures. * - //==============================================================*/ - if ( *nflags == 0 || procTrace[ID_ALLHDF] ) { - for ( i = ID_HDF_Last_Entry + 1; i < NUM_HDF_IDS; ++i ) { - procTrace[i] = 1; - } - } - if ( OUTPUT_SWITCH == RUNTIME_TRACE - || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) { - HDFinitTrace_SDDF( traceFileName, OUTPUT_SWITCH ); - IOtracingEnabled = 1; - } else if ( OUTPUT_SWITCH == SUMMARY_TRACE - || OUTPUT_SWITCH == MPI_SUMMARY_TRACE ) { - HDFinitTrace_RT( traceFileName, OUTPUT_SWITCH ); - IOtracingEnabled = 1; - } else if ( OUTPUT_SWITCH == NO_TRACE ) { - IOtracingEnabled = 0; - } else { - fprintf(stderr,">> Error in HDFinitTrace: the third argument "); - fprintf(stderr,"must have a value between %4d<<\n",RUNTIME_TRACE); - fprintf(stderr,">> and %4d, inclusive.",NO_TRACE); - fprintf(stderr," The value received was %4u.", OUTPUT_SWITCH); - fprintf(stderr," Exiting Program. <<\n"); - exit (-1); - } + char *traceFileName; + int i; + traceFileName = (char *)malloc(*len+1); + for ( i = 0; i < *len; ++i ) + { + traceFileName[i] = file[i]; + } + traceFileName[*len+1] = 0; + /*===================================================================* + // Allocate space for trace indicators. * + //===================================================================*/ + procTrace = ( int * ) malloc( NUM_HDF_IDS*sizeof(int) ); + if ( procTrace == NULL ) + { + fprintf(stderr,">> Error: Unable to allocate procTrace "); + fprintf(stderr,"array in program HDFinitTrace. <<<\n"); + fprintf(stderr,">>> Exiting program! <<<\n"); + exit (-1); + } + /*===================================================================* + // Initialize to 0. * + //===================================================================*/ + for ( i = 0; i <= NUM_HDF_IDS; ++i ) + { + procTrace[i] = 0; + } + /*===================================================================* + // Read in the flags indicating which procedures to trace. * + // The last parameter passed is an indicator of the type of * + // tracing to do. This indicator has a value larger than any * + // of the flags. * + //===================================================================*/ + for ( i = 0; i < *nflags; ++i ) + { + procTrace[flags[i]] = 1; + } + OUTPUT_SWITCH = *out_sw; + /*===================================================================* + // if no flags were passed, the default is to trace all of the * + // procedures. * + //===================================================================*/ + if ( *nflags == 0 || procTrace[ID_ALLHDF] ) + { + for ( i = 0; i < NUM_HDF_IDS; ++i ) + { + procTrace[i] = 1; + } + } + if ( OUTPUT_SWITCH == RUNTIME_TRACE + || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) + { + HDFinitTrace_SDDF( traceFileName, OUTPUT_SWITCH ); + IOtracingEnabled = 1; + } + else if ( OUTPUT_SWITCH == SUMMARY_TRACE + || OUTPUT_SWITCH == MPI_SUMMARY_TRACE ) + { + HDFinitTrace_RT( traceFileName, OUTPUT_SWITCH ); + IOtracingEnabled = 1; + } + else if ( OUTPUT_SWITCH == NO_TRACE ) + { + IOtracingEnabled = 0; + } + else + { + fprintf(stderr,">> Error in HDFinitTrace: the third argument "); + fprintf(stderr,"must have a value between %4d<<\n",RUNTIME_TRACE); + fprintf(stderr,">> and %4d, inclusive.",NO_TRACE); + fprintf(stderr," The value received was %4u.", OUTPUT_SWITCH); + fprintf(stderr," Exiting Program. <<\n"); + exit (-1); + } } void HDFinitTrace( const char *traceFileName, int id_flag, ... ) { - int i, nIDs; - va_list ap; - - /*==============================================================* - // Allocate space for trace indicators. * - //==============================================================*/ - procTrace = ( int * ) malloc( NUM_HDF_IDS*sizeof(int) ); - if ( procTrace == NULL ) { - fprintf(stderr,">> Error: Unable to allocate procTrace "); - fprintf(stderr,"array in program HDFinitTrace. <<<\n"); - fprintf(stderr,">>> Exiting program! <<<\n"); - exit (-1); - } - /*==============================================================* - // Initialize to 0. * - //==============================================================*/ - for ( i = 0; i < NUM_HDF_IDS; ++i ) { - procTrace[i] = 0; - } - /*==============================================================* - // Read in the flags indicating which procedures to trace. * - // The last parameter passed is an indicator of the type of * - // tracing to do. This indicator has a value larger than any * - // of the flags. * - //==============================================================*/ - nIDs = 0; - va_start( ap, id_flag ); - while ( id_flag > NO_TRACE ) { - procTrace[id_flag] = 1; - ++nIDs; - id_flag = va_arg ( ap, int ); - } - OUTPUT_SWITCH = id_flag; - /*==============================================================* - // if no flags were passed, the default is to trace all of the * - // procedures. * - //==============================================================*/ - if ( nIDs == 0 || procTrace[ID_ALLHDF] ) { - for ( i = ID_HDF_Last_Entry + 1; i < NUM_HDF_IDS; ++i ) { - procTrace[i] = 1; - } - } - if ( OUTPUT_SWITCH == RUNTIME_TRACE - || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) { - HDFinitTrace_SDDF( traceFileName, OUTPUT_SWITCH ); - IOtracingEnabled = 1; - } else if ( OUTPUT_SWITCH == SUMMARY_TRACE - || OUTPUT_SWITCH == MPI_SUMMARY_TRACE ) { - HDFinitTrace_RT( traceFileName, OUTPUT_SWITCH ); - IOtracingEnabled = 1; - } else if ( OUTPUT_SWITCH == NO_TRACE ) { - IOtracingEnabled = 0; - } else { - fprintf(stderr,">> Error in HDFinitTrace: the third argument "); - fprintf(stderr,"must have a value between %4d<<\n",RUNTIME_TRACE); - fprintf(stderr,">> and %4d, inclusive.",NO_TRACE); - fprintf(stderr," The value received was %4u.", OUTPUT_SWITCH); - fprintf(stderr," Exiting Program. <<\n"); - exit (-1); - } + int i, nIDs; + va_list ap; + + /*===================================================================* + // Allocate space for trace indicators. * + //===================================================================*/ + procTrace = ( int * ) malloc( NUM_HDF_IDS*sizeof(int) ); + if ( procTrace == NULL ) + { + fprintf(stderr,">> Error: Unable to allocate procTrace "); + fprintf(stderr,"array in program HDFinitTrace. <<<\n"); + fprintf(stderr,">>> Exiting program! <<<\n"); + exit (-1); + } + /*===================================================================* + // Initialize to 0. * + //===================================================================*/ + for ( i = 0; i < NUM_HDF_IDS; ++i ) + { + procTrace[i] = 0; + } + /*===================================================================* + // Read in the flags indicating which procedures to trace. * + // The last parameter passed is an indicator of the type of * + // tracing to do. This indicator has a value larger than any * + // of the flags. * + //===================================================================*/ + nIDs = 0; + va_start( ap, id_flag ); + while ( id_flag > NO_TRACE ) + { + procTrace[id_flag] = 1; + ++nIDs; + id_flag = va_arg ( ap, int ); + } + OUTPUT_SWITCH = id_flag; + /*===================================================================* + // if no flags were passed, the default is to trace all of the * + // procedures. * + //===================================================================*/ + if ( nIDs == 0 || procTrace[ID_ALLHDF] ) + { + for ( i = 0; i < NUM_HDF_IDS; ++i ) + { + procTrace[i] = 1; + } + } + suppressMPIOtrace = TRUE; + if ( OUTPUT_SWITCH == RUNTIME_TRACE + || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) + { + HDFinitTrace_SDDF( traceFileName, OUTPUT_SWITCH ); + IOtracingEnabled = 1; + } + else if ( OUTPUT_SWITCH == SUMMARY_TRACE + || OUTPUT_SWITCH == MPI_SUMMARY_TRACE ) + { + HDFinitTrace_RT( traceFileName, OUTPUT_SWITCH ); + IOtracingEnabled = 1; + } + else if ( OUTPUT_SWITCH == NO_TRACE ) + { + IOtracingEnabled = 0; + } + else + { + fprintf(stderr,">> Error in HDFinitTrace: the third argument "); + fprintf(stderr,"must have a value between %4d<<\n",RUNTIME_TRACE); + fprintf(stderr,">> and %4d, inclusive.",NO_TRACE); + fprintf(stderr," The value received was %4u.", OUTPUT_SWITCH); + fprintf(stderr," Exiting Program. <<\n"); + exit (-1); + } } /*======================================================================* // NAME * @@ -303,124 +335,155 @@ void HDFinitTrace( const char *traceFileName, int id_flag, ... ) //======================================================================*/ void hdfendtrace_( void ) { - HDFendTrace (); + HDFendTrace (); } void HDFendTrace(void) { - if ( OUTPUT_SWITCH == RUNTIME_TRACE - || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) { - HDFendTrace_SDDF( OUTPUT_SWITCH ); - } else if ( OUTPUT_SWITCH == SUMMARY_TRACE - || OUTPUT_SWITCH == MPI_SUMMARY_TRACE ) { - HDFendTrace_RT( OUTPUT_SWITCH ); - } + if ( OUTPUT_SWITCH == RUNTIME_TRACE + || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) + { + HDFendTrace_SDDF( OUTPUT_SWITCH ); + } + else if ( OUTPUT_SWITCH == SUMMARY_TRACE + || OUTPUT_SWITCH == MPI_SUMMARY_TRACE ) + { + HDFendTrace_RT( OUTPUT_SWITCH ); + } } void startHDFtraceEvent(int eventID) { - if ( OUTPUT_SWITCH == RUNTIME_TRACE - || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) { - traceEvent( eventID, NULL, 0 ) ; - } else { - HDFtraceEvent_RT( eventID, NULL, 0 ) ; - } + if ( OUTPUT_SWITCH == RUNTIME_TRACE + || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) + { + traceEvent( eventID, NULL, 0 ) ; + } + else + { + HDFtraceEvent_RT( eventID, NULL, 0 ) ; + } } void endHDFtraceEvent(int eventID, int setID, char *setName, int IDtype ) { - HDFsetInfo info; - info.setID = setID; - info.setName = setName; - if ( OUTPUT_SWITCH == RUNTIME_TRACE - || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) { - traceEvent( eventID, (char *)&info, 0 ) ; - } else if ( OUTPUT_SWITCH == SUMMARY_TRACE - || OUTPUT_SWITCH == MPI_SUMMARY_TRACE ) { - HDFtraceEvent_RT( eventID, &info, 0 ) ; - } else if ( OUTPUT_SWITCH != NO_TRACE ) { - fprintf(stderr,"endHDFtraceEvent: "); - fprintf(stderr,"invalid OUTPUT_SWITCH %d, IDtype = %d\n", + HDFsetInfo info; + info.setID = setID; + info.setName = setName; + if ( OUTPUT_SWITCH == RUNTIME_TRACE + || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) + { + traceEvent( eventID, (char *)&info, 0 ) ; + } + else if ( OUTPUT_SWITCH == SUMMARY_TRACE + || OUTPUT_SWITCH == MPI_SUMMARY_TRACE ) + { + HDFtraceEvent_RT( eventID, &info, 0 ) ; + } + else if ( OUTPUT_SWITCH != NO_TRACE ) + { + fprintf(stderr,"endHDFtraceEvent: "); + fprintf(stderr,"invalid OUTPUT_SWITCH %d, IDtype = %d\n", OUTPUT_SWITCH, IDtype ) ; - } + } } -/******************************************************************************/ - -/*+ Open routines +*/ -/*+ ------------- +*/ -/*+ +*/ -/*+ Routine: FILE *HDFtraceFOPEN( const char *filename, const char *type ) +*/ -/*+ substitute for fopen() +*/ -/*+ generates fopenBeginID, fopenEndID +*/ -/*+ record Open (fopenBegin) +*/ -/*+ Mode = -1 +*/ -/*+ +*/ -FILE *HDFtraceFOPEN( const char *filename, const char *type ) +/*****************************************************************************/ +/* The HDFtraceXXXX routines are substitutes for the standard I/O routines. */ +/* When libhdf5-inst.a is compiled, macros in HDFTrace.h substitute the name */ +/* HDFtraceWrite for write, HDFtraceRead for Read, etc. These routines are */ +/* then called when standard I/O is done. */ +/*****************************************************************************/ +/*****************************************************************************/ +/*+ Open routines +*/ +/*+ ------------- +*/ +/*+ +*/ +/*+ Routine: FILE *HDFtraceFOPEN( const char *filename, const char *type ) +*/ +/*+ substitute for fopen() +*/ +/*+ generates fopenBeginID, fopenEndID +*/ +/*+ record Open (fopenBegin) +*/ +/*+ Mode = -1 +*/ +/*+ +*/ +/*****************************************************************************/ +FILE*HDFtraceFOPEN( const char *filename, const char *type ) { - FILE *fp; - int fd, id; - int flags = 0; - struct open_args openArgs; - size_t typeLen; + FILE *fp; + int fd, id; + int flags = 0; + struct open_args openArgs; + size_t typeLen; - if ( IOtracingEnabled ) { - strcpy( openArgs.filename, filename ); + if ( IOtracingEnabled ) + { + strcpy( openArgs.filename, filename ); - /* check for 'b' - usually if 2 chars, second is '+' */ - typeLen = strlen( type ); - if ( ( typeLen == 2 ) && ( type [1] == 'b' ) ) { - typeLen = 1; - } - - if ( typeLen == 1 ) { - switch( type[0] ) { - case 'r': - flags = flags | O_RDONLY; - break; - case 'w': - flags = O_TRUNC | O_CREAT | O_WRONLY; - break; - case 'a': - flags = flags | O_APPEND | O_CREAT | O_WRONLY; - break; - } - } else { - switch( type[0] ) { - case 'r': - flags = O_RDWR; - break; - case 'w': - flags = O_TRUNC | O_CREAT | O_RDWR; - break; - case 'a': - flags = O_APPEND | O_CREAT | O_RDWR; - break; - } - } - openArgs.flags = flags; - openArgs.mode= -1; - - HDFtraceIOEvent( fopenBeginID, (void *)&openArgs, sizeof(openArgs) ); - } - - fp = fopen( filename, type ); - if ( fp != NULL ) { - fd = fileno( fp ); - id = set_c_mappedID( fd ); - } else { - id = -1; - } - - if ( IOtracingEnabled ) { - HDFtraceIOEvent( fopenEndID, (void *) &id, int_SIZE ); - } - - return( fp ); + /* check for 'b' - usually if 2 chars, second is '+' */ + typeLen = strlen( type ); + if ( ( typeLen == 2 ) && ( type [1] == 'b' ) ) + { + typeLen = 1; + } + + if ( typeLen == 1 ) + { + switch( type[0] ) + { + case 'r': + flags = flags | O_RDONLY; + break; + case 'w': + flags = O_TRUNC | O_CREAT | O_WRONLY; + break; + case 'a': + flags = flags | O_APPEND | O_CREAT | O_WRONLY; + break; + } + } + else + { + switch( type[0] ) + { + case 'r': + flags = O_RDWR; + break; + case 'w': + flags = O_TRUNC | O_CREAT | O_RDWR; + break; + case 'a': + flags = O_APPEND | O_CREAT | O_RDWR; + break; + } + } + openArgs.flags = flags; + openArgs.mode= -1; + + HDFtraceIOEvent( fopenBeginID, (void *)&openArgs, sizeof(openArgs) ); + } + + fp = fopen( filename, type ); + if ( fp != NULL ) + { + fd = fileno( fp ); + id = set_c_mappedID( fd ); + } + else + { + id = -1; + } + + if ( IOtracingEnabled ) + { + HDFtraceIOEvent( fopenEndID, (void *) &id, int_SIZE ); + } + + return( fp ); } -/*+ Routine: int HDFtraceCREAT( const char *path, mode_t mode ) +*/ -/*+ substitute for creat() +*/ -/*+ generates openBeginID, openEndID +*/ -/*+ record Open (openBeginID) +*/ -/*+ +*/ -int HDFtraceCREAT( const char *path, mode_t mode ) +/*****************************************************************************/ +/*+ Routine: int HDFtraceCREAT( const char *path, mode_t mode ) +*/ +/*+ substitute for creat() +*/ +/*+ generates openBeginID, openEndID +*/ +/*+ record Open (openBeginID) +*/ +/*+ +*/ +/*****************************************************************************/ +int +HDFtraceCREAT( const char *path, mode_t mode ) { struct open_args openArgs; int fd; @@ -444,504 +507,583 @@ int HDFtraceCREAT( const char *path, mode_t mode ) return( fd ); } -/******************************************************************************/ - -/*+ Flush routines +*/ -/*+ -------------- +*/ -/*+ +*/ -/*+ Routine: int HDFtraceFFLUSH( FILE *stream ) +*/ -/*+ substitute for fflush() +*/ -/*+ generates fflushBeginID, fflushEndID +*/ -/*+ record Flush (fflushBeginID) +*/ -/*+ +*/ +/*****************************************************************************/ +/*+ Flush routines +*/ +/*+ -------------- +*/ +/*+ +*/ +/*+ Routine: int HDFtraceFFLUSH( FILE *stream ) +*/ +/*+ substitute for fflush() +*/ +/*+ generates fflushBeginID, fflushEndID +*/ +/*+ record Flush (fflushBeginID) +*/ +/*+ +*/ +/*****************************************************************************/ int HDFtraceFFLUSH( FILE *stream ) { - int ret; - int id; - int fd; - - if ( IOtracingEnabled ) { - /* - * If stream is NULL, all files open for write are flushed. - * We show this with a -2 in the trace record as too much overhead - * to try and tell what files those are and generate individual - * trace records. - */ - if ( stream == NULL ) { - id = -2; - } else { - fd = fileno( stream ); - id = c_mappedID( fd ); - HDFtraceIOEvent( fflushBeginID, (void *) 0, int_SIZE ); - } - } - - ret = fflush( stream ); - - if ( IOtracingEnabled ) { - HDFtraceIOEvent( fflushEndID, (void *) &id, 0 ); - } - - /* - * Note that if fflush called on stream open for reading, the file pointer - * is moved to EOF if it isn't there already. We don't account for that - * in our file positioning information. - */ - - return( ret ); + int ret; + int id; + int fd; + + if ( IOtracingEnabled ) + { + /* + * If stream is NULL, all files open for write are flushed. + * We show this with a -2 in the trace record as too much overhead + * to try and tell what files those are and generate individual + * trace records. + */ + if ( stream == NULL ) + { + id = -2; + } + else + { + fd = fileno( stream ); + id = c_mappedID( fd ); + HDFtraceIOEvent( fflushBeginID, (void *) 0, int_SIZE ); + } + } + + ret = fflush( stream ); + + if ( IOtracingEnabled ) + { + HDFtraceIOEvent( fflushEndID, (void *) &id, 0 ); + } + + /* + * Note that if fflush called on stream open for reading, the file pointer + * is moved to EOF if it isn't there already. We don't account for that + * in our file positioning information. + */ + + return( ret ); } -/******************************************************************************/ -/*+ Close routines +*/ -/*+ -------------- +*/ -/*+ +*/ -/*+ Routine: int HDFtraceFCLOSE( FILE *stream ) +*/ -/*+ substitute for fclose() +*/ -/*+ generates fcloseBeginID, fcloseEndID +*/ -/*+ record Close (fcloseBeginID) +*/ -/*+ +*/ -int HDFtraceFCLOSE( FILE *stream ) +/*****************************************************************************/ +/*+ Close routines +*/ +/*+ -------------- +*/ +/*+ +*/ +/*+ Routine: int HDFtraceFCLOSE( FILE *stream ) +*/ +/*+ substitute for fclose() +*/ +/*+ generates fcloseBeginID, fcloseEndID +*/ +/*+ record Close (fcloseBeginID) +*/ +/*+ +*/ +/*****************************************************************************/ +int +HDFtraceFCLOSE( FILE *stream ) { - int ret; - int id; - int fd = fileno( stream ); + int ret; + int id; + int fd = fileno( stream ); - if ( IOtracingEnabled ) { - id = c_mappedID( fd ); - HDFtraceIOEvent( fcloseBeginID, (void *) &id, int_SIZE ); - } + if ( IOtracingEnabled ) + { + id = c_mappedID( fd ); + HDFtraceIOEvent( fcloseBeginID, (void *) &id, int_SIZE ); + } - ret = fclose( stream ); + ret = fclose( stream ); - if ( IOtracingEnabled ) { - HDFtraceIOEvent( fcloseEndID, (void *) 0, 0 ); - } + if ( IOtracingEnabled ) + { + HDFtraceIOEvent( fcloseEndID, (void *) 0, 0 ); + } - return( ret ); + return( ret ); } -/*+ Routine: int HDFtrace3OPEN( char *path, int flags, mode_t mode ) +*/ -/*+ substitute for open() when called with 3 arguments +*/ -/*+ generates openBeginID, openEndID +*/ -/*+ record Open (openBeginID) +*/ -/*+ +*/ -int HDFtrace3OPEN( const char *path, int flags, mode_t mode ) +/*****************************************************************************/ +/*+ Routine: int HDFtrace3OPEN( char *path, int flags, mode_t mode ) +*/ +/*+ substitute for open() when called with 3 arguments +*/ +/*+ generates openBeginID, openEndID +*/ +/*+ record Open (openBeginID) +*/ +/*+ +*/ +/*****************************************************************************/ +int +HDFtrace3OPEN( const char *path, int flags, mode_t mode ) { - struct open_args openArgs; - int fd; - int id; + struct open_args openArgs; + int fd; + int id; - if ( IOtracingEnabled ) { - strcpy( openArgs.filename, path ); - openArgs.flags = flags; - openArgs.mode = (int) mode; + if ( IOtracingEnabled ) + { + strcpy( openArgs.filename, path ); + openArgs.flags = flags; + openArgs.mode = (int) mode; - HDFtraceIOEvent( openBeginID, (char *)&openArgs, sizeof(openArgs) ); - } + HDFtraceIOEvent( openBeginID, (char *)&openArgs, sizeof(openArgs) ); + } - fd = open( path, flags, mode ); - id = set_c_mappedID( fd ); + fd = open( path, flags, mode ); + id = set_c_mappedID( fd ); - if ( IOtracingEnabled ) { - HDFtraceIOEvent( openEndID, (char *) &id, int_SIZE ); - } + if ( IOtracingEnabled ) + { + HDFtraceIOEvent( openEndID, (char *) &id, int_SIZE ); + } - return( fd ); + return( fd ); } -/*+ Routine: int HDFtraceCLOSE( int fd ) +*/ -/*+ substitute for close() +*/ -/*+ generates closeBeginID, closeEndID +*/ -/*+ record Close (closeBeginID) +*/ -/*+ +*/ -int HDFtraceCLOSE( int fd ) +/*****************************************************************************/ +/*+ Routine: int HDFtraceCLOSE( int fd ) +*/ +/*+ substitute for close() +*/ +/*+ generates closeBeginID, closeEndID +*/ +/*+ record Close (closeBeginID) +*/ +/*+ +*/ +/*****************************************************************************/ +int +HDFtraceCLOSE( int fd ) { - int ret; - int id; + int ret; + int id; - if ( IOtracingEnabled ) { - id = c_mappedID( fd ); - HDFtraceIOEvent( closeBeginID, (void *) &id, int_SIZE ); - } + if ( IOtracingEnabled ) + { + id = c_mappedID( fd ); + HDFtraceIOEvent( closeBeginID, (void *) &id, int_SIZE ); + } - ret = close( fd ); + ret = close( fd ); - if ( IOtracingEnabled ) { - HDFtraceIOEvent( closeEndID, (void *) 0, 0 ); - } + if ( IOtracingEnabled ) + { + HDFtraceIOEvent( closeEndID, (void *) 0, 0 ); + } - return( ret ); + return( ret ); } -/******************************************************************************/ -/*+ Read routines +*/ -/*+ ------------- +*/ -/*+ +*/ -/*+ Routine: int HDFtraceREAD( int fd, char *buf, int nbyte ) +*/ -/*+ substitute for read() +*/ -/*+ generates readBeginID, readEndID +*/ -/*+ record Read (readBeginID) +*/ -/*+ Number Variables = 1 +*/ -/*+ Cause = -1 +*/ -/*+ +*/ -ssize_t HDFtraceREAD( int fd, void *buf, size_t nbyte ) +/*****************************************************************************/ +/*+ Read routines +*/ +/*+ ------------- +*/ +/*+ +*/ +/*+ Routine: int HDFtraceREAD( int fd, char *buf, int nbyte ) +*/ +/*+ substitute for read() +*/ +/*+ generates readBeginID, readEndID +*/ +/*+ record Read (readBeginID) +*/ +/*+ Number Variables = 1 +*/ +/*+ Cause = -1 +*/ +/*+ +*/ +/*****************************************************************************/ +ssize_t +HDFtraceREAD( int fd, void *buf, size_t nbyte ) { - struct read_write_args readArgs; - ssize_t ret; - int bytes; - CLOCK t1, t2, incDur; - - if ( IOtracingEnabled ) { - readArgs.fileID = c_mappedID( fd ); - readArgs.numVariables = 1; - readArgs.cause = -1; - - HDFtraceIOEvent( readBeginID, (void *) &readArgs, sizeof(readArgs) ); - } - - t1 = getClock(); - ret = read( fd, buf, nbyte ); - t2 = getClock(); - incDur = clockSubtract(t2,t1); - ReadTotals += clockToSeconds( incDur ); - - if ( IOtracingEnabled ) { - if ( ret > 0 ) { - bytes = (int)ret; - } else { - bytes = 0; - } - HDFtraceIOEvent( readEndID, (void *) &bytes, int_SIZE ); - } - - return( ret ); + struct read_write_args readArgs; + ssize_t ret; + int bytes; + CLOCK t1, t2, incDur; + + if ( IOtracingEnabled ) + { + readArgs.fileID = c_mappedID( fd ); + readArgs.numVariables = 1; + readArgs.cause = -1; + + HDFtraceIOEvent( readBeginID, (void *) &readArgs, sizeof(readArgs) ); + } + + t1 = getClock(); + ret = read( fd, buf, nbyte ); + t2 = getClock(); + incDur = clockSubtract(t2,t1); + ReadTotals += clockToSeconds( incDur ); + + if ( IOtracingEnabled ) + { + if ( ret > 0 ) + { + bytes = (int)ret; + } + else + { + bytes = 0; + } + HDFtraceIOEvent( readEndID, (void *) &bytes, int_SIZE ); + } + + return( ret ); } - -/*+ Routine: int HDFtraceFREAD( char *ptr, int size, int nitems, +*/ -/*+ FILE *stream) +*/ -/*+ substitute for fread() +*/ -/*+ generates freadBeginID, freadEndID +*/ -/*+ record Read (freadBeginID) +*/ -/*+ Number Variables = nitems +*/ -/*+ Cause = -1 +*/ -/*+ +*/ -size_t HDFtraceFREAD( void *ptr, size_t size, size_t nitems, FILE *stream ) + +/*****************************************************************************/ +/*+ Routine: int HDFtraceFREAD( char *ptr, int size, int nitems, +*/ +/*+ FILE *stream) +*/ +/*+ substitute for fread() +*/ +/*+ generates freadBeginID, freadEndID +*/ +/*+ record Read (freadBeginID) +*/ +/*+ Number Variables = nitems +*/ +/*+ Cause = -1 +*/ +/*+ +*/ +/*****************************************************************************/ +size_t +HDFtraceFREAD( void *ptr, size_t size, size_t nitems, FILE *stream ) { - struct read_write_args readArgs; - size_t ret; - int nbytes; - int fd = fileno( stream ); - CLOCK t1, t2, incDur; - - if ( IOtracingEnabled ) { - readArgs.fileID = c_mappedID( fd ); - readArgs.numVariables = (int)nitems; - readArgs.cause = -1; - HDFtraceIOEvent( freadBeginID, (void *) &readArgs, sizeof(readArgs) ); - } - - t1 = getClock(); - ret = fread( ptr, size, nitems, stream ); - t2 = getClock(); - incDur = clockSubtract(t2,t1); - ReadTotals += clockToSeconds( incDur ); - - if ( IOtracingEnabled ) { - if ( ret > 0 ) { - nbytes = (int)(ret * size) ; - } else { - nbytes = 0; - } - HDFtraceIOEvent( freadEndID, (void *) &nbytes, int_SIZE ); - } - - return( ret ); + struct read_write_args readArgs; + size_t ret; + int nbytes; + int fd = fileno( stream ); + CLOCK t1, t2, incDur; + + if ( IOtracingEnabled ) + { + readArgs.fileID = c_mappedID( fd ); + readArgs.numVariables = (int)nitems; + readArgs.cause = -1; + HDFtraceIOEvent( freadBeginID, (void *) &readArgs, sizeof(readArgs) ); + } + + t1 = getClock(); + ret = fread( ptr, size, nitems, stream ); + t2 = getClock(); + incDur = clockSubtract(t2,t1); + ReadTotals += clockToSeconds( incDur ); + + if ( IOtracingEnabled ) + { + if ( ret > 0 ) + { + nbytes = (int)(ret * size) ; + } + else + { + nbytes = 0; + } + HDFtraceIOEvent( freadEndID, (void *) &nbytes, int_SIZE ); + } + + return( ret ); } -/******************************************************************************/ -/*+ Seek routines +*/ -/*+ ------------- +*/ -/*+ +*/ -/*+ Routine: off_t HDFtraceLSEEK( int fd, off_t offset, int whence ) +*/ -/*+ substitute for lseek() +*/ -/*+ generates lseekBeginID, lseekEndID +*/ -/*+ record Seek (lseekBeginID) +*/ +/*****************************************************************************/ +/*+ Seek routines +*/ +/*+ ------------- +*/ +/*+ +*/ +/*+ Routine: off_t HDFtraceLSEEK( int fd, off_t offset, int whence ) +*/ +/*+ substitute for lseek() +*/ +/*+ generates lseekBeginID, lseekEndID +*/ +/*+ record Seek (lseekBeginID) +*/ /*+ +*/ -off_t HDFtraceLSEEK( int fd, off_t offset, int whence ) +/*****************************************************************************/ +off_t +HDFtraceLSEEK( int fd, off_t offset, int whence ) { - struct seek_args seekArgs; - off_t ret; - long arg; + struct seek_args seekArgs; + off_t ret; + long arg; - if ( IOtracingEnabled ) { - seekArgs.fileID = c_mappedID( fd ); - seekArgs.offset = (int) offset; - seekArgs.whence = whence; + if ( IOtracingEnabled ) + { + seekArgs.fileID = c_mappedID( fd ); + seekArgs.offset = (int) offset; + seekArgs.whence = whence; - HDFtraceIOEvent( lseekBeginID, (void *) &seekArgs, sizeof(seekArgs) ); - } + HDFtraceIOEvent( lseekBeginID, (void *) &seekArgs, sizeof(seekArgs) ); + } - ret = lseek( fd, offset, whence ); + ret = lseek( fd, offset, whence ); - if ( IOtracingEnabled ) { - arg = (long) ret; - HDFtraceIOEvent( lseekEndID, (void *)&arg, long_SIZE ); - } + if ( IOtracingEnabled ) + { + arg = (long) ret; + HDFtraceIOEvent( lseekEndID, (void *)&arg, long_SIZE ); + } - return( ret ); + return( ret ); } -/*+ routine: int HDF traceFSEEK( FILE *stream, long offset, int whence ) +*/ -/*+ substitute for fseek() +*/ -/*+ generates fseekBeginID, fseekEndID +*/ -/*+ record Seek (fseekBeginID) +*/ -/*+ +*/ -int HDFtraceFSEEK( FILE *stream, long offset, int whence ) +/*****************************************************************************/ +/*+ routine: int HDF traceFSEEK( FILE *stream, long offset, int whence ) +*/ +/*+ substitute for fseek() +*/ +/*+ generates fseekBeginID, fseekEndID +*/ +/*+ record Seek (fseekBeginID) +*/ +/*+ +*/ +/*****************************************************************************/ +int +HDFtraceFSEEK( FILE *stream, long offset, int whence ) { - struct seek_args seekArgs; - int ret; - long arg; - int fd = fileno( stream ); + struct seek_args seekArgs; + int ret; + long arg; + int fd = fileno( stream ); - if ( IOtracingEnabled ) { - seekArgs.fileID = c_mappedID( fd );; - seekArgs.offset = (int) offset; - seekArgs.whence = whence; + if ( IOtracingEnabled ) + { + seekArgs.fileID = c_mappedID( fd );; + seekArgs.offset = (int) offset; + seekArgs.whence = whence; - HDFtraceIOEvent( fseekBeginID, (void *) &seekArgs, sizeof(seekArgs) ); - } + HDFtraceIOEvent( fseekBeginID, (void *) &seekArgs, sizeof(seekArgs) ); + } - ret = fseek( stream, offset, whence ); + ret = fseek( stream, offset, whence ); - if ( IOtracingEnabled ) { - arg = ftell( stream ); - HDFtraceIOEvent( fseekEndID, (void *)&arg, long_SIZE ); - } + if ( IOtracingEnabled ) + { + arg = ftell( stream ); + HDFtraceIOEvent( fseekEndID, (void *)&arg, long_SIZE ); + } - return( ret ); + return( ret ); } #ifdef fpos_t +/*****************************************************************************/ /*+ Routine: int HDFtraceFSETPOS( FILE *stream, const fpos_t *position ) +*/ -/*+ substitute for fsetpos() +*/ -/*+ generates fsetposBeginID, fsetposEndID +*/ -/*+ record Seek (fsetposBeginID) +*/ -/*+ +*/ -int HDFtraceFSETPOS( FILE stream, const fpos_t *position ) +/*+ substitute for fsetpos() +*/ +/*+ generates fsetposBeginID, fsetposEndID +*/ +/*+ record Seek (fsetposBeginID) +*/ +/*+ +*/ +/*****************************************************************************/ +int +HDFtraceFSETPOS( FILE stream, const fpos_t *position ) { - struct seek_args seekArgs; - int ret; - long arg; - int fd = fileno( stream ); + struct seek_args seekArgs; + int ret; + long arg; + int fd = fileno( stream ); - if ( IOtracingEnabled ) { - seekArgs.fileID = c_mappedID( fd );; - seekArgs.offset = (int) *position; - seekArgs.whence = SEEK_SET; + if ( IOtracingEnabled ) + { + seekArgs.fileID = c_mappedID( fd );; + seekArgs.offset = (int) *position; + seekArgs.whence = SEEK_SET; - HDFtraceIOEvent( fsetposBeginID, (void *) &seekArgs, sizeof(seekArgs) ); - } + HDFtraceIOEvent( fsetposBeginID, (void *) &seekArgs, sizeof(seekArgs) ); + } - ret = fsetpos( stream, position ); + ret = fsetpos( stream, position ); - if ( IOtracingEnabled ) { - arg = (long) *position; - HDFtraceIOEvent( fsetposEndID, (void *)&arg, long_SIZE ); - } + if ( IOtracingEnabled ) + { + arg = (long) *position; + HDFtraceIOEvent( fsetposEndID, (void *)&arg, long_SIZE ); + } - return( ret ); + return( ret ); } #endif /* fpos_t */ -/*+ Routine: void HDFtraceREWIND ( FILE *stream ) +*/ -/*+ substitute for rewind() +*/ -/*+ generates rewindBeginID, rewindEndID +*/ -/*+ record Seek (rewindBeginID) +*/ -/*+ Offset = 0 +*/ -/*+ Whence = SEEK_SET +*/ -/*+ +*/ +/*****************************************************************************/ +/*+ Routine: void HDFtraceREWIND ( FILE *stream ) +*/ +/*+ substitute for rewind() +*/ +/*+ generates rewindBeginID, rewindEndID +*/ +/*+ record Seek (rewindBeginID) +*/ +/*+ Offset = 0 +*/ +/*+ Whence = SEEK_SET +*/ +/*+ +*/ +/*****************************************************************************/ void HDFtraceREWIND( FILE *stream ) { - struct seek_args seekArgs; - long arg; - int fd = fileno( stream ); + struct seek_args seekArgs; + long arg; + int fd = fileno( stream ); - if ( IOtracingEnabled ) { - seekArgs.fileID = c_mappedID( fd ); - seekArgs.offset = 0; - seekArgs.whence = SEEK_SET; + if ( IOtracingEnabled ) + { + seekArgs.fileID = c_mappedID( fd ); + seekArgs.offset = 0; + seekArgs.whence = SEEK_SET; - HDFtraceIOEvent( rewindBeginID, (void *) &seekArgs, sizeof(seekArgs) ); - } + HDFtraceIOEvent( rewindBeginID, (void *) &seekArgs, sizeof(seekArgs) ); + } - rewind( stream ); + rewind( stream ); - if ( IOtracingEnabled ) { - arg = 0; - HDFtraceIOEvent( rewindEndID, (void *)&arg, long_SIZE ); - } + if ( IOtracingEnabled ) + { + arg = 0; + HDFtraceIOEvent( rewindEndID, (void *)&arg, long_SIZE ); + } - return; + return; } -/******************************************************************************/ -/*+ Write routines +*/ -/*+ -------------- +*/ -/*+ +*/ -/*+ Routine: int HDFtraceWRITE( int fd, char *buf, int nbyte ) +*/ -/*+ substitute for write() +*/ -/*+ generates writeBeginID, writeEndID +*/ -/*+ record Write (writeBeginID) +*/ -/*+ Number Variables = 1 +*/ -/*+ Cause = -1 +*/ -/*+ +*/ +/*****************************************************************************/ +/*+ Write routines +*/ +/*+ -------------- +*/ +/*+ +*/ +/*+ Routine: int HDFtraceWRITE( int fd, char *buf, int nbyte ) +*/ +/*+ substitute for write() +*/ +/*+ generates writeBeginID, writeEndID +*/ +/*+ record Write (writeBeginID) +*/ +/*+ Number Variables = 1 +*/ +/*+ Cause = -1 +*/ +/*+ +*/ +/*****************************************************************************/ ssize_t HDFtraceWRITE( int fd, const void *buf, size_t nbyte ) { - struct read_write_args writeArgs; - ssize_t ret; - int bytes; - CLOCK t1, t2, incDur; - - if ( IOtracingEnabled ) { - writeArgs.fileID = c_mappedID( fd ); - writeArgs.numVariables = 1; - writeArgs.cause = -1; - - HDFtraceIOEvent( writeBeginID, (void *) &writeArgs, sizeof(writeArgs) ); - } - - t1 = getClock(); - ret = write( fd, buf, nbyte ); - t2 = getClock(); - incDur = clockSubtract(t2,t1); - WriteTotals += clockToSeconds( incDur ); - - if ( IOtracingEnabled ) { - if ( ret > 0 ) { - bytes = (int)ret; - } else { - bytes = 0; - } - HDFtraceIOEvent( writeEndID, (void *) &bytes, int_SIZE ); - } - return( ret ); + struct read_write_args writeArgs; + ssize_t ret; + int bytes; + CLOCK t1, t2, incDur; + + if ( IOtracingEnabled ) + { + writeArgs.fileID = c_mappedID( fd ); + writeArgs.numVariables = 1; + writeArgs.cause = -1; + + HDFtraceIOEvent( writeBeginID, (void *) &writeArgs, sizeof(writeArgs) ); + } + + t1 = getClock(); + ret = write( fd, buf, nbyte ); + t2 = getClock(); + incDur = clockSubtract(t2,t1); + WriteTotals += clockToSeconds( incDur ); + + if ( IOtracingEnabled ) + { + if ( ret > 0 ) + { + bytes = (int)ret; + } + else + { + bytes = 0; + } + HDFtraceIOEvent( writeEndID, (void *) &bytes, int_SIZE ); + } + return( ret ); } -/*+ Routine: size_t HDFtraceFWRITE( const char *ptr, int size, int nitems, +*/ -/*+ FILE *stream ) +*/ -/*+ substitute for fwrite() +*/ -/*+ generates fwriteBeginID, fwriteEndID +*/ -/*+ record Write (fwriteBeginID) +*/ -/*+ Number Variables = nitems +*/ -/*+ Cause = -1 +*/ -/*+ +*/ -size_t HDFtraceFWRITE(const void *ptr,size_t size,size_t nitems,FILE *stream ) +/*****************************************************************************/ +/*+ Routine: size_t HDFtraceFWRITE( const char *ptr, int size, int nitems,+*/ +/*+ FILE *stream ) +*/ +/*+ substitute for fwrite() +*/ +/*+ generates fwriteBeginID, fwriteEndID +*/ +/*+ record Write (fwriteBeginID) +*/ +/*+ Number Variables = nitems +*/ +/*+ Cause = -1 +*/ +/*+ +*/ +/*****************************************************************************/ +size_t +HDFtraceFWRITE(const void *ptr,size_t size,size_t nitems,FILE *stream ) { - struct read_write_args writeArgs; - size_t ret; - int nbytes; - int fd = fileno( stream ); - CLOCK t1, t2, incDur; - - if ( IOtracingEnabled ) { - writeArgs.fileID = c_mappedID( fd ); - writeArgs.numVariables = (int)nitems; - writeArgs.cause = -1; - - HDFtraceIOEvent( fwriteBeginID, (void *) &writeArgs, sizeof(writeArgs) ); - } - - t1 = getClock(); - ret = fwrite( ptr, size, nitems, stream ); - t2 = getClock(); - incDur = clockSubtract(t2,t1); - WriteTotals += clockToSeconds( incDur ); - - - if ( IOtracingEnabled ) { - if ( ret > 0 ) { - nbytes = (int)(ret * size) ; - } else { - nbytes = 0; - } - HDFtraceIOEvent( fwriteEndID, (void *) &nbytes, int_SIZE ); - } - - return( ret ); + struct read_write_args writeArgs; + size_t ret; + int nbytes; + int fd = fileno( stream ); + CLOCK t1, t2, incDur; + + if ( IOtracingEnabled ) + { + writeArgs.fileID = c_mappedID( fd ); + writeArgs.numVariables = (int)nitems; + writeArgs.cause = -1; + + HDFtraceIOEvent(fwriteBeginID, (void *)&writeArgs, sizeof(writeArgs)); + } + + t1 = getClock(); + ret = fwrite( ptr, size, nitems, stream ); + t2 = getClock(); + incDur = clockSubtract(t2,t1); + WriteTotals += clockToSeconds( incDur ); + + + if ( IOtracingEnabled ) + { + if ( ret > 0 ) + { + nbytes = (int)(ret * size) ; + } + else + { + nbytes = 0; + } + HDFtraceIOEvent( fwriteEndID, (void *) &nbytes, int_SIZE ); + } + + return( ret ); } -/*+ Routine: int HDFtracePUTS( char *s ) +*/ -/*+ substitute for puts() +*/ -/*+ generates fwriteBeginID, fwriteEndID +*/ -/*+ record Write (fwriteBeginID) +*/ -/*+ Number Variables = 1 +*/ -/*+ Cause = -1 +*/ -/*+ +*/ -int HDFtracePUTS( char *s ) +/*****************************************************************************/ +/*+ Routine: int HDFtracePUTS( char *s ) +*/ +/*+ substitute for puts() +*/ +/*+ generates fwriteBeginID, fwriteEndID +*/ +/*+ record Write (fwriteBeginID) +*/ +/*+ Number Variables = 1 +*/ +/*+ Cause = -1 +*/ +/*+ +*/ +/*****************************************************************************/ +int +HDFtracePUTS( char *s ) { - struct read_write_args writeArgs; - int ret; - int fd = fileno( stdout ); + struct read_write_args writeArgs; + int ret; + int fd = fileno( stdout ); - if ( IOtracingEnabled ) { - writeArgs.fileID = c_mappedID( fd ); - writeArgs.numVariables = 1; - writeArgs.cause = -1; + if ( IOtracingEnabled ) + { + writeArgs.fileID = c_mappedID( fd ); + writeArgs.numVariables = 1; + writeArgs.cause = -1; - HDFtraceIOEvent( fwriteBeginID, (void *) &writeArgs, sizeof(writeArgs) ); - } + HDFtraceIOEvent( fwriteBeginID, (void *) &writeArgs, sizeof(writeArgs) ); + } - ret = puts( s ); + ret = puts( s ); - if ( IOtracingEnabled ) { - HDFtraceIOEvent( fwriteEndID, (void *) &ret, int_SIZE ); - } + if ( IOtracingEnabled ) + { + HDFtraceIOEvent( fwriteEndID, (void *) &ret, int_SIZE ); + } - return( ret ); + return( ret ); } -/*+ Routine: int HDFtraceFPUTC( int c, FILE *stream ) +*/ -/*+ substitute for fputc() +*/ -/*+ generates fwriteBeginID, fwriteEndID +*/ -/*+ record Write (fwriteBeginID) +*/ -/*+ Number Variables = 1 +*/ -/*+ Cause = -1 +*/ -/*+ +*/ -int HDFtraceFPUTC( int c, FILE *stream ) +/*****************************************************************************/ +/*+ Routine: int HDFtraceFPUTC( int c, FILE *stream ) +*/ +/*+ substitute for fputc() +*/ +/*+ generates fwriteBeginID, fwriteEndID +*/ +/*+ record Write (fwriteBeginID) +*/ +/*+ Number Variables = 1 +*/ +/*+ Cause = -1 +*/ +/*+ +*/ +/*****************************************************************************/ +int +HDFtraceFPUTC( int c, FILE *stream ) { - struct read_write_args writeArgs; - int ret; - int nbytes = char_SIZE; - int fd = fileno( stream ); + struct read_write_args writeArgs; + int ret; + int nbytes = char_SIZE; + int fd = fileno( stream ); - if ( IOtracingEnabled ) { - writeArgs.fileID = c_mappedID( fd ); - writeArgs.numVariables = 1; - writeArgs.cause = -1; + if ( IOtracingEnabled ) + { + writeArgs.fileID = c_mappedID( fd ); + writeArgs.numVariables = 1; + writeArgs.cause = -1; - HDFtraceIOEvent( fwriteBeginID, (void *) &writeArgs, sizeof(writeArgs) ); - } + HDFtraceIOEvent( fwriteBeginID, (void *) &writeArgs, sizeof(writeArgs) ); + } - ret = fputc( c, stream ); + ret = fputc( c, stream ); - if ( IOtracingEnabled ) { - if ( ret == EOF ) { - nbytes = 0; - HDFtraceIOEvent( fwriteEndID, (void *) &nbytes, int_SIZE ); - } - } + if ( IOtracingEnabled ) + { + if ( ret == EOF ) + { + nbytes = 0; + HDFtraceIOEvent( fwriteEndID, (void *) &nbytes, int_SIZE ); + } + } return( ret ); } -/*+ Routine: int HDFtraceFPUTS( char *s, FILE *stream ) +*/ -/*+ substitute for fputs() +*/ -/*+ generates fwriteBeginID, fwriteEndID +*/ -/*+ record Write (fwriteBeginID) +*/ -/*+ Number Variables = 1 +*/ -/*+ Cause = -1 +*/ -/*+ +*/ +/*****************************************************************************/ +/*+ Routine: int HDFtraceFPUTS( char *s, FILE *stream ) +*/ +/*+ substitute for fputs() +*/ +/*+ generates fwriteBeginID, fwriteEndID +*/ +/*+ record Write (fwriteBeginID) +*/ +/*+ Number Variables = 1 +*/ +/*+ Cause = -1 +*/ +/*+ +*/ +/*****************************************************************************/ int HDFtraceFPUTS( const char *s, FILE *stream ) { struct read_write_args writeArgs; @@ -1059,178 +1201,362 @@ void PabloHDFTrace( int ID ) exit (-1); } } -#ifdef HAVE_PARALLEL -/*======================================================================* -// Pass call through to regular MPIO entry except in case of Real Time * -// tracing. * -// Note: The regular MPIO entry may or may not be instrumented. * -//======================================================================*/ -int HDF_MPI_File_open( MPI_Comm comm, char *filename, int amode, - MPI_Info info, MPI_File *fh ) +#ifdef H5_HAVE_PARALLEL +#include "MPIO_Trace.h" +#include "MPIO_EventArgs.h" +#include "MPIO_Data.h" + +/* Global variable declarations and definitions. */ +static int HDFlocalNode = 0; +int HDFmyNode; +int myHDFid = 3; +/* Function prototypes */ +int HDF_get_mode( int ); +int HDF_get_source( int ); +int HDF_get_comm( MPI_Comm ); +int HDF_get_Datatype( MPI_Datatype ); +int HDF_get_DataRep( char* ); +int HDF_get_Bytes( MPI_Datatype, int ); +int HDF_MPI_Get_count( MPI_Status *, MPI_Datatype, int *, int ); +/************************************************************************/ +/* MPI_Get_count isn't always implemented correctly and may cause the */ +/* program to fail. This is a kluge to allow the program to complete. */ +/************************************************************************/ +int HDF_MPI_Get_count( MPI_Status* status, + MPI_Datatype t, + int* result, + int input ) { - 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; +#ifdef LAM_MPI + *result = input; +#else + MPI_Get_count( status, t, result ); +#endif + return; } - +/* Get the mode at the file openning */ +int HDF_get_mode( int amode ) +{ + if( amode == MPI_MODE_RDONLY || amode == MPI_MODE_RDWR || + amode == MPI_MODE_WRONLY || amode == MPI_MODE_CREATE || + amode == MPI_MODE_EXCL || amode == MPI_MODE_DELETE_ON_CLOSE || + amode == MPI_MODE_UNIQUE_OPEN || + /* amode == MPI_MODE_SEQUENTIAL || */ + amode == MPI_MODE_APPEND ) + return amode; + else + return PABLO_MPI_MODE_NULL; +} -/*======================================================================* -// Pass call through to regular MPIO entry except in case of Real Time * -// tracing. * -// Note: The regular MPIO entry may or may not be instrumented. * -//======================================================================*/ -int HDF_MPI_File_close( MPI_File *fh ) +/* Get the node number */ +int HDF_get_source( int source ) { - int returnVal; - HDFsetInfo dataPtr; - int dataLen; + if ( source == MPI_ANY_SOURCE ) { + return PABLO_MPI_ANYSOURCE; + } - 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 ( source == MPI_PROC_NULL ) { + return PABLO_MPI_PROCNULL; + } + + else { + return source; + } } -/*======================================================================* -// Pass call through to regular MPIO entry except in case of Real Time * -// tracing. * -// Note: The regular MPIO entry may or may not be instrumented. * -//======================================================================*/ -int HDF_MPI_File_delete( char *filename, MPI_Info info ) +/* get the communicator ID */ +/* this is dummy for compatability with MPIO Traceing */ +int HDF_get_comm( MPI_Comm in_comm ) { - int returnVal; - HDFsetInfo dataPtr; - int dataLen; + return 0; +} +/* Get the MPI_Datatype (mapped to a integer) */ +int HDF_get_Datatype( MPI_Datatype datatype ) +{ + /* elementary datatypes (C) */ + if ( datatype == MPI_CHAR ) + return PABLO_MPI_CHAR; + else if ( datatype == MPI_SHORT ) + return PABLO_MPI_SHORT; + else if ( datatype == MPI_INT ) + return PABLO_MPI_INT; + else if ( datatype == MPI_LONG ) + return PABLO_MPI_LONG; + else if ( datatype == MPI_UNSIGNED_CHAR ) + return PABLO_MPI_UNSIGNED_CHAR; + else if ( datatype == MPI_UNSIGNED_SHORT ) + return PABLO_MPI_UNSIGNED_SHORT; + else if ( datatype == MPI_UNSIGNED ) + return PABLO_MPI_UNSIGNED; + else if ( datatype == MPI_UNSIGNED_LONG ) + return PABLO_MPI_UNSIGNED_LONG; + else if ( datatype == MPI_FLOAT ) + return PABLO_MPI_FLOAT; + else if ( datatype == MPI_DOUBLE ) + return PABLO_MPI_DOUBLE; + else if ( datatype == MPI_LONG_DOUBLE ) + return PABLO_MPI_LONG_DOUBLE; - 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; + /* elementary datatypes (FORTRAN) */ +#ifdef MPI_INTEGER + else if ( datatype == MPI_INTEGER ) + return PABLO_MPI_INTEGER; +#endif +#ifdef MPI_REAL + else if ( datatype == MPI_REAL ) + return PABLO_MPI_REAL; +#endif +#ifdef MPI_DOUBLE_PRECISION + else if ( datatype == MPI_DOUBLE_PRECISION ) + return PABLO_MPI_DOUBLE_PRECISION; +#endif +#ifdef MPI_COMPLEX + else if ( datatype == MPI_COMPLEX ) + return PABLO_MPI_COMPLEX; +#endif +#ifdef MPI_DOUBLE_COMPLEX + else if ( datatype == MPI_DOUBLE_COMPLEX ) + return PABLO_MPI_DOUBLE_COMPLEX; +#endif +#ifdef MPI_LOGICAL + else if ( datatype == MPI_LOGICAL ) + return PABLO_MPI_LOGICAL; +#endif +#ifdef MPI_CHARACTER + else if ( datatype == MPI_CHARACTER ) + return PABLO_MPI_CHARACTER; +#endif + + /* other datatypes (C, Fortran).*/ + else if ( datatype == MPI_BYTE ) + return PABLO_MPI_BYTE; + else if ( datatype == MPI_PACKED ) + return PABLO_MPI_PACKED; + else if ( datatype == MPI_LB ) + return PABLO_MPI_LB; + else if ( datatype == MPI_UB ) + return PABLO_MPI_UB; + + + /* reduction datatypes (C). */ + else if ( datatype == MPI_FLOAT_INT ) + return PABLO_MPI_FLOAT_INT; + else if ( datatype == MPI_DOUBLE_INT ) + return PABLO_MPI_DOUBLE_INT; + else if ( datatype == MPI_LONG_INT ) + return PABLO_MPI_LONG_INT; + else if ( datatype == MPI_2INT ) + return PABLO_MPI_2INT; + else if ( datatype == MPI_SHORT_INT ) + return PABLO_MPI_SHORT_INT; + else if ( datatype == MPI_LONG_DOUBLE_INT ) + return PABLO_MPI_LONG_DOUBLE_INT; + + /* Reduction datatypes (FORTRAN) */ +#ifdef MPI_2REAL + else if ( datatype == MPI_2REAL ) + return PABLO_MPI_2REAL; +#endif +#ifdef MPI_2DOUBLE_PRECISION + else if ( datatype == MPI_2DOUBLE_PRECISION ) + return PABLO_MPI_2DOUBLE_PRECISION; +#endif +#ifdef MPI_2INTEGER + else if ( datatype == MPI_2INTEGER ) + return PABLO_MPI_2INTEGER; +#endif + +#ifdef MPI_2COMPLEX + else if ( datatype == MPI_2COMPLEX ) + return PABLO_MPI_2COMPLEX; +#endif +#ifdef MPI_2DOUBLE_COMPLEX + else if ( datatype == MPI_2DOUBLE_COMPLEX ) + return PABLO_MPI_2DOUBLE_COMPLEX; +#endif + +/* optional datatypes (C).*/ +#ifdef MPI_LONG_LONG_INT + else if ( datatype == MPI_LONG_LONG_INT ) + return PABLO_MPI_LONG_LONG_INT; +#endif + else if ( datatype == MPI_DATATYPE_NULL ) + return PABLO_MPI_DATATYPE_NULL; + else + return PABLO_MPI_USER_DEF; } -/*======================================================================* -// Pass call through to regular MPIO entry except in case of Real Time * -// tracing. * -// Note: The regular MPIO entry may or may not be instrumented. * -//======================================================================*/ -int HDF_MPI_File_set_size( MPI_File fh, MPI_Offset size ) +/* data representations */ +int HDF_get_DataRep( char* datarep ) { - 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; + if ( !strcmp( datarep, "native" ) ) + return PABLO_MPI_NATIVE; + else if ( !strcmp( datarep, "internal" ) ) + return PABLO_MPI_INTERNAL; + else if ( !strcmp( datarep, "external32" ) ) + return PABLO_MPI_EXTERNAL32; + else + return (-1); } +/*****************************************************************************/ +/* The routines below are there to bypass the MPI I/O Tracing. When MPI I/O */ +/* tracing is done with a nonstandard MPI I/O implementation, problems can */ +/* occur in linking and in data recording. */ +/* For each of the MPI I/O routines MPI_File_xxx used in HDF, there are two */ +/* entries: HDF_MPI_File_xxx and PabloMPI_File_xxx. Macros replace the */ +/* MPI_File_xxx call with HDF_MPI_File_xxx. */ +/* If SUMMARY Tracing is used */ +/* HDF_MPI_File_xxx routine will record entry data in a table, call the */ +/* IF RUNTIME Tracing is used */ +/* HDF_MPI_File_xxx routine calls PabloMPI_File_xxx. This routine writes */ +/* data to the trace file, calls the standard MPI_File_xxx routine, then */ +/* records exit data to a trace file. */ +/* The PabloMPI_File_xxx functionality could have been incorporated into the */ +/* HDF_MPI_File_xxx routine, but was not done so for expediency. */ +/*****************************************************************************/ +int PabloMPI_File_open( MPI_Comm comm, + char *filename, + int amode, + MPI_Info info, + MPI_File *fh ) ; + +int PabloMPI_File_close( MPI_File *fh ) ; + +int PabloMPI_File_set_size( MPI_File fh, MPI_Offset size ) ; + +int PabloMPI_File_get_size( MPI_File fh, MPI_Offset *size ) ; + +int PabloMPI_File_set_view( MPI_File fh, + MPI_Offset disp, + MPI_Datatype etype, + MPI_Datatype filetype, + char *datarep, + MPI_Info info ) ; + +int PabloMPI_File_get_view( MPI_File fh, + MPI_Offset *disp, + MPI_Datatype *etype, + MPI_Datatype *filetype, + char *datarep ) ; + +int PabloMPI_File_read_at( MPI_File fh, + MPI_Offset offset, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status *status ) ; + +int PabloMPI_File_read_at_all( MPI_File fh, + MPI_Offset offset, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status *status ) ; + +int PabloMPI_File_write_at( MPI_File fh, + MPI_Offset offset, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status *status ) ; + +int PabloMPI_File_write_at_all( MPI_File fh, + MPI_Offset offset, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status *status ) ; + +int +PabloMPI_File_sync( MPI_File fh ) ; + /*======================================================================* // Pass call through to regular MPIO entry except in case of Real Time * // tracing. * // Note: The regular MPIO entry may or may not be instrumented. * //======================================================================*/ -int HDF_MPI_File_preallocate( MPI_File fh, MPI_Offset size) +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_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_open( comm, filename, amode, info, fh ); + } + else + { + dataLen = sizeof( HDFsetInfo ); + dataPtr.setID = 0; + dataPtr.setName = (char *)malloc( strlen(filename) + 1); + strcpy( dataPtr.setName , filename ); + HDFtraceEvent_RT( HDFmpiOpenID, &dataPtr, dataLen ); + returnVal = MPI_File_open( comm, filename, amode, info, fh ); + dataPtr.setID = (long)fh; + HDFtraceEvent_RT( -HDFmpiOpenID, &dataPtr, dataLen ); + } + return returnVal; } + + /*======================================================================* // Pass call through to regular MPIO entry except in case of Real Time * // tracing. * // Note: The regular MPIO entry may or may not be instrumented. * //======================================================================*/ -int HDF_MPI_File_get_size( MPI_File fh, MPI_Offset *size ) +int HDF_MPI_File_close( MPI_File *fh ) { int returnVal; HDFsetInfo dataPtr; int dataLen; - - if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) { - returnVal = MPI_File_get_size( fh, size); - } else { - dataLen = 0; - HDFtraceEvent_RT( HDFmpiGetSizeID, - &dataPtr,dataLen ); - returnVal = PMPI_File_get_size( fh, size); - HDFtraceEvent_RT( -HDFmpiGetSizeID, - &dataPtr,dataLen ); - } - return returnVal; + + if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) + { + returnVal = PabloMPI_File_close( fh ); + } + else + { + dataLen = sizeof( HDFsetInfo ); + dataPtr.setID = (long)fh; + dataPtr.setName = NULL; + HDFtraceEvent_RT( HDFmpiCloseID, &dataPtr, dataLen ); + returnVal = MPI_File_close( fh ); + HDFtraceEvent_RT( -HDFmpiCloseID, &dataPtr, dataLen ); + free( dataPtr.setName ); + } + return returnVal; } + /*======================================================================* // Pass call through to regular MPIO entry except in case of Real Time * // tracing. * // Note: The regular MPIO entry may or may not be instrumented. * //======================================================================*/ -int HDF_MPI_File_get_group( MPI_File fh, MPI_Group *group ) +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_get_group( fh, group); - } else { - dataLen = 0; - HDFtraceEvent_RT( HDFmpiGetGroupID, - &dataPtr,dataLen ); - returnVal = PMPI_File_get_group( fh, group); - HDFtraceEvent_RT( -HDFmpiGetGroupID, - &dataPtr,dataLen ); - } - return returnVal; + if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) + { + returnVal = PabloMPI_File_set_size( fh, size ); + } + else + { + dataLen = 1; + dataPtr.setID = (long)fh; + HDFtraceEvent_RT( HDFmpiSetSizeID,&dataPtr,dataLen ); + returnVal = MPI_File_set_size( fh, size ); + HDFtraceEvent_RT( -HDFmpiSetSizeID, &dataPtr, dataLen ); + } + return returnVal; } /*======================================================================* @@ -1238,20 +1564,21 @@ int HDF_MPI_File_get_group( MPI_File fh, MPI_Group *group ) // tracing. * // Note: The regular MPIO entry may or may not be instrumented. * //======================================================================*/ -int HDF_MPI_File_get_amode( MPI_File fh, int *amode ) +int HDF_MPI_File_get_size( MPI_File fh, MPI_Offset *size ) { int returnVal; HDFsetInfo dataPtr; int dataLen; if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) { - returnVal = MPI_File_get_amode( fh, amode); + returnVal = PabloMPI_File_get_size( fh, size); } else { - dataLen = 0; - HDFtraceEvent_RT( HDFmpiGetAmodeID, + dataLen = 1; + dataPtr.setID = (long)fh; + HDFtraceEvent_RT( HDFmpiGetSizeID, &dataPtr,dataLen ); - returnVal = PMPI_File_get_amode( fh, amode); - HDFtraceEvent_RT( -HDFmpiGetAmodeID, + returnVal = MPI_File_get_size( fh, size); + HDFtraceEvent_RT( -HDFmpiGetSizeID, &dataPtr,dataLen ); } return returnVal; @@ -1270,13 +1597,14 @@ int HDF_MPI_File_set_view( MPI_File fh, MPI_Offset disp, MPI_Datatype etype, int dataLen; if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) { - returnVal = MPI_File_set_view( fh, disp, etype, filetype, + returnVal = PabloMPI_File_set_view( fh, disp, etype, filetype, datarep, info ); } else { - dataLen = 0; + dataLen = 1; + dataPtr.setID = (long)fh; HDFtraceEvent_RT( HDFmpiSetViewID, &dataPtr,dataLen ); - returnVal = PMPI_File_set_view( fh, disp, etype, filetype, + returnVal = MPI_File_set_view( fh, disp, etype, filetype, datarep, info ); HDFtraceEvent_RT( -HDFmpiSetViewID, &dataPtr,dataLen ); @@ -1292,23 +1620,26 @@ int HDF_MPI_File_set_view( MPI_File fh, MPI_Offset disp, MPI_Datatype etype, int HDF_MPI_File_get_view( MPI_File fh, MPI_Offset *disp, MPI_Datatype *etype, MPI_Datatype *filetype, char *datarep ) { - int returnVal; - HDFsetInfo dataPtr; - int dataLen; - - if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) { - returnVal = MPI_File_get_view(fh, disp, etype, filetype, datarep); - } else { - dataLen = 0; - HDFtraceEvent_RT( HDFmpiSetViewID, - &dataPtr,dataLen ); - returnVal = PMPI_File_get_view(fh, disp, etype, filetype, datarep); - HDFtraceEvent_RT( -HDFmpiSetViewID, + int returnVal; + HDFsetInfo dataPtr; + int dataLen; + + if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) + { + returnVal = PabloMPI_File_get_view(fh, disp, etype, filetype, datarep); + } + else + { + dataLen = 1; + dataPtr.setID = (long)fh; + HDFtraceEvent_RT( HDFmpiSetViewID, &dataPtr,dataLen ); - returnVal = PMPI_File_get_view(fh, disp, etype, filetype, datarep); + returnVal = MPI_File_get_view(fh, disp, etype, filetype, datarep); + HDFtraceEvent_RT( -HDFmpiSetViewID, &dataPtr,dataLen ); + returnVal = MPI_File_get_view(fh, disp, etype, filetype, datarep); - } - return returnVal; + } + return returnVal; } /*======================================================================* @@ -1322,16 +1653,28 @@ int HDF_MPI_File_read_at( MPI_File fh, MPI_Offset offset, void *buf, int returnVal; HDFsetInfo dataPtr; int dataLen; + int rCount; if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) { - returnVal = MPI_File_read_at( fh, offset, buf, count, datatype, + returnVal = PabloMPI_File_read_at( fh, offset, buf, count, datatype, status ); } else { - dataLen = 0; + dataLen = sizeof(dataPtr); + dataPtr.setID = (long)fh; + dataPtr.numBytes = HDF_get_Bytes( datatype, count ); HDFtraceEvent_RT( HDFmpiReadAtID, &dataPtr,dataLen ); - returnVal = PMPI_File_read_at( fh, offset, buf, count, datatype, + returnVal = MPI_File_read_at( fh, offset, buf, count, datatype, status ); + HDF_MPI_Get_count(status,datatype,&rCount,count); + if ( rCount < 0 || rCount > count ) + { + dataPtr.numBytes = -1; + } + else + { + dataPtr.numBytes = HDF_get_Bytes( datatype, rCount ); + } HDFtraceEvent_RT( -HDFmpiReadAtID, &dataPtr,dataLen ); } @@ -1350,16 +1693,28 @@ int HDF_MPI_File_read_at_all( MPI_File fh, MPI_Offset offset, void *buf, int returnVal; HDFsetInfo dataPtr; int dataLen; + int rCount; if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) { - returnVal = MPI_File_read_at_all( fh, offset, buf, + returnVal = PabloMPI_File_read_at_all( fh, offset, buf, count, datatype, status ); } else { - dataLen = 0; + dataLen = sizeof(dataPtr); + dataPtr.setID = (long)fh; + dataPtr.numBytes = HDF_get_Bytes( datatype, count ); HDFtraceEvent_RT( HDFmpiReadAtAllID, &dataPtr,dataLen ); - returnVal = PMPI_File_read_at_all( fh, offset, buf, + returnVal = MPI_File_read_at_all( fh, offset, buf, count, datatype, status ); + HDF_MPI_Get_count(status,datatype,&rCount,count); + if ( rCount < 0 || rCount > count ) + { + dataPtr.numBytes = -1; + } + else + { + dataPtr.numBytes = HDF_get_Bytes( datatype, rCount ); + } HDFtraceEvent_RT( -HDFmpiReadAtAllID, &dataPtr,dataLen ); } @@ -1375,23 +1730,36 @@ int HDF_MPI_File_write_at( MPI_File fh, MPI_Offset offset, void *buf, int count, MPI_Datatype datatype, MPI_Status *status ) { - int returnVal; - HDFsetInfo dataPtr; - int dataLen; - - if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) { - returnVal = MPI_File_write_at( fh, offset, buf, count, datatype, - status ); - } else { - dataLen = 0; - HDFtraceEvent_RT( HDFmpiWriteAtID, - &dataPtr,dataLen ); - returnVal = PMPI_File_write_at( fh, offset, buf, count, datatype, - status ); - HDFtraceEvent_RT( -HDFmpiWriteAtID, - &dataPtr,dataLen ); - } - return returnVal; + int returnVal; + HDFsetInfo dataPtr; + int dataLen; + int rCount; + + if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) + { + returnVal = PabloMPI_File_write_at( fh, offset, buf, count, datatype, + status ); + } + else + { + dataLen = sizeof(dataPtr); + dataPtr.setID = (long)fh; + dataPtr.numBytes = HDF_get_Bytes( datatype, count ); + HDFtraceEvent_RT( HDFmpiWriteAtID, &dataPtr,dataLen ); + returnVal = MPI_File_write_at( fh, offset, buf, count, datatype, + status ); + HDF_MPI_Get_count(status,datatype,&rCount,count); + if ( rCount < 0 || rCount > count ) + { + dataPtr.numBytes = -1; + } + else + { + dataPtr.numBytes = HDF_get_Bytes( datatype, rCount ); + } + HDFtraceEvent_RT( -HDFmpiWriteAtID, &dataPtr,dataLen ); + } + return returnVal; } /*======================================================================* @@ -1405,16 +1773,28 @@ int HDF_MPI_File_write_at_all( MPI_File fh, MPI_Offset offset, void *buf, int returnVal; HDFsetInfo dataPtr; int dataLen; + int numBytes; if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) { - returnVal = MPI_File_write_at_all( fh, offset, buf, + returnVal = PabloMPI_File_write_at_all( fh, offset, buf, count, datatype, status ); } else { - dataLen = 0; + dataLen = sizeof(dataPtr); + dataPtr.setID = (long)fh; + dataPtr.numBytes = HDF_get_Bytes( datatype, count ); HDFtraceEvent_RT( HDFmpiWriteAtAllID, &dataPtr,dataLen ); - returnVal = PMPI_File_write_at_all( fh, offset, buf, + returnVal = MPI_File_write_at_all( fh, offset, buf, count, datatype, status ); + if ( returnVal == MPI_SUCCESS ) + { + numBytes = HDF_get_Bytes( datatype, count ); + } + else + { + numBytes = -1; + } + dataPtr.numBytes = numBytes; HDFtraceEvent_RT( -HDFmpiWriteAtAllID, &dataPtr,dataLen ); } @@ -1426,317 +1806,530 @@ int HDF_MPI_File_write_at_all( MPI_File fh, MPI_Offset offset, void *buf, // tracing. * // Note: The regular MPIO entry may or may not be instrumented. * //======================================================================*/ -int HDF_MPI_File_iread_at( MPI_File fh, MPI_Offset offset, void *buf, - int count, MPI_Datatype datatype, MPIO_Request *request ) -{ - return MPI_File_iread_at( fh, offset, buf, count, datatype, request ); -} - -/*======================================================================* -// Pass call through to regular MPIO entry except in case of Real Time * -// tracing. * -// Note: The regular MPIO entry may or may not be instrumented. * -//======================================================================*/ -int HDF_MPI_File_iwrite_at( MPI_File fh, MPI_Offset offset, void *buf, - int count, MPI_Datatype datatype, MPIO_Request *request) -{ - return MPI_File_iwrite_at( fh, offset, buf, count, datatype, request ); -} - -/*======================================================================* -// Pass call through to regular MPIO entry except in case of Real Time * -// tracing. * -// Note: The regular MPIO entry may or may not be instrumented. * -//======================================================================*/ -int HDF_MPI_File_read( MPI_File fh, void *buf, int count, - MPI_Datatype datatype, MPI_Status *status) +int HDF_MPI_File_sync( MPI_File fh ) { int returnVal; HDFsetInfo dataPtr; int dataLen; - if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) { - returnVal = MPI_File_read( fh, buf, count, datatype, status ); + if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) { + returnVal = PabloMPI_File_sync ( fh ); } else { - dataLen = 0; - HDFtraceEvent_RT( HDFmpiReadID, + dataLen = 1; + dataPtr.setID = (long)fh; + HDFtraceEvent_RT( HDFmpiSyncID, &dataPtr,dataLen ); - returnVal = PMPI_File_read( fh, buf, count, datatype, status ); - HDFtraceEvent_RT( -HDFmpiReadID, + returnVal = MPI_File_sync ( fh ); + HDFtraceEvent_RT( -HDFmpiSyncID, &dataPtr,dataLen ); - } + } return returnVal; } -/*======================================================================* -// Pass call through to regular MPIO entry except in case of Real Time * -// tracing. * -// Note: The regular MPIO entry may or may not be instrumented. * -//======================================================================*/ -int HDF_MPI_File_read_all( MPI_File fh, void *buf, int count, - MPI_Datatype datatype, MPI_Status *status) +int HDF_get_Bytes( MPI_Datatype datatype, int count ) { - int returnVal; - HDFsetInfo dataPtr; - int dataLen; - - if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) { - returnVal = MPI_File_read_all( fh, buf, count, datatype, status ); - } else { - dataLen = 0; - HDFtraceEvent_RT( HDFmpiReadAllID, - &dataPtr,dataLen ); - returnVal = PMPI_File_read_all( fh, buf, count, datatype, status ); - HDFtraceEvent_RT( -HDFmpiReadAllID, - &dataPtr,dataLen ); - } - return returnVal; + int nm_bytes; + + MPI_Type_size( datatype, &nm_bytes ); + return( nm_bytes * count ); } -/*======================================================================* -// Pass call through to regular MPIO entry except in case of Real Time * -// tracing. * -// Note: The regular MPIO entry may or may not be instrumented. * -//======================================================================*/ -int HDF_MPI_File_write( MPI_File fh, void *buf, int count, - MPI_Datatype datatype, MPI_Status *status ) +int +PabloMPI_File_open( MPI_Comm comm, + char *filename, + int amode, + MPI_Info info, + MPI_File *fh ) { - int returnVal; - HDFsetInfo dataPtr; - int dataLen; - - if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) { - returnVal = MPI_File_write( fh, buf, count, datatype, status ); - } else { - dataLen = 0; - HDFtraceEvent_RT( HDFmpiWriteID, - &dataPtr,dataLen ); - returnVal = PMPI_File_write( fh, buf, count, datatype, status ); - HDFtraceEvent_RT( -HDFmpiWriteID, - &dataPtr,dataLen ); - } - return returnVal; + int returnVal; + + struct mpiOpenBeginArgs mpiOpenBeginArguments; + struct mpiOpenEndArgs mpiOpenEndArguments; + +#ifdef DEBUG + fprintf( debugFile, "MPI_File_open\n" ); + fflush( debugFile ); +#endif /* DEBUG */ + + MPI_Comm_rank( comm, &HDFlocalNode ); + MPI_Comm_rank( MPI_COMM_WORLD, &HDFmyNode ); + + mpiOpenBeginArguments.localNode = HDF_get_source( HDFlocalNode ); + mpiOpenBeginArguments.globalNode = HDFmyNode; + mpiOpenBeginArguments.communicatorID = HDF_get_comm( comm ); + mpiOpenBeginArguments.mode = amode; + strcpy( mpiOpenBeginArguments.fileName, filename ); + + /* Generate entry record */ + traceIOEvent( mpiOpenBeginID, (char *) &mpiOpenBeginArguments, + sizeof( mpiOpenBeginArguments ) ); + + returnVal = MPI_File_open( comm, filename, amode, info, fh ); + + mpiOpenEndArguments.localNode = HDF_get_source( HDFlocalNode ); + mpiOpenEndArguments.globalNode = HDFmyNode; + /* the fileID is mapped to the fp's address */ + myHDFid++; + mpiOpenEndArguments.fileID = myHDFid; + + /* Generate exit record */ + traceIOEvent( mpiOpenEndID, (char *) &mpiOpenEndArguments, + sizeof( mpiOpenEndArguments ) ); + + return returnVal; } -/*======================================================================* -// Pass call through to regular MPIO entry except in case of Real Time * -// tracing. * -// Note: The regular MPIO entry may or may not be instrumented. * -//======================================================================*/ -int HDF_MPI_File_write_all( MPI_File fh, void *buf, int count, - MPI_Datatype datatype, MPI_Status *status ) +int +PabloMPI_File_close( MPI_File *fh ) { - int returnVal; - HDFsetInfo dataPtr; - int dataLen; - - if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) { - returnVal =MPI_File_write_all( fh, buf, count, datatype, status ); - } else { - dataLen = 0; - HDFtraceEvent_RT( HDFmpiWriteAllID, - &dataPtr,dataLen ); - returnVal = PMPI_File_write_all( fh, buf, count, datatype, status ); - HDFtraceEvent_RT( -HDFmpiWriteAllID, - &dataPtr,dataLen ); - } - return returnVal; + int returnVal; + + struct mpiCloseBeginArgs mpiCloseBeginArguments; + struct mpiCloseEndArgs mpiCloseEndArguments; + +#ifdef DEBUG + fprintf( debugFile, "MPI_File_close\n" ); + fflush( debugFile ); +#endif /* DEBUG */ + + mpiCloseBeginArguments.localNode = HDFlocalNode; + mpiCloseBeginArguments.globalNode = HDFmyNode; + mpiCloseBeginArguments.fileID = myHDFid; + + /* Generate entry record */ + traceIOEvent( mpiCloseBeginID, (char *) &mpiCloseBeginArguments, + sizeof( mpiCloseBeginArguments ) ); + + returnVal = MPI_File_close( fh ); + + mpiCloseEndArguments.localNode = HDFlocalNode; + mpiCloseEndArguments.globalNode = HDFmyNode; + mpiCloseEndArguments.fileID = myHDFid; + + /* Generate exit record */ + traceIOEvent( mpiCloseEndID, (char *) &mpiCloseEndArguments, + sizeof( mpiCloseEndArguments ) ); + + return returnVal; } -/*======================================================================* -// Pass call through to regular MPIO entry except in case of Real Time * -// tracing. * -// Note: The regular MPIO entry may or may not be instrumented. * -//======================================================================*/ -int HDF_MPI_File_iread( MPI_File fh, void *buf, int count, - MPI_Datatype datatype, MPIO_Request *request ) +int +PabloMPI_File_set_size( MPI_File fh, MPI_Offset size ) { - return MPI_File_iread( fh, buf, count, datatype, request ); + int returnVal; + + struct mpiSetSizeBeginArgs mpiSetSizeBeginArguments; + struct mpiSetSizeEndArgs mpiSetSizeEndArguments; + +#ifdef DEBUG + fprintf( debugFile, "MPI_File_set_size\n" ); + fflush( debugFile ); +#endif /* DEBUG */ + + mpiSetSizeBeginArguments.localNode = HDFlocalNode; + mpiSetSizeBeginArguments.globalNode = HDFmyNode; + /* mpiSetSizeBeginArguments.fileID = (long) (&fh); */ + mpiSetSizeBeginArguments.fileID = myHDFid; + + mpiSetSizeBeginArguments.fileSize = (long) size; + + /* Generate entry record */ + traceIOEvent( mpiSetSizeBeginID, (char *) &mpiSetSizeBeginArguments, + sizeof( mpiSetSizeBeginArguments ) ); + + returnVal = MPI_File_set_size( fh, size ); + + mpiSetSizeEndArguments.localNode = HDFlocalNode; + mpiSetSizeEndArguments.globalNode = HDFmyNode; + /* mpiSetSizeEndArguments.fileID = (long) ( &fh ); */ + mpiSetSizeEndArguments.fileID = myHDFid; + + /* Generate entry record */ + traceIOEvent( mpiSetSizeEndID, (char *) &mpiSetSizeEndArguments, + sizeof( mpiSetSizeEndArguments ) ); + + return returnVal; } -/*======================================================================* -// Pass call through to regular MPIO entry except in case of Real Time * -// tracing. * -// Note: The regular MPIO entry may or may not be instrumented. * -//======================================================================*/ -int HDF_MPI_File_iwrite( MPI_File fh, void *buf, int count, - MPI_Datatype datatype, MPIO_Request *request ) +int +PabloMPI_File_get_size( MPI_File fh, MPI_Offset *size ) { - return MPI_File_iwrite( fh, buf, count, datatype, request ); + int returnVal; + + struct mpiGetSizeBeginArgs mpiGetSizeBeginArguments; + struct mpiGetSizeEndArgs mpiGetSizeEndArguments; + +#ifdef DEBUG + fprintf( debugFile, "MPI_File_get_size\n" ); + fflush( debugFile ); +#endif /* DEBUG */ + + mpiGetSizeBeginArguments.localNode = HDFlocalNode; + mpiGetSizeBeginArguments.globalNode = HDFmyNode; + /* mpiGetSizeBeginArguments.fileID = (long) (&fh); */ + mpiGetSizeBeginArguments.fileID = myHDFid; + + /* Generate entry record */ + traceIOEvent( mpiGetSizeBeginID, (char *) &mpiGetSizeBeginArguments, + sizeof( mpiGetSizeBeginArguments ) ); + + returnVal = MPI_File_get_size( fh, size); + + mpiGetSizeEndArguments.localNode = HDFlocalNode; + mpiGetSizeEndArguments.globalNode = HDFmyNode; + /* mpiGetSizeEndArguments.fileID = (long) ( &fh ); */ + mpiGetSizeEndArguments.fileID = myHDFid; + + mpiGetSizeEndArguments.fileSize = (long) (*size); + + /* Generate entry record */ + traceIOEvent( mpiGetSizeEndID, (char *) &mpiGetSizeEndArguments, + sizeof( mpiGetSizeEndArguments ) ); + + return returnVal; } -/*======================================================================* -// Pass call through to regular MPIO entry except in case of Real Time * -// tracing. * -// Note: The regular MPIO entry may or may not be instrumented. * -//======================================================================*/ -int HDF_MPI_File_seek( MPI_File fh, MPI_Offset offset, int whence ) +int +PabloMPI_File_set_view( MPI_File fh, + MPI_Offset disp, + MPI_Datatype etype, + MPI_Datatype filetype, + char *datarep, + MPI_Info info ) { + int returnVal; - int returnVal; - HDFsetInfo dataPtr; - int dataLen; - - if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) { - returnVal = MPI_File_seek( fh, offset, whence ); - } else { - dataLen = 0; - HDFtraceEvent_RT( HDFmpiSeekID, - &dataPtr,dataLen ); - returnVal = PMPI_File_seek( fh, offset, whence ); - HDFtraceEvent_RT( -HDFmpiSeekID, - &dataPtr,dataLen ); - } - return returnVal; + struct mpiSetViewBeginArgs mpiSetViewBeginArguments; + struct mpiSetViewEndArgs mpiSetViewEndArguments; + +#ifdef DEBUG + fprintf( debugFile, "MPI_File_set_view\n" ); + fflush( debugFile ); +#endif /* DEBUG */ + + mpiSetViewBeginArguments.localNode = HDFlocalNode; + mpiSetViewBeginArguments.globalNode = HDFmyNode; + /* mpiSetViewBeginArguments.fileID = (long) ( &fh ); */ + mpiSetViewBeginArguments.fileID = myHDFid; + + mpiSetViewBeginArguments.disp = (long) ( disp ); + mpiSetViewBeginArguments.etype = HDF_get_Datatype( etype ); + mpiSetViewBeginArguments.fileType = HDF_get_Datatype( filetype ); + mpiSetViewBeginArguments.dataRep = HDF_get_DataRep( datarep ); + + /* Generate entry record */ + traceIOEvent( mpiSetViewBeginID, (char *) &mpiSetViewBeginArguments, + sizeof( mpiSetViewBeginArguments ) ); + + returnVal = MPI_File_set_view( fh, disp, etype, filetype, + datarep, info ); + + mpiSetViewEndArguments.localNode = HDFlocalNode; + mpiSetViewEndArguments.globalNode = HDFmyNode; + /* mpiSetViewEndArguments.fileID = (long) ( &fh ); */ + mpiSetViewEndArguments.fileID = myHDFid; + + /* Generate entry record */ + traceIOEvent( mpiSetViewEndID, (char *) &mpiSetViewEndArguments, + sizeof( mpiSetViewEndArguments ) ); + + return returnVal; } -/*======================================================================* -// Pass call through to regular MPIO entry except in case of Real Time * -// tracing. * -// Note: The regular MPIO entry may or may not be instrumented. * -//======================================================================*/ -int HDF_MPI_File_get_position( MPI_File fh, MPI_Offset *offset ) +int +PabloMPI_File_get_view( MPI_File fh, + MPI_Offset *disp, + MPI_Datatype *etype, + MPI_Datatype *filetype, + char *datarep ) { + int returnVal; - int returnVal; - HDFsetInfo dataPtr; - int dataLen; + struct mpiGetViewBeginArgs mpiGetViewBeginArguments; + struct mpiGetViewEndArgs mpiGetViewEndArguments; - if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) { - returnVal = MPI_File_get_position( fh, offset ); - } else { - dataLen = 0; - HDFtraceEvent_RT( HDFmpiGetPositionID, - &dataPtr,dataLen ); - returnVal = PMPI_File_get_position( fh, offset ); - HDFtraceEvent_RT( -HDFmpiGetPositionID, - &dataPtr,dataLen ); - } - return returnVal; +#ifdef DEBUG + fprintf( debugFile, "MPI_File_get_view\n" ); + fflush( debugFile ); +#endif /* DEBUG */ + + mpiGetViewBeginArguments.localNode = HDFlocalNode; + mpiGetViewBeginArguments.globalNode = HDFmyNode; + /* mpiGetViewBeginArguments.fileID = (long) ( &fh ); */ + mpiGetViewBeginArguments.fileID = myHDFid; + + /* Generate entry record */ + traceIOEvent( mpiGetViewBeginID, (char *) &mpiGetViewBeginArguments, + sizeof( mpiGetViewBeginArguments ) ); + + returnVal = MPI_File_get_view( fh, disp, etype, filetype, datarep ); + + mpiGetViewEndArguments.localNode = HDFlocalNode; + mpiGetViewEndArguments.globalNode = HDFmyNode; + /* mpiGetViewEndArguments.fileID = (long) ( &fh ); */ + mpiGetViewEndArguments.fileID = myHDFid; + + mpiGetViewEndArguments.disp = (long) ( *disp ); + mpiGetViewEndArguments.etype = HDF_get_Datatype( *etype ); + mpiGetViewEndArguments.fileType = HDF_get_Datatype( *filetype ); + mpiGetViewEndArguments.dataRep = HDF_get_DataRep( datarep ); + + /* Generate entry record */ + traceIOEvent( mpiGetViewEndID, (char *) &mpiGetViewEndArguments, + sizeof( mpiGetViewEndArguments ) ); + + return returnVal; } -/*======================================================================* -// Pass call through to regular MPIO entry except in case of Real Time * -// tracing. * -// Note: The regular MPIO entry may or may not be instrumented. * -//======================================================================*/ -int HDF_MPI_File_get_byte_offset( MPI_File fh, MPI_Offset offset, - MPI_Offset *disp ) +int +PabloMPI_File_read_at( MPI_File fh, + MPI_Offset offset, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status *status ) { - int returnVal; - HDFsetInfo dataPtr; - int dataLen; - - if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) { - returnVal = MPI_File_get_byte_offset( fh, offset, disp ); - } else { - dataLen = 0; - HDFtraceEvent_RT( HDFmpiGetByteOffsetID, - &dataPtr,dataLen ); - returnVal = PMPI_File_get_byte_offset( fh, offset, disp ); - HDFtraceEvent_RT( -HDFmpiGetByteOffsetID, - &dataPtr,dataLen ); - } - return returnVal; + int returnVal, bcount; + + struct mpiReadAtBeginArgs mpiReadAtBeginArguments; + struct mpiReadAtEndArgs mpiReadAtEndArguments; + +#ifdef DEBUG + fprintf( debugFile, "MPI_File_read_at\n" ); + fflush( debugFile ); +#endif /* DEBUG */ + + mpiReadAtBeginArguments.localNode = HDFlocalNode; + mpiReadAtBeginArguments.globalNode = HDFmyNode; + /* mpiReadAtBeginArguments.fileID = (long) ( &fh ); */ + mpiReadAtBeginArguments.fileID = myHDFid; + + mpiReadAtBeginArguments.offset = (long) ( offset ); + mpiReadAtBeginArguments.count = count; + mpiReadAtBeginArguments.dataType = HDF_get_Datatype( datatype ); + mpiReadAtBeginArguments.numBytes = HDF_get_Bytes( datatype, count ); + + + /* Generate entry record */ + traceIOEvent( mpiReadAtBeginID, (char *) &mpiReadAtBeginArguments, + sizeof( mpiReadAtBeginArguments ) ); + + returnVal = MPI_File_read_at( fh, offset, buf, count, datatype, status ); + + mpiReadAtEndArguments.localNode = HDFlocalNode; + mpiReadAtEndArguments.globalNode = HDFmyNode; + /* mpiReadAtEndArguments.fileID = (long) ( &fh ); */ + mpiReadAtEndArguments.fileID = myHDFid; + + HDF_MPI_Get_count( status, datatype, &bcount, count ); + mpiReadAtEndArguments.rCount = bcount; + mpiReadAtEndArguments.numBytes = HDF_get_Bytes( datatype, bcount ); + + /* Generate entry record */ + traceIOEvent( mpiReadAtEndID, (char *) &mpiReadAtEndArguments, + sizeof( mpiReadAtEndArguments ) ); + + return returnVal; } -/*======================================================================* -// Pass call through to regular MPIO entry except in case of Real Time * -// tracing. * -// Note: The regular MPIO entry may or may not be instrumented. * -//======================================================================*/ -int HDF_MPI_File_get_type_extent( MPI_File fh, MPI_Datatype datatype, - MPI_Aint *extent ) +int +PabloMPI_File_read_at_all( MPI_File fh, + MPI_Offset offset, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status *status ) { + int returnVal, bcount; - int returnVal; - HDFsetInfo dataPtr; - int dataLen; - - if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) { - returnVal = MPI_File_get_type_extent( fh, datatype, extent ); - } else { - dataLen = 0; - HDFtraceEvent_RT( HDFmpiGetTypeExtentID, - &dataPtr,dataLen ); - returnVal = PMPI_File_get_type_extent( fh, datatype, extent ); - HDFtraceEvent_RT( -HDFmpiGetTypeExtentID, - &dataPtr,dataLen ); - } - return returnVal; + struct mpiReadAtAllBeginArgs mpiReadAtAllBeginArguments; + struct mpiReadAtAllEndArgs mpiReadAtAllEndArguments; + +#ifdef DEBUG + fprintf( debugFile, "MPI_File_read_at_all\n" ); + fflush( debugFile ); +#endif /* DEBUG */ + + mpiReadAtAllBeginArguments.localNode = HDFlocalNode; + mpiReadAtAllBeginArguments.globalNode = HDFmyNode; + /* mpiReadAtAllBeginArguments.fileID = (long) ( &fh ); */ + mpiReadAtAllBeginArguments.fileID = myHDFid; + + mpiReadAtAllBeginArguments.offset = (long) ( offset ); + mpiReadAtAllBeginArguments.count = count; + mpiReadAtAllBeginArguments.dataType = HDF_get_Datatype( datatype ); + mpiReadAtAllBeginArguments.numBytes = HDF_get_Bytes( datatype, count ); + + /* Generate entry record */ + traceIOEvent( mpiReadAtAllBeginID, (char *) &mpiReadAtAllBeginArguments, + sizeof( mpiReadAtAllBeginArguments ) ); + + returnVal = MPI_File_read_at_all( fh, offset, buf, + count, datatype, status ); + + mpiReadAtAllEndArguments.localNode = HDFlocalNode; + mpiReadAtAllEndArguments.globalNode = HDFmyNode; + /* mpiReadAtAllEndArguments.fileID = (long) ( &fh ); */ + mpiReadAtAllEndArguments.fileID = myHDFid; + + HDF_MPI_Get_count( status, datatype, &bcount, count ); + mpiReadAtAllEndArguments.rCount = bcount; + mpiReadAtAllEndArguments.numBytes = HDF_get_Bytes( datatype, bcount ); + + /* Generate entry record */ + traceIOEvent( mpiReadAtAllEndID, (char *) &mpiReadAtAllEndArguments, + sizeof( mpiReadAtAllEndArguments ) ); + + return returnVal; } -/*======================================================================* -// Pass call through to regular MPIO entry except in case of Real Time * -// tracing. * -// Note: The regular MPIO entry may or may not be instrumented. * -//======================================================================*/ -int HDF_MPI_File_set_atomicity( MPI_File fh, int flag ) +int +PabloMPI_File_write_at( MPI_File fh, + MPI_Offset offset, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status *status ) { - int returnVal; - HDFsetInfo dataPtr; - int dataLen; - - if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) { - returnVal = MPI_File_set_atomicity( fh, flag ); - } else { - dataLen = 0; - HDFtraceEvent_RT( HDFmpiSetAtomicityID, - &dataPtr,dataLen ); - returnVal = PMPI_File_set_atomicity( fh, flag ); - HDFtraceEvent_RT( -HDFmpiSetAtomicityID, - &dataPtr,dataLen ); - } - return returnVal; + int returnVal, bcount; + + struct mpiWriteAtBeginArgs mpiWriteAtBeginArguments; + struct mpiWriteAtEndArgs mpiWriteAtEndArguments; + +#ifdef DEBUG + fprintf( debugFile, "MPI_File_write_at\n" ); + fflush( debugFile ); +#endif /* DEBUG */ + + mpiWriteAtBeginArguments.localNode = HDFlocalNode; + mpiWriteAtBeginArguments.globalNode = HDFmyNode; + /* mpiWriteAtBeginArguments.fileID = (long) ( &fh ); */ + mpiWriteAtBeginArguments.fileID = myHDFid; + + mpiWriteAtBeginArguments.offset = (long) ( offset ); + mpiWriteAtBeginArguments.count = count; + mpiWriteAtBeginArguments.dataType = HDF_get_Datatype( datatype ); + mpiWriteAtBeginArguments.numBytes = HDF_get_Bytes( datatype, count ); + + /* Generate entry record */ + traceIOEvent( mpiWriteAtBeginID, (char *) &mpiWriteAtBeginArguments, + sizeof( mpiWriteAtBeginArguments ) ); + + returnVal = MPI_File_write_at( fh, offset, buf, count, + datatype, status ); + + mpiWriteAtEndArguments.localNode = HDFlocalNode; + mpiWriteAtEndArguments.globalNode = HDFmyNode; + /* mpiWriteAtEndArguments.fileID = (long) ( &fh ); */ + mpiWriteAtEndArguments.fileID = myHDFid; + + HDF_MPI_Get_count( status, datatype, &bcount, count ); + mpiWriteAtEndArguments.wCount = bcount; + mpiWriteAtEndArguments.numBytes = HDF_get_Bytes( datatype, bcount ); + + /* Generate entry record */ + traceIOEvent( mpiWriteAtEndID, (char *) &mpiWriteAtEndArguments, + sizeof( mpiWriteAtEndArguments ) ); + + return returnVal; } -/*======================================================================* -// Pass call through to regular MPIO entry except in case of Real Time * -// tracing. * -// Note: The regular MPIO entry may or may not be instrumented. * -//======================================================================*/ -int HDF_MPI_File_get_atomicity( MPI_File fh, int *flag ) +int +PabloMPI_File_write_at_all( MPI_File fh, + MPI_Offset offset, + void *buf, + int count, + MPI_Datatype datatype, + MPI_Status *status ) { + int returnVal, bcount; + int numBytes; - int returnVal; - HDFsetInfo dataPtr; - int dataLen; - - if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) { - returnVal = MPI_File_get_atomicity( fh, flag ); - } else { - dataLen = 0; - HDFtraceEvent_RT( HDFmpiGetAtomicityID, - &dataPtr,dataLen ); - returnVal = PMPI_File_get_atomicity( fh, flag ); - HDFtraceEvent_RT( -HDFmpiGetAtomicityID, - &dataPtr,dataLen ); - } - return returnVal; + struct mpiWriteAtAllBeginArgs mpiWriteAtAllBeginArguments; + struct mpiWriteAtAllEndArgs mpiWriteAtAllEndArguments; + +#ifdef DEBUG + fprintf( debugFile, "MPI_File_write_at\n" ); + fflush( debugFile ); +#endif /* DEBUG */ + + mpiWriteAtAllBeginArguments.localNode = HDFlocalNode; + mpiWriteAtAllBeginArguments.globalNode = HDFmyNode; + /* mpiWriteAtAllBeginArguments.fileID = (long) ( &fh ); */ + mpiWriteAtAllBeginArguments.fileID = myHDFid; + + mpiWriteAtAllBeginArguments.offset = (long) ( offset ); + mpiWriteAtAllBeginArguments.count = count; + mpiWriteAtAllBeginArguments.dataType = HDF_get_Datatype( datatype ); + mpiWriteAtAllBeginArguments.numBytes = HDF_get_Bytes( datatype, count ); + + /* Generate entry record */ + traceIOEvent( mpiWriteAtAllBeginID, (char *) &mpiWriteAtAllBeginArguments, + sizeof( mpiWriteAtAllBeginArguments ) ); + + returnVal = MPI_File_write_at_all( fh, offset, buf, + count, datatype, status ); + + mpiWriteAtAllEndArguments.localNode = HDFlocalNode; + mpiWriteAtAllEndArguments.globalNode = HDFmyNode; + /* mpiWriteAtAllEndArguments.fileID = (long) ( &fh ); */ + mpiWriteAtAllEndArguments.fileID = myHDFid; + + if ( returnVal == MPI_SUCCESS ) + { + bcount = count; + numBytes = HDF_get_Bytes( datatype, count ); + } + else + { + bcount = -1; + numBytes = -1; + } + mpiWriteAtAllEndArguments.wCount = bcount; + mpiWriteAtAllEndArguments.numBytes = numBytes; + + /* Generate entry record */ + traceIOEvent( mpiWriteAtAllEndID, (char *) &mpiWriteAtAllEndArguments, + sizeof( mpiWriteAtAllEndArguments ) ); + + return returnVal; } -/*======================================================================* -// Pass call through to regular MPIO entry except in case of Real Time * -// tracing. * -// Note: The regular MPIO entry may or may not be instrumented. * -//======================================================================*/ -int HDF_MPI_File_sync( MPI_File fh ) +int +PabloMPI_File_sync( MPI_File fh ) { - int returnVal; - HDFsetInfo dataPtr; - int dataLen; - - if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) { - returnVal = MPI_File_sync ( fh ); - } else { - dataLen = 0; - HDFtraceEvent_RT( HDFmpiSyncID, - &dataPtr,dataLen ); - returnVal = PMPI_File_sync ( fh ); - HDFtraceEvent_RT( -HDFmpiSyncID, - &dataPtr,dataLen ); - } - return returnVal; + int returnVal; + + struct mpiSyncBeginArgs mpiSyncBeginArguments; + struct mpiSyncEndArgs mpiSyncEndArguments; + +#ifdef DEBUG + fprintf( debugFile, "MPI_File_sync\n" ); + fflush( debugFile ); +#endif /* DEBUG */ + + mpiSyncBeginArguments.localNode = HDFlocalNode; + mpiSyncBeginArguments.globalNode = HDFmyNode; + /* mpiSyncBeginArguments.fileID = (long) ( &fh ); */ + mpiSyncBeginArguments.fileID = myHDFid; + + /* Generate entry record */ + traceIOEvent( mpiSyncBeginID, + (char *) &mpiSyncBeginArguments, + sizeof( mpiSyncBeginArguments ) ); + + returnVal = MPI_File_sync ( fh ); + + mpiSyncEndArguments.localNode = HDFlocalNode; + mpiSyncEndArguments.globalNode = HDFmyNode; + /* mpiSyncEndArguments.fileID = (long) ( &fh ); */ + mpiSyncEndArguments.fileID = myHDFid; + + /* Generate entry record */ + traceIOEvent( mpiSyncEndID, (char *) &mpiSyncEndArguments, + sizeof( mpiSyncEndArguments ) ); + + return returnVal; } -#endif /* HAVE_PARALLEL */ +#endif /* H5_HAVE_PARALLEL */ |