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

[svn-r1181] Changes to allow automatic building of tables for event IDs and for compatiblity of HDF 4 and HDF 5 trace files.

Browse Source
This commit is contained in:
Dan Wells 1999-04-14 16:20:11 -05:00
parent 92cc3fe39f
commit 9ec8530823
7 changed files with 1796 additions and 2033 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1807
pablo/PabloHDF5.c
View File

File diff suppressed because it is too large Load Diff

122
pablo/PabloHDF_RT.c
View File

@ -109,13 +109,15 @@
// printFileMappingsRT : print map of named identifiers *
// _hdfNameDescriptor() : writes SDDF descriptor packet for names *
//======================================================================*/
#ifdef _HDF5_
#include "H5config.h"
#endif
#include "SystemDepend.h"
#include "Trace.h"
#include "TraceParam.h"
#include "ProcIDs.h"
#include "IO_TraceParams.h"
#include "HDF5Trace.h"
#include "HDFTrace.h"
#include "SDDFparam.h"
#include <string.h>
#include <stdio.h>
@ -138,18 +140,13 @@
#endif
#define NEG_THREAD_ID -999
#include "HDF5record_RT.h"
#include "HDFrecord_RT.h"
#ifdef HAVE_PARALLEL
#include "mpio.h"
#include "MPIO_TraceParams.h"
#include "MPIO_Init.h"
#include "MPIO_EventArgs.h"
#endif
#ifdef HAVE_MPIOTRACE
#endif
#ifndef TRgetThreadID
#define TRgetThreadID TRgetNode
#endif
@ -195,7 +192,7 @@ void EndIOEventRecord ( int , CLOCK , void * );
void BeginMPIOEventRecord ( int, CLOCK , void *, int );
void EndMPIOEventRecord ( int , CLOCK , void *, int);
void BeginHDFEventRecord( int , CLOCK );
void EndHDFEventRecord ( int , CLOCK ,void *);
void EndHDFEventRecord ( CLOCK ,void *);
void HDFrecordFileName( HDFsetInfo * );
void HDFassignPabloIDs( int *, char *** );
void writeHDFNamePacketsRT( char **, int );
@ -237,11 +234,8 @@ void HDFinitTrace_RT( char *fileName, int OUTSW )
int myNode;
#endif
int error;
TR_LOCK criticalSection;
TRgetClock( &epoch );
criticalSection = TRlock();
error = initHDFProcTrace_RT() ;
TRunlock( criticalSection );
if ( error != SUCCESS ) {
fprintf (stderr,"Unable to Initialize properly. Exiting program\n");
exit(-1);
@ -287,10 +281,8 @@ void HDFendTrace_RT( int OUTSW )
HDFnode_t *P;
char **Names;
char* mapFile;
TR_LOCK criticalSection;
HDFfinalTimeStamp();
criticalSection = TRlock();
/*==============================================================*
// Assing pablo ids to named identifiers and tag records *
//==============================================================*/
@ -314,7 +306,6 @@ void HDFendTrace_RT( int OUTSW )
HDFSummarySDDF( HDFQueues[j], j );
}
endTracing();
TRunlock( criticalSection );
}
/*======================================================================*
// initHFDProcTrace_RT *
@ -399,10 +390,8 @@ int initHDFProcTrace_RT( void )
//======================================================================*/
void HDFtraceEvent_RT( int eventType, char *dataPtr, unsigned dataLen )
{
TR_LOCK criticalSection;
CLOCK seconds;
criticalSection = TRlock();
seconds = getClock();
if ( isBeginIOEvent ( eventType ) || eventType == ID_malloc ) {
@ -412,7 +401,7 @@ void HDFtraceEvent_RT( int eventType, char *dataPtr, unsigned dataLen )
} else if ( isBeginHDFEvent( eventType ) ) {
BeginHDFEventRecord ( eventType , seconds ) ;
} else if ( isEndHDFEvent( eventType ) ) {
EndHDFEventRecord ( eventType, seconds, dataPtr );
EndHDFEventRecord ( seconds, dataPtr );
#ifdef HAVE_PARALLEL
} else if ( isBeginMPIOEvent( eventType ) ) {
BeginMPIOEventRecord ( eventType, seconds, dataPtr, dataLen ) ;
@ -422,7 +411,6 @@ void HDFtraceEvent_RT( int eventType, char *dataPtr, unsigned dataLen )
} else {
fprintf(stderr,"eventType %d, dataLen = %u\n",eventType,dataLen);
}
TRunlock( criticalSection );
}
/*======================================================================*
// BeginIOEventRecord: *
@ -539,117 +527,117 @@ void BeginMPIOEventRecord( int eventType,
if ( dataLen == 0 ) return;
switch ( eventType )
{
case mpiGetSizeBeginID:
case HDFmpiGetSizeID:
CallStack->record.hdfID
= ((struct mpiGetSizeBeginArgs *)dataPtr)->fileID;
break;
case mpiGetGroupBeginID:
case HDFmpiGetGroupID:
CallStack->record.hdfID
= ((struct mpiGetGroupBeginArgs *)dataPtr)->fileID;
break;
case mpiGetAmodeBeginID:
case HDFmpiGetAmodeID:
CallStack->record.hdfID
= ((struct mpiGetAmodeBeginArgs *)dataPtr)->fileID;
break;
case mpiGetViewBeginID:
case HDFmpiGetViewID:
CallStack->record.hdfID
= ((struct mpiGetViewBeginArgs *)dataPtr)->fileID;
break;
case mpiGetPositionBeginID:
case HDFmpiGetPositionID:
CallStack->record.hdfID
= ((struct mpiGetPositionBeginArgs *)dataPtr)->fileID;
break;
case mpiGetByteOffsetBeginID:
case HDFmpiGetByteOffsetID:
CallStack->record.hdfID
= ((struct mpiGetByteOffsetBeginArgs *)dataPtr)->fileID;
break;
case mpiGetTypeExtentBeginID:
case HDFmpiGetTypeExtentID:
CallStack->record.hdfID
= ((struct mpiGetTypeExtentBeginArgs *)dataPtr)->fileID;
break;
case mpiGetAtomicityBeginID:
case HDFmpiGetAtomicityID:
CallStack->record.hdfID
= ((struct mpiGetAtomicityBeginArgs *)dataPtr)->fileID;
break;
case mpiOpenBeginID:
case HDFmpiOpenID:
strcpy( openName,
((struct mpiOpenBeginArgs *)dataPtr)->fileName);
break;
case mpiCloseBeginID:
case HDFmpiCloseID:
CallStack->record.hdfID
= ((struct mpiCloseBeginArgs *)dataPtr)->fileID;
break;
case mpiDeleteBeginID:
case HDFmpiDeleteID:
break;
case mpiSetSizeBeginID:
case HDFmpiSetSizeID:
CallStack->record.hdfID
= ((struct mpiSetSizeBeginArgs *)dataPtr)->fileID;
break;
case mpiPreallocateBeginID:
case HDFmpiPreallocateID:
CallStack->record.hdfID
= ((struct mpiPreallocateBeginArgs *)dataPtr)->fileID;
break;
case mpiSetViewBeginID:
case HDFmpiSetViewID:
CallStack->record.hdfID
= ((struct mpiSetViewBeginArgs *)dataPtr)->fileID;
break;
case mpiReadAtBeginID:
case HDFmpiReadAtID:
CallStack->record.hdfID
= ((struct mpiReadAtBeginArgs *)dataPtr)->fileID;
break;
case mpiReadAtAllBeginID:
case HDFmpiReadAtAllID:
CallStack->record.hdfID
= ((struct mpiReadAtAllBeginArgs *)dataPtr)->fileID;
break;
case mpiWriteAtBeginID:
case HDFmpiWriteAtID:
CallStack->record.hdfID
= ((struct mpiWriteAtBeginArgs *)dataPtr)->fileID;
break;
case mpiWriteAtAllBeginID:
case HDFmpiWriteAtAllID:
CallStack->record.hdfID
= ((struct mpiWriteAtAllBeginArgs *)dataPtr)->fileID;
break;
case mpiIreadAtBeginID:
case HDFmpiIreadAtID:
CallStack->record.hdfID
= ((struct mpiIreadAtBeginArgs *)dataPtr)->fileID;
break;
case mpiIwriteAtBeginID:
case HDFmpiIwriteAtID:
CallStack->record.hdfID
= ((struct mpiIwriteAtBeginArgs *)dataPtr)->fileID;
break;
case mpiReadBeginID:
case HDFmpiReadID:
CallStack->record.hdfID
= ((struct mpiReadBeginArgs *)dataPtr)->fileID;
break;
case mpiReadAllBeginID:
case HDFmpiReadAllID:
CallStack->record.hdfID
= ((struct mpiReadAllBeginArgs *)dataPtr)->fileID;
break;
case mpiWriteBeginID:
case HDFmpiWriteID:
CallStack->record.hdfID
= ((struct mpiWriteBeginArgs *)dataPtr)->fileID;
break;
case mpiWriteAllBeginID:
case HDFmpiWriteAllID:
CallStack->record.hdfID
= ((struct mpiWriteAllBeginArgs *)dataPtr)->fileID;
break;
case mpiIreadBeginID:
case HDFmpiIreadID:
CallStack->record.hdfID
= ((struct mpiIreadBeginArgs *)dataPtr)->fileID;
break;
case mpiIwriteBeginID:
case HDFmpiIwriteID:
CallStack->record.hdfID
= ((struct mpiIwriteBeginArgs *)dataPtr)->fileID;
break;
case mpiSeekBeginID:
case HDFmpiSeekID:
CallStack->record.hdfID
= ((struct mpiSeekBeginArgs *)dataPtr)->fileID;
break;
case mpiSetAtomicityBeginID:
case HDFmpiSetAtomicityID:
CallStack->record.hdfID
= ((struct mpiSetAtomicityBeginArgs *)dataPtr)->fileID;
break;
case mpiSyncBeginID:
case HDFmpiSyncID:
CallStack->record.hdfID
= ((struct mpiSyncBeginArgs *)dataPtr)->fileID;
break;
@ -674,7 +662,7 @@ void EndMPIOEventRecord ( int eventType,
CallStack->record.times[MPI]
= clockAdd ( CallStack->record.times[MPI], incDur );
++CallStack->record.counts[MPI];
if ( eventType == mpiOpenEndID && dataLen != 0 ) {
if ( eventType == -HDFmpiOpenID && dataLen != 0 ) {
/*===========================================================*
// complete the file information for the case of a file *
// open and record the information. *
@ -715,13 +703,12 @@ void BeginHDFEventRecord( int eventID, CLOCK secs )
// and adds it to the inclusive duration field of this record and to *
// the HDF time field of the calling routines record. *
//======================================================================*/
void EndHDFEventRecord ( int eventID, CLOCK secs, void *dataPtr )
void EndHDFEventRecord ( CLOCK secs, void *dataPtr )
{
HDFsetInfo *info;
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. *
@ -1000,7 +987,7 @@ void HDFupdateProcs( HDFnode_t *P )
//======================================================================*/
void HDFSummarySDDF( HDFnode_t *P, int procIndex )
{
int i, j, arrayLen;
int i, j, arrayLen, nodeID, nCalls;
int allIOCount;
CLOCK allIOTime, excDur;
double t;
@ -1011,9 +998,7 @@ void HDFSummarySDDF( HDFnode_t *P, int procIndex )
int packetLen,
packetType,
packetTag,
eventID,
threadID,
nCalls;
eventID;
double Seconds,
IncDur,
ExcDur;
@ -1022,6 +1007,7 @@ void HDFSummarySDDF( HDFnode_t *P, int procIndex )
} Header;
Header.packetLen = sizeof(Header)
+ sizeof(int) /* n Calls */
+ sizeof(int) /* array len */
+ nTallyFields*sizeof(double) /* times array */
+ sizeof(int) /* array len */
@ -1030,11 +1016,12 @@ void HDFSummarySDDF( HDFnode_t *P, int procIndex )
+ nByteFields*sizeof(int) /* bytes array */
+ nByteFields*sizeof(int) /* array lens */
+ nByteFields*nBkts*sizeof(int) /* byte hist */
+ sizeof(int) /* nodeID */
+ sizeof(int) ; /* Name len */
Header.packetTag = HDF_SUMMARY_FAMILY +
( procIndex + 1 )*8 + RECORD_TRACE ;
Header.packetType = PKT_DATA;
Header.threadID = TRgetNode();
nodeID = TRgetNode();
while ( P != NULL ) {
Q = P->ptr;
/*===========================================================*
@ -1061,7 +1048,6 @@ void HDFSummarySDDF( HDFnode_t *P, int procIndex )
// print header information. *
//===========================================================*/
Header.eventID = P->eventID;
Header.nCalls = P->record.nCalls;
Header.Seconds = clockToSeconds(P->record.lastCall);
Header.IncDur = clockToSeconds( P->record.incDur );
Header.ExcDur = clockToSeconds(excDur);
@ -1071,6 +1057,12 @@ void HDFSummarySDDF( HDFnode_t *P, int procIndex )
memcpy( Packet, &Header, sizeof(Header) );
Packet += sizeof(Header);
/*===========================================================*
// copy number of calls to Packet. *
//===========================================================*/
nCalls = P->record.nCalls;
memcpy( Packet, &nCalls, sizeof(int) );
Packet += sizeof(int);
/*===========================================================*
// copy length of times array and times array to Packet. *
//===========================================================*/
arrayLen = nTallyFields;
@ -1107,6 +1099,8 @@ void HDFSummarySDDF( HDFnode_t *P, int procIndex )
memcpy( Packet, P->record.Hists[i], nBkts*sizeof(int) );
Packet += nBkts*sizeof(int);
}
memcpy( Packet, &nodeID, sizeof(int) );
Packet += sizeof(int);
arrayLen = 0; /* name length */
memcpy( Packet, &arrayLen, sizeof(int) );
putBytes( buff, Header.packetLen );
@ -1322,14 +1316,6 @@ void _hdfDescriptorRT( char *recordName, char *recordDescription,
"Event ID",
"Corresponding Event",
INTEGER, 0 );
WRITE_HDF_FIELD( "Processor Number",
"Node",
"Processor number",
INTEGER, 0 );
WRITE_HDF_FIELD( "N Calls",
"N Calls",
"Number of Calls to this Proc",
INTEGER, 0 );
WRITE_HDF_FIELD( "Seconds",
"Seconds",
"Floating Point Timestamp",
@ -1350,6 +1336,10 @@ void _hdfDescriptorRT( char *recordName, char *recordDescription,
"Cross Reference",
"Index of related HDF ID or 0 if none",
LONG, 0 );
WRITE_HDF_FIELD( "N Calls",
"N Calls",
"Number of Calls to this Proc",
INTEGER, 0 );
WRITE_HDF_FIELD( "Times Array",
"Times Array",
"Array of Total Operation Times",
@ -1382,6 +1372,10 @@ void _hdfDescriptorRT( char *recordName, char *recordDescription,
"AWrite Histogram",
"Historgram of size Asynch Write Requests",
INTEGER, 1 );
WRITE_HDF_FIELD( "Processor Number",
"Node",
"Processor number",
INTEGER, 0 );
WRITE_HDF_FIELD( "HDF Name",
"HDF Name",
"Name of File,Data Set or Dim accessed",

2
pablo/PabloHDF_SDDF.c
View File

@ -71,7 +71,7 @@
#include "SDDFparam.h"
#include "TraceParam.h"
#include "Trace.h"
#include "HDF5Trace.h"
#include "HDFTrace.h"
void HDFendTrace_SDDF(int);
void startHDFtraceEvent(int eventID);
void endHDFtraceEvent(int , int , char *, int );

15
pablo/PabloSedscr Normal file
View File

@ -0,0 +1,15 @@
s/_//g
s/,//g
/^[0-9]/,/ID/{
/^[0-9]/h
/^[0-9]/d
s/$/ = /
G
s/\n//
s/ID/ parameter ( &/
s/$/ )/
h
s/parameter (/integer/
s/=.*//
G
}

99
pablo/ProcIDs.h
View File

@ -87,62 +87,7 @@ extern int *procTrace;
*/
#include "ProcTrace.h"
#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
#include "ProcMasks.h"
#define ID_HDFprocName 9996
#define ID_malloc 9997
@ -154,18 +99,48 @@ extern int *procTrace;
#define END_HDF (ID_HDF_Last_Entry + DUMMY_HDF)
#define NumHDFProcs ( ID_HDF_Last_Entry )
#define BEGIN_MPIO 900800
#define END_MPIO 900899
enum MPIeventIDs {
BEGIN_MPIO = END_HDF+1,
HDFmpiOpenID = BEGIN_MPIO,
HDFmpiCloseID,
HDFmpiDeleteID,
HDFmpiSetSizeID,
HDFmpiPreallocateID,
HDFmpiGetSizeID,
HDFmpiGetGroupID,
HDFmpiGetAmodeID,
HDFmpiGetViewID,
HDFmpiSetViewID,
HDFmpiReadAtID,
HDFmpiReadAtAllID,
HDFmpiWriteAtID,
HDFmpiWriteAtAllID,
HDFmpiReadID,
HDFmpiReadAllID,
HDFmpiWriteID,
HDFmpiWriteAllID,
HDFmpiSeekID,
HDFmpiGetPositionID,
HDFmpiGetByteOffsetID,
HDFmpiGetTypeExtentID,
HDFmpiSetAtomicityID,
HDFmpiGetAtomicityID,
HDFmpiIreadID,
HDFmpiIwriteID,
HDFmpiIreadAtID,
HDFmpiIwriteAtID,
HDFmpiSyncID,
END_MPIO
};
/*======================================================================*/
/* Macros to tell if the ID is that of an HDF Entry or Exit */
/*======================================================================*/
#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 )
#define isEndMPIOEvent( ID ) \
( BEGIN_MPIO <= (ID) && (ID) <= END_MPIO && (ID)%2 == 1 )
( BEGIN_MPIO <= (ID) && (ID) <= END_MPIO )
#define isEndMPIOEvent( ID ) isBeginMPIOEvent(-(ID))
#define isBeginIOEvent( ID ) \
( IOerrorID < (ID) && (ID) <= fsetposEndID && (ID)%2 == 1 )
#define isEndIOEvent( ID ) \

104
pablo/ProcTrace.h
View File

@ -81,43 +81,6 @@
#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 */
/*======================================================================*/
@ -131,68 +94,11 @@ 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
NUM_HDF_IDS
} ;
void PabloHDF5Trace( int ) ;
void HDF5initTrace( const char *, int trace_id, ... );
void HDF5endTrace( void );
#define ID_HDF_Last_Entry ID_ALLHDF
void HDFinitTrace( const char *, int trace_id, ... );
void HDFendTrace( void );
#endif /* PROCTRACE_H */

1680
pablo/ProcTrace.inc Normal file
View File

File diff suppressed because it is too large Load Diff