[svn-r853] Updated code to better handle new HDF entry points.

3 files changed, 131 insertions, 336 deletions

diff --git a/pablo/PabloHDF.c b/pablo/PabloHDF.c
index 4907e28..36bf0df 100644
--- a/pablo/PabloHDF.c
+++ b/pablo/PabloHDF.c
@@ -88,7 +88,6 @@ int fileno ( FILE * );
 #define HDFtrace3OPEN__
 int HDFtrace3OPEN( const char *, int, mode_t );
 
-/*#include "Assert_TrLib.h"*/
 #include "SDDFparam.h"
 #include "TraceParam.h"
 
@@ -115,7 +114,7 @@ int OUTPUT_SWITCH;
 extern void preInitIOTrace( void ); 
 
 #include "ProcIDs.h"
-#include "HDFTrace.h"
+#include "HDF5Trace.h"
 #include "IOTrace.h"
 #define NO_OUTPUT 0
 #define SDDF_OUTPUT 1
@@ -127,6 +126,7 @@ void hdfendtrace_ ( void ) ;
 void HDFendTrace (void);
 void HDFendTrace_RT (void);
 void HDFendTrace_SDDF(void);
+void HDFfinalTimeStamp( void );
 void startHDFtraceEvent (int );
 int computeProcMask (int eventID);
 int computePacketTag(int eventID);
@@ -839,13 +839,13 @@ void *HDFtraceMALLOC(size_t bytes )
 	size_t byte_req;
 	byte_req = bytes;
 	if ( IOtracingEnabled ) {
-	   HDFtraceIOEvent ( ID_malloc, &byte_req, sizeof(size_t) );
+	   HDFtraceIOEvent ( ID_malloc, NULL, 0 );
 	}
 	
 	ptr = malloc( bytes );
 
 	if ( IOtracingEnabled ) {
-	   HDFtraceIOEvent ( -ID_malloc, NULL, 0 );
+	   HDFtraceIOEvent ( -ID_malloc, &byte_req, sizeof(size_t) );
 	}
 	
 	return ptr ;
@@ -860,3 +860,36 @@ void HDFtraceIOEvent( int eventType, void *dataPtr, unsigned dataLen )
            HDFtraceEvent_RT( eventType, (HDFsetInfo *)dataPtr, dataLen );
         }
 }
+/*======================================================================*
+// record the final time stamp                                          *
+//======================================================================*/
+void HDFfinalTimeStamp( void )
+{
+        TR_LOCK criticalSection;
+        CLOCK   currentTime;
+        double  seconds;
+        struct {
+                int packetLength,
+                    packetType,
+                    packetTag,
+                    timeDim;
+                double Seconds;
+                int eventID,
+                    node,
+                    dataLen;
+        } Packet;
+
+        criticalSection = TRlock();
+        currentTime = getClock();
+        seconds = clockToSeconds( currentTime );
+
+        Packet.packetLength = sizeof(Packet);
+        Packet.packetType   = PKT_DATA;
+        Packet.packetTag    = FAMILY_EXTERNAL | RECORD_TRACE;
+        Packet.timeDim      = 0;        /* use fp time stamp only */
+        Packet.Seconds      = seconds;  /* fp time stamp          */
+        Packet.eventID      = ID_timeStamp;
+        Packet.node         = TRgetNode();
+        Packet.dataLen      = 0;
+        putBytes( (void *)&Packet , sizeof(Packet) );
+}
diff --git a/pablo/PabloHDF_RT.c b/pablo/PabloHDF_RT.c
index 66ecc72..ff04783 100644
--- a/pablo/PabloHDF_RT.c
+++ b/pablo/PabloHDF_RT.c
@@ -114,7 +114,7 @@
 #include "Trace.h"
 #include "TraceParam.h"
 #include "ProcIDs.h"
-#include "HDFTrace.h"
+#include "HDF5Trace.h"
 #include "SDDFparam.h"
 #include <string.h>
 #include <stdio.h>
@@ -137,7 +137,7 @@
 #endif
 #define NEG_THREAD_ID -999
 
-#include "HDFrecord_RT.h"
+#include "HDF5record_RT.h"
 
 #ifdef HAVE_PARALLEL
 #include "MPIO_Init.h"
@@ -207,6 +207,7 @@ void writeHDFRecDescrptrsRT( void );
 void printFileMappingsRT( char *, char **, int );
 void _hdfNameDescriptor( void );
 void _hdfDescriptorRT( char *, char *, int );
+void HDFfinalTimeStamp( void );
 /*======================================================================*
 // Global variables           						*
 //======================================================================*/
@@ -272,6 +273,7 @@ void HDFendTrace_RT( )
 	char **Names;
 	char* mapFile;
 
