[svn-r5220]

Purpose:
    Bug Fix
Description:
    Users could not trace MPI programs when library wasn't compiled for
    parallel execution
Solution:
    Allow Pablo Trace library to set the processor number and generate
    the filenames for each processor.
Platforms tested:
    Sun Workstation, HP VClass, Irix 64

1 files changed, 460 insertions, 474 deletions

diff --git a/pablo/PabloHDF_SDDF.c b/pablo/PabloHDF_SDDF.c
index 4858086..c46878f 100644
--- a/pablo/PabloHDF_SDDF.c
+++ b/pablo/PabloHDF_SDDF.c
@@ -69,7 +69,7 @@
 #include "TraceParam.h"
 #include "Trace.h"
 #include "HDFTrace.h"
-void HDFendTrace_SDDF(int);
+void HDFendTrace_SDDF(void);
 void startHDFtraceEvent(int eventID);
 void endHDFtraceEvent(int , int , char *, int );
 int preInitHDFProcTrace( void );
@@ -113,7 +113,7 @@ extern char HDFprocNames[][40];
 /*======================================================================*
 // Prototypes of functions in this file.				*
 //======================================================================*/
-void HDFinitTrace_SDDF( char *, int );
+void HDFinitTrace_SDDF( char * );
 /*======================================================================* 
 // Each procedure being traced has associated with it a distinct pair 	* 
 // of entry and exit event IDs.  This code maintains a vector of such  	* 
@@ -176,22 +176,24 @@ struct procTraceRecordData {
 /*======================================================================*
 // misc Record Data packets:						* 
 //======================================================================*/
