mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2024-11-21 01:04:10 +08:00
Code Issues Packages Projects Releases Wiki Activity
b6be270f1f
hdf5/pablo/PabloHDF.c
Dan Wells 42d84aa44f [svn-r7424] 
Purpose:
bug
Description:
pablo failed to build properly
Solution:
make needed header files on the fly once again.  also allowed for length of
hdf entry names to be 80 characters.
Platforms tested:
modi4, copper, arabica, verbena
Misc. update:
2003-08-27 12:04:21 -05:00

1417 lines
43 KiB
C
Raw Blame History

/* 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>
#include <limits.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 );
#ifdef TRACELIB_BUILD
#undef PCF_BUILD
#endif
#ifndef PCF_BUILD
#include "SDDFparam.h"
#include "TraceParam.h"
#include "SystemDepend.h"
#include "Trace.h"
#include "IO_TraceParams.h"
#include "IOTrace.h"
#endif
#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
#ifdef H5_HAVE_PARALLEL
#define HAVE_MPIO
#endif
int OUTPUT_SWITCH = 1;
int *procTrace;
extern void preInitIOTrace( void );
#include "ProcIDs.h"
#include "HDFTrace.h"
#define ID_HDFprocName 9996
#define ID_malloc 9997
#define ID_free 9998
#define ID_timeStamp 9999
#define DUMMY_HDF 10000
char HDFprocNames[][80] = {
"noName",
"noName",
"noName",
"noName",
"noName",
#include "HDFentryNames.h"
"HDF_LAST_ENTRY"
};
void startHDFtraceEvent (int );
void endHDFtraceEvent (int , int , char *, int );
void getHDFprocName( int, char[81] );
void setHDFcallLevel( int );
void resetHDFcallLevel( void );
int HDFcallLevel;
int MaxHDFcallLevel = INT_MAX;
#ifdef PCF_BUILD
#include "PcUIOinterface.h"
void hdfCaptureInit( const char* name, int procNum, int captureType );
void hdfCaptureEnd( void );
void traceHDFentryEvent( int eventID ) ;
void traceHDFexitEvent( int eventID );
void basePerformanceInit( const char* name, int procNum );
void genericBaseInit( int captureType, int procNum );
void unixIObaseInit( int captureType, int procNum );
int hdfBaseInit( int captureType,
int procNum,
int numHDFentries,
char HDFprocNames[][80] );
void timeStamp( void );
void hdfBaseEnd( void );
void unixIObaseEnd( void );
void genericBaseEnd( void );
void basePerformanceEnd( void );
/*void* traceMALLOC( size_t bytes );
FILE* traceFOPEN( const char* fileName, const char* type );
int traceOPEN( const char *path, int flags, ... ) ;
int trace3OPEN( const char *path, int flags, mode_t mode ) ;
int traceCREAT( const char *path, mode_t mode ) ;
int traceFFLUSH( FILE *stream ) ;
int traceFCLOSE( FILE *stream ) ;
int traceCLOSE( int fd ) ;
ssize_t traceREAD( int fd, void *buf, int nbyte ) ;
size_t traceFREAD( void *ptr, int size, int nItems, FILE *stream ) ;
int traceFGETC( FILE *stream ) ;
char* traceFGETS( char *s, int n, FILE *stream ) ;
int traceGETW( FILE *stream ) ;
off_t traceLSEEK( int fd, off_t offset, int whence ) ;
int traceFSEEK( FILE *stream, off_t offset, int whence ) ;
int traceFSETPOS( FILE *stream, const fpos_t *position ) ;
void traceREWIND( FILE *stream ) ;
ssize_t traceWRITE( int fd, const void *buf, int nbyte ) ;
size_t traceFWRITE(const void *ptr, int size, int nItems, FILE *stream ) ;
int traceFPUTC( int c, FILE *stream ) ;
int traceFPUTS( const char *s, FILE *stream ) ;
int tracePUTS( const char *s ) ;
int tracePUTW( int w, FILE *stream ) ;*/
#else
void HDFinitTrace_RT ( const char *, int procNum );
void HDFinitTrace_SDDF ( const char *, int procNum );
void hinittracex_ ( char [], int *, int*, int[], int *,unsigned * );
void hdfendtrace_ ( void ) ;
void HDFendTrace_RT (void );
void HDFendTrace_SDDF( void );
void HDFfinalTimeStamp( void );
void HDFtraceEvent_RT ( int , HDFsetInfo *, unsigned );
void HDFtraceIOEvent( int , void *, unsigned );
extern int IOtracingEnabled;
extern int suppressMPIOtrace;
char *hdfRecordPointer;
#endif
/*======================================================================*
// 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. *
// This is called from hdfinittracef_ *
//======================================================================*/
void
hinittracex_( char *file,
int *len,
int *procNum,
int flags[],
int *nflags,
unsigned *out_sw )
{
char *traceFileName;
int i;
traceFileName = (char *)malloc(*len+1);
HDFcallLevel = 0;
for ( i = 0; i < *len; ++i )
{
traceFileName[i] = file[i];
}
traceFileName[*len] = 0;
/*===================================================================*
// Allocate space for trace indicators. *
//===================================================================*/
procTrace = ( int * ) malloc( NUM_HDF_IDS*sizeof(int) );
if ( procTrace == NULL )
{
fprintf(stderr,">> Error: Unable to allocate procTrace ");
fprintf(stderr,"array in program HDFinitTrace. <<<\n");
fprintf(stderr,">>> Exiting program! <<<\n");
exit (-1);
}
/*===================================================================*
// Initialize to 0. *
//===================================================================*/
for ( i = 0; i < NUM_HDF_IDS; ++i )
{
procTrace[i] = 0;
}
/*===================================================================*
// Read in the flags indicating which procedures to trace. *
// The last parameter passed is an indicator of the type of *
// tracing to do. This indicator has a value larger than any *
// of the flags. *
//===================================================================*/
for ( i = 0; i < *nflags; ++i )
{
procTrace[flags[i]] = 1;
}
OUTPUT_SWITCH = *out_sw;
/*===================================================================*
// if no flags were passed, the default is to trace all of the *
// procedures. *
//===================================================================*/
if ( *nflags == 0 || procTrace[ID_ALLHDF] )
{
for ( i = 0; i < NUM_HDF_IDS; ++i )
{
procTrace[i] = 1;
}
}
#ifdef PCF_BUILD
hdfCaptureInit( traceFileName, *procNum, OUTPUT_SWITCH );
#else
suppressMPIOtrace = TRUE;
if ( OUTPUT_SWITCH == RUNTIME_TRACE
|| OUTPUT_SWITCH == MPI_RUNTIME_TRACE )
{
HDFinitTrace_SDDF( traceFileName, *procNum );
IOtracingEnabled = 1;
}
else if ( OUTPUT_SWITCH == SUMMARY_TRACE
|| OUTPUT_SWITCH == MPI_SUMMARY_TRACE )
{
HDFinitTrace_RT( traceFileName, *procNum );
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);
}
#endif /* PCF_BUILD */
}
void
HDFinitTrace( const char *traceFileName, int procNum, int id_flag, ... )
{
int i;
int nIDs;
va_list ap;
HDFcallLevel = 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. *
//===================================================================*/
nIDs = 0;
va_start( ap, id_flag );
while ( id_flag > LAST_TRACE_TYPE )
{
procTrace[id_flag] = 1;
++nIDs;
id_flag = va_arg ( ap, int );
}
OUTPUT_SWITCH = id_flag;
/*===================================================================*
// if no flags were passed, the default is to trace all of the *
// procedures. *
//===================================================================*/
if ( nIDs == 0 || procTrace[ID_ALLHDF] )
{
for ( i = 0; i < NUM_HDF_IDS; ++i )
{
procTrace[i] = 1;
}
}
#ifdef PCF_BUILD
hdfCaptureInit( traceFileName, procNum, OUTPUT_SWITCH );
#else
suppressMPIOtrace = TRUE;
if ( OUTPUT_SWITCH == RUNTIME_TRACE
|| OUTPUT_SWITCH == MPI_RUNTIME_TRACE )
{
HDFinitTrace_SDDF( traceFileName, procNum );
IOtracingEnabled = 1;
}
else if ( OUTPUT_SWITCH == SUMMARY_TRACE
|| OUTPUT_SWITCH == MPI_SUMMARY_TRACE )
{
HDFinitTrace_RT( traceFileName, procNum );
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);
}
#endif /* PCF_BUILD */
}
/*======================================================================*
// NAME *
// HDFendTrace -- end HDF tracing *
// USAGE *
// VOID HDFendTrace(VOID) *
// RETURNS *
// None. *
//======================================================================*/
void hdfendtrace_( void )
{
HDFendTrace ();
}
void setHDFcallLevel( int maxLevel )
{
MaxHDFcallLevel = maxLevel;
}
void resetHDFcallLevel()
{
MaxHDFcallLevel = INT_MAX;
}
void HDFendTrace(void)
{
#ifdef PCF_BUILD
hdfCaptureEnd();
#else
if ( OUTPUT_SWITCH == RUNTIME_TRACE
|| OUTPUT_SWITCH == MPI_RUNTIME_TRACE )
{
HDFendTrace_SDDF( );
}
else if ( OUTPUT_SWITCH == SUMMARY_TRACE
|| OUTPUT_SWITCH == MPI_SUMMARY_TRACE )
{
HDFendTrace_RT();
}
#endif /* PCF_BUILD */
OUTPUT_SWITCH = NO_TRACE;
MaxHDFcallLevel = INT_MAX;
}
void startHDFtraceEvent(int eventID)
{
++HDFcallLevel;
if ( HDFcallLevel <= MaxHDFcallLevel )
{
#ifdef PCF_BUILD
if (OUTPUT_SWITCH != NO_TRACE )
{
traceHDFentryEvent( eventID ) ;
}
#else
if ( OUTPUT_SWITCH == RUNTIME_TRACE
|| OUTPUT_SWITCH == MPI_RUNTIME_TRACE )
{
traceEvent( eventID, NULL, 0 ) ;
}
else if (OUTPUT_SWITCH != NO_TRACE )
{
HDFtraceEvent_RT( eventID, NULL, 0 ) ;
}
#endif /* PCF_BUILD */
}
}
void endHDFtraceEvent(int eventID, int setID, char *setName, int IDtype )
{
if ( HDFcallLevel <= MaxHDFcallLevel )
{
#ifdef PCF_BUILD
{
traceHDFexitEvent( eventID );
}
#else
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 ) ;
}
#endif /* PCF_BUILD */
}
--HDFcallLevel;
}
#ifdef PCF_BUILD
void
hdfCaptureInit( const char* name, int procNum, int captureType )
{
basePerformanceInit( name, procNum );
genericBaseInit( captureType, procNum );
unixIObaseInit( captureType, procNum );
#ifdef HAVE_MPIO
mpiIObaseInit( captureType, procNum );
#endif
hdfBaseInit( captureType,
procNum,
ID_HDF_Last_Entry,
HDFprocNames );
HDFcallLevel = 0;
}
void
hdfCaptureEnd( void )
{
int i;
timeStamp();
for ( i = 0; i < NUM_HDF_IDS; ++i )
{
procTrace[i] = 0;
}
hdfBaseEnd();
#ifdef HAVE_MPIO
mpiIObaseEnd();
#endif
unixIObaseEnd();
genericBaseEnd();
basePerformanceEnd();
MaxHDFcallLevel = INT_MAX;
}
#endif /* PCF_BUILD */
/*****************************************************************************/
/* The HDFtraceXXXX routines are substitutes for the standard I/O routines. */
/* When libhdf5-inst.a is compiled, macros in HDFTrace.h substitute the name */
/* HDFtraceWrite for write, HDFtraceRead for Read, etc. These routines are */
/* then called when standard I/O is done. */
/*****************************************************************************/
/*****************************************************************************/
/*+ Open routines +*/
/*+ ------------- +*/
/*+ +*/
/*+ Routine: FILE *HDFtraceFOPEN( const char *filename, const char *type ) +*/
/*+ substitute for fopen() +*/
/*+ generates fopenBeginID, fopenEndID +*/
/*+ record Open (fopenBegin) +*/
/*+ Mode = -1 +*/
/*+ +*/
/*****************************************************************************/
FILE*
HDFtraceFOPEN( const char *filename, const char *type )
{
FILE *fp;
#ifdef PCF_BUILD
fp = (FILE *)traceFOPEN( filename, type );
#else
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 );
}
#endif /* PCF_BUILD */
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 )
{
int fd;
#ifdef PCF_BUILD
fd = traceCREAT( path, mode );
#else
struct open_args openArgs;
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 );
}
#endif /* PCF_BUILD */
return( fd );
}
/*****************************************************************************/
/*+ Flush routines +*/
/*+ -------------- +*/
/*+ +*/
/*+ Routine: int HDFtraceFFLUSH( FILE *stream ) +*/
/*+ substitute for fflush() +*/
/*+ generates fflushBeginID, fflushEndID +*/
/*+ record Flush (fflushBeginID) +*/
/*+ +*/
/*****************************************************************************/
int
HDFtraceFFLUSH( FILE *stream )
{
int ret;
#ifdef PCF_BUILD
ret = traceFFLUSH( stream );
#else
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.
*/
#endif /* PCF_BUILD */
return( ret );
}
/*****************************************************************************/
/*+ Close routines +*/
/*+ -------------- +*/
/*+ +*/
/*+ Routine: int HDFtraceFCLOSE( FILE *stream ) +*/
/*+ substitute for fclose() +*/
/*+ generates fcloseBeginID, fcloseEndID +*/
/*+ record Close (fcloseBeginID) +*/
/*+ +*/
/*****************************************************************************/
int
HDFtraceFCLOSE( FILE *stream )
{
int ret;
#ifdef PCF_BUILD
ret = traceFCLOSE( stream );
#else
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 );
}
#endif /* PCF_BUILD */
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 )
{
int fd;
#ifdef PCF_BUILD
fd = trace3OPEN( path, flags, mode );
#else
struct open_args openArgs;
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 );
}
#endif /* PCF_BUILD */
return( fd );
}
/*****************************************************************************/
/*+ Routine: int HDFtraceCLOSE( int fd ) +*/
/*+ substitute for close() +*/
/*+ generates closeBeginID, closeEndID +*/
/*+ record Close (closeBeginID) +*/
/*+ +*/
/*****************************************************************************/
int
HDFtraceCLOSE( int fd )
{
int ret;
#ifdef PCF_BUILD
ret = traceCLOSE( fd );
#else
int id;
if ( IOtracingEnabled )
{
id = c_mappedID( fd );
HDFtraceIOEvent( closeBeginID, (void *) &id, int_SIZE );
}
ret = close( fd );
if ( IOtracingEnabled )
{
HDFtraceIOEvent( closeEndID, (void *) 0, 0 );
}
#endif /* PCF_BUILD */
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 )
{
ssize_t ret;
#ifdef PCF_BUILD
ret = traceREAD( fd, buf, nbyte );
#else
struct read_write_args readArgs;
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 );
}
#endif /* PCF_BUILD */
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 )
{
size_t ret;
#ifdef PCF_BUILD
ret = traceFREAD( ptr, size, nitems, stream );
#else
struct read_write_args readArgs;
int nbytes;
int fd = fileno( stream );
if ( IOtracingEnabled )
{
readArgs.fileID = c_mappedID( fd );
readArgs.numVariables = (int)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 );
}
#endif /* PCF_BUILD */
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 )
{
off_t ret;
#ifdef PCF_BUILD
ret = traceLSEEK( fd, offset, whence );
#else
struct seek_args seekArgs;
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 );
}
#endif /* PCF_BUILD */
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 )
{
int ret;
#ifdef PCF_BUILD
ret = traceFSEEK( stream, offset, whence );
#else
struct seek_args seekArgs;
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 );
}
#endif /* PCF_BUILD */
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 )
{
int ret;
#ifdef PCF_BUILD
ret = traceFSETPOS( stream, position );
#else
struct seek_args seekArgs;
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 );
}
#endif /* PCF_BUILD */
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 )
{
#ifdef PCF_BUILD
traceREWIND( stream );
#else
long arg;
struct seek_args seekArgs;
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 );
}
#endif /* PCF_BUILD */
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 )
{
ssize_t ret;
#ifdef PCF_BUILD
ret = traceWRITE( fd, buf, nbyte );
#else
struct read_write_args writeArgs;
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 );
}
#endif /* PCF_BUILD */
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 )
{
size_t ret;
#ifdef PCF_BUILD
ret = traceFWRITE( ptr, size, nitems, stream );
#else
struct read_write_args writeArgs;
int nbytes;
int fd = fileno( stream );
if ( IOtracingEnabled )
{
writeArgs.fileID = c_mappedID( fd );
writeArgs.numVariables = (int)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 );
}
#endif /* PCF_BUILD */
return( ret );
}
/*****************************************************************************/
/*+ Routine: int HDFtracePUTS( char *s ) +*/
/*+ substitute for puts() +*/
/*+ generates fwriteBeginID, fwriteEndID +*/
/*+ record Write (fwriteBeginID) +*/
/*+ Number Variables = 1 +*/
/*+ Cause = -1 +*/
/*+ +*/
/*****************************************************************************/
int
HDFtracePUTS( const char *s )
{
int ret;
#ifdef PCF_BUILD
ret = tracePUTS( s );
#else
int fd = fileno( stdout );
struct read_write_args writeArgs;
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 );
}
#endif
return( ret );
}
void getHDFprocName ( int i, char buff[81] )
{
strcpy( buff, HDFprocNames[i] );
}
/*****************************************************************************/
/*+ 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 )
{
int ret;
#ifdef PCF_BUILD
ret = traceFPUTC( c, stream );
#else
struct read_write_args writeArgs;
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 );
}
}
#endif /* PCF_BUILD */
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 )
{
int ret;
#ifdef PCF_BUILD
ret = traceFPUTS( s, stream );
#else
int fd = fileno( stream );
struct read_write_args writeArgs;
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 );
}
#endif /* PCF_BUILD */
return( ret );
}
void*
HDFtraceMALLOC(size_t bytes )
{
void *ptr;
#ifdef PCF_BUILD
ptr = (void *)traceMALLOC( bytes );
#else
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) );
}
#endif /* PCF_BUILD */
return ptr ;
}
#ifndef PCF_BUILD
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);
}
}
#endif /* PCF_BUILD */
Reference in New Issue View Git Blame Copy Permalink