summaryrefslogtreecommitdiffstats
path: root/pablo
diff options
context:
space:
mode:
Diffstat (limited to 'pablo')
-rw-r--r--pablo/HDF5record_RT.h10
-rw-r--r--pablo/PabloHDF_RT.c121
2 files changed, 72 insertions, 59 deletions
diff --git a/pablo/HDF5record_RT.h b/pablo/HDF5record_RT.h
index d062d9f..d86871e 100644
--- a/pablo/HDF5record_RT.h
+++ b/pablo/HDF5record_RT.h
@@ -122,10 +122,10 @@ int BktLim[] = { 1, 4*ONEK, 64*ONEK, 256*ONEK, INT_MAX } ;
//======================================================================*/
typedef struct {
int nCalls; /* number of proc calls */
- double lastCall; /* time of last call */
- double incDur; /* inclusive duration */
- double excDur; /* exclusive duration */
- double times[nTallyFields]; /* Tally op/calls times */
+ CLOCK lastCall; /* time of last call */
+ CLOCK incDur; /* inclusive duration */
+ CLOCK excDur; /* exclusive duration */
+ CLOCK times[nTallyFields]; /* Tally op/calls times */
int counts[nTallyFields]; /* Tally op/calls counts */
int bytes[nByteFields]; /* Tally bytes transferred */
int Hists[nByteFields][nBkts]; /* Historgrams */
@@ -136,7 +136,7 @@ typedef struct {
// Node used to maintain linked lists of HDF procedure activity. *
//======================================================================*/
typedef struct HDFnode {
- double lastIOtime; /* last IO time stamp */
+ CLOCK lastIOtime; /* last IO time stamp */
HDFrec_t record; /* data */
struct HDFnode *ptr; /* link pointer */
int eventID; /* event ID */
diff --git a/pablo/PabloHDF_RT.c b/pablo/PabloHDF_RT.c
index 738bff6..7daf6b1 100644
--- a/pablo/PabloHDF_RT.c
+++ b/pablo/PabloHDF_RT.c
@@ -188,12 +188,12 @@ void HDFendTrace_RT( void );
int initproctracert_( void );
int initHDFProcTrace_RT( void );
void HDFtraceEvent_RT( int , char *, unsigned ) ;
-void BeginIOEventRecord ( int, double , void * );
-void EndIOEventRecord ( int , double , void * );
-void BeginMPIOEventRecord ( int, double, void *, int );
-void EndMPIOEventRecord ( int , double , void *, int);
-void BeginHDFEventRecord( int , double );
-void EndHDFEventRecord ( int , double ,void *);
+void BeginIOEventRecord ( int, CLOCK , void * );
+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 HDFrecordFileName( HDFsetInfo * );
void HDFassignPabloIDs( int *, char *** );
void writeHDFNamePacketsRT( char **, int );
@@ -347,15 +347,15 @@ int initHDFProcTrace_RT( void )
//==============================================================*/
InitNode.ptr = NULL;
InitNode.eventID = 0;
- InitNode.lastIOtime = 0;
+ InitNode.lastIOtime = zeroClock;
InitNode.record.nCalls = 0;
- InitNode.record.lastCall = 0;
- InitNode.record.incDur = 0;
- InitNode.record.excDur = 0;
+ InitNode.record.lastCall = zeroClock;
+ InitNode.record.incDur = zeroClock;
+ InitNode.record.excDur = zeroClock;
InitNode.record.hdfID = 0;
InitNode.record.xRef = 0;
for ( j = 0; j < nTallyFields; ++j ) {
- InitNode.record.times[j] = 0;
+ InitNode.record.times[j] = zeroClock;
}
for ( j = 0; j < nTallyFields; ++j ) {
InitNode.record.counts[j] = 0;
@@ -405,12 +405,10 @@ int initHDFProcTrace_RT( void )
void HDFtraceEvent_RT( int eventType, char *dataPtr, unsigned dataLen )
{
TR_LOCK criticalSection;
- CLOCK currentTime;
- double seconds;
+ CLOCK seconds;
criticalSection = TRlock();
- currentTime = getClock();
- seconds = clockToSeconds( currentTime );
+ seconds = getClock();
if ( isBeginIOEvent ( eventType ) || eventType == ID_malloc ) {
BeginIOEventRecord ( eventType, seconds, dataPtr ) ;
@@ -436,7 +434,7 @@ void HDFtraceEvent_RT( int eventType, char *dataPtr, unsigned dataLen )
// This routine simply records the time in the record on the top of *
// the stack. *
//======================================================================*/
-void BeginIOEventRecord ( int eventType, double seconds, void *dataPtr )
+void BeginIOEventRecord ( int eventType, CLOCK seconds, void *dataPtr )
{
char *name;
/*==============================================================*
@@ -481,14 +479,15 @@ void BeginIOEventRecord ( int eventType, double seconds, void *dataPtr )
// record field corresponding to this type of I/O. The Bytes field in *
// the record is updated if this is a read or write operation. *
//======================================================================*/
-void EndIOEventRecord ( int eventType, double secs, void *dataPtr )
+void EndIOEventRecord ( int eventType, CLOCK secs, void *dataPtr )
{
- double incDur;
+ CLOCK incDur;
int i, Field, ByteField, bytes;
- incDur = secs - CallStack->lastIOtime;
+ incDur = clockSubtract(secs,CallStack->lastIOtime) ;
Field = getHDFFieldIndex( eventType ) ;
- CallStack->record.times[Field] += incDur;
+ CallStack->record.times[Field]
+ = clockAdd ( CallStack->record.times[Field] , incDur ) ;
++CallStack->record.counts[Field];
ByteField = getHDFByteFieldIndex( Field ) ;
switch ( eventType )
@@ -526,7 +525,7 @@ void EndIOEventRecord ( int eventType, double secs, void *dataPtr )
// the stack. *
//======================================================================*/
void BeginMPIOEventRecord( int eventType,
- double seconds,
+ CLOCK seconds,
void *dataPtr,
int dataLen )
{
@@ -670,14 +669,15 @@ void BeginMPIOEventRecord( int eventType,
// the record field corresponding MPI-I/O. *
//======================================================================*/
void EndMPIOEventRecord ( int eventType,
- double seconds,
+ CLOCK secs,
void *dataPtr,
int dataLen )
{
- double incDur;
+ CLOCK incDur;
- incDur = seconds - CallStack->lastIOtime;
- CallStack->record.times[MPI] += incDur;
+ incDur = clockSubtract(secs,CallStack->lastIOtime) ;
+ CallStack->record.times[MPI]
+ = clockAdd ( CallStack->record.times[MPI], incDur );
++CallStack->record.counts[MPI];
if ( eventType == mpiOpenEndID && dataLen != 0 ) {
/*===========================================================*
@@ -697,7 +697,7 @@ void EndMPIOEventRecord ( int eventType,
// this thread. If no stack exists, one is created. If no record *
// exist, a record is created. *
//======================================================================*/
-void BeginHDFEventRecord( int eventID, double secs )
+void BeginHDFEventRecord( int eventID, CLOCK secs )
{
HDFnode_t *HDFrec;
/*==============================================================*
@@ -720,11 +720,11 @@ void BeginHDFEventRecord( int eventID, double 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, double seconds, void *dataPtr )
+void EndHDFEventRecord ( int eventID, CLOCK secs, void *dataPtr )
{
HDFsetInfo *info;
HDFnode_t *HDFrec;
- double incSecs;
+ CLOCK incSecs;
static int dummyIDs = -4;
/*==============================================================*
// pop record from top of the stack, compute inclusive duration *
@@ -736,8 +736,9 @@ void EndHDFEventRecord ( int eventID, double seconds, void *dataPtr )
fprintf(stderr,">>> EndHDFEventRecord: Call Stack is empty. <<<\n");
return;
}
- incSecs = seconds - HDFrec->record.lastCall;
- HDFrec->record.incDur = +incSecs;
+ incSecs = clockSubtract(secs,HDFrec->record.lastCall) ;
+
+ HDFrec->record.incDur = incSecs;
++HDFrec->record.nCalls;
/*==============================================================*
// add old record to chain to have its xRef field tagged. *
@@ -760,7 +761,8 @@ void EndHDFEventRecord ( int eventID, double seconds, void *dataPtr )
/*==============================================================*
// Update the HDF totals for the calling program. *
//==============================================================*/
- CallStack->record.times[ HDF_ ] += incSecs ;
+ CallStack->record.times[ HDF_ ]
+ = clockAdd( CallStack->record.times[ HDF_ ] , incSecs ) ;
++CallStack->record.counts[ HDF_ ] ;
/*==============================================================*
// If the stack has only one record it represents the main *
@@ -1004,7 +1006,8 @@ void HDFSummarySDDF( HDFnode_t *P, int procIndex )
{
int i, j, arrayLen;
int allIOCount;
- double allIOTime;
+ CLOCK allIOTime, excDur;
+ double t;
char buff[1024];
char *Packet;
HDFnode_t *Q;
@@ -1038,22 +1041,12 @@ void HDFSummarySDDF( HDFnode_t *P, int procIndex )
Header.threadID = TRgetNode();
while ( P != NULL ) {
Q = P->ptr;
- Header.eventID = P->eventID;
- Header.nCalls = P->record.nCalls;
- Header.Seconds = P->record.lastCall;
- Header.IncDur = P->record.incDur;
- Header.ExcDur = P->record.excDur;
- Header.HDFid = P->record.hdfID;
- Header.XREFid = P->record.xRef;
- Packet = buff;
- memcpy( Packet, &Header, sizeof(Header) );
- Packet += sizeof(Header);
/*===========================================================*
// Total the I/O time and counts *
//===========================================================*/
- allIOTime = 0;
+ allIOTime = zeroClock;
for ( j = FirstIO; j <= LastIO; ++j ) {
- allIOTime += P->record.times[j];
+ allIOTime = clockAdd( allIOTime, P->record.times[j] );
}
P->record.times[AllIO] = allIOTime;
@@ -1063,13 +1056,35 @@ void HDFSummarySDDF( HDFnode_t *P, int procIndex )
}
P->record.counts[AllIO] = allIOCount;
/*===========================================================*
+ // compute exclusive duration. *
+ //===========================================================*/
+ excDur = clockSubtract(P->record.incDur,allIOTime);
+ excDur = clockSubtract(excDur,P->record.times[HDF_]);
+ excDur = clockSubtract(excDur,P->record.times[MPI]);
+ /*===========================================================*
+ // 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);
+ Header.HDFid = P->record.hdfID;
+ Header.XREFid = P->record.xRef;
+ Packet = buff;
+ memcpy( Packet, &Header, sizeof(Header) );
+ Packet += sizeof(Header);
+ /*===========================================================*
// copy length of times array and times array to Packet. *
//===========================================================*/
arrayLen = nTallyFields;
memcpy( Packet, &arrayLen, sizeof(int) );
Packet += sizeof(int);
- memcpy( Packet, P->record.times, nTallyFields*sizeof(double) );
- Packet += nTallyFields*sizeof(double);
+ for ( j = 0; j < nTallyFields; ++j ) {
+ t = clockToSeconds(P->record.times[j]);
+ memcpy( Packet, &t, sizeof(double) );
+ Packet += sizeof(double);
+ }
/*===========================================================*
// copy length of counts array and counts array to Packet. *
//===========================================================*/
@@ -1117,16 +1132,14 @@ void HDFnodeInit ( HDFnode_t *S )
void HDFrecordSum ( HDFrec_t *S, HDFrec_t *T )
{
int i, j;
-
- T->excDur = T->incDur - ( T->times[HDF_] + T->times[MPI]
- + T->times[AllIO] );
-
+
S->nCalls += T->nCalls;
- S->lastCall = max( S->lastCall, T->lastCall );
- S->incDur += T->incDur;
- S->excDur += T->excDur;
+ if ( clockCompare ( S->lastCall, T->lastCall ) < 0 ) {
+ S->lastCall = T->lastCall ;
+ }
+ S->incDur = clockAdd ( S->incDur, T->incDur );
for ( j = 0; j < nTallyFields; ++j ) {
- S->times[j] += T->times[j] ;
+ S->times[j] = clockAdd( S->times[j] , T->times[j] ) ;
}
for ( j = 0; j < nTallyFields; ++j ) {
S->counts[j] += T->counts[j] ;
generated by cgit v0.12 at 2024-11-03 08:16:48 (GMT)