Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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: 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 */