summaryrefslogtreecommitdiffstats
path: root/pablo/PabloHDF.c
diff options
context:
space:
mode:
Diffstat (limited to 'pablo/PabloHDF.c')
-rw-r--r--pablo/PabloHDF.c1745
1 files changed, 1745 insertions, 0 deletions
diff --git a/pablo/PabloHDF.c b/pablo/PabloHDF.c
new file mode 100644
index 0000000..b5e79da
--- /dev/null
+++ b/pablo/PabloHDF.c
@@ -0,0 +1,1745 @@
+/* This file is part of the Pablo Performance Analysis Environment
+//
+// (R)
+// The Pablo Performance Analysis Environment software is NOT in
+// the public domain. However, it is freely available without fee for
+// education, research, and non-profit purposes. By obtaining copies
+// of this and other files that comprise the Pablo Performance Analysis
+// Environment, you, the Licensee, agree to abide by the following
+// conditions and understandings with respect to the copyrighted software:
+//
+// 1. The software is copyrighted in the name of the Board of Trustees
+// of the University of Illinois (UI), and ownership of the software
+// remains with the UI.
+//
+// 2. Permission to use, copy, and modify this software and its documentation
+// for education, research, and non-profit purposes is hereby granted
+// to Licensee, provided that the copyright notice, the original author's
+// names and unit identification, and this permission notice appear on
+// all such copies, and that no charge be made for such copies. Any
+// entity desiring permission to incorporate this software into commercial
+// products should contact:
+//
+// Professor Daniel A. Reed reed@cs.uiuc.edu
+// University of Illinois
+// Department of Computer Science
+// 2413 Digital Computer Laboratory
+// 1304 West Springfield Avenue
+// Urbana, Illinois 61801
+// USA
+//
+// 3. Licensee may not use the name, logo, or any other symbol of the UI
+// nor the names of any of its employees nor any adaptation thereof in
+// advertizing or publicity pertaining to the software without specific
+// prior written approval of the UI.
+//
+// 4. THE UI MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE
+// SOFTWARE FOR ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS
+// OR IMPLIED WARRANTY.
+//
+// 5. The UI shall not be liable for any damages suffered by Licensee from
+// the use of this software.
+//
+// 6. The software was developed under agreements between the UI and the
+// Federal Government which entitle the Government to certain rights.
+//
+// *************************************************************************
+//
+// Developed by: The Pablo Research Group
+// University of Illinois at Urbana-Champaign
+// Department of Computer Science
+// 1304 W. Springfield Avenue
+// Urbana, IL 61801
+//
+// http://www-pablo.cs.uiuc.edu
+//
+// Send comments to: pablo-feedback@guitar.cs.uiuc.edu
+//
+// Copyright (c) 1987-1998
+// The University of Illinois Board of Trustees.
+// All Rights Reserved.
+//
+// PABLO is a registered trademark of
+// The Board of Trustees of the University of Illinois
+// registered in the U.S. Patent and Trademark Office.
+//
+// Project Manager and Principal Investigator:
+// Daniel A. Reed (reed@cs.uiuc.edu)
+//
+// Funded in part by the Defense Advanced Research Projects Agency under
+// DARPA contracts DABT63-94-C0049 (SIO Initiative), F30602-96-C-0161,
+// and DABT63-96-C-0027 by the National Science Foundation under the PACI
+// program and grants NSF CDA 94-01124 and ASC 97-20202, and by the
+// Department of Energy under contracts DOE B-341494, W-7405-ENG-48, and
+// 1-B-333164.
+//========================================================================*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#ifndef fileno
+int fileno ( FILE * );
+#endif
+/* on ipsc/860 don't include this or you'll get multiply defined SEEK_* */
+#ifndef __NX
+#include <unistd.h>
+#endif
+
+
+#define HDFtrace3OPEN__
+int HDFtrace3OPEN( const char *, int, mode_t );
+
+#include "SDDFparam.h"
+#include "TraceParam.h"
+
+#include "SystemDepend.h"
+#include "Trace.h"
+
+#include "IO_TraceParams.h"
+#include "HDFIOTrace.h"
+
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+/* mode_t is not defined on the ipsc/860 so we define it here */
+#ifdef __NX
+typedef unsigned int mode_t;
+#endif
+
+int OUTPUT_SWITCH = 1;
+int *procTrace;
+extern void preInitIOTrace( void );
+
+#include "ProcIDs.h"
+#include "HDFTrace.h"
+#include "IOTrace.h"
+
+#define ID_HDFprocName 9996
+#define ID_malloc 9997
+#define ID_free 9998
+#define ID_timeStamp 9999
+#define DUMMY_HDF 10000
+
+#ifdef HAVE_PARALLEL
+#include "mpio.h"
+#endif /* HAVE_PARALLEL*/
+
+void HDFinitTrace_RT ( const char *, int );
+void HDFinitTrace_SDDF ( const char *, int );
+void hinittracex_ ( int [], int *, int[], int *,unsigned * );
+void hdfendtrace_ ( void ) ;
+void HDFendTrace_RT (int);
+void HDFendTrace_SDDF(int);
+void HDFfinalTimeStamp( void );
+void startHDFtraceEvent (int );
+int computeProcMask (int eventID);
+int computePacketTag(int eventID);
+void endHDFtraceEvent (int , int , char *, int );
+void traceEvent ( int , char *, unsigned );
+void HDFtraceEvent_RT ( int , HDFsetInfo *, unsigned );
+void HDFtraceIOEvent( int , void *, unsigned );
+extern int IOtracingEnabled;
+char *hdfRecordPointer;
+double WriteTotals = 0.0;
+double ReadTotals = 0.0;
+/*======================================================================*
+// NAME *
+// HDFinitTrace -- initialize HDF tracing *
+// USAGE *
+// VOID HDFinitTrace( traceFileName, out_sw ) *
+// char *traceFileName; IN: name of the generated trace output *
+// file *
+// int ... IN: indicates which routines to trace *
+// The list is terminated by the *
+// OUTPUT_SWITCH value indicating *
+// whether to do RunTime or Summary *
+// tracing. *
+// RETURNS *
+// None. *
+//======================================================================*/
+/*======================================================================*
+// fortran to C interface. To insure portability, the character array *
+// passed in Fortran is converted to an integer array using the ICHAR *
+// function. This program converts it from integer to char, then *
+// passes it to the C initialization routine. *
+//======================================================================*/
+void hinittracex_( int *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);
+ }
+}
+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);
+ }
+}
+/*======================================================================*
+// NAME *
+// HDFendTrace -- end HDF tracing *
+// USAGE *
+// VOID HDFendTrace(VOID) *
+// RETURNS *
+// None. *
+//======================================================================*/
+void hdfendtrace_( void )
+{
+ 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 );
+ }
+}
+void startHDFtraceEvent(int eventID)
+{
+ 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",
+ 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 )
+{
+ FILE *fp;
+ int fd, id;
+ int flags = 0;
+ struct open_args openArgs;
+ size_t typeLen;
+
+ 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 );
+}
+
+/*+ 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;
+ int id;
+
+ if ( IOtracingEnabled ) {
+ strcpy( openArgs.filename, path );
+ openArgs.flags = O_WRONLY | O_CREAT | O_TRUNC;
+ openArgs.mode = (int) mode;
+
+ HDFtraceIOEvent( openBeginID, (void *)&openArgs, sizeof(openArgs) );
+ }
+
+ fd = creat( path, mode );
+ id = set_c_mappedID( fd );
+
+ if ( IOtracingEnabled ) {
+ HDFtraceIOEvent( openEndID, (void *) &id, int_SIZE );
+ }
+
+ return( fd );
+}
+
+/******************************************************************************/
+
+/*+ 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 );
+}
+
+/******************************************************************************/
+/*+ 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 );
+
+ if ( IOtracingEnabled ) {
+ id = c_mappedID( fd );
+ HDFtraceIOEvent( fcloseBeginID, (void *) &id, int_SIZE );
+ }
+
+ ret = fclose( stream );
+
+ if ( IOtracingEnabled ) {
+ HDFtraceIOEvent( fcloseEndID, (void *) 0, 0 );
+ }
+
+ 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 )
+{
+ struct open_args openArgs;
+ int fd;
+ int id;
+
+ if ( IOtracingEnabled ) {
+ strcpy( openArgs.filename, path );
+ openArgs.flags = flags;
+ openArgs.mode = (int) mode;
+
+ HDFtraceIOEvent( openBeginID, (char *)&openArgs, sizeof(openArgs) );
+ }
+
+ fd = open( path, flags, mode );
+ id = set_c_mappedID( fd );
+
+ if ( IOtracingEnabled ) {
+ HDFtraceIOEvent( openEndID, (char *) &id, int_SIZE );
+ }
+
+ return( fd );
+}
+
+/*+ Routine: int HDFtraceCLOSE( int fd ) +*/
+/*+ substitute for close() +*/
+/*+ generates closeBeginID, closeEndID +*/
+/*+ record Close (closeBeginID) +*/
+/*+ +*/
+int HDFtraceCLOSE( int fd )
+{
+ int ret;
+ int id;
+
+ if ( IOtracingEnabled ) {
+ id = c_mappedID( fd );
+ HDFtraceIOEvent( closeBeginID, (void *) &id, int_SIZE );
+ }
+
+ ret = close( fd );
+
+ if ( IOtracingEnabled ) {
+ HDFtraceIOEvent( closeEndID, (void *) 0, 0 );
+ }
+
+ 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 )
+{
+ 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 )
+{
+ 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 = 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) +*/
+/*+ +*/
+off_t HDFtraceLSEEK( int fd, off_t offset, int whence )
+{
+ struct seek_args seekArgs;
+ off_t ret;
+ long arg;
+
+ if ( IOtracingEnabled ) {
+ seekArgs.fileID = c_mappedID( fd );
+ seekArgs.offset = (int) offset;
+ seekArgs.whence = whence;
+
+ HDFtraceIOEvent( lseekBeginID, (void *) &seekArgs, sizeof(seekArgs) );
+ }
+
+ ret = lseek( fd, offset, whence );
+
+ if ( IOtracingEnabled ) {
+ arg = (long) ret;
+ HDFtraceIOEvent( lseekEndID, (void *)&arg, long_SIZE );
+ }
+
+ 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 )
+{
+ 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;
+
+ HDFtraceIOEvent( fseekBeginID, (void *) &seekArgs, sizeof(seekArgs) );
+ }
+
+ ret = fseek( stream, offset, whence );
+
+ if ( IOtracingEnabled ) {
+ arg = ftell( stream );
+ HDFtraceIOEvent( fseekEndID, (void *)&arg, long_SIZE );
+ }
+
+ 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 )
+{
+ 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;
+
+ HDFtraceIOEvent( fsetposBeginID, (void *) &seekArgs, sizeof(seekArgs) );
+ }
+
+ ret = fsetpos( stream, position );
+
+ if ( IOtracingEnabled ) {
+ arg = (long) *position;
+ HDFtraceIOEvent( fsetposEndID, (void *)&arg, long_SIZE );
+ }
+
+ return( ret );
+}
+#endif /* fpos_t */
+
+/*+ 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 );
+
+ if ( IOtracingEnabled ) {
+ seekArgs.fileID = c_mappedID( fd );
+ seekArgs.offset = 0;
+ seekArgs.whence = SEEK_SET;
+
+ HDFtraceIOEvent( rewindBeginID, (void *) &seekArgs, sizeof(seekArgs) );
+ }
+
+ rewind( stream );
+
+ if ( IOtracingEnabled ) {
+ arg = 0;
+ HDFtraceIOEvent( rewindEndID, (void *)&arg, long_SIZE );
+ }
+
+ 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 +*/
+/*+ +*/
+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 );
+}
+
+/*+ 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 = 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 )
+{
+ struct read_write_args writeArgs;
+ int ret;
+ int fd = fileno( stdout );
+
+ if ( IOtracingEnabled ) {
+ writeArgs.fileID = c_mappedID( fd );
+ writeArgs.numVariables = 1;
+ writeArgs.cause = -1;
+
+ HDFtraceIOEvent( fwriteBeginID, (void *) &writeArgs, sizeof(writeArgs) );
+ }
+
+ ret = puts( s );
+
+ if ( IOtracingEnabled ) {
+ HDFtraceIOEvent( fwriteEndID, (void *) &ret, int_SIZE );
+ }
+
+ 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 )
+{
+ 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;
+
+ HDFtraceIOEvent( fwriteBeginID, (void *) &writeArgs, sizeof(writeArgs) );
+ }
+
+ ret = fputc( c, stream );
+
+ 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 +*/
+/*+ +*/
+int HDFtraceFPUTS( const char *s, FILE *stream )
+{
+ struct read_write_args writeArgs;
+ int ret;
+ int fd = fileno( stream );
+
+ if ( IOtracingEnabled ) {
+ writeArgs.fileID = c_mappedID( fd );
+ writeArgs.numVariables = 1;
+ writeArgs.cause = -1;
+
+ HDFtraceIOEvent(fwriteBeginID, (void *)&writeArgs, sizeof(writeArgs));
+ }
+
+ ret = fputs( s, stream );
+
+ if ( IOtracingEnabled ) {
+ HDFtraceIOEvent( fwriteEndID, (void *) &ret, int_SIZE );
+ }
+
+ return( ret );
+}
+void *HDFtraceMALLOC(size_t bytes )
+{
+ void *ptr;
+ int byte_req;
+ byte_req = (int)bytes;
+ if ( IOtracingEnabled ) {
+ HDFtraceIOEvent ( ID_malloc, NULL, 0 );
+ }
+
+ ptr = malloc( bytes );
+
+ if ( IOtracingEnabled ) {
+ HDFtraceIOEvent ( -ID_malloc, &byte_req, sizeof(int) );
+ }
+
+ return ptr ;
+
+}
+
+void HDFtraceIOEvent( int eventType, void *dataPtr, unsigned dataLen )
+{
+ if ( OUTPUT_SWITCH == RUNTIME_TRACE
+ || OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) {
+ traceEvent( eventType, dataPtr, dataLen );
+ } else {
+ HDFtraceEvent_RT( eventType, (HDFsetInfo *)dataPtr, dataLen );
+ }
+}
+/*======================================================================*
+// record the final time stamp *
+//======================================================================*/
+void HDFfinalTimeStamp( void )
+{
+ CLOCK currentTime;
+ double seconds;
+ struct {
+ int packetLength,
+ packetType,
+ packetTag,
+ timeDim;
+ double Seconds;
+ int eventID,
+ node,
+ dataLen;
+ } Packet;
+
+ currentTime = getClock();
+ seconds = clockToSeconds( currentTime );
+
+ Packet.packetLength = sizeof(Packet);
+ Packet.packetType = PKT_DATA;
+ Packet.packetTag = FAMILY_EXTERNAL | RECORD_TRACE;
+ Packet.timeDim = 0; /* use fp time stamp only */
+ Packet.Seconds = seconds; /* fp time stamp */
+ Packet.eventID = ID_timeStamp;
+ Packet.node = TRgetNode();
+ Packet.dataLen = 0;
+ putBytes( (void *)&Packet , sizeof(Packet) );
+}
+/*======================================================================*
+// This Program is called to specify which routines are to be traced. *
+// On first entry, the program allocates storage for and initializes a *
+// global array procTrace. The array has one element for each possible *
+// HDF procedure and HDF library file. If a procedure or all of the *
+// procedure in an HDF file are to be traced, then the elemen in the *
+// array corresponding to the procedure or file is turned on. This is *
+// used by the macros TRACE_ON and TRACE_OFF to enable tracing. If *
+// this procedure is not called prior to initialization, then all of *
+// the elements of procTrace corresponding to HDF files will be *
+// turned on, in which case all HDF procedures will be traced. *
+//======================================================================*/
+void PabloHDFTrace( int ID )
+{
+ int i;
+ if ( procTrace == NULL ) {
+ procTrace = ( int * ) malloc( NUM_HDF_IDS*sizeof(int) );
+ if ( procTrace == NULL ) {
+ fprintf(stderr,">> Error: Unable to allocate procTrace ");
+ fprintf(stderr,"array in program PabloHDFTrace. <<<\n");
+ fprintf(stderr," Exiting program. <<<\n");
+ exit (-1);
+ }
+ for ( i = 0; i < NUM_HDF_IDS; ++i ) {
+ procTrace[i] = 0;
+ }
+ }
+ if ( ID >= 0 && ID < NUM_HDF_IDS ) {
+ procTrace[ID] = 1;
+ } else {
+ fprintf(stderr,">> Error: Value passed to PabloHDFTrace, ");
+ fprintf(stderr,"%d, is out of range. <<<\n",ID);
+ fprintf(stderr," Exiting program. <<<\n");
+ 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 )
+{
+ 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;
+}
+
+
+
+/*======================================================================*
+// 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 )
+{
+ int returnVal;
+ HDFsetInfo dataPtr;
+ int dataLen;
+
+ if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
+ returnVal = MPI_File_close( fh );
+ } else {
+ dataLen = sizeof( HDFsetInfo );
+ dataPtr.setID = (long)fh;
+ dataPtr.setName = NULL;
+ HDFtraceEvent_RT( HDFmpiCloseID, &dataPtr, dataLen );
+ returnVal = PMPI_File_close( fh );
+ HDFtraceEvent_RT( -HDFmpiCloseID, &dataPtr, dataLen );
+ free( dataPtr.setName );
+ }
+ return returnVal;
+}
+
+/*======================================================================*
+// Pass call through to regular MPIO entry except in case of Real Time *
+// tracing. *
+// Note: The regular MPIO entry may or may not be instrumented. *
+//======================================================================*/
+int HDF_MPI_File_delete( char *filename, MPI_Info info )
+{
+ int returnVal;
+ HDFsetInfo dataPtr;
+ int dataLen;
+
+ if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
+ returnVal = MPI_File_delete( filename, info );
+ } else {
+ dataLen = sizeof( HDFsetInfo );
+ dataPtr.setID = 0;
+ dataPtr.setName = (char *)malloc( sizeof(filename) );
+ strcpy( dataPtr.setName , filename );
+ HDFtraceEvent_RT( HDFmpiDeleteID, &dataPtr, dataLen );
+ returnVal = PMPI_File_delete( filename, info );
+ HDFtraceEvent_RT( -HDFmpiDeleteID, &dataPtr, dataLen );
+ free( dataPtr.setName );
+ }
+ return returnVal;
+}
+
+/*======================================================================*
+// 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 )
+{
+ int returnVal;
+ HDFsetInfo dataPtr;
+ int dataLen;
+
+ if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
+ returnVal = MPI_File_set_size( fh, size );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( HDFmpiSetSizeID,&dataPtr,dataLen );
+ returnVal = PMPI_File_set_size( fh, size );
+ HDFtraceEvent_RT( -HDFmpiSetSizeID, &dataPtr, dataLen );
+ }
+ return returnVal;
+}
+
+/*======================================================================*
+// Pass call through to regular MPIO entry except in case of Real Time *
+// tracing. *
+// Note: The regular MPIO entry may or may not be instrumented. *
+//======================================================================*/
+int HDF_MPI_File_preallocate( MPI_File fh, MPI_Offset size)
+{
+ int returnVal;
+ HDFsetInfo dataPtr;
+ int dataLen;
+
+ if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
+ returnVal = MPI_File_preallocate( fh, size);
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( HDFmpiPreallocateID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_preallocate( fh, size);
+ HDFtraceEvent_RT( -HDFmpiPreallocateID,
+ &dataPtr, dataLen );
+ }
+ return returnVal;
+}
+
+/*======================================================================*
+// 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 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;
+}
+
+/*======================================================================*
+// 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 returnVal;
+ HDFsetInfo dataPtr;
+ int dataLen;
+
+ if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
+ returnVal = MPI_File_get_group( fh, group);
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( HDFmpiGetGroupID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_get_group( fh, group);
+ HDFtraceEvent_RT( -HDFmpiGetGroupID,
+ &dataPtr,dataLen );
+ }
+ return returnVal;
+}
+
+/*======================================================================*
+// Pass call through to regular MPIO entry except in case of Real Time *
+// tracing. *
+// Note: The regular MPIO entry may or may not be instrumented. *
+//======================================================================*/
+int HDF_MPI_File_get_amode( MPI_File fh, int *amode )
+{
+ int returnVal;
+ HDFsetInfo dataPtr;
+ int dataLen;
+
+ if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
+ returnVal = MPI_File_get_amode( fh, amode);
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( HDFmpiGetAmodeID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_get_amode( fh, amode);
+ HDFtraceEvent_RT( -HDFmpiGetAmodeID,
+ &dataPtr,dataLen );
+ }
+ return returnVal;
+}
+
+/*======================================================================*
+// Pass call through to regular MPIO entry except in case of Real Time *
+// tracing. *
+// Note: The regular MPIO entry may or may not be instrumented. *
+//======================================================================*/
+int HDF_MPI_File_set_view( MPI_File fh, MPI_Offset disp, MPI_Datatype etype,
+ MPI_Datatype filetype, char *datarep, MPI_Info info )
+{
+ int returnVal;
+ HDFsetInfo dataPtr;
+ int dataLen;
+
+ if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
+ returnVal = MPI_File_set_view( fh, disp, etype, filetype,
+ datarep, info );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( HDFmpiSetViewID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_set_view( fh, disp, etype, filetype,
+ datarep, info );
+ HDFtraceEvent_RT( -HDFmpiSetViewID,
+ &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_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,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_get_view(fh, disp, etype, filetype, datarep);
+
+ }
+ 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_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_read_at( fh, offset, buf, count, datatype,
+ status );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( HDFmpiReadAtID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_read_at( fh, offset, buf, count, datatype,
+ status );
+ HDFtraceEvent_RT( -HDFmpiReadAtID,
+ &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_at_all( 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_read_at_all( fh, offset, buf,
+ count, datatype, status );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( HDFmpiReadAtAllID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_read_at_all( fh, offset, buf,
+ count, datatype, status );
+ HDFtraceEvent_RT( -HDFmpiReadAtAllID,
+ &dataPtr,dataLen );
+ }
+ return returnVal;
+}
+
+/*======================================================================*
+// Pass call through to regular MPIO entry except in case of Real Time *
+// tracing. *
+// Note: The regular MPIO entry may or may not be instrumented. *
+//======================================================================*/
+int HDF_MPI_File_write_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;
+}
+
+/*======================================================================*
+// 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_at_all( 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_all( fh, offset, buf,
+ count, datatype, status );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( HDFmpiWriteAtAllID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_write_at_all( fh, offset, buf,
+ count, datatype, status );
+ HDFtraceEvent_RT( -HDFmpiWriteAtAllID,
+ &dataPtr,dataLen );
+ }
+ return returnVal;
+}
+
+/*======================================================================*
+// Pass call through to regular MPIO entry except in case of Real Time *
+// tracing. *
+// Note: The regular MPIO entry may or may not be instrumented. *
+//======================================================================*/
+int HDF_MPI_File_iread_at( MPI_File fh, MPI_Offset offset, void *buf,
+ int count, MPI_Datatype datatype, MPIO_Request *request )
+{
+ return MPI_File_iread_at( fh, offset, buf, count, datatype, request );
+}
+
+/*======================================================================*
+// Pass call through to regular MPIO entry except in case of Real Time *
+// tracing. *
+// Note: The regular MPIO entry may or may not be instrumented. *
+//======================================================================*/
+int HDF_MPI_File_iwrite_at( MPI_File fh, MPI_Offset offset, void *buf,
+ int count, MPI_Datatype datatype, MPIO_Request *request)
+{
+ return MPI_File_iwrite_at( fh, offset, buf, count, datatype, request );
+}
+
+/*======================================================================*
+// Pass call through to regular MPIO entry except in case of Real Time *
+// tracing. *
+// Note: The regular MPIO entry may or may not be instrumented. *
+//======================================================================*/
+int HDF_MPI_File_read( MPI_File fh, void *buf, int count,
+ MPI_Datatype datatype, MPI_Status *status)
+{
+ int returnVal;
+ HDFsetInfo dataPtr;
+ int dataLen;
+
+ if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
+ returnVal = MPI_File_read( fh, buf, count, datatype, status );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( HDFmpiReadID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_read( fh, buf, count, datatype, status );
+ HDFtraceEvent_RT( -HDFmpiReadID,
+ &dataPtr,dataLen );
+ }
+ return returnVal;
+}
+
+/*======================================================================*
+// Pass call through to regular MPIO entry except in case of Real Time *
+// tracing. *
+// Note: The regular MPIO entry may or may not be instrumented. *
+//======================================================================*/
+int HDF_MPI_File_read_all( MPI_File fh, void *buf, int count,
+ MPI_Datatype datatype, MPI_Status *status)
+{
+ int returnVal;
+ HDFsetInfo dataPtr;
+ int dataLen;
+
+ if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
+ returnVal = MPI_File_read_all( fh, buf, count, datatype, status );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( HDFmpiReadAllID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_read_all( fh, buf, count, datatype, status );
+ HDFtraceEvent_RT( -HDFmpiReadAllID,
+ &dataPtr,dataLen );
+ }
+ return returnVal;
+}
+
+/*======================================================================*
+// Pass call through to regular MPIO entry except in case of Real Time *
+// tracing. *
+// Note: The regular MPIO entry may or may not be instrumented. *
+//======================================================================*/
+int HDF_MPI_File_write( MPI_File fh, void *buf, int count,
+ MPI_Datatype datatype, MPI_Status *status )
+{
+ int returnVal;
+ HDFsetInfo dataPtr;
+ int dataLen;
+
+ if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
+ returnVal = MPI_File_write( fh, buf, count, datatype, status );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( HDFmpiWriteID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_write( fh, buf, count, datatype, status );
+ HDFtraceEvent_RT( -HDFmpiWriteID,
+ &dataPtr,dataLen );
+ }
+ return returnVal;
+}
+
+/*======================================================================*
+// Pass call through to regular MPIO entry except in case of Real Time *
+// tracing. *
+// Note: The regular MPIO entry may or may not be instrumented. *
+//======================================================================*/
+int HDF_MPI_File_write_all( MPI_File fh, void *buf, int count,
+ MPI_Datatype datatype, MPI_Status *status )
+{
+ int returnVal;
+ HDFsetInfo dataPtr;
+ int dataLen;
+
+ if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
+ returnVal =MPI_File_write_all( fh, buf, count, datatype, status );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( HDFmpiWriteAllID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_write_all( fh, buf, count, datatype, status );
+ HDFtraceEvent_RT( -HDFmpiWriteAllID,
+ &dataPtr,dataLen );
+ }
+ return returnVal;
+}
+
+/*======================================================================*
+// Pass call through to regular MPIO entry except in case of Real Time *
+// tracing. *
+// Note: The regular MPIO entry may or may not be instrumented. *
+//======================================================================*/
+int HDF_MPI_File_iread( MPI_File fh, void *buf, int count,
+ MPI_Datatype datatype, MPIO_Request *request )
+{
+ return MPI_File_iread( fh, buf, count, datatype, request );
+}
+
+/*======================================================================*
+// Pass call through to regular MPIO entry except in case of Real Time *
+// tracing. *
+// Note: The regular MPIO entry may or may not be instrumented. *
+//======================================================================*/
+int HDF_MPI_File_iwrite( MPI_File fh, void *buf, int count,
+ MPI_Datatype datatype, MPIO_Request *request )
+{
+ return MPI_File_iwrite( fh, buf, count, datatype, request );
+}
+
+/*======================================================================*
+// Pass call through to regular MPIO entry except in case of Real Time *
+// tracing. *
+// Note: The regular MPIO entry may or may not be instrumented. *
+//======================================================================*/
+int HDF_MPI_File_seek( MPI_File fh, MPI_Offset offset, int whence )
+{
+
+ int returnVal;
+ HDFsetInfo dataPtr;
+ int dataLen;
+
+ if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
+ returnVal = MPI_File_seek( fh, offset, whence );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( HDFmpiSeekID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_seek( fh, offset, whence );
+ HDFtraceEvent_RT( -HDFmpiSeekID,
+ &dataPtr,dataLen );
+ }
+ return returnVal;
+}
+
+/*======================================================================*
+// Pass call through to regular MPIO entry except in case of Real Time *
+// tracing. *
+// Note: The regular MPIO entry may or may not be instrumented. *
+//======================================================================*/
+int HDF_MPI_File_get_position( MPI_File fh, MPI_Offset *offset )
+{
+
+ int returnVal;
+ HDFsetInfo dataPtr;
+ int dataLen;
+
+ if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
+ returnVal = MPI_File_get_position( fh, offset );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( HDFmpiGetPositionID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_get_position( fh, offset );
+ HDFtraceEvent_RT( -HDFmpiGetPositionID,
+ &dataPtr,dataLen );
+ }
+ return returnVal;
+}
+
+/*======================================================================*
+// Pass call through to regular MPIO entry except in case of Real Time *
+// tracing. *
+// Note: The regular MPIO entry may or may not be instrumented. *
+//======================================================================*/
+int HDF_MPI_File_get_byte_offset( MPI_File fh, MPI_Offset offset,
+ MPI_Offset *disp )
+{
+ int returnVal;
+ HDFsetInfo dataPtr;
+ int dataLen;
+
+ if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
+ returnVal = MPI_File_get_byte_offset( fh, offset, disp );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( HDFmpiGetByteOffsetID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_get_byte_offset( fh, offset, disp );
+ HDFtraceEvent_RT( -HDFmpiGetByteOffsetID,
+ &dataPtr,dataLen );
+ }
+ return returnVal;
+}
+
+/*======================================================================*
+// Pass call through to regular MPIO entry except in case of Real Time *
+// tracing. *
+// Note: The regular MPIO entry may or may not be instrumented. *
+//======================================================================*/
+int HDF_MPI_File_get_type_extent( MPI_File fh, MPI_Datatype datatype,
+ MPI_Aint *extent )
+{
+
+ int returnVal;
+ HDFsetInfo dataPtr;
+ int dataLen;
+
+ if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
+ returnVal = MPI_File_get_type_extent( fh, datatype, extent );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( HDFmpiGetTypeExtentID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_get_type_extent( fh, datatype, extent );
+ HDFtraceEvent_RT( -HDFmpiGetTypeExtentID,
+ &dataPtr,dataLen );
+ }
+ return returnVal;
+}
+
+/*======================================================================*
+// Pass call through to regular MPIO entry except in case of Real Time *
+// tracing. *
+// Note: The regular MPIO entry may or may not be instrumented. *
+//======================================================================*/
+int HDF_MPI_File_set_atomicity( MPI_File fh, int flag )
+{
+ int returnVal;
+ HDFsetInfo dataPtr;
+ int dataLen;
+
+ if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
+ returnVal = MPI_File_set_atomicity( fh, flag );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( HDFmpiSetAtomicityID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_set_atomicity( fh, flag );
+ HDFtraceEvent_RT( -HDFmpiSetAtomicityID,
+ &dataPtr,dataLen );
+ }
+ return returnVal;
+}
+
+/*======================================================================*
+// Pass call through to regular MPIO entry except in case of Real Time *
+// tracing. *
+// Note: The regular MPIO entry may or may not be instrumented. *
+//======================================================================*/
+int HDF_MPI_File_get_atomicity( MPI_File fh, int *flag )
+{
+
+ int returnVal;
+ HDFsetInfo dataPtr;
+ int dataLen;
+
+ if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
+ returnVal = MPI_File_get_atomicity( fh, flag );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( HDFmpiGetAtomicityID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_get_atomicity( fh, flag );
+ HDFtraceEvent_RT( -HDFmpiGetAtomicityID,
+ &dataPtr,dataLen );
+ }
+ return returnVal;
+}
+
+/*======================================================================*
+// Pass call through to regular MPIO entry except in case of Real Time *
+// tracing. *
+// Note: The regular MPIO entry may or may not be instrumented. *
+//======================================================================*/
+int HDF_MPI_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;
+}
+
+#endif /* HAVE_PARALLEL */