src/third_party/mozjs-45/nsprpub/pr/tests/instrumt.c - cobalt - Git at Google

 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 /*
 ** File:    instrumt.c
 ** Description: This test is for the NSPR debug aids defined in
 ** prcountr.h, prtrace.h, prolock.h
 **
 ** The test case tests the three debug aids in NSPR:
 **
 ** Diagnostic messages can be enabled using "instrumt -v 6"
 ** This sets the msgLevel to something that PR_LOG() likes.
 ** Also define in the environment "NSPR_LOG_MODULES=Test:6"
 **
 ** CounterTest() tests the counter facility. This test
 ** creates 4 threads. Each thread either increments, decrements,
 ** adds to or subtracts from a counter, depending on an argument
 ** passed to the thread at thread-create time. Each of these threads
 ** does COUNT_LIMIT iterations doing its thing. When all 4 threads
 ** are done, the result of the counter is evaluated. If all was atomic,
 ** the the value of the counter should be zero.
 **
 ** TraceTest():
 ** This test mingles with the counter test. Counters trace.
 ** A thread to extract trace entries on the fly is started.
 ** A thread to dump trace entries to a file is started.
 **
 ** OrderedLockTest():
 **
 **
 **
 **
 **
 */

 #include <stdio.h>
 #include <plstr.h>
 #include <prclist.h>
 #include <prmem.h>
 #include <plgetopt.h>
 #include <prlog.h>
 #include <prmon.h>
 #include <pratom.h>
 #include <prtrace.h>
 #include <prcountr.h>
 #include <prolock.h>

 #define COUNT_LIMIT  (10 * ( 1024))

 #define SMALL_TRACE_BUFSIZE  ( 60 * 1024 )

 typedef enum
 {
     CountLoop = 1,
     TraceLoop = 2,
     TraceFlow = 3
 } TraceTypes;


 PRLogModuleLevel msgLevel = PR_LOG_ALWAYS;

 PRBool  help = PR_FALSE;
 PRBool  failed = PR_FALSE;


 PRLogModuleInfo *lm;
 PRMonitor   *mon;
 PRInt32     activeThreads = 0;
 PR_DEFINE_COUNTER( hCounter );
 PR_DEFINE_TRACE( hTrace );

 static void Help(void)
 {
     printf("Help? ... Ha!\n");
 }

 static void ListCounters(void)
 {
     PR_DEFINE_COUNTER( qh );
     PR_DEFINE_COUNTER( rh );
     const char *qn, *rn, *dn;
     const char **qname = &qn, **rname = &rn, **desc = &dn;
     PRUint32    tCtr;

     PR_INIT_COUNTER_HANDLE( qh, NULL );
     PR_FIND_NEXT_COUNTER_QNAME(qh, qh );
     while ( qh != NULL )
     {
         PR_INIT_COUNTER_HANDLE( rh, NULL );
         PR_FIND_NEXT_COUNTER_RNAME(rh, rh, qh );
         while ( rh != NULL )
         {
             PR_GET_COUNTER_NAME_FROM_HANDLE( rh, qname, rname, desc );
             PR_GET_COUNTER(tCtr, rh);
             PR_LOG( lm, msgLevel,
                 ( "QName: %s  RName: %s  Desc: %s  Value: %ld\n",
                 qn, rn, dn, tCtr ));
             PR_FIND_NEXT_COUNTER_RNAME(rh, rh, qh );
         }
         PR_FIND_NEXT_COUNTER_QNAME(qh, qh);
     }
     return;
 } /* end ListCounters() */

 static void ListTraces(void)
 {
     PR_DEFINE_TRACE( qh );
     PR_DEFINE_TRACE( rh );
     const char *qn, *rn, *dn;
     const char **qname = &qn, **rname = &rn, **desc = &dn;

     PR_INIT_TRACE_HANDLE( qh, NULL );
     PR_FIND_NEXT_TRACE_QNAME(qh, qh );
     while ( qh != NULL )
     {
         PR_INIT_TRACE_HANDLE( rh, NULL );
         PR_FIND_NEXT_TRACE_RNAME(rh, rh, qh );
         while ( rh != NULL )
         {
             PR_GET_TRACE_NAME_FROM_HANDLE( rh, qname, rname, desc );
             PR_LOG( lm, msgLevel,
                 ( "QName: %s  RName: %s  Desc: %s",
                 qn, rn, dn ));
             PR_FIND_NEXT_TRACE_RNAME(rh, rh, qh );
         }
         PR_FIND_NEXT_TRACE_QNAME(qh, qh);
     }
     return;
 } /* end ListCounters() */


 static PRInt32 one = 1;
 static PRInt32 two = 2;
 static PRInt32 three = 3;
 static PRInt32 four = 4;

 /*
 ** Thread to iteratively count something.
 */
 static void PR_CALLBACK CountSomething( void *arg )
 {
     PRInt32 switchVar = *((PRInt32 *)arg);
     PRInt32 i;

     PR_LOG( lm, msgLevel,
         ("CountSomething: begin thread %ld", switchVar ));

     for ( i = 0; i < COUNT_LIMIT ; i++)
     {
         switch ( switchVar )
         {
         case 1 :
             PR_INCREMENT_COUNTER( hCounter );
             break;
         case 2 :
             PR_DECREMENT_COUNTER( hCounter );
             break;
         case 3 :
             PR_ADD_TO_COUNTER( hCounter, 1 );
             break;
         case 4 :
             PR_SUBTRACT_FROM_COUNTER( hCounter, 1 );
             break;
         default :
             PR_ASSERT( 0 );
             break;
         }
         PR_TRACE( hTrace, CountLoop, switchVar, i, 0, 0, 0, 0, 0 );
     } /* end for() */

     PR_LOG( lm, msgLevel,
         ("CounterSomething: end thread %ld", switchVar ));

     PR_EnterMonitor(mon);
     --activeThreads;
     PR_Notify( mon );
     PR_ExitMonitor(mon);

     return;
 } /* end CountSomething() */

 /*
 ** Create the counter threads.
 */
 static void CounterTest( void )
 {
     PRThread *t1, *t2, *t3, *t4;
     PRIntn i = 0;
     PR_DEFINE_COUNTER( tc );
     PR_DEFINE_COUNTER( zCounter );

     PR_LOG( lm, msgLevel,
         ("Begin CounterTest"));

     /*
     ** Test Get and Set of a counter.
     **
     */
     PR_CREATE_COUNTER( zCounter, "Atomic", "get/set test", "test get and set of counter" );
     PR_SET_COUNTER( zCounter, 9 );
     PR_GET_COUNTER( i, zCounter );
     if ( i != 9 )
     {
         failed = PR_TRUE;
         PR_LOG( lm, msgLevel,
             ("Counter set/get failed"));
     }

     activeThreads += 4;
     PR_CREATE_COUNTER( hCounter, "Atomic", "SMP Tests", "test atomic nature of counter" );

     PR_GET_COUNTER_HANDLE_FROM_NAME( tc, "Atomic", "SMP Tests" );
     PR_ASSERT( tc == hCounter );

 	t1 = PR_CreateThread(PR_USER_THREAD,
 	        CountSomething, &one,
 			PR_PRIORITY_NORMAL,
 			PR_GLOBAL_THREAD,
     		PR_UNJOINABLE_THREAD,
 			0);
 	PR_ASSERT(t1);

 	t2 = PR_CreateThread(PR_USER_THREAD,
 			CountSomething, &two,
 			PR_PRIORITY_NORMAL,
 			PR_GLOBAL_THREAD,
     		PR_UNJOINABLE_THREAD,
 			0);
 	PR_ASSERT(t2);

 	t3 = PR_CreateThread(PR_USER_THREAD,
 			CountSomething, &three,
 			PR_PRIORITY_NORMAL,
 			PR_GLOBAL_THREAD,
     		PR_UNJOINABLE_THREAD,
 			0);
 	PR_ASSERT(t3);

 	t4 = PR_CreateThread(PR_USER_THREAD,
 			CountSomething, &four,
 			PR_PRIORITY_NORMAL,
 			PR_GLOBAL_THREAD,
     		PR_UNJOINABLE_THREAD,
 			0);
 	PR_ASSERT(t4);

     PR_LOG( lm, msgLevel,
         ("Counter Threads started"));

     ListCounters();
     return;
 } /* end CounterTest() */

 /*
 ** Thread to dump trace buffer to a file.
 */
 static void PR_CALLBACK RecordTrace(void *arg )
 {
     PR_RECORD_TRACE_ENTRIES();

     PR_EnterMonitor(mon);
     --activeThreads;
     PR_Notify( mon );
     PR_ExitMonitor(mon);

     return;
 } /* end RecordTrace() */


 #define NUM_TRACE_RECORDS ( 10000 )
 /*
 ** Thread to extract and print trace entries from the buffer.
 */
 static void PR_CALLBACK SampleTrace( void *arg )
 {
 #if defined(DEBUG) || defined(FORCE_NSPR_TRACE)
     PRInt32 found, rc;
     PRTraceEntry    *foundEntries;
     PRInt32 i;

     foundEntries = (PRTraceEntry *)PR_Malloc( NUM_TRACE_RECORDS * sizeof(PRTraceEntry));
     PR_ASSERT(foundEntries != NULL );

     do
     {
         rc = PR_GetTraceEntries( foundEntries, NUM_TRACE_RECORDS, &found);
         PR_LOG( lm, msgLevel,
             ("SampleTrace: Lost Data: %ld found: %ld", rc, found ));

         if ( found != 0)
         {
             for ( i = 0 ; i < found; i++ )
             {
                 PR_LOG( lm, msgLevel,
                     ("SampleTrace, detail: Thread: %p, Time: %llX, UD0: %ld, UD1: %ld, UD2: %8.8ld",
                         (foundEntries +i)->thread,
                         (foundEntries +i)->time,
                         (foundEntries +i)->userData[0],
                         (foundEntries +i)->userData[1],
                         (foundEntries +i)->userData[2] ));
             }
         }
         PR_Sleep(PR_MillisecondsToInterval(50));
     }
     while( found != 0 && activeThreads >= 1 );

     PR_Free( foundEntries );

     PR_EnterMonitor(mon);
     --activeThreads;
     PR_Notify( mon );
     PR_ExitMonitor(mon);

     PR_LOG( lm, msgLevel,
         ("SampleTrace(): exiting"));

 #endif
     return;
 } /* end RecordTrace() */

 /*
 ** Basic trace test.
 */
 static void TraceTest( void )
 {
     PRInt32 i;
     PRInt32 size;
     PR_DEFINE_TRACE( th );
     PRThread *t1, *t2;

     PR_LOG( lm, msgLevel,
         ("Begin TraceTest"));

     size = SMALL_TRACE_BUFSIZE;
     PR_SET_TRACE_OPTION( PRTraceBufSize, &size );
     PR_GET_TRACE_OPTION( PRTraceBufSize, &i );

     PR_CREATE_TRACE( th, "TraceTest", "tt2", "A description for the trace test" );
     PR_CREATE_TRACE( th, "TraceTest", "tt3", "A description for the trace test" );
     PR_CREATE_TRACE( th, "TraceTest", "tt4", "A description for the trace test" );
     PR_CREATE_TRACE( th, "TraceTest", "tt5", "A description for the trace test" );
     PR_CREATE_TRACE( th, "TraceTest", "tt6", "A description for the trace test" );
     PR_CREATE_TRACE( th, "TraceTest", "tt7", "A description for the trace test" );
     PR_CREATE_TRACE( th, "TraceTest", "tt8", "A description for the trace test" );

     PR_CREATE_TRACE( th, "Trace Test", "tt0", "QName is Trace Test, not TraceTest" );
     PR_CREATE_TRACE( th, "Trace Test", "tt1", "QName is Trace Test, not TraceTest" );
     PR_CREATE_TRACE( th, "Trace Test", "tt2", "QName is Trace Test, not TraceTest" );
     PR_CREATE_TRACE( th, "Trace Test", "tt3", "QName is Trace Test, not TraceTest" );
     PR_CREATE_TRACE( th, "Trace Test", "tt4", "QName is Trace Test, not TraceTest" );
     PR_CREATE_TRACE( th, "Trace Test", "tt5", "QName is Trace Test, not TraceTest" );
     PR_CREATE_TRACE( th, "Trace Test", "tt6", "QName is Trace Test, not TraceTest" );
     PR_CREATE_TRACE( th, "Trace Test", "tt7", "QName is Trace Test, not TraceTest" );
     PR_CREATE_TRACE( th, "Trace Test", "tt8", "QName is Trace Test, not TraceTest" );
     PR_CREATE_TRACE( th, "Trace Test", "tt9", "QName is Trace Test, not TraceTest" );
     PR_CREATE_TRACE( th, "Trace Test", "tt10", "QName is Trace Test, not TraceTest" );


     activeThreads += 2;
 	t1 = PR_CreateThread(PR_USER_THREAD,
 			RecordTrace, NULL,
 			PR_PRIORITY_NORMAL,
 			PR_GLOBAL_THREAD,
     		PR_UNJOINABLE_THREAD,
 			0);
 	PR_ASSERT(t1);

 	t2 = PR_CreateThread(PR_USER_THREAD,
 			SampleTrace, 0,
 			PR_PRIORITY_NORMAL,
 			PR_GLOBAL_THREAD,
     		PR_UNJOINABLE_THREAD,
 			0);
 	PR_ASSERT(t2);

     ListTraces();

     PR_GET_TRACE_HANDLE_FROM_NAME( th, "TraceTest","tt1" );
     PR_ASSERT( th == hTrace );

     PR_LOG( lm, msgLevel,
         ("End TraceTest"));
     return;
 } /* end TraceTest() */


 /*
 ** Ordered lock test.
 */
 static void OrderedLockTest( void )
 {
     PR_LOG( lm, msgLevel,
         ("Begin OrderedLockTest"));


 } /* end OrderedLockTest() */


 int main(int argc, char **argv)
 {
 #if defined(DEBUG) || defined(FORCE_NSPR_TRACE)
     PRUint32    counter;
     PLOptStatus os;
     PLOptState *opt = PL_CreateOptState(argc, argv, "hdv:");
     lm = PR_NewLogModule("Test");

 	while (PL_OPT_EOL != (os = PL_GetNextOpt(opt)))
     {
 		if (PL_OPT_BAD == os) continue;
         switch (opt->option)
         {
         case 'v':  /* verbose mode */
 			msgLevel = (PRLogModuleLevel)atol( opt->value);
             break;
         case 'h':  /* help message */
 			Help();
 			help = PR_TRUE;
             break;
          default:
             break;
         }
     }
 	PL_DestroyOptState(opt);

     PR_CREATE_TRACE( hTrace, "TraceTest", "tt1", "A description for the trace test" );
     mon = PR_NewMonitor();
     PR_EnterMonitor( mon );

     TraceTest();
     CounterTest();
     OrderedLockTest();

     /* Wait for all threads to exit */
     while ( activeThreads > 0 ) {
         if ( activeThreads == 1 )
             PR_SET_TRACE_OPTION( PRTraceStopRecording, NULL );
     	PR_Wait(mon, PR_INTERVAL_NO_TIMEOUT);
         PR_GET_COUNTER( counter, hCounter );
     }
     PR_ExitMonitor( mon );

     /*
     ** Evaluate results
     */
     PR_GET_COUNTER( counter, hCounter );
     if ( counter != 0 )
     {
         failed = PR_TRUE;
         PR_LOG( lm, msgLevel,
             ("Expected counter == 0, found: %ld", counter));
         printf("FAIL\n");
     }
     else
     {
         printf("PASS\n");
     }


     PR_DESTROY_COUNTER( hCounter );

     PR_DestroyMonitor( mon );

     PR_TRACE( hTrace, TraceFlow, 0xfff,0,0,0,0,0,0);
     PR_DESTROY_TRACE( hTrace );
 #else
     printf("Test not defined\n");
 #endif
     return 0;
 }  /* main() */
 /* end instrumt.c */
	/* -- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -- */
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

	/*
	** File: instrumt.c
	** Description: This test is for the NSPR debug aids defined in
	** prcountr.h, prtrace.h, prolock.h
	**
	** The test case tests the three debug aids in NSPR:
	**
	** Diagnostic messages can be enabled using "instrumt -v 6"
	** This sets the msgLevel to something that PR_LOG() likes.
	** Also define in the environment "NSPR_LOG_MODULES=Test:6"
	**
	** CounterTest() tests the counter facility. This test
	** creates 4 threads. Each thread either increments, decrements,
	** adds to or subtracts from a counter, depending on an argument
	** passed to the thread at thread-create time. Each of these threads
	** does COUNT_LIMIT iterations doing its thing. When all 4 threads
	** are done, the result of the counter is evaluated. If all was atomic,
	** the the value of the counter should be zero.
	**
	** TraceTest():
	** This test mingles with the counter test. Counters trace.
	** A thread to extract trace entries on the fly is started.
	** A thread to dump trace entries to a file is started.
	**
	** OrderedLockTest():
	**
	**
	**
	**
	**
	*/

	#include <stdio.h>
	#include <plstr.h>
	#include <prclist.h>
	#include <prmem.h>
	#include <plgetopt.h>
	#include <prlog.h>
	#include <prmon.h>
	#include <pratom.h>
	#include <prtrace.h>
	#include <prcountr.h>
	#include <prolock.h>

	#define COUNT_LIMIT (10 * ( 1024))

	#define SMALL_TRACE_BUFSIZE ( 60 * 1024 )

	typedef enum
	{
	CountLoop = 1,
	TraceLoop = 2,
	TraceFlow = 3
	} TraceTypes;


	PRLogModuleLevel msgLevel = PR_LOG_ALWAYS;

	PRBool help = PR_FALSE;
	PRBool failed = PR_FALSE;


	PRLogModuleInfo *lm;
	PRMonitor *mon;
	PRInt32 activeThreads = 0;
	PR_DEFINE_COUNTER( hCounter );
	PR_DEFINE_TRACE( hTrace );

	static void Help(void)
	{
	printf("Help? ... Ha!\n");
	}

	static void ListCounters(void)
	{
	PR_DEFINE_COUNTER( qh );
	PR_DEFINE_COUNTER( rh );
	const char qn, rn, *dn;
	const char qname = &qn, rname = &rn, **desc = &dn;
	PRUint32 tCtr;

	PR_INIT_COUNTER_HANDLE( qh, NULL );
	PR_FIND_NEXT_COUNTER_QNAME(qh, qh );
	while ( qh != NULL )
	{
	PR_INIT_COUNTER_HANDLE( rh, NULL );
	PR_FIND_NEXT_COUNTER_RNAME(rh, rh, qh );
	while ( rh != NULL )
	{
	PR_GET_COUNTER_NAME_FROM_HANDLE( rh, qname, rname, desc );
	PR_GET_COUNTER(tCtr, rh);
	PR_LOG( lm, msgLevel,
	( "QName: %s RName: %s Desc: %s Value: %ld\n",
	qn, rn, dn, tCtr ));
	PR_FIND_NEXT_COUNTER_RNAME(rh, rh, qh );
	}
	PR_FIND_NEXT_COUNTER_QNAME(qh, qh);
	}
	return;
	} /* end ListCounters() */

	static void ListTraces(void)
	{
	PR_DEFINE_TRACE( qh );
	PR_DEFINE_TRACE( rh );
	const char qn, rn, *dn;
	const char qname = &qn, rname = &rn, **desc = &dn;

	PR_INIT_TRACE_HANDLE( qh, NULL );
	PR_FIND_NEXT_TRACE_QNAME(qh, qh );
	while ( qh != NULL )
	{
	PR_INIT_TRACE_HANDLE( rh, NULL );
	PR_FIND_NEXT_TRACE_RNAME(rh, rh, qh );
	while ( rh != NULL )
	{
	PR_GET_TRACE_NAME_FROM_HANDLE( rh, qname, rname, desc );
	PR_LOG( lm, msgLevel,
	( "QName: %s RName: %s Desc: %s",
	qn, rn, dn ));
	PR_FIND_NEXT_TRACE_RNAME(rh, rh, qh );
	}
	PR_FIND_NEXT_TRACE_QNAME(qh, qh);
	}
	return;
	} /* end ListCounters() */


	static PRInt32 one = 1;
	static PRInt32 two = 2;
	static PRInt32 three = 3;
	static PRInt32 four = 4;

	/*
	** Thread to iteratively count something.
	*/
	static void PR_CALLBACK CountSomething( void *arg )
	{
	PRInt32 switchVar = ((PRInt32 )arg);
	PRInt32 i;

	PR_LOG( lm, msgLevel,
	("CountSomething: begin thread %ld", switchVar ));

	for ( i = 0; i < COUNT_LIMIT ; i++)
	{
	switch ( switchVar )
	{
	case 1 :
	PR_INCREMENT_COUNTER( hCounter );
	break;
	case 2 :
	PR_DECREMENT_COUNTER( hCounter );
	break;
	case 3 :
	PR_ADD_TO_COUNTER( hCounter, 1 );
	break;
	case 4 :
	PR_SUBTRACT_FROM_COUNTER( hCounter, 1 );
	break;
	default :
	PR_ASSERT( 0 );
	break;
	}
	PR_TRACE( hTrace, CountLoop, switchVar, i, 0, 0, 0, 0, 0 );
	} /* end for() */

	PR_LOG( lm, msgLevel,
	("CounterSomething: end thread %ld", switchVar ));

	PR_EnterMonitor(mon);
	--activeThreads;
	PR_Notify( mon );
	PR_ExitMonitor(mon);

	return;
	} /* end CountSomething() */

	/*
	** Create the counter threads.
	*/
	static void CounterTest( void )
	{
	PRThread t1, t2, t3, t4;
	PRIntn i = 0;
	PR_DEFINE_COUNTER( tc );
	PR_DEFINE_COUNTER( zCounter );

	PR_LOG( lm, msgLevel,
	("Begin CounterTest"));

	/*
	** Test Get and Set of a counter.
	**
	*/
	PR_CREATE_COUNTER( zCounter, "Atomic", "get/set test", "test get and set of counter" );
	PR_SET_COUNTER( zCounter, 9 );
	PR_GET_COUNTER( i, zCounter );
	if ( i != 9 )
	{
	failed = PR_TRUE;
	PR_LOG( lm, msgLevel,
	("Counter set/get failed"));
	}

	activeThreads += 4;
	PR_CREATE_COUNTER( hCounter, "Atomic", "SMP Tests", "test atomic nature of counter" );

	PR_GET_COUNTER_HANDLE_FROM_NAME( tc, "Atomic", "SMP Tests" );
	PR_ASSERT( tc == hCounter );

	t1 = PR_CreateThread(PR_USER_THREAD,
	CountSomething, &one,
	PR_PRIORITY_NORMAL,
	PR_GLOBAL_THREAD,
	PR_UNJOINABLE_THREAD,
	0);
	PR_ASSERT(t1);

	t2 = PR_CreateThread(PR_USER_THREAD,
	CountSomething, &two,
	PR_PRIORITY_NORMAL,
	PR_GLOBAL_THREAD,
	PR_UNJOINABLE_THREAD,
	0);
	PR_ASSERT(t2);

	t3 = PR_CreateThread(PR_USER_THREAD,
	CountSomething, &three,
	PR_PRIORITY_NORMAL,
	PR_GLOBAL_THREAD,
	PR_UNJOINABLE_THREAD,
	0);
	PR_ASSERT(t3);

	t4 = PR_CreateThread(PR_USER_THREAD,
	CountSomething, &four,
	PR_PRIORITY_NORMAL,
	PR_GLOBAL_THREAD,
	PR_UNJOINABLE_THREAD,
	0);
	PR_ASSERT(t4);

	PR_LOG( lm, msgLevel,
	("Counter Threads started"));

	ListCounters();
	return;
	} /* end CounterTest() */

	/*
	** Thread to dump trace buffer to a file.
	*/
	static void PR_CALLBACK RecordTrace(void *arg )
	{
	PR_RECORD_TRACE_ENTRIES();

	PR_EnterMonitor(mon);
	--activeThreads;
	PR_Notify( mon );
	PR_ExitMonitor(mon);

	return;
	} /* end RecordTrace() */



	#define NUM_TRACE_RECORDS ( 10000 )
	/*
	** Thread to extract and print trace entries from the buffer.
	*/
	static void PR_CALLBACK SampleTrace( void *arg )
	{
	#if defined(DEBUG) \|\| defined(FORCE_NSPR_TRACE)
	PRInt32 found, rc;
	PRTraceEntry *foundEntries;
	PRInt32 i;

	foundEntries = (PRTraceEntry )PR_Malloc( NUM_TRACE_RECORDS sizeof(PRTraceEntry));
	PR_ASSERT(foundEntries != NULL );

	do
	{
	rc = PR_GetTraceEntries( foundEntries, NUM_TRACE_RECORDS, &found);
	PR_LOG( lm, msgLevel,
	("SampleTrace: Lost Data: %ld found: %ld", rc, found ));

	if ( found != 0)
	{
	for ( i = 0 ; i < found; i++ )
	{
	PR_LOG( lm, msgLevel,
	("SampleTrace, detail: Thread: %p, Time: %llX, UD0: %ld, UD1: %ld, UD2: %8.8ld",
	(foundEntries +i)->thread,
	(foundEntries +i)->time,
	(foundEntries +i)->userData[0],
	(foundEntries +i)->userData[1],
	(foundEntries +i)->userData[2] ));
	}
	}
	PR_Sleep(PR_MillisecondsToInterval(50));
	}
	while( found != 0 && activeThreads >= 1 );

	PR_Free( foundEntries );

	PR_EnterMonitor(mon);
	--activeThreads;
	PR_Notify( mon );
	PR_ExitMonitor(mon);

	PR_LOG( lm, msgLevel,
	("SampleTrace(): exiting"));

	#endif
	return;
	} /* end RecordTrace() */

	/*
	** Basic trace test.
	*/
	static void TraceTest( void )
	{
	PRInt32 i;
	PRInt32 size;
	PR_DEFINE_TRACE( th );
	PRThread t1, t2;

	PR_LOG( lm, msgLevel,
	("Begin TraceTest"));

	size = SMALL_TRACE_BUFSIZE;
	PR_SET_TRACE_OPTION( PRTraceBufSize, &size );
	PR_GET_TRACE_OPTION( PRTraceBufSize, &i );

	PR_CREATE_TRACE( th, "TraceTest", "tt2", "A description for the trace test" );
	PR_CREATE_TRACE( th, "TraceTest", "tt3", "A description for the trace test" );
	PR_CREATE_TRACE( th, "TraceTest", "tt4", "A description for the trace test" );
	PR_CREATE_TRACE( th, "TraceTest", "tt5", "A description for the trace test" );
	PR_CREATE_TRACE( th, "TraceTest", "tt6", "A description for the trace test" );
	PR_CREATE_TRACE( th, "TraceTest", "tt7", "A description for the trace test" );
	PR_CREATE_TRACE( th, "TraceTest", "tt8", "A description for the trace test" );

	PR_CREATE_TRACE( th, "Trace Test", "tt0", "QName is Trace Test, not TraceTest" );
	PR_CREATE_TRACE( th, "Trace Test", "tt1", "QName is Trace Test, not TraceTest" );
	PR_CREATE_TRACE( th, "Trace Test", "tt2", "QName is Trace Test, not TraceTest" );
	PR_CREATE_TRACE( th, "Trace Test", "tt3", "QName is Trace Test, not TraceTest" );
	PR_CREATE_TRACE( th, "Trace Test", "tt4", "QName is Trace Test, not TraceTest" );
	PR_CREATE_TRACE( th, "Trace Test", "tt5", "QName is Trace Test, not TraceTest" );
	PR_CREATE_TRACE( th, "Trace Test", "tt6", "QName is Trace Test, not TraceTest" );
	PR_CREATE_TRACE( th, "Trace Test", "tt7", "QName is Trace Test, not TraceTest" );
	PR_CREATE_TRACE( th, "Trace Test", "tt8", "QName is Trace Test, not TraceTest" );
	PR_CREATE_TRACE( th, "Trace Test", "tt9", "QName is Trace Test, not TraceTest" );
	PR_CREATE_TRACE( th, "Trace Test", "tt10", "QName is Trace Test, not TraceTest" );



	activeThreads += 2;
	t1 = PR_CreateThread(PR_USER_THREAD,
	RecordTrace, NULL,
	PR_PRIORITY_NORMAL,
	PR_GLOBAL_THREAD,
	PR_UNJOINABLE_THREAD,
	0);
	PR_ASSERT(t1);

	t2 = PR_CreateThread(PR_USER_THREAD,
	SampleTrace, 0,
	PR_PRIORITY_NORMAL,
	PR_GLOBAL_THREAD,
	PR_UNJOINABLE_THREAD,
	0);
	PR_ASSERT(t2);

	ListTraces();

	PR_GET_TRACE_HANDLE_FROM_NAME( th, "TraceTest","tt1" );
	PR_ASSERT( th == hTrace );

	PR_LOG( lm, msgLevel,
	("End TraceTest"));
	return;
	} /* end TraceTest() */


	/*
	** Ordered lock test.
	*/
	static void OrderedLockTest( void )
	{
	PR_LOG( lm, msgLevel,
	("Begin OrderedLockTest"));


	} /* end OrderedLockTest() */


	int main(int argc, char **argv)
	{
	#if defined(DEBUG) \|\| defined(FORCE_NSPR_TRACE)
	PRUint32 counter;
	PLOptStatus os;
	PLOptState *opt = PL_CreateOptState(argc, argv, "hdv:");
	lm = PR_NewLogModule("Test");

	while (PL_OPT_EOL != (os = PL_GetNextOpt(opt)))
	{
	if (PL_OPT_BAD == os) continue;
	switch (opt->option)
	{
	case 'v': /* verbose mode */
	msgLevel = (PRLogModuleLevel)atol( opt->value);
	break;
	case 'h': /* help message */
	Help();
	help = PR_TRUE;
	break;
	default:
	break;
	}
	}
	PL_DestroyOptState(opt);

	PR_CREATE_TRACE( hTrace, "TraceTest", "tt1", "A description for the trace test" );
	mon = PR_NewMonitor();
	PR_EnterMonitor( mon );

	TraceTest();
	CounterTest();
	OrderedLockTest();

	/* Wait for all threads to exit */
	while ( activeThreads > 0 ) {
	if ( activeThreads == 1 )
	PR_SET_TRACE_OPTION( PRTraceStopRecording, NULL );
	PR_Wait(mon, PR_INTERVAL_NO_TIMEOUT);
	PR_GET_COUNTER( counter, hCounter );
	}
	PR_ExitMonitor( mon );

	/*
	** Evaluate results
	*/
	PR_GET_COUNTER( counter, hCounter );
	if ( counter != 0 )
	{
	failed = PR_TRUE;
	PR_LOG( lm, msgLevel,
	("Expected counter == 0, found: %ld", counter));
	printf("FAIL\n");
	}
	else
	{
	printf("PASS\n");
	}


	PR_DESTROY_COUNTER( hCounter );

	PR_DestroyMonitor( mon );

	PR_TRACE( hTrace, TraceFlow, 0xfff,0,0,0,0,0,0);
	PR_DESTROY_TRACE( hTrace );
	#else
	printf("Test not defined\n");
	#endif
	return 0;
	} /* main() */
	/* end instrumt.c */