diff options
Diffstat (limited to 'pablo/PabloHDF.c')
-rw-r--r-- | pablo/PabloHDF.c | 1585 |
1 files changed, 0 insertions, 1585 deletions
diff --git a/pablo/PabloHDF.c b/pablo/PabloHDF.c deleted file mode 100644 index cba0c87..0000000 --- a/pablo/PabloHDF.c +++ /dev/null @@ -1,1585 +0,0 @@ -/* 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> -#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; -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 -void HDFinitTrace_RT ( const char *, unsigned int ); -void HDFinitTrace_SDDF ( const char *, unsigned int ); -void hinittracex_ ( int [], int *, unsigned *, int * ); -void hdfendtrace_ ( void ) ; -void HDFendTrace (void); -void HDFendTrace_RT (void); -void HDFendTrace_SDDF(void); -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 ); -uint procTrace; -extern int IOtracingEnabled; -char *hdfRecordPointer; -/*======================================================================* -// NAME * -// HDFinitTrace -- initialize HDF tracing * -// USAGE * -// VOID HDFinitTrace( traceFileName, procTraceMask, out_sw ) * -// char *traceFileName; IN: name of the generated trace output * -// file * -// uint32 procTraceMask; IN: families of procedures to trace * -// int out_sw IN: indicates whether to produce SDDF * -// file or Final Summary * -// 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, unsigned *procMask, int *out_sw ) -{ - char *fileName; - int i; - fileName = (char *)malloc(*len+1); - for ( i = 0; i < *len; ++i ) { - fileName[i] = file[i]; - } - fileName[*len+1] = 0; - HDFinitTrace ( fileName, *procMask, *out_sw ); -} -void HDFinitTrace( const char *traceFileName, unsigned procTraceMask, - unsigned out_sw ) -{ - OUTPUT_SWITCH = out_sw; - if ( out_sw == SDDF_OUTPUT ) { - HDFinitTrace_SDDF( traceFileName, procTraceMask ); - IOtracingEnabled = 1; - } else if ( out_sw == RT_OUTPUT ) { - HDFinitTrace_RT( traceFileName, procTraceMask ); - IOtracingEnabled = 1; - } else if ( out_sw == NO_OUTPUT ) { - procTrace = 0; - IOtracingEnabled = 0; - } else { - fprintf(stderr,">> Error in HDFinitTrace: the third argument "); - fprintf(stderr,"must have the value 0, 1, <<<\n"); - fprintf(stderr,">> or 2. The value received was %u.", out_sw); - 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 == SDDF_OUTPUT ) { - HDFendTrace_SDDF( ); - } else if ( OUTPUT_SWITCH == RT_OUTPUT ) { - HDFendTrace_RT( ); - } - procTrace = 0; -} -void startHDFtraceEvent(int eventID) -{ - if ( OUTPUT_SWITCH == SDDF_OUTPUT ) { - 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 == SDDF_OUTPUT ) { - traceEvent( eventID, (char *)&info, 0 ) ; - } else if (OUTPUT_SWITCH == RT_OUTPUT ) { - HDFtraceEvent_RT( eventID, &info, 0 ) ; - } else if ( OUTPUT_SWITCH < 0 ) { - 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 +*/ -/*+ +*/ -size_t HDFtraceREAD( int fd, char *buf, int nbyte ) -{ - struct read_write_args readArgs; - size_t ret; - int bytes; - - if ( IOtracingEnabled ) { - readArgs.fileID = c_mappedID( fd ); - readArgs.numVariables = 1; - readArgs.cause = -1; - - HDFtraceIOEvent( readBeginID, (void *) &readArgs, sizeof(readArgs) ); - } - - ret = read( fd, buf, nbyte ); - - 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, int size, int nitems, FILE *stream ) -{ - struct read_write_args readArgs; - size_t ret; - int nbytes; - int fd = fileno( stream ); - - if ( IOtracingEnabled ) { - readArgs.fileID = c_mappedID( fd ); - readArgs.numVariables = nitems; - readArgs.cause = -1; - HDFtraceIOEvent( freadBeginID, (void *) &readArgs, sizeof(readArgs) ); - } - - ret = fread( ptr, size, nitems, stream ); - - 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 +*/ -/*+ +*/ -size_t HDFtraceWRITE( int fd, const char *buf, int nbyte ) -{ - struct read_write_args writeArgs; - size_t ret; - int bytes; - - if ( IOtracingEnabled ) { - writeArgs.fileID = c_mappedID( fd ); - writeArgs.numVariables = 1; - writeArgs.cause = -1; - - HDFtraceIOEvent( writeBeginID, (void *) &writeArgs, sizeof(writeArgs) ); - } - - ret = write( fd, buf, nbyte ); - - 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 char *ptr, int size, int nitems, FILE *stream ) -{ - struct read_write_args writeArgs; - size_t ret; - int nbytes; - int fd = fileno( stream ); - - if ( IOtracingEnabled ) { - writeArgs.fileID = c_mappedID( fd ); - writeArgs.numVariables = nitems; - writeArgs.cause = -1; - - HDFtraceIOEvent( fwriteBeginID, (void *) &writeArgs, sizeof(writeArgs) ); - } - - ret = fwrite( ptr, size, nitems, stream ); - - 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 == 1 ) { - traceEvent( eventType, dataPtr, dataLen ); - } else { - HDFtraceEvent_RT( eventType, (HDFsetInfo *)dataPtr, dataLen ); - } -} -/*======================================================================* -// record the final time stamp * -//======================================================================*/ -void HDFfinalTimeStamp( void ) -{ - TR_LOCK criticalSection; - CLOCK currentTime; - double seconds; - struct { - int packetLength, - packetType, - packetTag, - timeDim; - double Seconds; - int eventID, - node, - dataLen; - } Packet; - - criticalSection = TRlock(); - 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) ); -} -#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 */ |