+	HDFfinalTimeStamp();
 	/*==============================================================*
 	//  Assing pablo ids to named identifiers and tag records	*
 	//==============================================================*/
@@ -398,9 +400,9 @@ void HDFtraceEvent_RT( int eventType, char *dataPtr, unsigned dataLen )
 	currentTime = getClock();
 	seconds = clockToSeconds( currentTime );
 
-	if ( isBeginIOEvent ( eventType ) ) {
+	if ( isBeginIOEvent ( eventType ) || eventType == ID_malloc ) {
 	   BeginIOEventRecord ( eventType, seconds, dataPtr ) ;
-	} else if ( isEndIOEvent( eventType ) ) {
+	} else if ( isEndIOEvent( eventType )  || eventType == -ID_malloc) {
 	   EndIOEventRecord ( eventType, seconds, dataPtr );
 	} else if ( isBeginHDFEvent( eventType ) ) { 
 	   BeginHDFEventRecord ( eventType , seconds ) ;
@@ -988,8 +990,8 @@ void HDFSummarySDDF( HDFnode_t *P, int procIndex )
 	HDFnode_t *Q;
 	struct {
 		int packetLen,
-		    packetTag,
 		    packetType,
+		    packetTag,
 	            eventID,
 		    threadID,
 	            nCalls;
@@ -1011,17 +1013,19 @@ void HDFSummarySDDF( HDFnode_t *P, int procIndex )
 	                 + nByteFields*sizeof(int)	 /* array lens  */
 	                 + nByteFields*nBkts*sizeof(int) /* byte hist   */
 	                 + sizeof(int) ;                 /* Name len    */
-	Header.packetTag = ( procIndex + 1 )*HDF_FAMILY | RECORD_TRACE ;
+	Header.packetTag = HDF_SUMMARY_FAMILY +
+			   ( procIndex + 1 )*8 + RECORD_TRACE ;
 	Header.packetType = PKT_DATA;
 	Header.threadID = TRgetNode();
         while ( P != NULL ) {
 	   Q = P->ptr;
-	   Header.eventID = Q->eventID;
-           Header.Seconds = Q->record.lastCall;
-	   Header.IncDur  = Q->record.incDur;
-	   Header.ExcDur  = Q->record.excDur;
-	   Header.HDFid   = Q->record.hdfID;
-	   Header.XREFid  = Q->record.xRef;
+	   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;
 	   memcpy( Packet, &Header, sizeof(Header) );
 	   Packet += sizeof(Header);
 	   /*===========================================================*
@@ -1030,15 +1034,15 @@ void HDFSummarySDDF( HDFnode_t *P, int procIndex )
 	   arrayLen = nTallyFields;
 	   memcpy( Packet, &arrayLen, sizeof(int) );
 	   Packet += sizeof(int);
-	   memcpy( Packet, Q->record.times, nTallyFields*sizeof(int) );
-	   Packet += nTallyFields*sizeof(int);
+	   memcpy( Packet, P->record.times, nTallyFields*sizeof(double) );
+	   Packet += nTallyFields*sizeof(double);
 	   /*===========================================================*
 	   // copy length of counts array and counts array to Packet.	*
 	   //===========================================================*/
 	   arrayLen = nTallyFields;
 	   memcpy( Packet, &arrayLen, sizeof(int) );
 	   Packet += sizeof(int);
-	   memcpy( Packet, Q->record.counts, nTallyFields*sizeof(int) );
+	   memcpy( Packet, P->record.counts, nTallyFields*sizeof(int) );
 	   Packet += nTallyFields*sizeof(int);
 	   /*===========================================================*
 	   // copy length of bytes array and bytes array to Packet.	*
@@ -1046,7 +1050,7 @@ void HDFSummarySDDF( HDFnode_t *P, int procIndex )
 	   arrayLen = nByteFields;
 	   memcpy( Packet, &arrayLen, sizeof(int) );
 	   Packet += sizeof(int);
-	   memcpy( Packet, Q->record.counts, nByteFields*sizeof(int) );
+	   memcpy( Packet, P->record.bytes, nByteFields*sizeof(int) );
 	   Packet += nByteFields*sizeof(int);
 	   /*===========================================================*
 	   // copy length of historgram arrays and arrays to Packet.	*
@@ -1055,7 +1059,7 @@ void HDFSummarySDDF( HDFnode_t *P, int procIndex )
 	   for ( i = 0; i < nByteFields; ++i ) {
 	      memcpy( Packet, &arrayLen, sizeof(int) );
 	      Packet += sizeof(int);
-	      memcpy( Packet, Q->record.Hists[i], nBkts*sizeof(int) );
+	      memcpy( Packet, P->record.Hists[i], nBkts*sizeof(int) );
 	      Packet += nBkts*sizeof(int);
 	   }
 	   arrayLen = 0;	/* name length */
@@ -1375,7 +1379,7 @@ void writeHDFRecDescrptrsRT()
 #	include "HDFentryNames.h"
 	"HDF_Last_Entry"
 	};
-	int j;
+	int j, FAMILY;
         char BUF1[256], BUF2[256] ;
 	_hdfNameDescriptor();	/* Descriptor for named identifiers	*/
         for ( j = 0; j < NumHDFProcs; ++j ) {
@@ -1385,7 +1389,8 @@ void writeHDFRecDescrptrsRT()
               strcat( BUF2, " Procedure Summary");
               strcpy( BUF1, BUF2 );
               strcat( BUF1, " Trace");
-              _hdfDescriptorRT( BUF1, BUF2, (j+1)*HDF_FAMILY );
+	      FAMILY = HDF_SUMMARY_FAMILY + (j + 1)*8;
+              _hdfDescriptorRT( BUF1, BUF2, FAMILY );
            }
         }
         return;
diff --git a/pablo/PabloHDF_SDDF.c b/pablo/PabloHDF_SDDF.c
index af57200..6faf551 100644
--- a/pablo/PabloHDF_SDDF.c
+++ b/pablo/PabloHDF_SDDF.c
@@ -71,7 +71,7 @@
 #include "SDDFparam.h"
 #include "TraceParam.h"
 #include "Trace.h"
-#include "HDFTrace.h"
+#include "HDF5Trace.h"
 void HDFendTrace_SDDF(void);
 void startHDFtraceEvent(int eventID);
 void endHDFtraceEvent(int , int , char *, int );
@@ -81,8 +81,6 @@ int  writeHDFProcRecordDescriptors( void );
 int findHDFProcEvent( int ) ;
 TR_RECORD *HDFprocEventRecord( int, TR_EVENT *, CLOCK, HDFsetInfo *, unsigned );
 TR_RECORD *miscEventRecord( int , TR_EVENT *, CLOCK, void *, unsigned );
-void _hdfTraceEntryDescriptor( void );
-void _hdfTraceExitDescriptor( void );
 void _hdfMiscDescriptor( void );
 void _hdfProcNameDescriptor( void );
 int setEventRecordFunction( int, void * );
@@ -92,6 +90,9 @@ void enableIOdetail( void );
 void disableLifetimeSummaries( void );
 void disableTimeWindowSummaries( void );
 void disableFileRegionSummaries( void );
+void _hdfTraceDescriptor( char *, char *, int );
+void createHDFTraceDescriptor( int );
+void HDFfinalTimeStamp( void );
 
 void initIOTrace( void );
 void endIOTrace( void );
@@ -156,24 +157,10 @@ static PROC_ENTRY	**procEntryStack =*/	/* array of pointers to	*/
 // records, similarly to record data structures in Trace.h	 	* 
 //======================================================================*/
 
-/*======================================================================*
-// FAMILY_PROCENTRY family Record Data packets:				* 
-//======================================================================*/
-struct procEntryTraceRecordData {
-	int	packetLength;	/* bytes in packet		    	*/
-	int	packetType;	/* == PKT_DATA			    	*/
-	int	packetTag;	/* FAMILY_PROCENTRY | RECORD_TRACE  	*/
-	int	eventID;	/* ID of corresponding event	    	*/
-	double	seconds;	/* floating-point timestamp	    	*/
-	long	sourceByte;	/* source code byte offset in file  	*/
-	int	sourceLine;	/* source code line number in file  	*/
-	int	nodeNumber;	/* occurred on which node	    	*/
-};
-#define procEntryTraceLen 6*sizeof(int) + sizeof(long) + sizeof(double)
 /*======================================================================* 
-// FAMILY_PROCEXIT family Record Data packets:				* 
+// TraceRecord Data packets:						* 
 //======================================================================*/
-struct procExitTraceRecordData {
+struct procTraceRecordData {
 	int	packetLength;	   /* bytes in packet		    	*/
 	int	packetType;	   /* == PKT_DATA		    	*/
 	int	packetTag;	   /* FAMILY_PROCEXIT | RECORD_TRACE   	*/
@@ -184,7 +171,7 @@ struct procExitTraceRecordData {
 	int	nameLen;	   /* Length of file or data set name	*/
 	/* name comes next, but no space is allocated	*/
 };
-#define procExitTraceLen 6*sizeof(int) + 3*sizeof(double) +sizeof(long)
+#define procTraceRecLen 6*sizeof(int) + sizeof(double) +sizeof(long)
 /*======================================================================*
 // misc Record Data packets:						* 
 //======================================================================*/
@@ -200,31 +187,6 @@ struct miscTraceRecordData {
 };
 #define miscTraceLen 5*sizeof(int) + 2*sizeof(double) +sizeof(long)
 /*======================================================================*
-// HDFprocName Record Data packets:					* 
-// These are used to pass information about the names of the traced	*
-// routine in the trace file to the post processing utilities.		*
-//======================================================================*/
-struct HDFprocNameRecordData {
-	int	packetLength;	/* bytes in packet		    	*/
-	int	packetType;	/* == PKT_DATA			    	*/
-	int	packetTag;	/* FAMILY_HDFPROCNAME | RECORD_TRACE	*/
-	int	eventID;	/* ID of corresponding event	    	*/
-	int	HDFeventID;	/* ID of HDF proc               	*/
-	int	procIndex;	/* Index of HDF proc            	*/
-	int	numProcs;	/* Number of HDF procs          	*/
-	int	NameLen;	/* length of HDF proc Name	    	*/
-	char   *Name;
-};
-#define HDFprocNameRecLen 8*sizeof(int)
-/*======================================================================*
-// Define data structures used to contain source code location data for *
-// Pablo instrumenting parser-generated code.				*
-//======================================================================*/
-static long	procByteOffset = -1;	/* source code byte offset    	*/
-
-static int	procLineNumber = -1;	/* source code line number 	*/
-
-/*======================================================================*
 // The procEntries array specifies the event IDs of procedure entry 	*
 // events. 								*
 //======================================================================*/
@@ -307,7 +269,6 @@ void HDFinitTrace_SDDF( char *traceFileName, uint32 procTraceMask )
 //======================================================================*/
 void HDFendTrace_SDDF(void)
 {
-	HDFtraceIOEvent( -ID_timeStamp, 0, 0 ); 
 #ifdef HAVE_MPIOTRACE
 	/*===============================================================
 	// termintate MPI-IO tracing in the parallel case.  This will	*
@@ -318,6 +279,7 @@ void HDFendTrace_SDDF(void)
 	/*===============================================================
 	// terminate tracing 						*
 	//==============================================================*/
+	HDFfinalTimeStamp();
        	endIOTrace();
        	endTracing();
 #endif
@@ -391,10 +353,6 @@ int initHDFProcTrace( int numProcs, int *procEntryID )
 	procEvents[ numProcs+1 ].exitID = -ID_free;
 	setEventRecordFunction( ID_free, miscEventRecord );
 	setEventRecordFunction( -ID_free, miscEventRecord );
-	procEvents[ numProcs+2 ].entryID = ID_timeStamp;
-	procEvents[ numProcs+2 ].exitID = -ID_timeStamp;
-	setEventRecordFunction( ID_timeStamp, miscEventRecord );
-	setEventRecordFunction( -ID_timeStamp, miscEventRecord );
 
 	return SUCCESS;
 }
@@ -448,9 +406,6 @@ int  writeHDFProcRecordDescriptors( void )
 #endif /* DEBUG */
 
 	_hdfMiscDescriptor();
-	_hdfTraceEntryDescriptor() ;
-	_hdfTraceExitDescriptor()  ;
-	_hdfProcNameDescriptor();
 
 #ifdef DEBUG
 	fprintf( debugFile, "writeHDFProcRecordDescriptors done\n" );
@@ -484,19 +439,15 @@ HDFprocEventRecord( int recordType, TR_EVENT *eventPointer, CLOCK timeStamp,
 	static TR_RECORD		traceRecord;
 	static void			*recordBuffer = NULL;
 	static int			bufferLength = 0;
-	struct procEntryTraceRecordData	*entryTraceRecordHeader;
-	struct procExitTraceRecordData	*exitTraceRecordHeader;
-	struct HDFprocNameRecordData 	*nameRecord;
+	struct procTraceRecordData	*TraceRecordHeader;
 	int				procIndex;
 	int				recordFamily;
 	char				*namePtr;
-	int				NameLen;
-	int				NameRecLen;
-	
-#ifdef DEBUG
-	fprintf( debugFile, "HDFprocEventRecord\n" );
-	fflush( debugFile );
-#endif /* DEBUG */
+		
+	#ifdef DEBUG
+		fprintf( debugFile, "HDFprocEventRecord\n" );
+		fflush( debugFile );
+	#endif /* DEBUG */
 
 	/*==============================================================* 
 	// Find the index in the tables for the procedure corresponding *
@@ -512,25 +463,7 @@ HDFprocEventRecord( int recordType, TR_EVENT *eventPointer, CLOCK timeStamp,
 	// not already been produced.					*
 	//==============================================================*/
 	if ( procEntryCalled[procIndex] == 0 ) {
-	   NameLen = strlen( HDFProcNames[procIndex] );
-	   NameRecLen = HDFprocNameRecLen + NameLen;
-	   nameRecord = ( struct HDFprocNameRecordData *)malloc( NameRecLen );
-	   nameRecord->packetLength = NameRecLen;
-	   nameRecord->packetType  = PKT_DATA;
-	   nameRecord->packetTag   = FAMILY_HDFPROCNAME | RECORD_TRACE;
-	   nameRecord->eventID     = ID_HDFprocName;
-	   nameRecord->HDFeventID  = abs(eventPointer->eventID);
-	   nameRecord->procIndex   = procIndex;
-	   nameRecord->numProcs    = NumHDFProcs;
-	   nameRecord->NameLen     = NameLen;
-	   /*===========================================================*
-	   // copy procedure name into the packet, write out the packet	*
-	   // and set ProcEntryCalled[procIndex] to indicate the name	*
-	   // packet was produced.					*
-	   //===========================================================*/
-	   memcpy( &(nameRecord->Name), HDFProcNames[procIndex], NameLen );
-	   putBytes( (char *)nameRecord , NameRecLen );
-	   free( nameRecord );
+	   createHDFTraceDescriptor( procIndex );
 	   procEntryCalled[procIndex] = 1;
 	}
 	/*==============================================================* 
@@ -538,11 +471,7 @@ HDFprocEventRecord( int recordType, TR_EVENT *eventPointer, CLOCK timeStamp,
 	// exit family event by lookup in the procedure event ID 	* 
 	// matching.  							* 
 	//==============================================================*/
-	if ( procEvents[ procIndex ].entryID == eventPointer->eventID ) {
-	   recordFamily = FAMILY_PROCENTRY;
-	} else {
-	   recordFamily = FAMILY_PROCEXIT;
-	}
+	recordFamily = HDF_FAMILY + ( procIndex + 1)*8;
 	/*==============================================================* 
 	// The time stamp stored in the event descriptor will be used	*  
 	// unless one is specified in the timeStamp parameter.	    	*  
@@ -554,16 +483,7 @@ HDFprocEventRecord( int recordType, TR_EVENT *eventPointer, CLOCK timeStamp,
 	// Determine how many bytes of storage will be needed for the 	*  
 	// contents of the trace record.			    	* 
 	//==============================================================*/
-	switch (( recordFamily | recordType )) {
-
-	   case FAMILY_PROCENTRY | RECORD_TRACE:
-		traceRecord.recordLength = sizeof *entryTraceRecordHeader;
-		break;
-
-	   case FAMILY_PROCEXIT | RECORD_TRACE:
-		traceRecord.recordLength = sizeof *exitTraceRecordHeader;
-		break;
-	}
+	traceRecord.recordLength = sizeof *TraceRecordHeader;
         if ( dataPointer != NULL && dataPointer->setName != NULL ) {
 	   traceRecord.recordLength += strlen( dataPointer->setName );
         }
@@ -590,54 +510,30 @@ HDFprocEventRecord( int recordType, TR_EVENT *eventPointer, CLOCK timeStamp,
 	/*==============================================================* 
 	// Load the trace record fields into the allocated buffer 	* 
 	//==============================================================*/
-	switch (( recordFamily | recordType )) {
-
-	   case FAMILY_PROCENTRY | RECORD_TRACE:
-		entryTraceRecordHeader = (struct procEntryTraceRecordData *)
-							recordBuffer;
-		entryTraceRecordHeader->packetLength =
-				traceRecord.recordLength;
-		entryTraceRecordHeader->packetType = PKT_DATA;
-		entryTraceRecordHeader->packetTag = recordFamily | recordType;
-		entryTraceRecordHeader->seconds = clockToSeconds( timeStamp );
-		entryTraceRecordHeader->eventID = eventPointer->eventID;
-		entryTraceRecordHeader->nodeNumber = TRgetNode();
-		entryTraceRecordHeader->sourceByte = procByteOffset;
-		entryTraceRecordHeader->sourceLine = procLineNumber;
-		break;
-
-	   case FAMILY_PROCEXIT | RECORD_TRACE:
-		exitTraceRecordHeader = (struct procExitTraceRecordData *)
-							recordBuffer;
-		exitTraceRecordHeader->packetLength =
-				                  traceRecord.recordLength;
-		exitTraceRecordHeader->packetType = PKT_DATA;
-		exitTraceRecordHeader->packetTag = recordFamily | recordType;
-		exitTraceRecordHeader->seconds = clockToSeconds( timeStamp );
-		exitTraceRecordHeader->eventID = eventPointer->eventID;
-		exitTraceRecordHeader->nodeNumber = TRgetNode();
-
-		if ( dataPointer != 0 ) {
-	           exitTraceRecordHeader->setID = dataPointer->setID;
-		   if (dataPointer->setName != NULL ) {
-		      exitTraceRecordHeader->nameLen 
-					= (int)strlen( dataPointer->setName );
-		      /*================================================* 
-		      // copy name directly into the end of the buffer.	*
-		      //================================================*/
-		      namePtr = (char *)exitTraceRecordHeader 
-                                                  + procExitTraceLen;
-	              memcpy( namePtr, dataPointer->setName,
-		              exitTraceRecordHeader->nameLen );
-	           } else {
-		      exitTraceRecordHeader->nameLen = 0;
-	           }   
-		} else {
-	           exitTraceRecordHeader->setID = NoDSid;
-		   exitTraceRecordHeader->nameLen = 0;
-		} 
-		break;
-	}
+	TraceRecordHeader = (struct procTraceRecordData *)recordBuffer;
+	TraceRecordHeader->packetLength = traceRecord.recordLength;
+	TraceRecordHeader->packetType = PKT_DATA;
+	TraceRecordHeader->packetTag = recordFamily | recordType;
+	TraceRecordHeader->seconds = clockToSeconds( timeStamp );
+	TraceRecordHeader->eventID = eventPointer->eventID;
+	TraceRecordHeader->nodeNumber = TRgetNode();
+
+	if ( dataPointer != 0 ) {
+	  TraceRecordHeader->setID = dataPointer->setID;
+	  if (dataPointer->setName != NULL ) {
+	     TraceRecordHeader->nameLen = (int)strlen( dataPointer->setName );
+ 	     /*================================================* 
+	     // copy name directly into the end of the buffer.	*
+	     //================================================*/
+	     namePtr = (char *)TraceRecordHeader + procTraceRecLen;
+	     memcpy(namePtr, dataPointer->setName, TraceRecordHeader->nameLen);
+	  } else {
+	     TraceRecordHeader->nameLen = 0;
+	  }   
+	} else {
+	  TraceRecordHeader->setID = NoDSid;
+	  TraceRecordHeader->nameLen = 0;
+        } 
 
 #ifdef DEBUG
 	fprintf( debugFile, "HDFprocEventRecord done\n" );
@@ -680,23 +576,15 @@ TR_RECORD *miscEventRecord( int recordType,
        case ID_malloc:
        case ID_free:
 	  miscRecord.seconds = clockToSeconds( timeStamp ) ;
-	  miscRecord.bytes = *(size_t *)dataPointer;
           miscRecord.eventID = eventID ;
 	  break;
        case -ID_malloc:
        case -ID_free:
+	  miscRecord.bytes = *(size_t *)dataPointer;
           miscRecord.duration = clockToSeconds( timeStamp) 
                                       - miscRecord.seconds;
           return &traceRecord;		/* generate trace record */
 	  break;
-       case ID_timeStamp:
-       case -ID_timeStamp:
-	  miscRecord.seconds = clockToSeconds( timeStamp ) ;
-	  miscRecord.bytes = 0;
-          miscRecord.eventID = eventID ;
-          miscRecord.duration = 0;
-          return &traceRecord;	
-	  break;
        default:
           fprintf( stderr, "miscEventRecord: unknown eventID %d\n", eventID );
 	  break;
@@ -738,43 +626,54 @@ int findHDFProcEvent( int eventID )
 	}
 	return procIndex;
 }
+void createHDFTraceDescriptor( int Inx )
+{
+        char BUF1[256], BUF2[256] ;
+	int FAMILY;
+        strcpy( BUF2, "HDF ");
+        strcat( BUF2, HDFProcNames[Inx] );
+        strcat( BUF2, " Procedure");
+        strcpy( BUF1, BUF2 );
+        strcat( BUF1, " Trace");
+
+	FAMILY = HDF_FAMILY + (Inx + 1)*8;
+        _hdfTraceDescriptor( BUF1, BUF2, FAMILY );
+}
 /*======================================================================*
 // NAME									*
-//	_hdfTraceEntryDescriptor					* 
+//	_hdfTraceDescriptor						* 
 //	   Generate a SDDF binary format record descriptor for the	* 
 //	   full trace class of events in the HDF procedure entry 	* 
 // USAGE								*
-//      _hdfTraceEntryDescriptro()					*
+//   _hdfTraceDescriptro( recordName, recordDescription, recordFamily )	*
 // RETURNS								*
 //      void								*
 //======================================================================*/
-void _hdfTraceEntryDescriptor( void )
+void _hdfTraceDescriptor( char *recordName,
+                    	  char *recordDescription,
+                          int recordFamily )
 {
     static char recordBuffer[ 4096 ];
     int         recordLength;
 
-#ifdef DEBUG
-	fprintf( debugFile, "_hdfTraceEntryDescriptor entered\n" );
-	fflush( debugFile );
-#endif /* DEBUG */
     hdfRecordPointer = recordBuffer;
-    /*==================================================================* 
+    /*===================================================================
     // Allow space at the beginning of the record for the packet        *
     //length which will be computed after the packet is complete.       *
     //==================================================================*/
     sddfWriteInteger( &hdfRecordPointer, 0 );
-    /*==================================================================* 
-    // The record type, tag, and name                                   * 
+    /*===================================================================
+    // The record type, tag, and name                                   *
     //==================================================================*/
     sddfWriteInteger( &hdfRecordPointer, PKT_DESCRIPTOR );
-    sddfWriteInteger( &hdfRecordPointer, ( FAMILY_PROCENTRY | RECORD_TRACE ) );
-    sddfWriteString( &hdfRecordPointer, "HDF Procedure Entry Trace" );
-    /*==================================================================*
+    sddfWriteInteger( &hdfRecordPointer, ( recordFamily | RECORD_TRACE ) );
+    sddfWriteString( &hdfRecordPointer, recordName );
+    /*===================================================================
     // The record attribute count and string pair                       *
     //==================================================================*/
     sddfWriteInteger( &hdfRecordPointer, 1 );
     sddfWriteString( &hdfRecordPointer, "description" );
-    sddfWriteString( &hdfRecordPointer, "HDF Procedure Entry Trace Record" );
+    sddfWriteString( &hdfRecordPointer, recordDescription );
     /*==================================================================*
     // The record field count                                           * 
     //==================================================================*/
@@ -782,78 +681,6 @@ void _hdfTraceEntryDescriptor( void )
     /*==================================================================* 
     // Create fields                                               	*
     //==================================================================*/
-    WRITE_HDF_FIELD( "Event Identifier", 
-		     "Event ID", 
-		     "Event Identifier Number", 
-		     INTEGER, 0 );
-    WRITE_HDF_FIELD( "Seconds", 
-		     "Seconds", 
-		     "Floating Point Timestamp", 
-		     DOUBLE, 0 );
-    WRITE_HDF_FIELD( "Source Byte", 
-		     "Byte", 
-		     "Source Byte Offset", 
-		     LONG, 0 );
-    WRITE_HDF_FIELD( "Source Line", 
-		     "Line", 
-		     "Source Line Number",
-		     INTEGER, 0 );
-    WRITE_HDF_FIELD( "Processor Number", 
-		     "Node", 
-		     "Processor number", 
-		     INTEGER, 0 );
-
-    recordLength = (int)(hdfRecordPointer - recordBuffer);
-
-    hdfRecordPointer = recordBuffer;
-    sddfWriteInteger( &hdfRecordPointer, recordLength );
-
-    putBytes( recordBuffer, (unsigned) recordLength );
-}
-/*======================================================================*
-// NAME									*
-//	_hdfTraceExitDescriptor	     					* 
-//	   Generate a SDDF binary format record descriptor for the	* 
-//	   full trace class of events in the HDF procedure exit  	* 
-// USAGE								*
-//	_hdfTraceExitDescriptor()					*	
-// RETURNS								*
-//  	void								*
-//======================================================================*/
-void _hdfTraceExitDescriptor( void )
-{
-    static char recordBuffer[ 4096 ];
-    int         recordLength;
-
-#ifdef DEBUG
-	fprintf( debugFile, "_hdfExitTraceDescriptor entered\n" );
-	fflush( debugFile );
-#endif /* DEBUG */
-    hdfRecordPointer = recordBuffer;
-    /*==================================================================* 
-    // Allow space at the beginning of the record for the packet        * 
-    // length which will be computed after the packet is complete.      * 
-    //==================================================================*/
-    sddfWriteInteger( &hdfRecordPointer, 0 );
-    /*==================================================================* 
-    // The record type, tag, and name                                   * 
-    /===================================================================*/
-    sddfWriteInteger( &hdfRecordPointer, PKT_DESCRIPTOR );
-    sddfWriteInteger( &hdfRecordPointer, ( FAMILY_PROCEXIT | RECORD_TRACE ) );
-    sddfWriteString( &hdfRecordPointer, "HDF Procedure Exit Trace" );
-    /*==================================================================*
-    // The record attribute count and string pair                       *
-    //==================================================================*/
-    sddfWriteInteger( &hdfRecordPointer, 1 );
-    sddfWriteString( &hdfRecordPointer, "description" );
-    sddfWriteString( &hdfRecordPointer, "HDF Procedure Exit Trace Record" );
-    /*==================================================================* 
-    // The record field count                                           *
-    //==================================================================*/
-    sddfWriteInteger( &hdfRecordPointer, 5);
-    /*==================================================================* 
-    // Create fields                                               	* 
-    //==================================================================*/
     WRITE_HDF_FIELD(  "Event Identifier", 
 		      "Event ID", 
 		      "Event Identifier Number", 
@@ -870,10 +697,11 @@ void _hdfTraceExitDescriptor( void )
 		      "Node", 
 		      "Processor number", 
 		      INTEGER, 0 );
-    WRITE_HDF_FIELD( "HDF Name",
-                     "HDF Name", "Name of File, Data Set or Dim",
+    WRITE_HDF_FIELD(  "HDF Name",
+                      "HDF Name", "Name of File, Data Set or Dim",
                       CHARACTER, 1 );
 
+
     recordLength = (int)(hdfRecordPointer - recordBuffer);
 
     hdfRecordPointer = recordBuffer;
@@ -881,7 +709,6 @@ void _hdfTraceExitDescriptor( void )
 
     putBytes( recordBuffer, (unsigned) recordLength );
 }
-
 /*======================================================================*
 // NAME									*
 //	_hdfMiscDescriptor						* 
@@ -954,75 +781,5 @@ void _hdfMiscDescriptor( void )
 
     putBytes( recordBuffer, (unsigned) recordLength );
 }
-/*======================================================================*
-// NAME									*
-//	_hdfProcNameDescriptor						* 
-//	   Generate a SDDF binary format record descriptor for the	* 
-//	   HDFProcName Records                                   	* 
-// USAGE								*
-//      _hdfProcNameDescriptor()					*
-// RETURNS								*
-//      void								*
-//======================================================================*/
-void _hdfProcNameDescriptor( void )
-{
-    static char recordBuffer[ 4096 ];
-    int         recordLength;
-
-#ifdef DEBUG
-	fprintf( debugFile, "_hdfProcNameDescriptor entered\n" );
-	fflush( debugFile );
-#endif /* DEBUG */
-    hdfRecordPointer = recordBuffer;
-    /*==================================================================* 
-    // Allow space at the beginning of the record for the packet        *
-    //length which will be computed after the packet is complete.       *
-    //==================================================================*/
-    sddfWriteInteger( &hdfRecordPointer, 0 );
-    /*==================================================================* 
-    // The record type, tag, and name                                   * 
-    //==================================================================*/
-    sddfWriteInteger( &hdfRecordPointer, PKT_DESCRIPTOR );
-    sddfWriteInteger( &hdfRecordPointer, ( FAMILY_HDFPROCNAME| RECORD_TRACE ) );
-    sddfWriteString( &hdfRecordPointer, "HDF Procedure Information" );
-    /*==================================================================*
-    // The record attribute count and string pair                       *
-    //==================================================================*/
-    sddfWriteInteger( &hdfRecordPointer, 1 );
-    sddfWriteString( &hdfRecordPointer, "description" );
-    sddfWriteString( &hdfRecordPointer, "HDF Proc Info Record" );
-    /*==================================================================*
-    // The record field count                                           * 
-    //==================================================================*/
-    sddfWriteInteger( &hdfRecordPointer, 5);
-    /*==================================================================* 
-    // Create fields                                               	*
-    //==================================================================*/
-    WRITE_HDF_FIELD( "Event Identifier", 
-		     "Event ID", 
-		     "Event Identifier Number", 
-		     INTEGER, 0 );
-    WRITE_HDF_FIELD( "HDF Proc Event Id", 
-		     "HDF Proc Event Identifier", 
-		     "HDF Proc Event Identifier Number", 
-		     INTEGER, 0 );
-    WRITE_HDF_FIELD( "HDF Proc Index", 
-		     "HDF Proc Index", 
-		     "Index of HDF Proc in Tables", 
-		     INTEGER, 0 );
-    WRITE_HDF_FIELD( "Num HDF Procs", 
-		     "Num HDF Procs", 
-		     "Number of HDF Procedures", 
-		     INTEGER, 0 );
-    WRITE_HDF_FIELD( "HDF Proc Name",
-                     "HDF Proc Name", 
-		     "Name of HDF Procedure",
-                     CHARACTER, 1 );
-    recordLength = (int)(hdfRecordPointer - recordBuffer);
 
-    hdfRecordPointer = recordBuffer;
-    sddfWriteInteger( &hdfRecordPointer, recordLength );
-
-    putBytes( recordBuffer, (unsigned) recordLength );
-}
 /*#endif */ /* HAVE_PABLO */