mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2025-03-31 17:10:47 +08:00
Code Issues Packages Projects Releases Wiki Activity

[svn-r1123] Updates for bug fixes and new entry points in files from src directory.

Browse Source
This commit is contained in:
Dan Wells 1999-03-09 16:00:07 -05:00
parent ebb0060a05
commit cd06c38d65
8 changed files with 927 additions and 680 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

78
pablo/HDF5record_RT.h
View File

@ -167,84 +167,6 @@ typedef struct fileRec {
int getHDFFieldIndex( int eventID );
int getHDFByteFieldIndex( int eventID );
#define IOerrorID 700000
#define openBeginID 700001
#define openEndID 700002
#define fopenBeginID 700003
#define fopenEndID 700004
#define closeBeginID 700005
#define closeEndID 700006
#define fcloseBeginID 700007
#define fcloseEndID 700008
#define readBeginID 700009
#define readEndID 700010
#define freadBeginID 700011
#define freadEndID 700012
#define lseekBeginID 700013
#define lseekEndID 700014
#define fseekBeginID 700015
#define fseekEndID 700016
#define writeBeginID 700017
#define writeEndID 700018
#define fwriteBeginID 700019
#define fwriteEndID 700020
#define fflushBeginID 700021
#define fflushEndID 700022
#define flushBeginID 700023
#define flushEndID 700024
#define rewindBeginID 700025
#define rewindEndID 700026
#define fsetposBeginID 700027
#define fsetposEndID 700028
#define lifetimeID 700040
#define timeSummaryID 700041
#define regionSummaryID 700042
#define IOinitTraceID 700100
#define IOendTraceID 700101
#define IOenableTraceID 700102
#define IOdisableTraceID 700103
#define IOenableDetailID 700104
#define IOdisableDetailID 700105
#define IOenableLifeSummID 700106
#define IOdisableLifeSummID 700107
#define IOenableTimeSummID 700108
#define IOdisableTimeSummID 700109
#define IOchangeTimeWindowID 700110
#define IOenableRegionSummID 700111
#define IOdisableRegionSummID 700112
#define IOchangeFileRegionID 700113
/*
* Define the masks for the I/O event families,
*/
#define FAMILY_OPEN 0500
#define FAMILY_FLUSH 0510
#define FAMILY_CLOSE 0520
#define FAMILY_READ 0530
#define FAMILY_SEEK 0540
#define FAMILY_WRITE 0550
#define FAMILY_LIFETIME 0560
#define FAMILY_TIME_SUMMARY 0570
#define FAMILY_REGION_SUMMARY 0600
#define FAMILY_IOTRACE_STATE 0610
#define FAMILY_IO_MISC 0620
/*
* Define flags to distinguish misc i/o begin from misc i/o end
*/

520
pablo/HDFentries.txt
View File

@ -1,138 +1,137 @@
ANannlen
ANannlist
ANcreate
ANcreatef
ANend
ANendaccess
ANfileinfo
ANnumann
ANreadann
ANselect
ANstart
ANwriteann
DAcreate_array
DAdel_elem
DAdestroy_array
DAget_elem
DAset_elem
DAsize_array
DF24addimage
DF24getdims
DF24getimage
DF24lastref
DF24nimages
DF24putimage
DF24readref
DF24reqil
DF24restart
DF24setcompress
DF24setdims
DF24setil
DFANaddfds
DFANaddfid
DFANclear
DFANgetdesc
DFANgetdesclen
DFANgetfds
DFANgetfdslen
DFANgetfid
DFANgetfidlen
DFANgetlabel
DFANgetlablen
DFANlablist
DFANlastref
DFANputdesc
DFANputlabel
DFPaddpal
DFPgetpal
DFPlastref
DFPnpals
DFPputpal
DFPreadref
DFPrestart
DFPwriteref
DFR8Istart
DFR8addimage
DFR8getdims
DFR8getimage
DFR8lastref
DFR8nimages
DFR8putimage
DFR8readref
DFR8restart
DFR8setcompress
DFR8setpalette
DFR8writeref
DFSDadddata
DFSDclear
DFSDendslab
DFSDendslice
DFSDgetNT
DFSDgetcal
DFSDgetdata
DFSDgetdatalen
DFSDgetdatastrs
DFSDgetdimlen
DFSDgetdims
DFSDgetdimscale
DFSDgetdimstrs
DFSDgetfillvalue
DFSDgetrange
DFSDgetslice
DFSDlastref
DFSDndatasets
DFSDpre32sdg
DFSDputdata
DFSDputslice
DFSDreadref
DFSDreadslab
DFSDrestart
DFSDsetNT
DFSDsetcal
DFSDsetdatastrs
DFSDsetdims
DFSDsetdimscale
DFSDsetdimstrs
DFSDsetfillvalue
DFSDsetlengths
DFSDsetrange
DFSDstartslab
DFSDstartslice
DFSDwriteref
DFSDwriteslab
GRattrinfo
GRcreate
GRdiminfo
GRend
GRendaccess
GRfileinfo
GRfindattr
GRgetattr
GRgetchunkinfo
GRgetdimid
GRgetiminfo
GRgetlutid
GRgetlutinfo
GRidtoref
GRluttoref
GRnametoindex
GRreadimage
GRreadlut
GRreftoindex
GRreqimageil
GRreqlutil
GRselect
GRsetaccesstype
GRsetattr
GRsetchunk
GRsetchunkcache
GRsetcompress
GRsetdimname
GRsetexternalfile
GRstart
GRwriteimage
GRwritelut
H5AC_create
H5I_debug
H5F_flush_all
H5F_close_all
H5S_none_select_serialize
H5S_none_select_deserialize
H5T_conv_enum_init
H5T_conv_enum
H5T_conv_schar_uchar
H5T_conv_uchar_schar
H5T_conv_schar_short
H5T_conv_schar_ushort
H5T_conv_uchar_short
H5T_conv_uchar_ushort
H5T_conv_schar_int
H5T_conv_schar_uint
H5T_conv_uchar_int
H5T_conv_uchar_uint
H5T_conv_schar_long
H5T_conv_schar_ulong
H5T_conv_uchar_long
H5T_conv_uchar_ulong
H5T_conv_schar_llong
H5T_conv_schar_ullong
H5T_conv_uchar_llong
H5T_conv_uchar_ullong
H5T_conv_short_schar
H5T_conv_short_uchar
H5T_conv_ushort_schar
H5T_conv_ushort_uchar
H5T_conv_short_ushort
H5T_conv_ushort_short
H5T_conv_short_int
H5T_conv_short_uint
H5T_conv_ushort_int
H5T_conv_ushort_uint
H5T_conv_short_long
H5T_conv_short_ulong
H5T_conv_ushort_long
H5T_conv_ushort_ulong
H5T_conv_short_llong
H5T_conv_short_ullong
H5T_conv_ushort_llong
H5T_conv_ushort_ullong
H5T_conv_int_schar
H5T_conv_int_uchar
H5T_conv_uint_schar
H5T_conv_uint_uchar
H5T_conv_int_short
H5T_conv_int_ushort
H5T_conv_uint_short
H5T_conv_uint_ushort
H5T_conv_int_uint
H5T_conv_uint_int
H5T_conv_int_long
H5T_conv_int_ulong
H5T_conv_uint_long
H5T_conv_uint_ulong
H5T_conv_int_llong
H5T_conv_int_ullong
H5T_conv_uint_llong
H5T_conv_uint_ullong
H5T_conv_long_schar
H5T_conv_long_uchar
H5T_conv_ulong_schar
H5T_conv_ulong_uchar
H5T_conv_long_short
H5T_conv_long_ushort
H5T_conv_ulong_short
H5T_conv_ulong_ushort
H5T_conv_long_int
H5T_conv_long_uint
H5T_conv_ulong_int
H5T_conv_ulong_uint
H5T_conv_long_ulong
H5T_conv_ulong_long
H5T_conv_long_llong
H5T_conv_long_ullong
H5T_conv_ulong_llong
H5T_conv_ulong_ullong
H5T_conv_llong_schar
H5T_conv_llong_uchar
H5T_conv_ullong_schar
H5T_conv_ullong_uchar
H5T_conv_llong_short
H5T_conv_llong_ushort
H5T_conv_ullong_short
H5T_conv_ullong_ushort
H5T_conv_llong_int
H5T_conv_llong_uint
H5T_conv_ullong_int
H5T_conv_ullong_uint
H5T_conv_llong_long
H5T_conv_llong_ulong
H5T_conv_ullong_long
H5T_conv_ullong_ulong
H5T_conv_llong_ullong
H5T_conv_ullong_llong
H5Tset_precision
H5Tenum_create
H5Tenum_insert
H5Tget_super
H5Tget_member_value
H5Tenum_nameof
H5Tenum_valueof
H5Tregister
H5T_isa
H5T_set_size
H5T_set_precision
H5T_set_offset
H5T_struct_insert
H5T_sort_value
H5T_sort_name
H5T_enum_insert
H5T_enum_nameof
H5T_enum_valueof
H5T_convert
H5T_print_stats
H5S_select_elements
H5S_select_all
H5S_select_none
H5S_select_serial_size
H5S_select_serialize
H5S_select_deserialize
H5S_point_select_serial_size
H5S_point_select_serialize
H5S_point_select_deserialize
H5S_hyper_node_release
H5S_hyper_select_serial_size
H5S_hyper_select_serialize
H5S_hyper_select_deserialize
H5S_all_select_deserialize
H5S_all_select_serialize
H5RA_isa
H5Pset_gc_references
H5AC_debug
H5AC_dest
H5AC_find
@ -140,6 +139,7 @@ H5AC_flush
H5AC_protect
H5AC_rename
H5AC_set
H5AC_create
H5AC_unprotect
H5A_close
H5A_copy
@ -185,8 +185,7 @@ H5D_get_file
H5D_get_space
H5D_init_interface
H5D_init_storage
H5D_isa
H5D_new
H5D_new
H5D_open
H5D_open_oid
H5D_read
@ -318,12 +317,10 @@ H5G_ent_modified
H5G_find
H5G_get_comment
H5G_get_objinfo
H5G_get_type
H5G_getcwg
H5G_init_interface
H5G_insert
H5G_insertion_file
H5G_isa
H5G_link
H5G_linkval
H5G_loc
@ -345,7 +342,6 @@ H5G_node_remove
H5G_open
H5G_pop
H5G_push
H5G_register_type
H5G_reopen
H5G_rootof
H5G_set
@ -445,15 +441,14 @@ H5O_efl_reset
H5O_efl_size
H5O_efl_total_size
H5O_efl_write
H5O_exists
H5O_fill_convert
H5O_fill_copy
H5O_fill_debug
H5O_find_in_ohdr
H5O_fill_decode
H5O_fill_encode
H5O_fill_reset
H5O_fill_copy
H5O_fill_size
H5O_find_in_ohdr
H5O_fill_reset
H5O_fill_debug
H5O_fill_convert
H5O_flush
H5O_free
H5O_init_interface
@ -510,6 +505,9 @@ H5P_copy
H5P_create
H5P_get_class
H5P_init_interface
H5PC_Signal_right_neighbor
H5PC_Wait_for_left_neighbor
H5PC_Wait_for_right_neighbor
H5Pclose
H5Pcopy
H5Pcreate
@ -561,19 +559,6 @@ H5Pset_stdio
H5Pset_sym_k
H5Pset_userblock
H5Pset_xfer
H5RA_close
H5RA_create
H5RA_fix_overflow
H5RA_init_interface
H5RA_isa
H5RA_open
H5RA_read
H5RA_write
H5RAclose
H5RAcreate
H5RAopen
H5RAread
H5RAwrite
H5R_close
H5R_create
H5R_dereference
@ -590,6 +575,18 @@ H5Rget_region
H5Ropen
H5Rread
H5Rwrite
H5RAcreate
H5RA_create
H5RAopen
H5RA_open
H5RAclose
H5RA_close
H5RA_init_interface
H5RAwrite
H5RA_write
H5RA_fix_overflow
H5RAread
H5RA_read
H5S_all_favail
H5S_all_fgath
H5S_all_fscat
@ -716,7 +713,6 @@ H5T_init
H5T_init_interface
H5T_insert
H5T_is_atomic
H5T_isa
H5T_lock
H5T_open
H5T_pack
@ -794,201 +790,9 @@ H5_init_thread
H5dont_atexit
H5get_libversion
H5open
HAatom_group
HAatom_object
HAdestroy_group
HAinit_group
HAregister_atom
HAremove_atom
HAsearch_atom
HDFnewentry
HDdont_atexit
HDreuse_tagref
HEclear
HEprint
HEpush
HEreport
HEstring
HIbitstart
HIstart
HLconvert
HLcreate
HMCPchunkread
HMCPchunkwrite
HMCPendaccess
HMCPinfo
HMCPinquire
HMCPread
HMCPseek
HMCPstread
HMCPstwrite
HMCPwrite
HMCcreate
HMCreadChunk
HMCsetMaxcache
HMCwriteChunk
HPregister_term_func
HULadd_node
HULcreate_list
HULdestroy_list
HULfirst_node
HULnext_node
HULremove_node
HULsearch_node
HXcreate
HXsetcreatedir
HXsetdir
Happendable
Hcache
Hclose
Hdeldd
Hdupdd
Hendaccess
Hexist
Hfidinquire
Hfind
Hgetelement
Hgetfileversion
Hgetlibversion
Hinquire
Hisappendable
Hishdf
Hlength
Hnewref
Hnextread
Hnumber
Hoffset
Hopen
Hputelement
Hread
Hseek
Hsetaccesstype
Hsetlength
Hstartaccess
Hstartread
Hstartwrite
Hsync
Htagnewref
Htell
Htrunc
Hwrite
SDattrinfo
SDcheckempty
SDcreate
SDdiminfo
SDend
SDendaccess
SDfileinfo
SDfindattr
SDgetcal
SDgetchunkinfo
SDgetdatastrs
SDgetdimid
SDgetdimscale
SDgetdimstrs
SDgetfillvalue
SDgetinfo
SDgetrange
SDidtoref
SDiscoordvar
SDisdimval_bwcomp
SDisrecord
SDnametoindex
SDreadattr
SDreadchunk
SDreaddata
SDreftoindex
SDselect
SDsetaccesstype
SDsetattr
SDsetblocksize
SDsetcal
SDsetchunk
SDsetchunkcache
SDsetcompress
SDsetdatastrs
SDsetdimname
SDsetdimscale
SDsetdimstrs
SDsetdimval_comp
SDsetexternalfile
SDsetfillmode
SDsetfillvalue
SDsetnbitdataset
SDsetrag
SDsetrange
SDstart
SDwritechunk
SDwritedata
VFfieldesize
VFfieldisize
VFfieldname
VFfieldorder
VFfieldtype
VFnfields
VHmakegroup
VHstoredata
VHstoredatam
VSappendable
VSattach
VSattrinfo
VSdelete
VSdetach
VSelts
VSfdefine
VSfexist
VSfind
VSfindattr
VSfindclass
VSfindex
VSfnattrs
VSfpack
VSgetattr
VSgetclass
VSgetfields
VSgetid
VSgetinterlace
VSgetname
VSinquire
VSisattr
VSlone
VSnattrs
VSread
VSseek
VSsetattr
VSsetclass
VSsetfields
VSsetinterlace
VSsetname
VSsizeof
VSwrite
Vaddtagref
Vattach
Vattrinfo
Vdeletetagref
Vdetach
Vfind
Vfindattr
Vfindclass
Vfinish
Vgetattr
Vgetclass
Vgetid
Vgetname
Vgettagref
Vgettagrefs
Vgetversion
Vinitialize
Vinqtagref
Vinquire
Vinsert
Vlone
Vnattrs
Vntagrefs
Vsetattr
Vsetclass
Vsetname
vpackvg
vpackvs
vunpackvg
vunpackvs
H5D_isa
H5F_init
H5G_register_type
H5G_isa
H5G_get_type
H5O_exists

46
pablo/Makefile.in
View File

@ -29,9 +29,9 @@ LIB_SRC=H5.c H5A.c H5AC.c H5B.c H5D.c H5E.c H5F.c H5Farray.c H5Fcore.c \
H5Fstdio.c H5G.c H5Gent.c H5Gnode.c H5Gstab.c H5HG.c H5HL.c H5I.c H5MF.c \
H5MM.c H5O.c H5Oattr.c H5Ocomp.c H5Ocont.c H5Odtype.c H5Oefl.c H5Ofill.c \
H5Olayout.c H5Omtime.c H5Oname.c H5Onull.c H5Osdspace.c H5Oshared.c \
H5Ostab.c H5P.c H5R.c H5RA.c H5S.c H5Sall.c H5Shyper.c H5Smpio.c H5Spoint.c \
H5Sselect.c H5T.c H5Tbit.c H5Tconv.c H5Tinit.c H5TB.c H5V.c H5Z.c \
PabloHDF.c PabloHDF_RT.c PabloHDF_SDDF.c
H5Ostab.c H5P.c H5R.c H5RA.c H5S.c H5Sall.c H5Shyper.c H5Smpio.c \
H5Snone.c H5Spoint.c H5Sselect.c H5T.c H5Tbit.c H5Tconv.c H5Tinit.c \
H5TB.c H5V.c H5Z.c PabloHDF5.c PabloHDF_RT.c PabloHDF_SDDF.c
LIB_OBJ=$(LIB_SRC:.c=.o)
@ -53,8 +53,8 @@ PRIVATE_HDR=H5private.h H5Aprivate.h H5Apkg.h H5ACprivate.h H5Bprivate.h \
H5Tprivate.h H5TBprivate.h H5Tpkg.h H5Vprivate.h H5Zprivate.h
# Number format detection
H5Tinit.c: ../src/H5detect
$(RUNTEST) ../src/H5detect >H5Tinit.c
H5Tinit.c: ../src/H5Tinit.c
cp ../src/H5Tinit.c .
#------------------------------------------------------------- -*- makefile -*-
# The following section of this makefile comes from the
@ -138,9 +138,10 @@ maintainer-clean: distclean
.c.o:
$(CC) $(CFLAGS) $(CPPFLAGS) -c ../src/$*.c
PABLO_INCLUDES = HDFentryNames.h HDFidList.h HDF5record_RT.h ProcIDs.h
PABLO_INCLUDES = HDFentryNames.h HDFidList.h HDF5record_RT.h ProcIDs.h \
ProcTrace.h
PabloHDF.o: PabloHDF.c $(PABLO_INCLUDES)
PabloHDF5.o: PabloHDF5.c $(PABLO_INCLUDES)
$(CC) $(CFLAGS) $(CPPFLAGS) -c $<
PabloHDF_RT.o: PabloHDF_RT.c $(PABLO_INCLUDES)
@ -150,10 +151,10 @@ PabloHDF_SDDF.o: PabloHDF_SDDF.c $(PABLO_INCLUDES)
$(CC) $(CFLAGS) $(CPPFLAGS) -c $<
HDFentryNames.h: HDFentries.txt
sed "s/.*/\"&\",/" $? > $@
sort $? | sed "s/.*/\"&\",/" > $@
HDFidList.h: HDFentries.txt
sed "s/.*/ID_&,/" $? > $@
sort $? | sed "s/.*/ID_&,/" > $@
#------------------------------------------------------------------------------
# The following section of this makefile contains dependencies between the
@ -1250,6 +1251,33 @@ HDFidList.h \
../src/H5HGpublic.h \
../src/H5Tprivate.h \
../src/H5Tpublic.h
H5Snone.c: ../src/H5Snone.c
H5Snone.o: \
H5Snone.c \
ProcIDs.h \
HDFidList.h \
../src/H5private.h \
../src/H5public.h \
../src/H5config.h \
../src/H5api_adpt.h \
../src/H5Eprivate.h \
../src/H5Epublic.h \
../src/H5Ipublic.h \
../src/H5Sprivate.h \
../src/H5Spublic.h \
../src/H5Fprivate.h \
../src/H5Fpublic.h \
../src/H5Dpublic.h \
../src/H5Gprivate.h \
../src/H5Gpublic.h \
../src/H5Bprivate.h \
../src/H5Bpublic.h \
../src/H5Oprivate.h \
../src/H5Opublic.h \
../src/H5HGprivate.h \
../src/H5HGpublic.h \
../src/H5Tprivate.h \
../src/H5Tpublic.h
H5Spoint.c: ../src/H5Spoint.c
H5Spoint.o: \
H5Spoint.c \

454
pablo/PabloHDF.c → pablo/PabloHDF5.c
View File

@ -77,6 +77,7 @@
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <stdarg.h>
#ifndef fileno
int fileno ( FILE * );
#endif
@ -111,31 +112,37 @@ int HDFtrace3OPEN( const char *, int, mode_t );
typedef unsigned int mode_t;
#endif
int OUTPUT_SWITCH;
int OUTPUT_SWITCH = 1;
int *procTrace;
extern void preInitIOTrace( void );
#include "ProcIDs.h"
#include "ProcTrace.h"
#include "HDF5Trace.h"
#include "IOTrace.h"
#define ID_HDFprocName 9996
#define ID_malloc 9997
#define ID_free 9998
#define ID_timeStamp 9999
#define DUMMY_HDF 10000
#ifdef HAVE_PARALLEL
#include "mpio.h"
#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);
#ifdef HAVE_MPIOTRACE
#include "MPIO_Init.h"
#include "MPIO_EventArgs.h"
#include "HDFmpioProtos.h"
#endif /* HAVE_MPIOTRACE */
void HDFinitTrace_RT ( const char *, int );
void HDFinitTrace_SDDF ( const char *, int );
void h5inittracex_ ( int [], int *, int[], int *,unsigned * );
void hdf5endtrace_ ( void ) ;
void HDFendTrace_RT (int);
void HDFendTrace_SDDF(int);
void HDFfinalTimeStamp( void );
void startHDFtraceEvent (int );
int computeProcMask (int eventID);
@ -144,19 +151,22 @@ 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;
double WriteTotals = 0.0;
double ReadTotals = 0.0;
/*======================================================================*
// NAME *
// HDFinitTrace -- initialize HDF tracing *
// HDF5initTrace -- initialize HDF tracing *
// USAGE *
// VOID HDFinitTrace( traceFileName, procTraceMask, out_sw ) *
// VOID HDFinitTrace( traceFileName, 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 *
// 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. *
//======================================================================*/
@ -166,62 +176,159 @@ char *hdfRecordPointer;
// 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 )
void h5inittracex_( int *file, int *len, int flags[], int *nflags,
unsigned *out_sw )
{
char *fileName;
char *traceFileName;
int i;
fileName = (char *)malloc(*len+1);
traceFileName = (char *)malloc(*len+1);
for ( i = 0; i < *len; ++i ) {
fileName[i] = file[i];
traceFileName[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 );
traceFileName[*len+1] = 0;
/*==============================================================*
// Allocate space for trace indicators. *
//==============================================================*/
procTrace = ( int * ) malloc( NUM_HDF5_IDS*sizeof(int) );
if ( procTrace == NULL ) {
fprintf(stderr,">> Error: Unable to allocate procTrace ");
fprintf(stderr,"array in program HDF5initTrace. <<<\n");
fprintf(stderr,">>> Exiting program! <<<\n");
exit (-1);
}
/*==============================================================*
// Initialize to 0. *
//==============================================================*/
for ( i = 0; i <= NUM_HDF5_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[AllHDF5] ) {
for ( i = ID_HDF_Last_Entry + 1; i < NUM_HDF5_IDS; ++i ) {
procTrace[i] = 1;
}
}
if ( OUTPUT_SWITCH == RUNTIME_TRACE
|| OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) {
HDFinitTrace_SDDF( traceFileName, OUTPUT_SWITCH );
IOtracingEnabled = 1;
} else if ( out_sw == RT_OUTPUT ) {
HDFinitTrace_RT( traceFileName, procTraceMask );
} else if ( OUTPUT_SWITCH == SUMMARY_TRACE
|| OUTPUT_SWITCH == MPI_SUMMARY_TRACE ) {
HDFinitTrace_RT( traceFileName, OUTPUT_SWITCH );
IOtracingEnabled = 1;
} else if ( out_sw == NO_OUTPUT ) {
procTrace = 0;
} else if ( OUTPUT_SWITCH == NO_TRACE ) {
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");
fprintf(stderr,">> Error in HDF5initTrace: the third argument ");
fprintf(stderr,"must have a value between %4d<<\n",RUNTIME_TRACE);
fprintf(stderr,">> and %4d, inclusive.",NO_TRACE);
fprintf(stderr," The value received was %4u.", OUTPUT_SWITCH);
fprintf(stderr," Exiting Program. <<\n");
exit (-1);
}
}
void HDF5initTrace( const char *traceFileName, int id_flag, ... )
{
int i, nIDs;
va_list ap;
/*==============================================================*
// Allocate space for trace indicators. *
//==============================================================*/
procTrace = ( int * ) malloc( NUM_HDF5_IDS*sizeof(int) );
if ( procTrace == NULL ) {
fprintf(stderr,">> Error: Unable to allocate procTrace ");
fprintf(stderr,"array in program HDF5initTrace. <<<\n");
fprintf(stderr,">>> Exiting program! <<<\n");
exit (-1);
}
/*==============================================================*
// Initialize to 0. *
//==============================================================*/
for ( i = 0; i < NUM_HDF5_IDS; ++i ) {
procTrace[i] = 0;
}
/*==============================================================*
// Read in the flags indicating which procedures to trace. *
// The last parameter passed is an indicator of the type of *
// tracing to do. This indicator has a value larger than any *
// of the flags. *
//==============================================================*/
nIDs = 0;
va_start( ap, id_flag );
while ( id_flag > NO_TRACE ) {
procTrace[id_flag] = 1;
++nIDs;
id_flag = va_arg ( ap, int );
}
OUTPUT_SWITCH = id_flag;
/*==============================================================*
// if no flags were passed, the default is to trace all of the *
// procedures. *
//==============================================================*/
if ( nIDs == 0 || procTrace[AllHDF5] ) {
for ( i = ID_HDF_Last_Entry + 1; i < NUM_HDF5_IDS; ++i ) {
procTrace[i] = 1;
}
}
if ( OUTPUT_SWITCH == RUNTIME_TRACE
|| OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) {
HDFinitTrace_SDDF( traceFileName, OUTPUT_SWITCH );
IOtracingEnabled = 1;
} else if ( OUTPUT_SWITCH == SUMMARY_TRACE
|| OUTPUT_SWITCH == MPI_SUMMARY_TRACE ) {
HDFinitTrace_RT( traceFileName, OUTPUT_SWITCH );
IOtracingEnabled = 1;
} else if ( OUTPUT_SWITCH == NO_TRACE ) {
IOtracingEnabled = 0;
} else {
fprintf(stderr,">> Error in HDF5initTrace: the third argument ");
fprintf(stderr,"must have a value between %4d<<\n",RUNTIME_TRACE);
fprintf(stderr,">> and %4d, inclusive.",NO_TRACE);
fprintf(stderr," The value received was %4u.", OUTPUT_SWITCH);
fprintf(stderr," Exiting Program. <<\n");
exit (-1);
}
}
/*======================================================================*
// NAME *
// HDFendTrace -- end HDF tracing *
// HDF5endTrace -- end HDF tracing *
// USAGE *
// VOID HDFendTrace(VOID) *
// VOID HDF5endTrace(VOID) *
// RETURNS *
// None. *
//======================================================================*/
void hdfendtrace_( void )
void hdf5endtrace_( void )
{
HDFendTrace ();
HDF5endTrace ();
}
void HDFendTrace(void)
void HDF5endTrace(void)
{
if ( OUTPUT_SWITCH == SDDF_OUTPUT ) {
HDFendTrace_SDDF( );
} else if ( OUTPUT_SWITCH == RT_OUTPUT ) {
HDFendTrace_RT( );
if ( OUTPUT_SWITCH == RUNTIME_TRACE
|| OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) {
HDFendTrace_SDDF( OUTPUT_SWITCH );
} else if ( OUTPUT_SWITCH == SUMMARY_TRACE
|| OUTPUT_SWITCH == MPI_SUMMARY_TRACE ) {
HDFendTrace_RT( OUTPUT_SWITCH );
}
procTrace = 0;
}
void startHDFtraceEvent(int eventID)
{
if ( OUTPUT_SWITCH == SDDF_OUTPUT ) {
if ( OUTPUT_SWITCH == RUNTIME_TRACE
|| OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) {
traceEvent( eventID, NULL, 0 ) ;
} else {
HDFtraceEvent_RT( eventID, NULL, 0 ) ;
@ -232,11 +339,13 @@ void endHDFtraceEvent(int eventID, int setID, char *setName, int IDtype )
HDFsetInfo info;
info.setID = setID;
info.setName = setName;
if ( OUTPUT_SWITCH == SDDF_OUTPUT ) {
if ( OUTPUT_SWITCH == RUNTIME_TRACE
|| OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) {
traceEvent( eventID, (char *)&info, 0 ) ;
} else if (OUTPUT_SWITCH == RT_OUTPUT ) {
} else if ( OUTPUT_SWITCH == SUMMARY_TRACE
|| OUTPUT_SWITCH == MPI_SUMMARY_TRACE ) {
HDFtraceEvent_RT( eventID, &info, 0 ) ;
} else if ( OUTPUT_SWITCH < 0 ) {
} else if ( OUTPUT_SWITCH != NO_TRACE ) {
fprintf(stderr,"endHDFtraceEvent: ");
fprintf(stderr,"invalid OUTPUT_SWITCH %d, IDtype = %d\n",
OUTPUT_SWITCH, IDtype ) ;
@ -490,6 +599,7 @@ size_t HDFtraceREAD( int fd, char *buf, int nbyte )
struct read_write_args readArgs;
size_t ret;
int bytes;
CLOCK t1, t2, incDur;
if ( IOtracingEnabled ) {
readArgs.fileID = c_mappedID( fd );
@ -499,7 +609,11 @@ size_t HDFtraceREAD( int fd, char *buf, int nbyte )
HDFtraceIOEvent( readBeginID, (void *) &readArgs, sizeof(readArgs) );
}
t1 = getClock();
ret = read( fd, buf, nbyte );
t2 = getClock();
incDur = clockSubtract(t2,t1);
ReadTotals += clockToSeconds( incDur );
if ( IOtracingEnabled ) {
if ( ret > 0 ) {
@ -527,6 +641,7 @@ size_t HDFtraceFREAD( void *ptr, int size, int nitems, FILE *stream )
size_t ret;
int nbytes;
int fd = fileno( stream );
CLOCK t1, t2, incDur;
if ( IOtracingEnabled ) {
readArgs.fileID = c_mappedID( fd );
@ -535,7 +650,11 @@ size_t HDFtraceFREAD( void *ptr, int size, int nitems, FILE *stream )
HDFtraceIOEvent( freadBeginID, (void *) &readArgs, sizeof(readArgs) );
}
t1 = getClock();
ret = fread( ptr, size, nitems, stream );
t2 = getClock();
incDur = clockSubtract(t2,t1);
ReadTotals += clockToSeconds( incDur );
if ( IOtracingEnabled ) {
if ( ret > 0 ) {
@ -692,6 +811,7 @@ size_t HDFtraceWRITE( int fd, const char *buf, int nbyte )
struct read_write_args writeArgs;
size_t ret;
int bytes;
CLOCK t1, t2, incDur;
if ( IOtracingEnabled ) {
writeArgs.fileID = c_mappedID( fd );
@ -701,7 +821,11 @@ size_t HDFtraceWRITE( int fd, const char *buf, int nbyte )
HDFtraceIOEvent( writeBeginID, (void *) &writeArgs, sizeof(writeArgs) );
}
ret = write( fd, buf, nbyte );
t1 = getClock();
ret = (size_t)write( fd, buf, nbyte );
t2 = getClock();
incDur = clockSubtract(t2,t1);
WriteTotals += clockToSeconds( incDur );
if ( IOtracingEnabled ) {
if ( ret > 0 ) {
@ -728,6 +852,7 @@ size_t HDFtraceFWRITE( const char *ptr, int size, int nitems, FILE *stream )
size_t ret;
int nbytes;
int fd = fileno( stream );
CLOCK t1, t2, incDur;
if ( IOtracingEnabled ) {
writeArgs.fileID = c_mappedID( fd );
@ -737,7 +862,12 @@ size_t HDFtraceFWRITE( const char *ptr, int size, int nitems, FILE *stream )
HDFtraceIOEvent( fwriteBeginID, (void *) &writeArgs, sizeof(writeArgs) );
}
t1 = getClock();
ret = fwrite( ptr, size, nitems, stream );
t2 = getClock();
incDur = clockSubtract(t2,t1);
WriteTotals += clockToSeconds( incDur );
if ( IOtracingEnabled ) {
if ( ret > 0 ) {
@ -864,7 +994,8 @@ void *HDFtraceMALLOC(size_t bytes )
void HDFtraceIOEvent( int eventType, void *dataPtr, unsigned dataLen )
{
if ( OUTPUT_SWITCH == 1 ) {
if ( OUTPUT_SWITCH == RUNTIME_TRACE
|| OUTPUT_SWITCH == MPI_RUNTIME_TRACE ) {
traceEvent( eventType, dataPtr, dataLen );
} else {
HDFtraceEvent_RT( eventType, (HDFsetInfo *)dataPtr, dataLen );
@ -875,7 +1006,6 @@ void HDFtraceIOEvent( int eventType, void *dataPtr, unsigned dataLen )
//======================================================================*/
void HDFfinalTimeStamp( void )
{
TR_LOCK criticalSection;
CLOCK currentTime;
double seconds;
struct {
@ -889,7 +1019,6 @@ void HDFfinalTimeStamp( void )
dataLen;
} Packet;
criticalSection = TRlock();
currentTime = getClock();
seconds = clockToSeconds( currentTime );
@ -903,7 +1032,99 @@ void HDFfinalTimeStamp( void )
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 *
// HDF5 procedure and HDF5 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 5 files will be *
// turned on, in which case all HDF 5 procedures will be traced. *
//======================================================================*/
void PabloHDF5Trace( int ID )
{
int i;
if ( procTrace == NULL ) {
procTrace = ( int * ) malloc( NUM_HDF5_IDS*sizeof(int) );
if ( procTrace == NULL ) {
fprintf(stderr,">> Error: Unable to allocate procTrace ");
fprintf(stderr,"array in program PabloHDF5Trace. <<<\n");
fprintf(stderr," Exiting program. <<<\n");
exit (-1);
}
for ( i = 0; i < NUM_HDF5_IDS; ++i ) {
procTrace[i] = 0;
}
}
if ( ID >= 0 && ID < NUM_HDF5_IDS ) {
procTrace[ID] = 1;
} else {
fprintf(stderr,">> Error: Value passed to PabloHDF5Trace, ");
fprintf(stderr,"%d, is out of range. <<<\n",ID);
fprintf(stderr," Exiting program. <<<\n");
exit (-1);
}
}
#ifdef HAVE_PARALLEL
int HDF_XMPI_File_open( MPI_Comm comm, char *filename, int amode,
MPI_Info info, MPI_File *fh );
int HDF_XMPI_File_close( MPI_File *fh );
int HDF_XMPI_File_delete( char *filename, MPI_Info info );
int HDF_XMPI_File_set_size( MPI_File fh, MPI_Offset size );
int HDF_XMPI_File_preallocate( MPI_File fh, MPI_Offset size);
int HDF_XMPI_File_get_size( MPI_File fh, MPI_Offset *size );
int HDF_XMPI_File_get_group( MPI_File fh, MPI_Group *group );
int HDF_XMPI_File_get_amode( MPI_File fh, int *amode );
int HDF_XMPI_File_set_view( MPI_File fh, MPI_Offset disp, MPI_Datatype etype,
MPI_Datatype filetype, char *datarep,
MPI_Info info );
int HDF_XMPI_File_get_view( MPI_File fh, MPI_Offset *disp,
MPI_Datatype *etype, MPI_Datatype *filetype,
char *datarep );
int HDF_XMPI_File_read_at( MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype,
MPI_Status *status );
int HDF_XMPI_File_read_at_all( MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype,
MPI_Status *status );
int HDF_XMPI_File_write_at( MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype,
MPI_Status *status );
int HDF_XMPI_File_write_at_all( MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype,
MPI_Status *status );
int HDF_XMPI_File_iread_at( MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype,
MPIO_Request *request );
int HDF_XMPI_File_iwrite_at( MPI_File fh, MPI_Offset offset, void *buf,
int count, MPI_Datatype datatype,
MPIO_Request *request );
int HDF_XMPI_File_read( MPI_File fh, void *buf, int count,
MPI_Datatype datatype, MPI_Status *status );
int HDF_XMPI_File_read_all( MPI_File fh, void *buf, int count,
MPI_Datatype datatype, MPI_Status *status );
int HDF_XMPI_File_write( MPI_File fh, void *buf, int count,
MPI_Datatype datatype, MPI_Status *status );
int HDF_XMPI_File_write_all( MPI_File fh, void *buf, int count,
MPI_Datatype datatype, MPI_Status *status );
int HDF_XMPI_File_iread( MPI_File fh, void *buf, int count,
MPI_Datatype datatype, MPIO_Request *request );
int HDF_XMPI_File_iwrite( MPI_File fh, void *buf, int count,
MPI_Datatype datatype, MPIO_Request *request );
int HDF_XMPI_File_seek( MPI_File fh,
MPI_Offset offset, int whence ) ;
int HDF_XMPI_File_get_position( MPI_File fh, MPI_Offset *offset );
int HDF_XMPI_File_get_byte_offset( MPI_File fh, MPI_Offset offset,
MPI_Offset *disp) ;
int HDF_XMPI_File_get_type_extent( MPI_File fh, MPI_Datatype datatype,
MPI_Aint *extent );
int HDF_XMPI_File_set_atomicity( MPI_File fh, int flag );
int HDF_XMPI_File_get_atomicity( MPI_File fh, int *flag );
int HDF_XMPI_File_sync( MPI_File fh );
/*======================================================================*
// Pass call through to regular MPIO entry except in case of Real Time *
// tracing. *
@ -916,8 +1137,8 @@ int HDF_MPI_File_open( MPI_Comm comm, char *filename, int amode,
HDFsetInfo dataPtr;
int dataLen;
if ( OUTPUT_SWITCH != RT_OUTPUT ) {
returnVal = MPI_File_open( comm, filename, amode, info, fh );
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = HDF_XMPI_File_open( comm, filename, amode, info, fh );
} else {
dataLen = sizeof( HDFsetInfo );
dataPtr.setID = (long)fh;
@ -943,8 +1164,8 @@ int HDF_MPI_File_close( MPI_File *fh )
HDFsetInfo dataPtr;
int dataLen;
if ( OUTPUT_SWITCH != RT_OUTPUT ) {
returnVal = MPI_File_close( fh );
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = HDF_XMPI_File_close( fh );
} else {
dataLen = sizeof( HDFsetInfo );
dataPtr.setID = (long)fh;
@ -968,8 +1189,8 @@ int HDF_MPI_File_delete( char *filename, MPI_Info info )
HDFsetInfo dataPtr;
int dataLen;
if ( OUTPUT_SWITCH != RT_OUTPUT ) {
returnVal = MPI_File_delete( filename, info );
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = HDF_XMPI_File_delete( filename, info );
} else {
dataLen = sizeof( HDFsetInfo );
dataPtr.setID = 0;
@ -994,8 +1215,8 @@ int HDF_MPI_File_set_size( MPI_File fh, MPI_Offset size )
HDFsetInfo dataPtr;
int dataLen;
if ( OUTPUT_SWITCH != RT_OUTPUT ) {
returnVal = MPI_File_set_size( fh, size );
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = HDF_XMPI_File_set_size( fh, size );
} else {
dataLen = 0;
HDFtraceEvent_RT( mpiSetSizeBeginID,&dataPtr,dataLen );
@ -1016,8 +1237,8 @@ int HDF_MPI_File_preallocate( MPI_File fh, MPI_Offset size)
HDFsetInfo dataPtr;
int dataLen;
if ( OUTPUT_SWITCH != RT_OUTPUT ) {
returnVal = MPI_File_preallocate( fh, size);
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = HDF_XMPI_File_preallocate( fh, size);
} else {
dataLen = 0;
HDFtraceEvent_RT( mpiPreallocateBeginID,
@ -1040,8 +1261,8 @@ int HDF_MPI_File_get_size( MPI_File fh, MPI_Offset *size )
HDFsetInfo dataPtr;
int dataLen;
if ( OUTPUT_SWITCH != RT_OUTPUT ) {
returnVal = MPI_File_get_size( fh, size);
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = HDF_XMPI_File_get_size( fh, size);
} else {
dataLen = 0;
HDFtraceEvent_RT( mpiGetSizeBeginID,
@ -1064,8 +1285,8 @@ int HDF_MPI_File_get_group( MPI_File fh, MPI_Group *group )
HDFsetInfo dataPtr;
int dataLen;
if ( OUTPUT_SWITCH != RT_OUTPUT ) {
returnVal = MPI_File_get_group( fh, group);
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = HDF_XMPI_File_get_group( fh, group);
} else {
dataLen = 0;
HDFtraceEvent_RT( mpiGetGroupBeginID,
@ -1088,8 +1309,8 @@ int HDF_MPI_File_get_amode( MPI_File fh, int *amode )
HDFsetInfo dataPtr;
int dataLen;
if ( OUTPUT_SWITCH != RT_OUTPUT ) {
returnVal = MPI_File_get_amode( fh, amode);
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = HDF_XMPI_File_get_amode( fh, amode);
} else {
dataLen = 0;
HDFtraceEvent_RT( mpiGetAmodeBeginID,
@ -1113,14 +1334,14 @@ int HDF_MPI_File_set_view( MPI_File fh, MPI_Offset disp, MPI_Datatype etype,
HDFsetInfo dataPtr;
int dataLen;
if ( OUTPUT_SWITCH != RT_OUTPUT ) {
returnVal = MPI_File_set_view( fh, disp, etype, filetype,
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = HDF_XMPI_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,
returnVal = PMPI_File_set_view( fh, disp, etype, filetype,
datarep, info );
HDFtraceEvent_RT( mpiSetViewEndID,
&dataPtr,dataLen );
@ -1140,8 +1361,8 @@ int HDF_MPI_File_get_view( MPI_File fh, MPI_Offset *disp, MPI_Datatype *etype,
HDFsetInfo dataPtr;
int dataLen;
if ( OUTPUT_SWITCH != RT_OUTPUT ) {
returnVal = MPI_File_get_view(fh, disp, etype, filetype, datarep);
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = HDF_XMPI_File_get_view(fh, disp, etype, filetype, datarep);
} else {
dataLen = 0;
HDFtraceEvent_RT( mpiSetViewBeginID,
@ -1167,8 +1388,8 @@ int HDF_MPI_File_read_at( MPI_File fh, MPI_Offset offset, void *buf,
HDFsetInfo dataPtr;
int dataLen;
if ( OUTPUT_SWITCH != RT_OUTPUT ) {
returnVal = MPI_File_read_at( fh, offset, buf, count, datatype,
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = HDF_XMPI_File_read_at( fh, offset, buf, count, datatype,
status );
} else {
dataLen = 0;
@ -1195,8 +1416,8 @@ int HDF_MPI_File_read_at_all( MPI_File fh, MPI_Offset offset, void *buf,
HDFsetInfo dataPtr;
int dataLen;
if ( OUTPUT_SWITCH != RT_OUTPUT ) {
returnVal = MPI_File_read_at_all( fh, offset, buf,
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = HDF_XMPI_File_read_at_all( fh, offset, buf,
count, datatype, status );
} else {
dataLen = 0;
@ -1223,8 +1444,8 @@ int HDF_MPI_File_write_at( MPI_File fh, MPI_Offset offset, void *buf,
HDFsetInfo dataPtr;
int dataLen;
if ( OUTPUT_SWITCH != RT_OUTPUT ) {
returnVal = MPI_File_write_at( fh, offset, buf, count, datatype,
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = HDF_XMPI_File_write_at( fh, offset, buf, count, datatype,
status );
} else {
dataLen = 0;
@ -1250,8 +1471,8 @@ int HDF_MPI_File_write_at_all( MPI_File fh, MPI_Offset offset, void *buf,
HDFsetInfo dataPtr;
int dataLen;
if ( OUTPUT_SWITCH != RT_OUTPUT ) {
returnVal = MPI_File_write_at_all( fh, offset, buf,
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = HDF_XMPI_File_write_at_all( fh, offset, buf,
count, datatype, status );
} else {
dataLen = 0;
@ -1273,7 +1494,7 @@ int HDF_MPI_File_write_at_all( MPI_File fh, MPI_Offset offset, void *buf,
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 );
return HDF_XMPI_File_iread_at( fh, offset, buf, count, datatype, request );
}
/*======================================================================*
@ -1284,7 +1505,7 @@ int HDF_MPI_File_iread_at( MPI_File fh, MPI_Offset offset, void *buf,
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 );
return HDF_XMPI_File_iwrite_at( fh, offset, buf, count, datatype, request );
}
/*======================================================================*
@ -1299,8 +1520,8 @@ int HDF_MPI_File_read( MPI_File fh, void *buf, int count,
HDFsetInfo dataPtr;
int dataLen;
if ( OUTPUT_SWITCH != RT_OUTPUT ) {
returnVal = MPI_File_read( fh, buf, count, datatype, status );
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = HDF_XMPI_File_read( fh, buf, count, datatype, status );
} else {
dataLen = 0;
HDFtraceEvent_RT( mpiReadBeginID,
@ -1324,8 +1545,8 @@ int HDF_MPI_File_read_all( MPI_File fh, void *buf, int count,
HDFsetInfo dataPtr;
int dataLen;
if ( OUTPUT_SWITCH != RT_OUTPUT ) {
returnVal = MPI_File_read_all( fh, buf, count, datatype, status );
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = HDF_XMPI_File_read_all( fh, buf, count, datatype, status );
} else {
dataLen = 0;
HDFtraceEvent_RT( mpiReadAllBeginID,
@ -1349,8 +1570,8 @@ int HDF_MPI_File_write( MPI_File fh, void *buf, int count,
HDFsetInfo dataPtr;
int dataLen;
if ( OUTPUT_SWITCH != RT_OUTPUT ) {
returnVal = MPI_File_write( fh, buf, count, datatype, status );
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = HDF_XMPI_File_write( fh, buf, count, datatype, status );
} else {
dataLen = 0;
HDFtraceEvent_RT( mpiWriteBeginID,
@ -1374,8 +1595,8 @@ int HDF_MPI_File_write_all( MPI_File fh, void *buf, int count,
HDFsetInfo dataPtr;
int dataLen;
if ( OUTPUT_SWITCH != RT_OUTPUT ) {
returnVal = MPI_File_write_all( fh, buf, count, datatype, status );
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal =HDF_XMPI_File_write_all( fh, buf, count, datatype, status );
} else {
dataLen = 0;
HDFtraceEvent_RT( mpiWriteAllBeginID,
@ -1395,7 +1616,7 @@ int HDF_MPI_File_write_all( MPI_File fh, void *buf, int count,
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 );
return HDF_XMPI_File_iread( fh, buf, count, datatype, request );
}
/*======================================================================*
@ -1406,7 +1627,7 @@ int HDF_MPI_File_iread( MPI_File fh, void *buf, int count,
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 );
return HDF_XMPI_File_iwrite( fh, buf, count, datatype, request );
}
/*======================================================================*
@ -1421,8 +1642,8 @@ int HDF_MPI_File_seek( MPI_File fh, MPI_Offset offset, int whence )
HDFsetInfo dataPtr;
int dataLen;
if ( OUTPUT_SWITCH != RT_OUTPUT ) {
returnVal = MPI_File_seek( fh, offset, whence );
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = HDF_XMPI_File_seek( fh, offset, whence );
} else {
dataLen = 0;
HDFtraceEvent_RT( mpiSeekBeginID,
@ -1446,8 +1667,8 @@ int HDF_MPI_File_get_position( MPI_File fh, MPI_Offset *offset )
HDFsetInfo dataPtr;
int dataLen;
if ( OUTPUT_SWITCH != RT_OUTPUT ) {
returnVal = MPI_File_get_position( fh, offset );
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = HDF_XMPI_File_get_position( fh, offset );
} else {
dataLen = 0;
HDFtraceEvent_RT( mpiGetPositionBeginID,
@ -1471,8 +1692,8 @@ int HDF_MPI_File_get_byte_offset( MPI_File fh, MPI_Offset offset,
HDFsetInfo dataPtr;
int dataLen;
if ( OUTPUT_SWITCH != RT_OUTPUT ) {
returnVal = MPI_File_get_byte_offset( fh, offset, disp );
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = HDF_XMPI_File_get_byte_offset( fh, offset, disp );
} else {
dataLen = 0;
HDFtraceEvent_RT( mpiGetByteOffsetBeginID,
@ -1497,8 +1718,8 @@ int HDF_MPI_File_get_type_extent( MPI_File fh, MPI_Datatype datatype,
HDFsetInfo dataPtr;
int dataLen;
if ( OUTPUT_SWITCH != RT_OUTPUT ) {
returnVal = MPI_File_get_type_extent( fh, datatype, extent );
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = HDF_XMPI_File_get_type_extent( fh, datatype, extent );
} else {
dataLen = 0;
HDFtraceEvent_RT( mpiGetTypeExtentBeginID,
@ -1521,8 +1742,8 @@ int HDF_MPI_File_set_atomicity( MPI_File fh, int flag )
HDFsetInfo dataPtr;
int dataLen;
if ( OUTPUT_SWITCH != RT_OUTPUT ) {
returnVal = MPI_File_set_atomicity( fh, flag );
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = HDF_XMPI_File_set_atomicity( fh, flag );
} else {
dataLen = 0;
HDFtraceEvent_RT( mpiSetAtomicityBeginID,
@ -1546,8 +1767,8 @@ int HDF_MPI_File_get_atomicity( MPI_File fh, int *flag )
HDFsetInfo dataPtr;
int dataLen;
if ( OUTPUT_SWITCH != RT_OUTPUT ) {
returnVal = MPI_File_get_atomicity( fh, flag );
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = HDF_XMPI_File_get_atomicity( fh, flag );
} else {
dataLen = 0;
HDFtraceEvent_RT( mpiGetAtomicityBeginID,
@ -1570,16 +1791,17 @@ int HDF_MPI_File_sync( MPI_File fh )
HDFsetInfo dataPtr;
int dataLen;
if ( OUTPUT_SWITCH != RT_OUTPUT ) {
returnVal = MPI_File_sync ( fh );
if ( OUTPUT_SWITCH != MPI_SUMMARY_TRACE ) {
returnVal = HDF_XMPI_File_sync ( fh );
} else {
dataLen = 0;
HDFtraceEvent_RT( mpiSyncBeginID,
&dataPtr,dataLen );
returnVal = MPI_File_sync ( fh );
returnVal = PMPI_File_sync ( fh );
HDFtraceEvent_RT( mpiSyncEndID,
&dataPtr,dataLen );
}
return returnVal;
}
#endif /* HAVE_PARALLEL */

66
pablo/PabloHDF_RT.c
View File

@ -114,6 +114,7 @@
#include "Trace.h"
#include "TraceParam.h"
#include "ProcIDs.h"
#include "IO_TraceParams.h"
#include "HDF5Trace.h"
#include "SDDFparam.h"
#include <string.h>
@ -141,9 +142,12 @@
#ifdef HAVE_PARALLEL
#include "mpio.h"
#include "MPIO_TraceParams.h"
#include "MPIO_Init.h"
#include "MPIO_EventArgs.h"
#include "MPIO_TraceParams.h"
#endif
#ifdef HAVE_MPIOTRACE
#endif
#ifndef TRgetThreadID
@ -156,8 +160,6 @@
#define AllThreads -1
#define set_c_mappedID( fd ) (fd)
#define c_mappedID( fd ) (fd)
/*======================================================================*
// User output file pointer. *
//======================================================================*/
@ -183,8 +185,8 @@ fileRec_t *HDFfileList;
/*======================================================================*
// Internal Function prototypes *
//======================================================================*/
void HDFinitTrace_RT( char *, unsigned );
void HDFendTrace_RT( void );
void HDFinitTrace_RT( char *, int );
void HDFendTrace_RT( int );
int initproctracert_( void );
int initHDFProcTrace_RT( void );
void HDFtraceEvent_RT( int , char *, unsigned ) ;
@ -222,14 +224,14 @@ extern char *hdfRecordPointer;
// NAME *
// HDFinitTrace_RT-- initialize HDF real-time tracing *
// USAGE *
// VOID HDFinitTrace_RT( fileName, procTraceMask) *
// VOID HDFinitTrace_RT( fileName, OUTSW ) *
// *
// char *fileName; IN: name of output file *
// unsigned procTraceMask; IN: families of procedures to trace *
// int OUTSW ; IN: Type of tracing *
// RETURNS *
// None. *
//======================================================================*/
void HDFinitTrace_RT( char *fileName, unsigned procTraceMask )
void HDFinitTrace_RT( char *fileName, int OUTSW )
{
#ifdef HAVE_PARALLEL
int myNode;
@ -239,7 +241,6 @@ void HDFinitTrace_RT( char *fileName, unsigned procTraceMask )
TRgetClock( &epoch );
criticalSection = TRlock();
error = initHDFProcTrace_RT() ;
procTrace = procTraceMask;
TRunlock( criticalSection );
if ( error != SUCCESS ) {
fprintf (stderr,"Unable to Initialize properly. Exiting program\n");
@ -247,13 +248,21 @@ void HDFinitTrace_RT( char *fileName, unsigned procTraceMask )
}
FileName = ( char * ) malloc ( strlen( fileName ) + 10 );
#ifdef HAVE_PARALLEL
MPI_Comm_rank( MPI_COMM_WORLD, &myNode );
setTraceProcessorNumber( myNode );
sprintf(FileName,"%s.nd%d",fileName,myNode);
/*==============================================================*
// In the parallel case, initialize MPI-IO tracing. This will *
// set the trace file name. *
// Here the library was built to linked with the MPI and MPIO *
// libraries. However, the use may chose not to run with MPI. *
// A check is made to see if MPI has been initialized. If so, *
// a trace file is assigned to the current node with the number *
// of the node as a suffix; if not, only one file is opened *
// and it is not given a suffix. *
//==============================================================*/
if ( OUTSW == MPI_SUMMARY_TRACE ) {
MPI_Comm_rank( MPI_COMM_WORLD, &myNode );
setTraceProcessorNumber( myNode );
sprintf(FileName,"%s.nd%d",fileName,myNode);
} else {
strcpy( FileName, fileName ) ;
}
#else
/*==============================================================*
// In the non-parallel case, set the trace file name and *
@ -272,14 +281,16 @@ void HDFinitTrace_RT( char *fileName, unsigned procTraceMask )
// RETURNS *
// None. *
//======================================================================*/
void HDFendTrace_RT( void )
void HDFendTrace_RT( int OUTSW )
{
int j, numSetIDs;
HDFnode_t *P;
char **Names;
char* mapFile;
TR_LOCK criticalSection;
HDFfinalTimeStamp();
criticalSection = TRlock();
/*==============================================================*
// Assing pablo ids to named identifiers and tag records *
//==============================================================*/
@ -303,23 +314,7 @@ void HDFendTrace_RT( void )
HDFSummarySDDF( HDFQueues[j], j );
}
endTracing();
/*==============================================================*
// Clean up storage *
//==============================================================*/
free( (void *)mapFile );
for ( j = 0; j < numSetIDs; ++j ) {
if ( Names[j] != NULL ) {
free((void *)Names[j]);
}
}
free( (void *)Names );
P = CallStack;
if ( P->ptr != NULL ) {
fprintf(stderr,"CallStack not empty at termination\n");
} else {
free((void *)P);
}
free((void *)HDFQueues) ;
TRunlock( criticalSection );
}
/*======================================================================*
// initHFDProcTrace_RT *
@ -726,6 +721,7 @@ void EndHDFEventRecord ( int eventID, CLOCK secs, void *dataPtr )
HDFnode_t *HDFrec;
CLOCK incSecs;
static int dummyIDs = -4;
eventID = 0;
/*==============================================================*
// pop record from top of the stack, compute inclusive duration *
// and set the corresponding record field and increment nCalls. *
@ -1114,7 +1110,6 @@ void HDFSummarySDDF( HDFnode_t *P, int procIndex )
arrayLen = 0; /* name length */
memcpy( Packet, &arrayLen, sizeof(int) );
putBytes( buff, Header.packetLen );
free((void *)P);
P = Q;
}
}
@ -1411,6 +1406,11 @@ void _hdfDescriptorRT( char *recordName, char *recordDescription,
void writeHDFRecDescrptrsRT( void )
{
char HDFProcNames[][40] = {
"noName",
"noName",
"noName",
"noName",
"noName",
# include "HDFentryNames.h"
"HDF_Last_Entry"
};

127
pablo/PabloHDF_SDDF.c
View File

@ -72,7 +72,7 @@
#include "TraceParam.h"
#include "Trace.h"
#include "HDF5Trace.h"
void HDFendTrace_SDDF(void);
void HDFendTrace_SDDF(int);
void startHDFtraceEvent(int eventID);
void endHDFtraceEvent(int , int , char *, int );
int preInitHDFProcTrace( void );
@ -83,7 +83,8 @@ TR_RECORD *HDFprocEventRecord( int, TR_EVENT *, CLOCK, HDFsetInfo *, unsigned );
TR_RECORD *miscEventRecord( int , TR_EVENT *, CLOCK, void *, unsigned );
void _hdfMiscDescriptor( void );
void _hdfProcNameDescriptor( void );
int setEventRecordFunction( int, void *(*)() );
/*int setEventRecordFunction( int, void *(*)() );*/
int setEventRecordFunction( int, TR_RECORD *(*)() );
void HDFtraceIOEvent( int, void *, unsigned );
void initIOTrace( void );
void enableIOdetail( void );
@ -107,12 +108,14 @@ void endIOTrace( void );
#ifdef HAVE_MPIOTRACE
int initMPIOTrace( char *, int );
void endMPIOTrace( void ) ;
#else
void endMPIOTrace( void ) {return;}
#endif
extern char *hdfRecordPointer;
/*======================================================================*
// Prototypes of functions in this file. *
//======================================================================*/
void HDFinitTrace_SDDF( char *, uint32 );
void HDFinitTrace_SDDF( char *, int );
/*======================================================================*
// Each procedure being traced has associated with it a distinct pair *
// of entry and exit event IDs. This code maintains a vector of such *
@ -191,6 +194,7 @@ struct miscTraceRecordData {
// events. *
//======================================================================*/
int procEntries[] = {
0, 0, 0, 0, 0,
#include "HDFidList.h"
ID_HDF_Last_Entry
};
@ -203,6 +207,11 @@ int *procEntryCalled;
// The HDFProcNames array holds the names of the HDF entries. *
//======================================================================*/
static char HDFProcNames[][40] = {
"noName",
"noName",
"noName",
"noName",
"noName",
#include "HDFentryNames.h"
"HDF_LAST_ENTRY"
};
@ -218,30 +227,64 @@ static char HDFProcNames[][40] = {
// RETURNS *
// None *
//======================================================================*/
void HDFinitTrace_SDDF( char *traceFileName, uint32 procTraceMask )
void HDFinitTrace_SDDF( char *traceFileName, int OUTSW )
{
/*===============================================================
// set traceFileName and set IO tracing switches. If MPIO *
// tracing is available, this will be initialized also. *
// tracing is available, MPIO tracing will also be initialized. *
//==============================================================*/
#ifdef HAVE_PARALLEL
/*===============================================================
// The code is built to handle parallel processing using MPI. *
// However, the code may or may not be run using MPI and there *
// may or may not be support for MPIO tracing in the Pablo *
// Trace libraries. The type of initialization performed *
// depends on these factors. *
//==============================================================*/
int myNode;
char *buff;
/*===============================================================
// in the parallel case, initialize MPI-IO tracing. This will *
// initialize the traceFileName and set the I/O tracing *
// switches. *
// Determine if MPI is running the program. *
//==============================================================*/
MPI_Comm_rank( MPI_COMM_WORLD, &myNode );
setTraceProcessorNumber( myNode );
if ( OUTSW == MPI_RUNTIME_TRACE ) {
/*============================================================
// in the parallel case, initialize MPI-IO tracing. This *
// will initialize the traceFileName and set the I/O tracing *
// switches. *
//===========================================================*/
MPI_Comm_rank( MPI_COMM_WORLD, &myNode );
setTraceProcessorNumber( myNode );
#ifdef HAVE_MPIOTRACE
initMPIOTrace( traceFileName, 0 );
/*============================================================
// MPIO Tracing is supported in the Pablo Library. Let the *
// MPIO initialization be performed and handle the naming of *
// trace files. *
//===========================================================*/
initMPIOTrace( traceFileName, RUNTIME_TRACE );
#else
buff = (char *)malloc( strlen(traceFileName)+12);
sprintf( buff, "%s.nd%.4d\0",traceFileName,myNode);
setTraceFileName( buff );
free( buff );
/*============================================================
// MPIO tracing is not supported. *
// Set up the trace file names depending on the number of *
// current node. *
//===========================================================*/
buff = (char *)malloc( strlen(traceFileName)+12);
sprintf( buff, "%s.nd%.4d\0",traceFileName,myNode);
setTraceFileName( buff );
free( buff );
#endif
} else {
/*============================================================
// The HDF library was built to run with MPI, but the *
// application is being run in serial mode. Initialization *
// is done as in the serial case. *
//===========================================================*/
setTraceFileName(traceFileName);
initIOTrace();
enableIOdetail();
disableLifetimeSummaries();
disableTimeWindowSummaries();
disableFileRegionSummaries();
}
#else
/*===============================================================
// in the non-parallel case, set the trace file name and the *
@ -259,7 +302,6 @@ void HDFinitTrace_SDDF( char *traceFileName, uint32 procTraceMask )
//==============================================================*/
preInitHDFProcTrace();
initHDFProcTrace( sizeof(procEntries)/sizeof(int), procEntries );
procTrace = procTraceMask;
}
/*=======================================================================
// NAME *
@ -269,22 +311,23 @@ void HDFinitTrace_SDDF( char *traceFileName, uint32 procTraceMask )
// RETURNS *
// None. *
//======================================================================*/
void HDFendTrace_SDDF(void)
void HDFendTrace_SDDF(int OUTSW)
{
HDFfinalTimeStamp();
#ifdef HAVE_MPIOTRACE
/*===============================================================
// termintate MPI-IO tracing in the parallel case. This will *
// terminate the I/O tracing and close tracing as well. *
//==============================================================*/
endMPIOTrace();
#else
/*===============================================================
// terminate tracing *
//==============================================================*/
endIOTrace();
endTracing();
#endif
if ( OUTSW == MPI_RUNTIME_TRACE ) {
/*============================================================
// termintate MPI-IO tracing in the parallel case. This *
// will terminate the I/O tracing and close tracing as well. *
//===========================================================*/
endMPIOTrace();
} else {
/*============================================================
// terminate tracing *
//===========================================================*/
endIOTrace();
endTracing();
exit(1);
}
}
/*=======================================================================
// NAME *
@ -306,7 +349,7 @@ void HDFendTrace_SDDF(void)
//======================================================================*/
int initHDFProcTrace( int numProcs, int *procEntryID )
{
int procIndex;
int procIndex, IX, ID;
if (( numProcs <= 0 ) || ( procEntryID == (int *) 0 ) )
return FAILURE;
@ -331,13 +374,13 @@ int initHDFProcTrace( int numProcs, int *procEntryID )
//==============================================================*/
for ( procIndex = 0; procIndex < numProcs; procIndex++ ) {
procEvents[ procIndex ].entryID = procEntryID[ procIndex ];
procEvents[ procIndex ].exitID = -procEntryID[ procIndex ];
IX = procEntryID[ procIndex ];
ID = HDFIXtoEventID( IX );
procEvents[ procIndex ].entryID = ID;
procEvents[ procIndex ].exitID = -ID;
setEventRecordFunction( procEntryID[ procIndex ],
(void *(*)())HDFprocEventRecord );
setEventRecordFunction( -procEntryID[ procIndex ],
(void *(*)())HDFprocEventRecord );
setEventRecordFunction( ID, HDFprocEventRecord );
setEventRecordFunction( -ID, HDFprocEventRecord );
procEntryCalled[ procIndex ] = 0;
}
@ -349,12 +392,12 @@ int initHDFProcTrace( int numProcs, int *procEntryID )
//==============================================================*/
procEvents[ numProcs ].entryID = ID_malloc;
procEvents[ numProcs ].exitID = -ID_malloc;
setEventRecordFunction( ID_malloc, (void *(*)())miscEventRecord );
setEventRecordFunction( -ID_malloc, (void *(*)())miscEventRecord );
setEventRecordFunction( ID_malloc, miscEventRecord );
setEventRecordFunction( -ID_malloc, miscEventRecord );
procEvents[ numProcs+1 ].entryID = ID_free;
procEvents[ numProcs+1 ].exitID = -ID_free;
setEventRecordFunction( ID_free, (void *(*)())miscEventRecord );
setEventRecordFunction( -ID_free, (void *(*)())miscEventRecord );
setEventRecordFunction( ID_free, miscEventRecord );
setEventRecordFunction( -ID_free, miscEventRecord );
return SUCCESS;
}
@ -533,7 +576,7 @@ HDFprocEventRecord( int recordType, TR_EVENT *eventPointer, CLOCK timeStamp,
TraceRecordHeader->nameLen = 0;
}
} else {
TraceRecordHeader->setID = NoDSid;
TraceRecordHeader->setID = 0;
TraceRecordHeader->nameLen = 0;
}

118
pablo/ProcIDs.h
View File

@ -81,55 +81,85 @@
#ifndef PROCIDS_H /* avoid re-inclusion */
#define PROCIDS_H
#include "ProcMasks.h"
extern unsigned procTrace;
extern int *procTrace;
/*
* Define the event IDs that will be used for the various I/O events
* Define the event IDs that will be used for the various HDF events
*/
#include "ProcTrace.h"
/*======================================================================*/
/* Assign HDF identifier routine tags */
/*======================================================================*/
enum HDF_IDS {
ID_HDFprocName=9996,
ID_malloc=9997,
ID_free=9998,
ID_timeStamp=9999,
DUMMY_HDF = 10000,
/*======================================================================*/
/* the following part of the enumeration is only needed when the */
/* instrumented HDF library is built. It is created in the pablo */
/* subdirectory of HDF. */
/*======================================================================*/
#include "HDFidList.h"
ID_HDF_Last_Entry
} ;
#define H5_mask ID_H5_c
#define H5A_mask ID_H5A_c
#define H5AC_mask ID_H5AC_c
#define H5B_mask ID_H5B_c
#define H5D_mask ID_H5D_c
#define H5E_mask ID_H5E_c
#define H5F_mask ID_H5F_c
#define H5F_arr_mask ID_H5Farray_c
#define H5F_core_mask ID_H5Fcore_c
#define H5F_family_mask ID_H5Ffamily_c
#define H5F_istore_mask ID_H5Fistore_c
#define H5F_low_mask ID_H5Flow_c
#define H5F_mpio_mask ID_H5Fmpio_c
#define H5F_sec2_mask ID_H5Fsec2_c
#define H5F_split_mask ID_H5Fsplit_c
#define H5F_stdio_mask ID_H5Fstdio_c
#define H5G_mask ID_H5G_c
#define H5G_ent_mask ID_H5Gent_c
#define H5G_node_mask ID_H5Gnode_c
#define H5G_stab_mask ID_H5Gstab_c
#define H5HG_mask ID_H5HG_c
#define H5HL_mask ID_H5HL_c
#define H5I_mask ID_H5I_c
#define H5MF_mask ID_H5MF_c
#define H5MM_mask ID_H5MM_c
#define H5O_mask ID_H5O_c
#define H5O_attr_mask ID_H5Oattr_c
#define H5O_pline_mask ID_H5Ocomp_c
#define H5O_cont_mask ID_H5Ocont_c
#define H5O_dtype_mask ID_H5Odtype_c
#define H5O_efl_mask ID_H5Oefl_c
#define H5O_fill_mask ID_H5Ofill_c
#define H5O_layout_mask ID_H5Olayout_c
#define H5O_mtime_mask ID_H5Omtime_c
#define H5O_name_mask ID_H5Oname_c
#define H5O_null_mask ID_H5Onull_c
#define H5O_sdspace_mask ID_H5Osdspace_c
#define H5O_shared_mask ID_H5Oshared_c
#define H5O_stab_mask ID_H5Ostab_c
#define H5P_mask ID_H5P_c
#define H5R_mask ID_H5R_c
#define H5RA_mask ID_H5RA_c
#define H5S_mask ID_H5S_c
#define H5S_all_mask ID_H5Sall_c
#define H5S_hyper_mask ID_H5Shyper_c
#define H5S_mpio_mask ID_H5Smpio_c
#define H5S_none_mask ID_H5Snone_c
#define H5S_point_mask ID_H5Spoint_c
#define H5S_select_mask ID_H5Sselect_c
#define H5T_mask ID_H5T_c
#define H5TB_mask ID_H5TB_c
#define H5Tbit_mask ID_H5Tbit_c
#define H5T_conv_mask ID_H5Tconv_c
#define H5T_init_mask ID_H5Tinit_c
#define H5V_mask ID_H5V_c
#define H5Z_mask ID_H5Z_c
#define ID_HDFprocName 9996
#define ID_malloc 9997
#define ID_free 9998
#define ID_timeStamp 9999
#define DUMMY_HDF 10000
#define BEGIN_HDF (DUMMY_HDF + 1)
#define END_HDF ID_HDF_Last_Entry
#define NumHDFProcs ( END_HDF - BEGIN_HDF )
/*======================================================================*/
/* HDF attribute, file, data_set, etc ID codes. May not be used. */
/*======================================================================*/
#define NoDSid 0 /* no data set id */
#define HDF_NULL_ID 0
#define HDF_File_ID 1
#define HDF_SDS_ID 2
#define HDF_Dim_ID 3
#define HDF_Attribute_ID 4
#define HDF_Label_ID 5
#define HDF_Access_ID 6
#define HDF_Directory_ID 7
#define HDF_Annotation_ID 8
#define HDF_Gen_Raster_ID 9
#define HDF_Look_Up_Table_ID 10
#define HDF_Vdata_ID 11
#define END_HDF (ID_HDF_Last_Entry + DUMMY_HDF)
#define NumHDFProcs ( ID_HDF_Last_Entry )
#define BEGIN_MPIO 900800
#define END_MPIO 900899
/*======================================================================*/
/* Macros to tell if the ID is that of an HDF Entry or Exit */
/*======================================================================*/
#define isBeginHDFEvent( ID ) ( BEGIN_HDF <= (ID) && (ID) < END_HDF )
#define isBeginHDFEvent( ID ) ( BEGIN_HDF <= (ID) && (ID) <= END_HDF )
#define isEndHDFEvent( ID ) isBeginHDFEvent(-(ID))
#define isBeginMPIOEvent( ID ) \
( BEGIN_MPIO <= (ID) && (ID) <= END_MPIO && (ID)%2 == 0 )
@ -143,11 +173,11 @@ ID_HDF_Last_Entry
#define ProcIndex( ID ) ( (ID) - BEGIN_HDF )
#define ProcIndexForHDFEntry( ID ) ( (ID) - BEGIN_HDF )
#define ProcIndexForHDFExit( ID ) ProcIndexForHDFEntry(-ID)
#define HDFProcIXtoEventID( ID ) ( (ID) + BEGIN_HDF )
#define HDFIXtoEventID( ID ) ( (ID) + BEGIN_HDF )
#define TRACE_ON(mask, eventID) \
if (procTrace & mask) startHDFtraceEvent(eventID)
#define TRACE_OFF(mask, eventID ) \
if (procTrace & mask) endHDFtraceEvent(-eventID, 0, NULL, 0 )
#define TRACE_ON(mask, ID) \
if ( procTrace[mask] || procTrace[ID] ) startHDFtraceEvent( HDFIXtoEventID( ID ) )
#define TRACE_OFF(mask, ID ) \
if ( procTrace[mask] || procTrace[ID] ) endHDFtraceEvent(-HDFIXtoEventID(ID), 0, NULL, 0 )
#endif /* PROCIDS_H */

198
pablo/ProcTrace.h Normal file
View File

@ -0,0 +1,198 @@
/* 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.
//-------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------
* File: ProcTrace.h
* Purpose: define entities for tracing HDF procedures
*-------------------------------------------------------------------------*/
#ifndef PROCTRACE_H /* avoid re-inclusion */
#define PROCTRACE_H
#include <stdarg.h>
/*======================================================================*
// By default, all HDF procedures are traced. Tracing of individual *
// procedures or all of the procedures in a particular source file in *
// the HDF 5 library can be done by calling the procedure PabloHDF5trace*
// with the appropriate argument. The call must be made prior to *
// calling HDF5initTrace. As many calls as necessary may be made prior *
// to calling HDF5initTrace so several specific procedures can be *
// traced. *
// PabloHDF5trace has the following syntax. *
// #include "ProcTrace.h" *
// void PabloHDF5trace( int traceID ); *
// where *
// traceID specifies the procedure or procedures within an HDF 5 file *
// that are to be traced. If a single procedure named <proc> is to *
// be traced, then traceID should have the value ID_<proc>. If all *
// of the procedures within the HDF 5 library routine <file>.c are to *
// be traced, then the value of traceID should be FID_<file>. The *
// constants ID_<proc> and FID_<file> are declared for all possible *
// values of <proc> and <file> below. *
// *
// Example: *
// To enable tracing of the individual procedures H5I_register and *
// H5Topen and all of the procedures in the HDF 5 library source *
// files H5A.c and H5Gent.c the following code segements could be *
// used: *
// *
// #include "ProcTrace.h" *
// ... *
// PabloHDF5trace( ID_H5I_register ); *
// PabloHDF5trace( ID_H5Topenr ); *
// PabloHDF5trace( FID_H5A ); *
// PabloHDF5trace( FID_H5Gent ); *
// ... *
// HDF5initTrace( ... ); *
// *
// See the document PabloHDF5.doc for further information *
//======================================================================*/
/*======================================================================*/
/* Assign HDF identifier routine tags */
/*======================================================================*/
#ifdef RUNTIME_TRACE
#undef RUNTIME_TRACE
#endif
enum HDF_IDS {
RUNTIME_TRACE,
SUMMARY_TRACE,
MPI_RUNTIME_TRACE,
MPI_SUMMARY_TRACE,
NO_TRACE,
#include "HDFidList.h"
ID_HDF_Last_Entry,
AllHDF5 = ID_HDF_Last_Entry,
ID_H5_c,
ID_H5A_c,
ID_H5AC_c,
ID_H5B_c,
ID_H5D_c,
ID_H5E_c,
ID_H5F_c,
ID_H5Farray_c,
ID_H5Fcore_c,
ID_H5Ffamily_c,
ID_H5Fistore_c,
ID_H5Flow_c,
ID_H5Fmpio_c,
ID_H5Fsec2_c,
ID_H5Fsplit_c,
ID_H5Fstdio_c,
ID_H5G_c,
ID_H5Gent_c,
ID_H5Gnode_c,
ID_H5Gstab_c,
ID_H5HG_c,
ID_H5HL_c,
ID_H5I_c,
ID_H5MF_c,
ID_H5MM_c,
ID_H5O_c,
ID_H5Oattr_c,
ID_H5Ocomp_c,
ID_H5Ocont_c,
ID_H5Odtype_c,
ID_H5Oefl_c,
ID_H5Ofill_c,
ID_H5Olayout_c,
ID_H5Omtime_c,
ID_H5Oname_c,
ID_H5Onull_c,
ID_H5Osdspace_c,
ID_H5Oshared_c,
ID_H5Ostab_c,
ID_H5P_c,
ID_H5R_c,
ID_H5RA_c,
ID_H5S_c,
ID_H5Sall_c,
ID_H5Shyper_c,
ID_H5Smpio_c,
ID_H5Snone_c,
ID_H5Spoint_c,
ID_H5Sselect_c,
ID_H5T_c,
ID_H5TB_c,
ID_H5Tbit_c,
ID_H5Tconv_c,
ID_H5Tinit_c,
ID_H5V_c,
ID_H5Z_c,
NUM_HDF5_IDS
} ;
void PabloHDF5Trace( int ) ;
void HDF5initTrace( const char *, int trace_id, ... );
void HDF5endTrace( void );
#endif /* PROCTRACE_H */