-struct miscTraceRecordData {
-	int	packetLength;	/* bytes in packet		    	*/
-	int	packetType;	/* == PKT_DATA			    	*/
-	int	packetTag;	/* FAMILY_MISC | RECORD_TRACE  		*/
-	int	eventID;	/* ID of corresponding event	    	*/
-	double	seconds;	/* floating-point timestamp	    	*/
-	double	duration;	/* floating-point operation duration	*/
-	unsigned long	bytes;	/* number of bytes requested        	*/
-	int	nodeNumber;	/* occurred on which node	    	*/
+struct miscTraceRecordData 
+{
+   int	packetLength;		/* bytes in packet		    	*/
+   int	packetType;		/* == PKT_DATA			    	*/
+   int	packetTag;		/* FAMILY_MISC | RECORD_TRACE  		*/
+   int	eventID;		/* ID of corresponding event	    	*/
+   double seconds;		/* floating-point timestamp	    	*/
+   double duration;		/* floating-point operation duration	*/
+   unsigned long bytes;		/* number of bytes requested        	*/
+   int	nodeNumber;		/* occurred on which node	    	*/
 };
 #define miscTraceLen 5*sizeof(int) + 2*sizeof(double) +sizeof(long)
 /*======================================================================*
 // The procEntries array specifies the event IDs of procedure entry 	*
 // events. 								*
 //======================================================================*/
-int procEntries[] = {
+int procEntries[] = 
+{
 0, 0, 0, 0, 0,
 #include "HDFidList.h"
 ID_HDF_Last_Entry
@@ -201,105 +203,46 @@ ID_HDF_Last_Entry
 // was called.					*
 //======================================================================*/
 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"
-};*/
 /*=======================================================================
 // NAME									*
 //     	HDFinitTrace_SDDF -- initalize HDF tracing with SDDF records	*
 // USAGE								*
-//     	HDFinitTrace_SDDF( traceFileName, procTraceMask )		*
+//     	HDFinitTrace_SDDF( traceFileName )                	*
 // PARAMETERS								*
 //	char *traceFileName  -- name of trace file to hold output	*
-//	uint32 prcoTraceMask -- mask indicating classes of HDF procs to *
-//				be traced				*
 // RETURNS								*
 //     	None 								*
 //======================================================================*/
-void HDFinitTrace_SDDF( char *traceFileName, int OUTSW )
+void HDFinitTrace_SDDF( char *traceFileName )
 {
-	/*===============================================================
-        // set traceFileName and set IO tracing switches.  If MPIO 	*
-	// tracing is available, MPIO tracing will also be initialized. *
-	//==============================================================*/
-#ifdef H5_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;
-	/*===============================================================
-	// Determine if MPI is running the program.			*
-	//==============================================================*/
-	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 );
+   /*====================================================================
+   // set traceFileName and set IO tracing switches.  If MPIO 		*
+   // tracing is available, MPIO tracing will also be initialized. 	*
+   //===================================================================*/
 #ifdef H5_HAVE_MPIOTRACE
-	   /*============================================================
-	   // MPIO Tracing is supported in the Pablo Library.  Let the  *
-	   // MPIO initialization be performed and handle the naming of *
-	   // trace files.						*
-	   //===========================================================*/
-           initMPIOTrace( traceFileName, SUPPRESS_MPIO_TRACE ); 
+   int myNode;
+   char *buff;
+   /*====================================================================
+   // in the parallel case, initialize MPI-IO tracing. This  		*
+   // will initialize the traceFileName and set the I/O tracing		*
+   // switches.								*
+   //===================================================================*/
+   /*====================================================================
+   // MPIO Tracing is supported in the Pablo Library.  Let the  	*
+   // MPIO initialization be performed and handle the naming of 	*
+   // trace files.							*
+   //===================================================================*/
+   initMPIOTrace( traceFileName, SUPPRESS_MPIO_TRACE ); 
+   MPI_Comm_rank( MPI_COMM_WORLD, &myNode );
+   setTraceProcessorNumber( myNode );
 #else 
-	   /*============================================================
-	   // 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 );
+   IOtraceInit( traceFileName, RUNTIME_TRACE );
 #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 	*
-	// I/O tracing switches.					*
-	//==============================================================*/
-	setTraceFileName(traceFileName);
-    	initIOTrace();
-    	enableIOdetail();
-    	disableLifetimeSummaries();
-        disableTimeWindowSummaries();
-	disableFileRegionSummaries();
-#endif /* H5_HAVE_PARALLEL */
-	/*===============================================================
-	// complete HDF initiailization.				*
-	//==============================================================*/
-	preInitHDFProcTrace();
-        initHDFProcTrace( sizeof(procEntries)/sizeof(int), procEntries );
+   /*====================================================================
+   // complete HDF initiailization.					*
+   //===================================================================*/
+   preInitHDFProcTrace();
+   initHDFProcTrace( sizeof(procEntries)/sizeof(int), procEntries );
 }
 /*=======================================================================
 // NAME									*
@@ -309,23 +252,22 @@ void HDFinitTrace_SDDF( char *traceFileName, int OUTSW )
 // RETURNS								*
 //     None.								*
 //======================================================================*/
-void HDFendTrace_SDDF(int OUTSW)
+void HDFendTrace_SDDF()
 {
-	HDFfinalTimeStamp();
-	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);
-	} 
+   HDFfinalTimeStamp();
+#ifdef H5_HAVE_MPIORACE
+   /*====================================================================
+   // 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
 }
 /*=======================================================================
 // NAME									*
@@ -347,57 +289,65 @@ void HDFendTrace_SDDF(int OUTSW)
 //======================================================================*/
 int initHDFProcTrace( int numProcs, int *procEntryID )
 {
-	int			procIndex, IX, ID;
-
-  	if (( numProcs <= 0 ) || ( procEntryID == (int *) 0 )  )
-		return FAILURE; 
-	/*===============================================================
-	// Allocate space to store a copy of the procedure entry-exit	*
-	// event ID matchings and also the procedure entry stacks.	*
-	//==============================================================*/
-	procEvents = (PROC_EVENTS *) TRgetBuffer(
-					   (numProcs+4)*sizeof(PROC_EVENTS) );
-
-	if ( procEvents == (PROC_EVENTS *) 0 )
-		TRfailure( "cannot allocate procedure events matching" );
-
-	procEntryCalled = ( int *)malloc( numProcs*sizeof(int) );
-	if ( procEvents == NULL )
-	   TRfailure( "cannot allocate procedure Called indicators" );
-	/*===============================================================
-	// Initialize the procedure events matching from the arguments	*
-	// passed.  Configure the trace record-generating function for  *
-	// these events.  Initialize the flags indicating whether or	*
-	// not the procedure was called.				*
-	//==============================================================*/
-	for ( procIndex = 0; procIndex < numProcs; procIndex++ ) {
-
-	        IX = procEntryID[ procIndex ];
-		ID = HDFIXtoEventID( IX );
-		procEvents[ procIndex ].entryID = ID;
-		procEvents[ procIndex ].exitID = -ID;
-
-		setEventRecordFunction( ID, HDFprocEventRecord );
-		setEventRecordFunction( -ID, HDFprocEventRecord );
-		procEntryCalled[ procIndex ] = 0;
-
-	}
-
-	/*===============================================================
-	// Initialize the procedure events for malloc.  		*
-	// Configure the trace record-generating function for this  	*
-	// event.							*
-	//==============================================================*/
-	procEvents[ numProcs ].entryID = ID_malloc;
-	procEvents[ numProcs ].exitID = -ID_malloc;
-	setEventRecordFunction( ID_malloc, miscEventRecord );
-	setEventRecordFunction( -ID_malloc, miscEventRecord );
-	procEvents[ numProcs+1 ].entryID = ID_free;
-	procEvents[ numProcs+1 ].exitID = -ID_free;
-	setEventRecordFunction( ID_free, miscEventRecord );
-	setEventRecordFunction( -ID_free, miscEventRecord );
-
-	return SUCCESS;
+   int procIndex;
+   int IX;
+   int ID;
+
+   if (( numProcs <= 0 ) || ( procEntryID == (int *) 0 )  )
+   {
+      return FAILURE; 
+   }
+   /*====================================================================
+   // Allocate space to store a copy of the procedure entry-exit	*
+   // event ID matchings and also the procedure entry stacks.		*
+   //===================================================================*/
+   procEvents = (PROC_EVENTS *)TRgetBuffer((numProcs+4)*sizeof(PROC_EVENTS));
+
+   if ( procEvents == (PROC_EVENTS *) 0 )
+   {
+      TRfailure( "cannot allocate procedure events matching" );
+   }
+
+   procEntryCalled = ( int *)malloc( numProcs*sizeof(int) );
+   if ( procEvents == NULL ) 
+   {
+      TRfailure( "cannot allocate procedure Called indicators" );
+   }
+   /*====================================================================
+   // Initialize the procedure events matching from the arguments	*
+   // passed.  Configure the trace record-generating function for  	*
+   // these events.  Initialize the flags indicating whether or		*
+   // not the procedure was called.					*
+   //===================================================================*/
+   for ( procIndex = 0; procIndex < numProcs; procIndex++ ) 
+   {
+
+      IX = procEntryID[ procIndex ];
+      ID = HDFIXtoEventID( IX );
+      procEvents[ procIndex ].entryID = ID;
+      procEvents[ procIndex ].exitID = -ID;
+
+      setEventRecordFunction( ID, HDFprocEventRecord );
+      setEventRecordFunction( -ID, HDFprocEventRecord );
+      procEntryCalled[ procIndex ] = 0;
+
+   }
+
+   /*====================================================================
+   // Initialize the procedure events for malloc.  			*
+   // Configure the trace record-generating function for this  		*
+   // event.								*
+   //===================================================================*/
+   procEvents[ numProcs ].entryID = ID_malloc;
+   procEvents[ numProcs ].exitID = -ID_malloc;
+   setEventRecordFunction( ID_malloc, miscEventRecord );
+   setEventRecordFunction( -ID_malloc, miscEventRecord );
+   procEvents[ numProcs+1 ].entryID = ID_free;
+   procEvents[ numProcs+1 ].exitID = -ID_free;
+   setEventRecordFunction( ID_free, miscEventRecord );
+   setEventRecordFunction( -ID_free, miscEventRecord );
+
+   return SUCCESS;
 }
 /*=======================================================================
 // NAME									*
@@ -414,19 +364,21 @@ int initHDFProcTrace( int numProcs, int *procEntryID )
 /=======================================================================*/
 int preInitHDFProcTrace( void )
 {
-	static int	preInitDone = FALSE;
-
-	if ( preInitDone == TRUE )
-		return SUCCESS;
-	/*===============================================================
-	// Give the instrumentation library a pointer to the functions	*
-	// in which we output the specialized record descriptors for	*
-	// procedure entry/exit.					*
-        //==============================================================*/
-	setRecordDescriptor( writeHDFProcRecordDescriptors );
-
-	preInitDone = TRUE;
-	return SUCCESS;
+   static int preInitDone = FALSE;
+
+   if ( preInitDone == TRUE )
+   {
+      return SUCCESS;
+   }
+   /*====================================================================
+   // Give the instrumentation library a pointer to the functions	*
+   // in which we output the specialized record descriptors for		*
+   // procedure entry/exit.						*
+   //===================================================================*/
+   setRecordDescriptor( writeHDFProcRecordDescriptors );
+
+   preInitDone = TRUE;
+   return SUCCESS;
 }
 /*=======================================================================
 // NAME									*
@@ -443,18 +395,18 @@ int preInitHDFProcTrace( void )
 /=======================================================================*/
 int  writeHDFProcRecordDescriptors( void )
 {
-#ifdef DEBUG
-	fprintf( debugFile, "writeHDFProcRecordDescriptors\n" );
-	fflush( debugFile );
-#endif /* DEBUG */
-
-	_hdfMiscDescriptor();
-
-#ifdef DEBUG
-	fprintf( debugFile, "writeHDFProcRecordDescriptors done\n" );
-	fflush( debugFile );
-#endif /* DEBUG */
-	return SUCCESS;
+#ifdef PABLODEBUG
+   fprintf( debugFile, "writeHDFProcRecordDescriptors\n" );
+   fflush( debugFile );
+#endif /* PABLODEBUG */
+
+   _hdfMiscDescriptor();
+
+#ifdef PABLODEBUG
+   fprintf( debugFile, "writeHDFProcRecordDescriptors done\n" );
+   fflush( debugFile );
+#endif /* PABLODEBUG */
+   return SUCCESS;
 }
 /*=======================================================================
 // NAME									*
@@ -476,166 +428,182 @@ int  writeHDFProcRecordDescriptors( void )
 //   pointer to trace record for this event 				*
 //======================================================================*/
 TR_RECORD *
