//-------------------------------------------------------------------------
//
// Create a new thread and run the message pump in there
//
//-------------------------------------------------------------------------
void nsToolkit::CreateUIThread()
{
PRMonitor *monitor = ::PR_NewMonitor();
PR_EnterMonitor(monitor);
ThreadInitInfo *ti = new ThreadInitInfo();
if (ti)
{
ti->monitor = monitor;
ti->toolkit = this;
// create a gui thread
mGuiThread = PR_CreateThread(PR_SYSTEM_THREAD,
RunPump,
(void*)ti,
PR_PRIORITY_HIGH,
PR_LOCAL_THREAD,
PR_UNJOINABLE_THREAD,
0);
// wait for the gui thread to start
while(gThreadState == PR_FALSE)
{
PR_Wait(monitor, PR_INTERVAL_NO_TIMEOUT);
}
}
image_info iinfo;
int32 cookie = 0;
char *leaf = NULL;
do {
if (get_next_image_info(0, &cookie, &iinfo) == B_OK &&
strlen(iinfo.name) > 0 &&
(leaf = strrchr(iinfo.name, '/')) != NULL)
{
leaf++;
mGUIThreadID = find_thread(leaf);
}
else
{
mGUIThreadID = find_thread(0);
}
} while(iinfo.type != B_APP_IMAGE);
// at this point the thread is running
PR_ExitMonitor(monitor);
PR_DestroyMonitor(monitor);
}
/*
* The write-thread is spawned on a timeout(which is reset with every write). This
* can avoid a slow shutdown. After writing out the cache, the zipreader is
* reloaded on the worker thread.
*/
void
StartupCache::WriteTimeout(nsITimer *aTimer, void *aClosure)
{
gStartupCache->mWriteThread = PR_CreateThread(PR_USER_THREAD,
StartupCache::ThreadedWrite,
NULL,
PR_PRIORITY_NORMAL,
PR_LOCAL_THREAD,
PR_JOINABLE_THREAD,
0);
}
nsresult
ClosingService::StartInternal()
{
mThread = PR_CreateThread(PR_USER_THREAD, ThreadFunc, this,
PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,
PR_JOINABLE_THREAD, 32 * 1024);
if (!mThread) {
return NS_ERROR_FAILURE;
}
return NS_OK;
}
PRIntn main ()
{
PRUint32 elapsed;
PRThread *thread;
struct timeval timein, timeout;
PRInt32 onePercent = 3000000UL / 100UL;
fprintf (stderr, "First sleep will sleep 3 seconds.\n");
fprintf (stderr, " sleep 1 begin\n");
(void)GTOD(&timein);
sleep (3);
(void)GTOD(&timeout);
fprintf (stderr, " sleep 1 end\n");
elapsed = 1000000UL * (timeout.tv_sec - timein.tv_sec);
elapsed += (timeout.tv_usec - timein.tv_usec);
fprintf(stderr, "elapsed %u usecs\n", elapsed);
if (labs(elapsed - 3000000UL) > onePercent) rv = 1;
PR_Init (PR_USER_THREAD, PR_PRIORITY_NORMAL, 100);
PR_STDIO_INIT();
fprintf (stderr, "Second sleep should do the same (does it?).\n");
fprintf (stderr, " sleep 2 begin\n");
(void)GTOD(&timein);
sleep (3);
(void)GTOD(&timeout);
fprintf (stderr, " sleep 2 end\n");
elapsed = 1000000UL * (timeout.tv_sec - timein.tv_sec);
elapsed += (timeout.tv_usec - timein.tv_usec);
fprintf(stderr, "elapsed %u usecs\n", elapsed);
if (labs(elapsed - 3000000UL) > onePercent) rv = 1;
fprintf (stderr, "What happens to other threads?\n");
fprintf (stderr, "You should see dots every quarter second.\n");
fprintf (stderr, "If you don't, you're probably running on classic NSPR.\n");
thread = PR_CreateThread(
PR_USER_THREAD, Other, NULL, PR_PRIORITY_NORMAL,
PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0);
fprintf (stderr, " sleep 2 begin\n");
(void)GTOD(&timein);
sleep (3);
(void)GTOD(&timeout);
fprintf (stderr, " sleep 2 end\n");
PR_Interrupt(thread);
PR_JoinThread(thread);
elapsed = 1000000UL * (timeout.tv_sec - timein.tv_sec);
elapsed += (timeout.tv_usec - timein.tv_usec);
fprintf(stderr, "elapsed %u usecs\n", elapsed);
if (labs(elapsed - 3000000UL) > onePercent) rv = 1;
fprintf(stderr, "%s\n", (0 == rv) ? "PASSED" : "FAILED");
return rv;
}
thread_t thread_create(thread_proc_t start, void *param) {
thread_t *rv;
return (thread_t)PR_CreateThread(
PR_USER_THREAD,
start,
param,
PR_PRIORITY_LOW,
PR_GLOBAL_THREAD,
PR_JOINABLE_THREAD,
0
);
return rv;
}
static void T1CMon(void)
{
PRStatus rv;
PRThread *t2, *t3;
PR_fprintf(err, "\n**********************************\n");
PR_fprintf(err, " CACHED MONITORS\n");
PR_fprintf(err, "**********************************\n");
base = PR_IntervalNow();
PR_CEnterMonitor(&sharedCM.o1);
LogNow("T1 waiting 3 seconds on o1", PR_SUCCESS);
rv = PR_CWait(&sharedCM.o1, PR_SecondsToInterval(3));
if (PR_SUCCESS == rv) LogNow("T1 resuming on o1", rv);
else LogNow("T1 wait on o1 failed", rv);
PR_CExitMonitor(&sharedCM.o1);
LogNow("T1 creating T2", PR_SUCCESS);
t2 = PR_CreateThread(
PR_USER_THREAD, T2CMon, &sharedCM, PR_PRIORITY_NORMAL,
PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0);
LogNow("T1 creating T3", PR_SUCCESS);
t3 = PR_CreateThread(
PR_USER_THREAD, T3CMon, &sharedCM, PR_PRIORITY_NORMAL,
PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0);
PR_CEnterMonitor(&sharedCM.o2);
LogNow("T1 waiting forever on o2", PR_SUCCESS);
rv = PR_CWait(&sharedCM.o2, PR_INTERVAL_NO_TIMEOUT);
if (PR_SUCCESS == rv) LogNow("T1 resuming on o2", rv);
else LogNow("T1 wait on o2 failed", rv);
PR_CExitMonitor(&sharedCM.o2);
(void)PR_JoinThread(t2);
(void)PR_JoinThread(t3);
} /* T1CMon */
/*
* eq_start: start the event queue system.
*
* This should be called exactly once. It will start a
* thread which wakes up periodically and schedules events.
*/
void
eq_start()
{
PR_ASSERT(eq_initialized);
eq_running = 1;
if ((eq_loop_tid = PR_CreateThread(PR_USER_THREAD, (VFP)eq_loop,
NULL, PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD, PR_JOINABLE_THREAD,
SLAPD_DEFAULT_THREAD_STACKSIZE)) == NULL) {
slapi_log_error(SLAPI_LOG_FATAL, NULL, "eq_init PR_CreateThread failed\n");
exit(1);
}
slapi_log_error(SLAPI_LOG_HOUSE, NULL, "event queue services have started\n");
}
GraphRunner::GraphRunner(MediaStreamGraphImpl* aGraph)
: mMonitor("GraphRunner::mMonitor"),
mGraph(aGraph),
mStateEnd(0),
mStillProcessing(true),
mThreadState(ThreadState::Wait),
// Note that mThread needs to be initialized last, as it may pre-empt the
// thread running this ctor and enter Run() with uninitialized members.
mThread(PR_CreateThread(PR_SYSTEM_THREAD, &Start, this,
PR_PRIORITY_URGENT, PR_GLOBAL_THREAD,
PR_JOINABLE_THREAD, 0)) {
MOZ_COUNT_CTOR(GraphRunner);
}
/*
* add a job to the work queue
*/
static void
add_to_jobq(PRThreadPool *tp, PRJob *jobp)
{
/*
* add to jobq
*/
#ifdef OPT_WINNT
PR_Lock(tp->jobq.lock);
tp->jobq.cnt++;
PR_Unlock(tp->jobq.lock);
/*
* notify worker thread(s)
*/
PostQueuedCompletionStatus(tp->jobq.nt_completion_port, 0,
FALSE, &jobp->nt_notifier.overlapped);
#else
PR_Lock(tp->jobq.lock);
PR_APPEND_LINK(&jobp->links,&tp->jobq.list);
tp->jobq.cnt++;
if ((tp->idle_threads < tp->jobq.cnt) &&
(tp->current_threads < tp->max_threads)) {
wthread *wthrp;
/*
* increment thread count and unlock the jobq lock
*/
tp->current_threads++;
PR_Unlock(tp->jobq.lock);
/* create new worker thread */
wthrp = PR_NEWZAP(wthread);
if (wthrp) {
wthrp->thread = PR_CreateThread(PR_USER_THREAD, wstart,
tp, PR_PRIORITY_NORMAL,
PR_GLOBAL_THREAD,PR_JOINABLE_THREAD,tp->stacksize);
if (NULL == wthrp->thread) {
PR_DELETE(wthrp); /* this sets wthrp to NULL */
}
}
PR_Lock(tp->jobq.lock);
if (NULL == wthrp) {
tp->current_threads--;
} else {
PR_APPEND_LINK(&wthrp->links, &tp->jobq.wthreads);
}
}
/*
* wakeup a worker thread
*/
PR_NotifyCondVar(tp->jobq.cv);
PR_Unlock(tp->jobq.lock);
#endif
}
BackgroundHangManager::BackgroundHangManager()
: mShutdown(false)
, mLock("BackgroundHangManager")
, mIntervalNow(0)
{
// Lock so we don't race against the new monitor thread
MonitorAutoLock autoLock(mLock);
mHangMonitorThread = PR_CreateThread(
PR_USER_THREAD, MonitorThread, this,
PR_PRIORITY_LOW, PR_GLOBAL_THREAD, PR_JOINABLE_THREAD, 0);
MOZ_ASSERT(mHangMonitorThread,
"Failed to create monitor thread");
}
static PRTime
CalculateProcessCreationTimestamp()
{
PRThread *thread = PR_CreateThread(PR_USER_THREAD,
ThreadedCalculateProcessCreationTimestamp,
NULL,
PR_PRIORITY_NORMAL,
PR_LOCAL_THREAD,
PR_JOINABLE_THREAD,
0);
PR_JoinThread(thread);
return gProcessCreationTimestamp;
}
nsresult
VideoSourceCanvas::Start(nsIDOMCanvasRenderingContext2D *ctx)
{
if (!g2g)
return NS_ERROR_FAILURE;
vCanvas = ctx;
running = PR_TRUE;
sampler = PR_CreateThread(
PR_SYSTEM_THREAD, VideoSourceCanvas::Grabber, this,
PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD, PR_JOINABLE_THREAD, 0
);
return NS_OK;
}
NPError
nsPluginInstance::DestroyStream(NPStream *stream, NPError reason)
{
DBG("nsPluginInstance::DestroyStream\n");
DBG("stream->url: %s\n", stream->url);
// N.B. We can only support one Gnash VM/thread right now.
if (!_thread) {
_thread = PR_CreateThread(PR_USER_THREAD, playerThread, this,
PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD, PR_JOINABLE_THREAD, 0);
}
return NPERR_NO_ERROR;
}
uint64_t
TimeStamp::ComputeProcessUptime()
{
uint64_t uptime = 0;
PRThread *thread = PR_CreateThread(PR_USER_THREAD,
ComputeProcessUptimeThread,
&uptime,
PR_PRIORITY_NORMAL,
PR_LOCAL_THREAD,
PR_JOINABLE_THREAD,
0);
PR_JoinThread(thread);
return uptime / kNsPerUs;
}
void NeverStops(void *unused)
{
int i = 0;
printf("The child sproc has pid %d.\n", getpid());
printf("The child sproc won't stop on its own.\n");
fflush(stdout);
/* create the grandchild sproc */
PR_CreateThread(PR_USER_THREAD, SegFault, NULL,
PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD, PR_UNJOINABLE_THREAD, 0);
while (1) {
i++;
}
}
JD_METHOD_(void*) CNSAdapter_NSPR::JD_CreateThread(JDThreadType type,
void (*start)(void* arg),
void* arg,
JDThreadPriority priority,
JDThreadScope scope,
JDThreadState state,
JDUint32 stackSize)
{
return PR_CreateThread((PRThreadType)type,
start,
arg,
(PRThreadPriority)priority,
(PRThreadScope)scope,
(PRThreadState)state,
(PRUint32)stackSize);
}
void
thread_test(PRInt32 scope, PRInt32 num_threads)
{
PRInt32 index;
PRThread *thr;
PRLock *dead_lock;
PRCondVar *dead_cv;
PRInt32 alive;
if (debug_mode) printf("IO Timeout test started with %d threads\n", num_threads);
dead_lock = PR_NewLock();
dead_cv = PR_NewCondVar(dead_lock);
alive = num_threads;
for (index = 0; index < num_threads; index++) {
threadInfo *info = (threadInfo *)malloc(sizeof(threadInfo));
info->id = index;
info->dead_lock = dead_lock;
info->dead_cv = dead_cv;
info->alive = &alive;
info->accept_timeout = DEFAULT_ACCEPT_TIMEOUT;
thr = PR_CreateThread( PR_USER_THREAD,
thread_main,
(void *)info,
PR_PRIORITY_NORMAL,
scope,
PR_UNJOINABLE_THREAD,
0);
if (!thr) {
PR_Lock(dead_lock);
alive--;
PR_Unlock(dead_lock);
}
}
PR_Lock(dead_lock);
while(alive) {
if (debug_mode) printf("main loop awake; alive = %d\n", alive);
PR_WaitCondVar(dead_cv, PR_INTERVAL_NO_TIMEOUT);
}
PR_Unlock(dead_lock);
}
int main(int argc, const char *argv[]) {
if(argc == 1) {
printf("Usage: threads count");
return 1;
}
GLOBAL_STATE = atoi(argv[1]);
RUN_THREADED = atoi(argv[2]);
NUM_THREADS = atoi(argv[3]);
int i;
thread_info* threads[NUM_THREADS];
START_TIME
for(i=0; i<NUM_THREADS; i++) {
thread_info *ti = (thread_info*)malloc(sizeof(thread_info));
ti->n = i;
ti->thread = PR_CreateThread(PR_USER_THREAD, run, (void*)ti, 1000,
PR_GLOBAL_THREAD, PR_JOINABLE_THREAD, 0);
if(!RUN_THREADED) {
PR_JoinThread(ti->thread);
}
threads[i] = ti;
}
for(i=0; i<NUM_THREADS; i++) {
thread_info *ti = threads[i];
if(RUN_THREADED) {
PR_JoinThread(ti->thread);
}
free(ti);
threads[i] = NULL;
}
END_TIME
printf("%d\n", TIMER);
return 0;
}
bool InitEventTracing()
{
// Initialize the widget backend.
if (!InitWidgetTracing())
return false;
// Create a thread that will fire events back at the
// main thread to measure responsiveness.
NS_ABORT_IF_FALSE(!sTracerThread, "Event tracing already initialized!");
sTracerThread = PR_CreateThread(PR_USER_THREAD,
TracerThread,
NULL,
PR_PRIORITY_NORMAL,
PR_GLOBAL_THREAD,
PR_JOINABLE_THREAD,
0);
return sTracerThread != NULL;
}
static
void *XpuPrintToFile( Display *pdpy, XPContext pcontext, const char *filename )
{
MyPrintFileData *mpfd; /* warning: shared between threads !! */
if( (mpfd = malloc(sizeof(MyPrintFileData))) == NULL )
return(NULL);
mpfd->parent_pdpy = pdpy;
mpfd->displayname = XDisplayString(pdpy);
mpfd->pdpy = NULL;
mpfd->pcontext = pcontext;
mpfd->file_name = filename;
mpfd->file = NULL;
mpfd->status = XPGetDocError;
/* make sure we can open the file for writing */
if( (mpfd->file = fopen(mpfd->file_name, "w")) == NULL )
{
/* fopen() error */
free(mpfd);
return(NULL);
}
/* its important to flush before we start the consumer thread,
* to make sure that the XpStartJob gets through first in the parent
*/
XFlush(pdpy);
#ifdef XPU_USE_NSPR
if( (mpfd->prthread = PR_CreateThread(PR_SYSTEM_THREAD, PrintToFile_Consumer, mpfd, PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD, PR_JOINABLE_THREAD, 0)) == NULL )
#else
if( pthread_create(&(mpfd->tid), NULL, PrintToFile_Consumer, mpfd) != 0 )
#endif
{
/* pthread_create() error */
fclose(mpfd->file);
free(mpfd);
return(NULL);
}
/* we're still in the parent */
XPU_DEBUG_ONLY(printf("### parent started consumer thread.\n" ));
return(mpfd);
}
int main(PRIntn argc, const char **argv)
{
PRThread *thread;
PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0);
PR_STDIO_INIT();
#ifndef XP_MAC
if (argc > 1)
{
if (!PR_SetLogFile(argv[1]))
{
Error("Access: Cannot create log file");
goto exit;
}
}
#else
SetupMacPrintfLog("logger.log");
#endif
/* Start logging something here */
PR_LogPrint("%s logging into %s\n", argv[0], argv[1]);
PR_LogPrint("%s creating new thread\n", argv[0]);
/*
** Now change buffering.
*/
PR_SetLogBuffering( 65500 );
thread = PR_CreateThread(
PR_USER_THREAD, forked, (void*)argv[0], PR_PRIORITY_NORMAL,
PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0);
PR_LogPrint("%s joining thread\n", argv[0]);
UserLogStuff();
PR_JoinThread(thread);
PR_LogFlush();
return 0;
exit:
return -1;
}
static void Server(void)
{
PRStatus rv;
PRNetAddr server_address, client_address;
PRFileDesc *xport = PR_Socket(domain, PR_SOCK_STREAM, protocol);
if (NULL == xport)
{
PL_FPrintError(err, "PR_Socket");
return;
}
rv = PR_InitializeNetAddr(PR_IpAddrAny, PORT_NUMBER, &server_address);
if (PR_FAILURE == rv) PL_FPrintError(err, "PR_InitializeNetAddr");
else
{
rv = PR_Bind(xport, &server_address);
if (PR_FAILURE == rv) PL_FPrintError(err, "PR_Bind");
else
{
PRFileDesc *client;
rv = PR_Listen(xport, 10);
PR_fprintf(err, "Server listening on ");
(void)PrintAddress(&server_address);
do
{
client = PR_Accept(
xport, &client_address, PR_INTERVAL_NO_TIMEOUT);
if (NULL == client) PL_FPrintError(err, "PR_Accept");
else
{
PR_fprintf(err, "Server accepting from ");
(void)PrintAddress(&client_address);
shared->threads += 1;
(void)PR_CreateThread(
PR_USER_THREAD, Servette, client,
PR_PRIORITY_NORMAL, thread_scope,
PR_UNJOINABLE_THREAD, 8 * 1024);
}
} while (PR_TRUE);
}
}
} /* Server */
/*
* The write-thread is spawned on a timeout(which is reset with every write). This
* can avoid a slow shutdown. After writing out the cache, the zipreader is
* reloaded on the worker thread.
*/
void
StartupCache::WriteTimeout(nsITimer *aTimer, void *aClosure)
{
/*
* It is safe to use the pointer passed in aClosure to reference the
* StartupCache object because the timer's lifetime is tightly coupled to
* the lifetime of the StartupCache object; this timer is canceled in the
* StartupCache destructor, guaranteeing that this function runs if and only
* if the StartupCache object is valid.
*/
StartupCache* startupCacheObj = static_cast<StartupCache*>(aClosure);
startupCacheObj->mWriteThread = PR_CreateThread(PR_USER_THREAD,
StartupCache::ThreadedWrite,
startupCacheObj,
PR_PRIORITY_NORMAL,
PR_GLOBAL_THREAD,
PR_JOINABLE_THREAD,
0);
}
/*
* End recording
*/
NS_IMETHODIMP
MediaRecorder::EndRecording()
{
if (!a_rec && !v_rec) {
NS_DispatchToMainThread(new MediaCallback(
observer, "error", "no recording in progress"
));
return NS_ERROR_FAILURE;
}
PR_CreateThread(
PR_SYSTEM_THREAD,
MediaRecorder::EndRecordingThread, this,
PR_PRIORITY_NORMAL,
PR_GLOBAL_THREAD,
PR_JOINABLE_THREAD, 0
);
return NS_OK;
}
int main()
{
int i= 0;
PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0);
printf("The parent sproc has pid %d.\n", getpid());
printf("The parent sproc won't stop on its own.\n");
fflush(stdout);
/* create the child sproc */
PR_CreateThread(PR_USER_THREAD, NeverStops, NULL,
PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD, PR_UNJOINABLE_THREAD, 0);
while (1) {
i++;
}
return 0;
}
void HRTFDatabaseLoader::loadAsynchronously()
{
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(m_refCnt, "Must not be called before a reference is added");
// Add a reference so that the destructor won't run and wait for the
// loader thread, until load() has completed.
AddRef();
MutexAutoLock locker(m_threadLock);
MOZ_ASSERT(!m_hrtfDatabase.get() && !m_databaseLoaderThread,
"Called twice");
// Start the asynchronous database loading process.
m_databaseLoaderThread =
PR_CreateThread(PR_USER_THREAD, databaseLoaderEntry, this,
PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,
PR_JOINABLE_THREAD, 0);
}
static PRStatus TimerInit(void)
{
tm_vars.ml = PR_NewLock();
if (NULL == tm_vars.ml)
{
goto failed;
}
tm_vars.new_timer = PR_NewCondVar(tm_vars.ml);
if (NULL == tm_vars.new_timer)
{
goto failed;
}
tm_vars.cancel_timer = PR_NewCondVar(tm_vars.ml);
if (NULL == tm_vars.cancel_timer)
{
goto failed;
}
PR_INIT_CLIST(&tm_vars.timer_queue);
tm_vars.manager_thread = PR_CreateThread(
PR_SYSTEM_THREAD, TimerManager, NULL, PR_PRIORITY_NORMAL,
PR_LOCAL_THREAD, PR_UNJOINABLE_THREAD, 0);
if (NULL == tm_vars.manager_thread)
{
goto failed;
}
return PR_SUCCESS;
failed:
if (NULL != tm_vars.cancel_timer)
{
PR_DestroyCondVar(tm_vars.cancel_timer);
}
if (NULL != tm_vars.new_timer)
{
PR_DestroyCondVar(tm_vars.new_timer);
}
if (NULL != tm_vars.ml)
{
PR_DestroyLock(tm_vars.ml);
}
return PR_FAILURE;
}
static PRUint32 ContentiousMonitor(PRUint32 loops)
{
PRStatus status;
PRThread *thread = NULL;
MonitorContentious_t * contention;
PRIntervalTime rv, overhead, timein = PR_IntervalNow();
contention = PR_NEWZAP(MonitorContentious_t);
contention->loops = loops;
contention->overhead = 0;
contention->ml = PR_NewMonitor();
contention->interval = contention_interval;
thread = PR_CreateThread(
PR_USER_THREAD, MonitorContender, contention,
PR_PRIORITY_LOW, PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0);
PR_ASSERT(thread != NULL);
overhead = PR_IntervalNow() - timein;
while (contention->loops-- > 0)
{
PR_EnterMonitor(contention->ml);
PR_ASSERT_CURRENT_THREAD_IN_MONITOR(contention->ml);
contention->contentious+= 1;
contention->overhead += contention->interval;
PR_Sleep(contention->interval);
PR_ASSERT_CURRENT_THREAD_IN_MONITOR(contention->ml);
PR_ExitMonitor(contention->ml);
}
timein = PR_IntervalNow();
status = PR_JoinThread(thread);
PR_DestroyMonitor(contention->ml);
overhead += (PR_IntervalNow() - timein);
rv = overhead + contention->overhead;
if (verbosity)
PR_fprintf(
std_err, "Access ratio: %u to %u\n",
contention->contentious, contention->contender);
PR_Free(contention);
return rv;
} /* ContentiousMonitor */
int main(int argc, char **argv)
{
PRThread *thread;
PRIntervalTime start, end;
PRUint32 elapsed_ms;
lock1 = PR_NewLock();
PR_ASSERT(NULL != lock1);
cv1 = PR_NewCondVar(lock1);
PR_ASSERT(NULL != cv1);
lock2 = PR_NewLock();
PR_ASSERT(NULL != lock2);
cv2 = PR_NewCondVar(lock2);
PR_ASSERT(NULL != cv2);
start = PR_IntervalNow();
thread = PR_CreateThread(
PR_USER_THREAD,
ThreadFunc,
NULL,
PR_PRIORITY_NORMAL,
PR_LOCAL_THREAD,
PR_JOINABLE_THREAD,
0);
PR_ASSERT(NULL != thread);
PR_Lock(lock2);
PR_WaitCondVar(cv2, PR_MillisecondsToInterval(LONG_TIMEOUT));
PR_Unlock(lock2);
PR_JoinThread(thread);
end = PR_IntervalNow();
elapsed_ms = PR_IntervalToMilliseconds((PRIntervalTime)(end - start));
/* Allow 100ms imprecision */
if (elapsed_ms < LONG_TIMEOUT - 100 || elapsed_ms > LONG_TIMEOUT + 100) {
printf("Elapsed time should be %u ms but is %u ms\n",
LONG_TIMEOUT, elapsed_ms);
printf("FAIL\n");
exit(1);
}
printf("Elapsed time: %u ms, expected time: %u ms\n",
LONG_TIMEOUT, elapsed_ms);
printf("PASS\n");
return 0;
}
int main()
{
int *p = 0;
PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0);
printf("The parent sproc has pid %d.\n", getpid());
printf("The parent sproc will first create a child sproc.\n");
printf("Then the parent sproc will get a segmentation fault and die.\n");
printf("The child sproc should be killed after the parent sproc dies.\n");
printf("Use 'ps' to make sure this is so.\n");
fflush(stdout);
PR_CreateThread(PR_USER_THREAD, NeverStops, NULL,
PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD, PR_UNJOINABLE_THREAD, 0);
/* Force a segmentation fault */
*p = 0;
return 0;
}
