summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--pablo/PabloHDF.c690
-rw-r--r--pablo/PabloHDF_RT.c66
2 files changed, 731 insertions, 25 deletions
diff --git a/pablo/PabloHDF.c b/pablo/PabloHDF.c
index 5c4cc73..cba0c87 100644
--- a/pablo/PabloHDF.c
+++ b/pablo/PabloHDF.c
@@ -85,6 +85,7 @@ int fileno ( FILE * );
#include <unistd.h>
#endif
+
#define HDFtrace3OPEN__
int HDFtrace3OPEN( const char *, int, mode_t );
@@ -116,6 +117,15 @@ extern void preInitIOTrace( void );
#include "ProcIDs.h"
#include "HDF5Trace.h"
#include "IOTrace.h"
+
+#ifdef HAVE_PARALLEL
+#include "mpio.h"
+#include "MPIO_Init.h"
+#include "MPIO_EventArgs.h"
+#include "MPIO_TraceParams.h"
+#include "HDFmpioProtos.h"
+#endif /* HAVE_PARALLEL*/
+
#define NO_OUTPUT 0
#define SDDF_OUTPUT 1
#define RT_OUTPUT 2
@@ -893,3 +903,683 @@ void HDFfinalTimeStamp( void )
Packet.dataLen = 0;
putBytes( (void *)&Packet , sizeof(Packet) );
}
+#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 != RT_OUTPUT ) {
+ 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( mpiOpenBeginID, &dataPtr, dataLen );
+ returnVal = PMPI_File_open( comm, filename, amode, info, fh );
+ HDFtraceEvent_RT( mpiOpenEndID, &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 != RT_OUTPUT ) {
+ returnVal = MPI_File_close( fh );
+ } else {
+ dataLen = sizeof( HDFsetInfo );
+ dataPtr.setID = (long)fh;
+ dataPtr.setName = NULL;
+ HDFtraceEvent_RT( mpiCloseBeginID, &dataPtr, dataLen );
+ returnVal = PMPI_File_close( fh );
+ HDFtraceEvent_RT( mpiCloseEndID, &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 != RT_OUTPUT ) {
+ 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( mpiDeleteBeginID, &dataPtr, dataLen );
+ returnVal = PMPI_File_delete( filename, info );
+ HDFtraceEvent_RT( mpiDeleteEndID, &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 != RT_OUTPUT ) {
+ returnVal = MPI_File_set_size( fh, size );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( mpiSetSizeBeginID,&dataPtr,dataLen );
+ returnVal = PMPI_File_set_size( fh, size );
+ HDFtraceEvent_RT( mpiSetSizeEndID, &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 != RT_OUTPUT ) {
+ returnVal = MPI_File_preallocate( fh, size);
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( mpiPreallocateBeginID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_preallocate( fh, size);
+ HDFtraceEvent_RT( mpiPreallocateEndID,
+ &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 != RT_OUTPUT ) {
+ returnVal = MPI_File_get_size( fh, size);
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( mpiGetSizeBeginID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_get_size( fh, size);
+ HDFtraceEvent_RT( mpiGetSizeEndID,
+ &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 != RT_OUTPUT ) {
+ returnVal = MPI_File_get_group( fh, group);
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( mpiGetGroupBeginID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_get_group( fh, group);
+ HDFtraceEvent_RT( mpiGetGroupEndID,
+ &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 != RT_OUTPUT ) {
+ returnVal = MPI_File_get_amode( fh, amode);
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( mpiGetAmodeBeginID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_get_amode( fh, amode);
+ HDFtraceEvent_RT( mpiGetAmodeEndID,
+ &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 != RT_OUTPUT ) {
+ returnVal = MPI_File_set_view( fh, disp, etype, filetype,
+ datarep, info );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( mpiSetViewBeginID,
+ &dataPtr,dataLen );
+ returnVal = MPI_File_set_view( fh, disp, etype, filetype,
+ datarep, info );
+ HDFtraceEvent_RT( mpiSetViewEndID,
+ &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 != RT_OUTPUT ) {
+ returnVal = MPI_File_get_view(fh, disp, etype, filetype, datarep);
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( mpiSetViewBeginID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_get_view(fh, disp, etype, filetype, datarep);
+ HDFtraceEvent_RT( mpiSetViewEndID,
+ &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 != RT_OUTPUT ) {
+ returnVal = MPI_File_read_at( fh, offset, buf, count, datatype,
+ status );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( mpiReadAtBeginID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_read_at( fh, offset, buf, count, datatype,
+ status );
+ HDFtraceEvent_RT( mpiReadAtEndID,
+ &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 != RT_OUTPUT ) {
+ returnVal = MPI_File_read_at_all( fh, offset, buf,
+ count, datatype, status );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( mpiReadAtAllBeginID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_read_at_all( fh, offset, buf,
+ count, datatype, status );
+ HDFtraceEvent_RT( mpiReadAtAllEndID,
+ &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 != RT_OUTPUT ) {
+ returnVal = MPI_File_write_at( fh, offset, buf, count, datatype,
+ status );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( mpiWriteAtBeginID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_write_at( fh, offset, buf, count, datatype,
+ status );
+ HDFtraceEvent_RT( mpiWriteAtEndID,
+ &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 != RT_OUTPUT ) {
+ returnVal = MPI_File_write_at_all( fh, offset, buf,
+ count, datatype, status );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( mpiWriteAtAllBeginID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_write_at_all( fh, offset, buf,
+ count, datatype, status );
+ HDFtraceEvent_RT( mpiWriteAtAllEndID,
+ &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 != RT_OUTPUT ) {
+ returnVal = MPI_File_read( fh, buf, count, datatype, status );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( mpiReadBeginID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_read( fh, buf, count, datatype, status );
+ HDFtraceEvent_RT( mpiReadEndID,
+ &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 != RT_OUTPUT ) {
+ returnVal = MPI_File_read_all( fh, buf, count, datatype, status );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( mpiReadAllBeginID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_read_all( fh, buf, count, datatype, status );
+ HDFtraceEvent_RT( mpiReadAllEndID,
+ &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 != RT_OUTPUT ) {
+ returnVal = MPI_File_write( fh, buf, count, datatype, status );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( mpiWriteBeginID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_write( fh, buf, count, datatype, status );
+ HDFtraceEvent_RT( mpiWriteEndID,
+ &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 != RT_OUTPUT ) {
+ returnVal = MPI_File_write_all( fh, buf, count, datatype, status );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( mpiWriteAllBeginID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_write_all( fh, buf, count, datatype, status );
+ HDFtraceEvent_RT( mpiWriteAllEndID,
+ &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 != RT_OUTPUT ) {
+ returnVal = MPI_File_seek( fh, offset, whence );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( mpiSeekBeginID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_seek( fh, offset, whence );
+ HDFtraceEvent_RT( mpiSeekEndID,
+ &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 != RT_OUTPUT ) {
+ returnVal = MPI_File_get_position( fh, offset );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( mpiGetPositionBeginID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_get_position( fh, offset );
+ HDFtraceEvent_RT( mpiGetPositionEndID,
+ &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 != RT_OUTPUT ) {
+ returnVal = MPI_File_get_byte_offset( fh, offset, disp );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( mpiGetByteOffsetBeginID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_get_byte_offset( fh, offset, disp );
+ HDFtraceEvent_RT( mpiGetByteOffsetEndID,
+ &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 != RT_OUTPUT ) {
+ returnVal = MPI_File_get_type_extent( fh, datatype, extent );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( mpiGetTypeExtentBeginID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_get_type_extent( fh, datatype, extent );
+ HDFtraceEvent_RT( mpiGetTypeExtentEndID,
+ &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 != RT_OUTPUT ) {
+ returnVal = MPI_File_set_atomicity( fh, flag );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( mpiSetAtomicityBeginID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_set_atomicity( fh, flag );
+ HDFtraceEvent_RT( mpiSetAtomicityEndID,
+ &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 != RT_OUTPUT ) {
+ returnVal = MPI_File_get_atomicity( fh, flag );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( mpiGetAtomicityBeginID,
+ &dataPtr,dataLen );
+ returnVal = PMPI_File_get_atomicity( fh, flag );
+ HDFtraceEvent_RT( mpiGetAtomicityEndID,
+ &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 != RT_OUTPUT ) {
+ returnVal = MPI_File_sync ( fh );
+ } else {
+ dataLen = 0;
+ HDFtraceEvent_RT( mpiSyncBeginID,
+ &dataPtr,dataLen );
+ returnVal = MPI_File_sync ( fh );
+ HDFtraceEvent_RT( mpiSyncEndID,
+ &dataPtr,dataLen );
+ }
+ return returnVal;
+}
+#endif /* HAVE_PARALLEL */
diff --git a/pablo/PabloHDF_RT.c b/pablo/PabloHDF_RT.c
index 9c3feb6..f40fd5b 100644
--- a/pablo/PabloHDF_RT.c
+++ b/pablo/PabloHDF_RT.c
@@ -140,6 +140,7 @@
#include "HDF5record_RT.h"
#ifdef HAVE_PARALLEL
+#include "mpio.h"
#include "MPIO_Init.h"
#include "MPIO_EventArgs.h"
#include "MPIO_TraceParams.h"
@@ -189,10 +190,10 @@ int initHDFProcTrace_RT( void );
void HDFtraceEvent_RT( int , char *, unsigned ) ;
void BeginIOEventRecord ( int, double , void * );
void EndIOEventRecord ( int , double , void * );
-void BeginMPIOEventRecord ( int, double, void * );
-void EndMPIOEventRecord ( int , double , void *);
+void BeginMPIOEventRecord ( int, double, void *, int );
+void EndMPIOEventRecord ( int , double , void *, int);
void BeginHDFEventRecord( int , double );
-void EndHDFEventRecord ( int , double ,void * );
+void EndHDFEventRecord ( int , double ,void *);
void HDFrecordFileName( HDFsetInfo * );
void HDFassignPabloIDs( int *, char *** );
void writeHDFNamePacketsRT( char **, int );
@@ -230,6 +231,10 @@ extern char *hdfRecordPointer;
//======================================================================*/
void HDFinitTrace_RT( char *fileName, unsigned procTraceMask )
{
+#ifdef HAVE_PARALLEL
+ int myNode;
+#endif
+ char *nameBuff;
int error;
TR_LOCK criticalSection;
TRgetClock( &epoch );
@@ -241,22 +246,25 @@ void HDFinitTrace_RT( char *fileName, unsigned procTraceMask )
fprintf (stderr,"Unable to Initialize properly. Exiting program\n");
exit(-1);
}
- FileName = ( char * ) malloc ( strlen( fileName ) + 1 );
- strcpy( FileName, fileName ) ;
+ FileName = ( char * ) malloc ( strlen( fileName ) + 10 );
#ifdef HAVE_PARALLEL
+ MPI_Comm_rank( MPI_COMM_WORLD, &myNode );
+ setTraceProcessorNumber( myNode );
+ sprintf(FileName,"%s.nd%d\0",fileName,myNode);
/*==============================================================*
// In the parallel case, initialize MPI-IO tracing. This will *
// set the trace file name. *
//==============================================================*/
-/* initMPIOTrace( FileName, RUNTIME_TRACE ); */
+ /*initMPIOTrace( FileName, 1); */
#else
/*==============================================================*
// In the non-parallel case, set the trace file name and *
// initialize the trace library. *
//==============================================================*/
+ strcpy( FileName, fileName ) ;
+#endif /* HAVE_PARALLEL */
setTraceFileName(FileName);
basicLibraryInit( );
-#endif /* HAVE_PARALLEL */
}
/*======================================================================*
// NAME *
@@ -278,23 +286,22 @@ void HDFendTrace_RT( void )
// Assing pablo ids to named identifiers and tag records *
//==============================================================*/
HDFassignPabloIDs( &numSetIDs, &Names );
- mapFile = (char *)malloc( strlen(FileName) + 5 );
- strcpy(mapFile,FileName);
- strcat(mapFile,".map");
- printFileMappingsRT( mapFile, Names, numSetIDs );
+ mapFile = (char *)malloc( strlen(FileName) + 15 );
+ sprintf( mapFile,"%s.map.nd%d\0", FileName, TRgetNode() );
+ printFileMappingsRT( mapFile, Names, numSetIDs );
/*==============================================================*
// Print SDDF summary records *
//==============================================================*/
writeHDFRecDescrptrsRT();
writeHDFNamePacketsRT( Names, numSetIDs );
- for ( j = 0; j < NumHDFProcs; ++j ) {
+ for ( j = 0; j < NumHDFProcs; ++j ) {
HDFSummarySDDF( HDFQueues[j], j );
- }
+ }
endTracing();
/*==============================================================*
// Clean up storage *
//==============================================================*/
- free( (void *)mapFile );
+ /* free( (void *)mapFile );
for ( j = 0; j < numSetIDs; ++j ) {
if ( Names[j] != NULL ) {
free((void *)Names[j]);
@@ -307,7 +314,7 @@ void HDFendTrace_RT( void )
} else {
free((void *)P);
}
- free((void *)HDFQueues) ;
+ free((void *)HDFQueues) ; */
}
/*======================================================================*
// initHFDProcTrace_RT *
@@ -410,9 +417,9 @@ void HDFtraceEvent_RT( int eventType, char *dataPtr, unsigned dataLen )
EndHDFEventRecord ( eventType, seconds, dataPtr );
#ifdef HAVE_PARALLEL
} else if ( isBeginMPIOEvent( eventType ) ) {
- BeginMPIOEventRecord ( eventType, seconds, dataPtr ) ;
+ BeginMPIOEventRecord ( eventType, seconds, dataPtr, dataLen ) ;
} else if ( isEndMPIOEvent( eventType ) ) {
- EndMPIOEventRecord ( eventType, seconds, dataPtr );
+ EndMPIOEventRecord ( eventType, seconds, dataPtr, dataLen );
#endif /* HAVE_PARALLEL */
} else {
fprintf(stderr,"eventType %d, dataLen = %u\n",eventType,dataLen);
@@ -513,7 +520,10 @@ void EndIOEventRecord ( int eventType, double secs, void *dataPtr )
// This routine simply records the time in the record on the top of *
// the stack. *
//======================================================================*/
-void BeginMPIOEventRecord( int eventType, double seconds, void *dataPtr )
+void BeginMPIOEventRecord( int eventType,
+ double seconds,
+ void *dataPtr,
+ int dataLen )
{
/*==============================================================*
// save the time value temporarily in top of stack *
@@ -527,6 +537,7 @@ void BeginMPIOEventRecord( int eventType, double seconds, void *dataPtr )
// name of the file. For mpiDelete, no information is of any *
// use. *
//==============================================================*/
+ if ( dataLen == 0 ) return;
switch ( eventType )
{
case mpiGetSizeBeginID:
@@ -653,14 +664,17 @@ void BeginMPIOEventRecord( int eventType, double seconds, void *dataPtr )
// and computes the duration of the MPI-I/O event. This is added to *
// the record field corresponding MPI-I/O. *
//======================================================================*/
-void EndMPIOEventRecord ( int eventType, double seconds, void *dataPtr )
+void EndMPIOEventRecord ( int eventType,
+ double seconds,
+ void *dataPtr,
+ int dataLen )
{
double incDur;
incDur = seconds - CallStack->lastIOtime;
CallStack->record.times[MPI] += incDur;
++CallStack->record.counts[MPI];
- if ( eventType == mpiOpenEndID ) {
+ if ( eventType == mpiOpenEndID && dataLen != 0 ) {
/*===========================================================*
// complete the file information for the case of a file *
// open and record the information. *
@@ -761,7 +775,8 @@ void HDFrecordFileName( HDFsetInfo *info )
{
fileRec_t *P;
char *t;
- int match, id;
+ int match;
+ long id;
P = HDFfileList;
match = FALSE;
id = info->setID;
@@ -793,7 +808,8 @@ void HDFassignPabloIDs( int *nSetIDs, char ***Names )
{
fileRec_t *F, *G;
HDFnode_t *P;
- int j, PabloID = 1;
+ int j;
+ long PabloID = 1;
long hdfID, xRef;
char *fName, **T;
@@ -815,7 +831,7 @@ void HDFassignPabloIDs( int *nSetIDs, char ***Names )
}
F = F->ptr;
}
- *nSetIDs = PabloID - 1;
+ *nSetIDs = (int)(PabloID - 1);
if ( *nSetIDs <= 0 ) return;
/*==============================================================*
// Repace hdfID and xRef fields with corresponding Pablo ID *
@@ -999,7 +1015,6 @@ void HDFSummarySDDF( HDFnode_t *P, int procIndex )
XREFid;
} Header;
- Packet = buff;
Header.packetLen = sizeof(Header)
+ sizeof(int) /* array len */
+ nTallyFields*sizeof(double) /* times array */
@@ -1023,6 +1038,7 @@ void HDFSummarySDDF( HDFnode_t *P, int procIndex )
Header.ExcDur = P->record.excDur;
Header.HDFid = P->record.hdfID;
Header.XREFid = P->record.xRef;
+ Packet = buff;
memcpy( Packet, &Header, sizeof(Header) );
Packet += sizeof(Header);
/*===========================================================*
@@ -1061,7 +1077,7 @@ void HDFSummarySDDF( HDFnode_t *P, int procIndex )
}
arrayLen = 0; /* name length */
memcpy( Packet, &arrayLen, sizeof(int) );
- putBytes( buff, Header.packetLen );
+ putBytes( buff, Header.packetLen );
free((void *)P);
P = Q;
}