-HDFprocEventRecord( int recordType, TR_EVENT *eventPointer, CLOCK timeStamp,
-		    HDFsetInfo *dataPointer, unsigned dataLength )
+HDFprocEventRecord( int recordType, 
+                    TR_EVENT *eventPointer, 
+                    CLOCK timeStamp,
+		    HDFsetInfo *dataPointer, 
+                    unsigned dataLength )
 {
-	static TR_RECORD		traceRecord;
-	static void			*recordBuffer = NULL;
-	static int			bufferLength = 0;
-	struct procTraceRecordData	*TraceRecordHeader;
-	int				procIndex;
-	int				recordFamily;
-	char				*namePtr;
+   static TR_RECORD		traceRecord;
+   static void			*recordBuffer = NULL;
+   static int			bufferLength = 0;
+   struct procTraceRecordData	*TraceRecordHeader;
+   int				procIndex;
+   int				recordFamily;
+   char				*namePtr;
 		
-	#ifdef DEBUG
-		fprintf( debugFile, "HDFprocEventRecord\n" );
-		fflush( debugFile );
-	#endif /* DEBUG */
-
-	/*==============================================================* 
-	// Find the index in the tables for the procedure corresponding *
-	// to this eventID.						*
-	//==============================================================*/
-	procIndex = findHDFProcEvent( eventPointer->eventID );
-	if ( procIndex < 0 ) {
-	   return nullRecordFunction( recordType, eventPointer,
+#ifdef PABLODEBUG
+   fprintf( debugFile, "HDFprocEventRecord\n" );
+   fflush( debugFile );
+#endif /* PABLODEBUG */
+
+   /*==============================================================* 
+   // Find the index in the tables for the procedure corresponding *
+   // to this eventID.						*
+   //==============================================================*/
+   procIndex = findHDFProcEvent( eventPointer->eventID );
+   if ( procIndex < 0 ) 
+   {
+      return nullRecordFunction( recordType, eventPointer,
 				timeStamp, (char *)dataPointer, dataLength );
-	}
-	/*==============================================================* 
-	// Produce a packet for the name of the procedure if one has 	*
-	// not already been produced.					*
-	//==============================================================*/
-	if ( procEntryCalled[procIndex] == 0 ) {
-	   createHDFTraceDescriptor( procIndex );
-	   procEntryCalled[procIndex] = 1;
-	}
-	/*==============================================================* 
-	// Determine whether this is a procedure entry or a procedure 	* 
-	// exit family event by lookup in the procedure event ID 	* 
-	// matching.  							* 
-	//==============================================================*/
-	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.	    	*  
-	//==============================================================*/
-	if ( clockCompare( timeStamp, noSuchClock ) == 0 ) {
-	   timeStamp = eventPointer->eventLast;
-	}
-	/*==============================================================* 
-	// Determine how many bytes of storage will be needed for the 	*  
-	// contents of the trace record.			    	* 
-	//==============================================================*/
-	traceRecord.recordLength = sizeof *TraceRecordHeader;
-        if ( dataPointer != NULL && dataPointer->setName != NULL ) {
-	   traceRecord.recordLength += strlen( dataPointer->setName );
-        }
-	/*==============================================================* 
-	// If there is a previously-allocated buffer and its size will	* 
-	// hold this record, re-use the buffer.  Otherwise, deallocate	* 
-	// the buffer (if allocated) and allocate a bigger one.	    	* 
-	//==============================================================*/
-	if ( bufferLength < traceRecord.recordLength ) {
-
-	   if ( recordBuffer != NULL ) {
-	      TRfreeBuffer( recordBuffer );
-	   }
-
-	   recordBuffer = (char *)TRgetBuffer( traceRecord.recordLength );
-
-	   if ( recordBuffer == NULL ) {
-	      TRfailure( "cannot allocate storage for trace record" );
-	   }
-	   bufferLength = traceRecord.recordLength;
-	}
-
-	traceRecord.recordContents = recordBuffer;
-	/*==============================================================* 
-	// Load the trace record fields into the allocated buffer 	* 
-	//==============================================================*/
-	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 = 0;
-	  TraceRecordHeader->nameLen = 0;
-        } 
-
-#ifdef DEBUG
-	fprintf( debugFile, "HDFprocEventRecord done\n" );
-	fflush( debugFile );
-#endif /* DEBUG */
-	returnRecord(&traceRecord);
+   }
+   /*===================================================================* 
+   // Produce a packet for the name of the procedure if one has 	*
+   // not already been produced.					*
+   //===================================================================*/
+   if ( procEntryCalled[procIndex] == 0 ) {
+      createHDFTraceDescriptor( procIndex );
+      procEntryCalled[procIndex] = 1;
+   }
+   /*===================================================================* 
+   // Determine whether this is a procedure entry or a procedure 	* 
+   // exit family event by lookup in the procedure event ID 	* 
+   // matching.  							* 
+   //===================================================================*/
+   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.	    	*  
+   //===================================================================*/
+   if ( clockCompare( timeStamp, noSuchClock ) == 0 ) {
+      timeStamp = eventPointer->eventLast;
+   }
+   /*===================================================================* 
+   // Determine how many bytes of storage will be needed for the 	*  
+   // contents of the trace record.			    	* 
+   //===================================================================*/
+   traceRecord.recordLength = sizeof *TraceRecordHeader;
+   if ( dataPointer != NULL && dataPointer->setName != NULL ) 
+   {
+      traceRecord.recordLength += strlen( dataPointer->setName );
+   }
+   /*===================================================================* 
+   // If there is a previously-allocated buffer and its size will	* 
+   // hold this record, re-use the buffer.  Otherwise, deallocate	* 
+   // the buffer (if allocated) and allocate a bigger one.	    	* 
+   //===================================================================*/
+   if ( bufferLength < traceRecord.recordLength ) 
+   {
+
+      if ( recordBuffer != NULL ) 
+      {
+         TRfreeBuffer( recordBuffer );
+      }
+
+      recordBuffer = (char *)TRgetBuffer( traceRecord.recordLength );
+
+      if ( recordBuffer == NULL ) 
+      {
+         TRfailure( "cannot allocate storage for trace record" );
+      }
+      bufferLength = traceRecord.recordLength;
+   }
+
+   traceRecord.recordContents = recordBuffer;
+   /*===================================================================* 
+   // Load the trace record fields into the allocated buffer 		*
+   //===================================================================*/
+   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 = 0;
+      TraceRecordHeader->nameLen = 0;
+   } 
+#ifdef PABLODEBUG
+   fprintf( debugFile, "HDFprocEventRecord done\n" );
+   fflush( debugFile );
+#endif /* PABLODEBUG */
+   returnRecord(&traceRecord);
 }
 /*======================================================================*
 // Internal Routine:  miscEventRecord					*
 //	  Called for misc start and end events.		       		*
 //======================================================================*/
 TR_RECORD *miscEventRecord( int recordType, 
-			      TR_EVENT *eventPointer, 
-                              CLOCK timeStamp, 
-			      void *dataPointer, 
-			      unsigned dataLength )
+		            TR_EVENT *eventPointer, 
+                            CLOCK timeStamp, 
+		            void *dataPointer, 
+		            unsigned dataLength )
 {
-    static TR_RECORD traceRecord;
-    static struct miscTraceRecordData miscRecord;
-    static int initialized = FALSE;
-    int eventID;
-
-    if ( clockCompare( timeStamp, noSuchClock ) == 0 ) {
-        timeStamp = eventPointer->eventLast;
-    }
-
-    eventID =  eventPointer->eventID;
-    if ( ! initialized ) {
-       miscRecord.packetLength = sizeof( miscRecord );
-       miscRecord.packetType = PKT_DATA;
-       miscRecord.packetTag = FAMILY_MISC | RECORD_TRACE;
-       miscRecord.nodeNumber = traceProcessorNumber;
-
-       traceRecord.recordLength = miscRecord.packetLength;
-       traceRecord.recordContents = (char *) &miscRecord;
-       initialized = TRUE;
-    }
-
-    switch ( eventID ) {
-       case ID_malloc:
-       case ID_free:
-	  miscRecord.seconds = clockToSeconds( timeStamp ) ;
-          miscRecord.eventID = eventID ;
-	  break;
-       case -ID_malloc:
-       case -ID_free:
-	  miscRecord.bytes = *(int *)dataPointer;
-          miscRecord.duration = clockToSeconds( timeStamp) 
-                                      - miscRecord.seconds;
-          return &traceRecord;		/* generate trace record */
-       default:
-          fprintf( stderr, "miscEventRecord: unknown eventID %d\n", eventID );
-	  break;
-    }
-    /*==================================================================*
-    // If we get here then no trace record generated.  Normally we 	*	
-    // should get here if this is an entry call.			*
-    //==================================================================*/
-    return( nullRecordFunction( recordType, eventPointer, timeStamp,
+   static TR_RECORD traceRecord;
+   static struct miscTraceRecordData miscRecord;
+   static int initialized = FALSE;
+   int eventID;
+
+   if ( clockCompare( timeStamp, noSuchClock ) == 0 ) 
+   {
+       timeStamp = eventPointer->eventLast;
+   }
+
+   eventID =  eventPointer->eventID;
+   if ( ! initialized ) 
+   {
+      miscRecord.packetLength = sizeof( miscRecord );
+      miscRecord.packetType = PKT_DATA;
+      miscRecord.packetTag = FAMILY_MISC | RECORD_TRACE;
+      miscRecord.nodeNumber = traceProcessorNumber;
+
+      traceRecord.recordLength = miscRecord.packetLength;
+      traceRecord.recordContents = (char *) &miscRecord;
+      initialized = TRUE;
+   }
+
+   switch ( eventID ) 
+   {
+      case ID_malloc:
+      case ID_free:
+         miscRecord.seconds = clockToSeconds( timeStamp ) ;
+         miscRecord.eventID = eventID ;
+         break;
+      case -ID_malloc:
+      case -ID_free:
+         miscRecord.bytes = *(int *)dataPointer;
+         miscRecord.duration = clockToSeconds( timeStamp) 
+                                   - miscRecord.seconds;
+         return &traceRecord;		/* generate trace record */
+      default:
+        fprintf( stderr, "miscEventRecord: unknown eventID %d\n", eventID );
+        break;
+   }
+   /*===================================================================*
+   // If we get here then no trace record generated.  Normally we 	*	
+   // should get here if this is an entry call.				*
+   //===================================================================*/
+   return( nullRecordFunction( recordType, eventPointer, timeStamp,
 				            dataPointer, dataLength ) );
 }
 /*======================================================================*
@@ -653,33 +621,39 @@ TR_RECORD *miscEventRecord( int recordType,
 //======================================================================*/
 int findHDFProcEvent( int eventID )
 {
-	int	procIndex;
-
-#ifdef DEBUG
-	fprintf( debugFile, "findHDFProcEvent\n" );
-	fflush( debugFile );
-#endif /* DEBUG */
-        if ( isBeginHDFEvent(eventID) ) {
-	   procIndex = eventID - BEGIN_HDF;
-        } else if ( isEndHDFEvent( eventID ) ) {
-	   procIndex = -eventID - BEGIN_HDF;
-	} else {
-	   procIndex = -1 ;
-	}
-	return procIndex;
+   int	procIndex;
+
+#ifdef PABLODEBUG
+   fprintf( debugFile, "findHDFProcEvent\n" );
+   fflush( debugFile );
+#endif /* PABLODEBUG */
+   if ( isBeginHDFEvent(eventID) ) 
+   {
+      procIndex = eventID - BEGIN_HDF;
+   } 
+   else if ( isEndHDFEvent( eventID ) ) 
+   {
+      procIndex = -eventID - BEGIN_HDF;
+   } 
+   else 
+   {
+      procIndex = -1 ;
+   }
+   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 );
+   char BUF1[256]; 
+   char 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									*
@@ -695,61 +669,68 @@ void _hdfTraceDescriptor( char *recordName,
                     	  char *recordDescription,
                           int recordFamily )
 {
-    static char recordBuffer[ 4096 ];
-    int         recordLength;
+   static char recordBuffer[ 4096 ];
+   int         recordLength;
+
+   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, ( recordFamily | RECORD_TRACE ) );
+   sddfWriteString( &hdfRecordPointer, recordName );
+   /*====================================================================
+   // The record attribute count and string pair                       	*
+   //===================================================================*/
+   sddfWriteInteger( &hdfRecordPointer, 1 );
+   sddfWriteString( &hdfRecordPointer, "description" );
+   sddfWriteString( &hdfRecordPointer, recordDescription );
+   /*===================================================================*
+   // The record field count                                           	* 
+   //===================================================================*/
+   sddfWriteInteger( &hdfRecordPointer, 5);
+   /*===================================================================* 
+   // 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_FIELD2( "HDF ID",
+                     "HDF ID", 
+                     "File, Data Set or Dim Identifier number",
+                     "0", 
+                     "No HDF ID specified",
+                     LONG, 
+                     0 ); 
+   WRITE_HDF_FIELD(  "Processor Number", 
+		     "Node", 
+		     "Processor number", 
+		     INTEGER, 
+                     0 );
+   WRITE_HDF_FIELD(  "HDF Name",
+                     "HDF Name", 
+                     "Name of File, Data Set or Dim",
+                     CHARACTER, 
+                     1 );
+
+   recordLength = (int)(hdfRecordPointer - recordBuffer);
 
-    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, ( recordFamily | RECORD_TRACE ) );
-    sddfWriteString( &hdfRecordPointer, recordName );
-    /*===================================================================
-    // The record attribute count and string pair                       *
-    //==================================================================*/
-    sddfWriteInteger( &hdfRecordPointer, 1 );
-    sddfWriteString( &hdfRecordPointer, "description" );
-    sddfWriteString( &hdfRecordPointer, recordDescription );
-    /*==================================================================*
-    // The record field count                                           * 
-    //==================================================================*/
-    sddfWriteInteger( &hdfRecordPointer, 5);
-    /*==================================================================* 
-    // 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_FIELD2( "HDF ID",
-                      "HDF ID", "File, Data Set or Dim Identifier number",
-                      "0", "No HDF ID specified",
-                      LONG, 0 ); 
-    WRITE_HDF_FIELD(  "Processor Number", 
-		      "Node", 
-		      "Processor number", 
-		      INTEGER, 0 );
-    WRITE_HDF_FIELD(  "HDF Name",
-                      "HDF Name", "Name of File, Data Set or Dim",
-                      CHARACTER, 1 );
-
-
-    recordLength = (int)(hdfRecordPointer - recordBuffer);
-
-    hdfRecordPointer = recordBuffer;
-    sddfWriteInteger( &hdfRecordPointer, recordLength );
-
-    putBytes( recordBuffer, (unsigned) recordLength );
+   hdfRecordPointer = recordBuffer;
+   sddfWriteInteger( &hdfRecordPointer, recordLength );
+
+   putBytes( recordBuffer, (unsigned) recordLength );
 }
 /*======================================================================*
 // NAME									*
@@ -766,62 +747,67 @@ void _hdfMiscDescriptor( void )
     static char recordBuffer[ 4096 ];
     int         recordLength;
 
-#ifdef DEBUG
-	fprintf( debugFile, "_hdfMiscDescriptor 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_MISC | RECORD_TRACE ) );
-    sddfWriteString( &hdfRecordPointer, "Misc Trace" );
-    /*==================================================================*
-    // The record attribute count and string pair                       *
-    //==================================================================*/
-    sddfWriteInteger( &hdfRecordPointer, 1 );
-    sddfWriteString( &hdfRecordPointer, "description" );
-    sddfWriteString( &hdfRecordPointer, "Misc Trace 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( "Seconds", 
-		     "Seconds", 
-		     "Floating Point Timestamp", 
-		     DOUBLE, 0 );
-    WRITE_HDF_FIELD( "Duration", 
-		     "Duration", 
-		     "Operation Duration", 
-		     DOUBLE, 0 );
-    WRITE_HDF_FIELD( "Bytes", 
-		     "Bytes", 
-		     "Bytes Requested", 
-		     LONG, 0 );
-    WRITE_HDF_FIELD( "Processor Number", 
-		     "Node", 
-		     "Processor number", 
-		     INTEGER, 0 );
-
-    recordLength = (int)(hdfRecordPointer - recordBuffer);
-
-    hdfRecordPointer = recordBuffer;
-    sddfWriteInteger( &hdfRecordPointer, recordLength );
-
-    putBytes( recordBuffer, (unsigned) recordLength );
+#ifdef PABLODEBUG
+   fprintf( debugFile, "_hdfMiscDescriptor entered\n" );
+   fflush( debugFile );
+#endif /* PABLODEBUG */
+   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_MISC | RECORD_TRACE ) );
+   sddfWriteString( &hdfRecordPointer, "Misc Trace" );
+   /*===================================================================*
+   // The record attribute count and string pair                       	*
+   //===================================================================*/
+   sddfWriteInteger( &hdfRecordPointer, 1 );
+   sddfWriteString( &hdfRecordPointer, "description" );
+   sddfWriteString( &hdfRecordPointer, "Misc Trace 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( "Seconds", 
+		    "Seconds", 
+		    "Floating Point Timestamp", 
+		    DOUBLE, 
+                    0 );
+   WRITE_HDF_FIELD( "Duration", 
+		    "Duration", 
+		    "Operation Duration", 
+		    DOUBLE, 
+                    0 );
+   WRITE_HDF_FIELD( "Bytes", 
+		    "Bytes", 
+		    "Bytes Requested", 
+		    LONG, 
+                    0 );
+   WRITE_HDF_FIELD( "Processor Number", 
+		    "Node", 
+		    "Processor number", 
+		    INTEGER, 
+                    0 );
+
+   recordLength = (int)(hdfRecordPointer - recordBuffer);
+
+   hdfRecordPointer = recordBuffer;
+   sddfWriteInteger( &hdfRecordPointer, recordLength );
+
+   putBytes( recordBuffer, (unsigned) recordLength );
 }
 
 #endif /* PCF_BUILD */