diff options
Diffstat (limited to 'nsprpub/pr/src/threads/combined')
| -rw-r--r-- | nsprpub/pr/src/threads/combined/prucpu.c | 83 | ||||
| -rw-r--r-- | nsprpub/pr/src/threads/combined/prucv.c | 256 | ||||
| -rw-r--r-- | nsprpub/pr/src/threads/combined/prulock.c | 201 | ||||
| -rw-r--r-- | nsprpub/pr/src/threads/combined/prustack.c | 133 | ||||
| -rw-r--r-- | nsprpub/pr/src/threads/combined/pruthr.c | 765 |
5 files changed, 773 insertions, 665 deletions
diff --git a/nsprpub/pr/src/threads/combined/prucpu.c b/nsprpub/pr/src/threads/combined/prucpu.c index 3913dc8de..25ffcce86 100644 --- a/nsprpub/pr/src/threads/combined/prucpu.c +++ b/nsprpub/pr/src/threads/combined/prucpu.c @@ -41,8 +41,9 @@ void _PR_InitCPUs() { PRThread *me = _PR_MD_CURRENT_THREAD(); - if (_native_threads_only) + if (_native_threads_only) { return; + } _pr_cpuID = 0; _MD_NEW_LOCK( &_pr_cpuLock); @@ -119,13 +120,14 @@ static _PRCPUQueue *_PR_CreateCPUQueue(void) PRInt32 index; _PRCPUQueue *cpuQueue; cpuQueue = PR_NEWZAP(_PRCPUQueue); - + _MD_NEW_LOCK( &cpuQueue->runQLock ); _MD_NEW_LOCK( &cpuQueue->sleepQLock ); _MD_NEW_LOCK( &cpuQueue->miscQLock ); - for (index = 0; index < PR_ARRAY_SIZE(cpuQueue->runQ); index++) + for (index = 0; index < PR_ARRAY_SIZE(cpuQueue->runQ); index++) { PR_INIT_CLIST( &(cpuQueue->runQ[index]) ); + } PR_INIT_CLIST( &(cpuQueue->sleepQ) ); PR_INIT_CLIST( &(cpuQueue->pauseQ) ); PR_INIT_CLIST( &(cpuQueue->suspendQ) ); @@ -191,7 +193,7 @@ static PRStatus _PR_StartCPU(_PRCPU *cpu, PRThread *thread) cpu->last_clock = PR_IntervalNow(); /* Before we create any threads on this CPU we have to - * set the current CPU + * set the current CPU */ _PR_MD_SET_CURRENT_CPU(cpu); _PR_MD_INIT_RUNNING_CPU(cpu); @@ -210,15 +212,16 @@ static PRStatus _PR_StartCPU(_PRCPU *cpu, PRThread *thread) /* didn't clean up CPU queue XXXMB */ PR_DELETE(cpu); return PR_FAILURE; - } + } PR_ASSERT(cpu->idle_thread->cpu == cpu); cpu->idle_thread->no_sched = 0; cpu->thread = thread; - if (_pr_cpu_affinity_mask) + if (_pr_cpu_affinity_mask) { PR_SetThreadAffinityMask(thread, _pr_cpu_affinity_mask); + } /* Created and started a new CPU */ _PR_CPU_LIST_LOCK(); @@ -273,8 +276,10 @@ static void _PR_RunCPU(void *arg) while(1) { PRInt32 is; - if (!_PR_IS_NATIVE_THREAD(me)) _PR_INTSOFF(is); - _PR_MD_START_INTERRUPTS(); + if (!_PR_IS_NATIVE_THREAD(me)) { + _PR_INTSOFF(is); + } + _PR_MD_START_INTERRUPTS(); _PR_MD_SWITCH_CONTEXT(me); } } @@ -289,13 +294,18 @@ static void PR_CALLBACK _PR_CPU_Idle(void *_cpu) me->cpu = cpu; cpu->idle_thread = me; - if (_MD_LAST_THREAD()) + if (_MD_LAST_THREAD()) { _MD_LAST_THREAD()->no_sched = 0; - if (!_PR_IS_NATIVE_THREAD(me)) _PR_MD_SET_INTSOFF(0); + } + if (!_PR_IS_NATIVE_THREAD(me)) { + _PR_MD_SET_INTSOFF(0); + } while(1) { PRInt32 is; PRIntervalTime timeout; - if (!_PR_IS_NATIVE_THREAD(me)) _PR_INTSOFF(is); + if (!_PR_IS_NATIVE_THREAD(me)) { + _PR_INTSOFF(is); + } _PR_RUNQ_LOCK(cpu); #if !defined(_PR_LOCAL_THREADS_ONLY) && !defined(_PR_GLOBAL_THREADS_ONLY) @@ -345,14 +355,16 @@ static void PR_CALLBACK _PR_CPU_Idle(void *_cpu) #endif /* _PR_HAVE_ATOMIC_OPS */ #endif - _PR_ClockInterrupt(); + _PR_ClockInterrupt(); - /* Now schedule any thread that is on the runq - * INTS must be OFF when calling PR_Schedule() - */ - me->state = _PR_RUNNABLE; - _PR_MD_SWITCH_CONTEXT(me); - if (!_PR_IS_NATIVE_THREAD(me)) _PR_FAST_INTSON(is); + /* Now schedule any thread that is on the runq + * INTS must be OFF when calling PR_Schedule() + */ + me->state = _PR_RUNNABLE; + _PR_MD_SWITCH_CONTEXT(me); + if (!_PR_IS_NATIVE_THREAD(me)) { + _PR_FAST_INTSON(is); + } } } #endif /* _PR_GLOBAL_THREADS_ONLY */ @@ -370,36 +382,43 @@ PR_IMPLEMENT(void) PR_SetConcurrency(PRUintn numCPUs) PRThread *thr; - if (!_pr_initialized) _PR_ImplicitInitialization(); + if (!_pr_initialized) { + _PR_ImplicitInitialization(); + } + + if (_native_threads_only) { + return; + } - if (_native_threads_only) - return; - _PR_CPU_LIST_LOCK(); if (_pr_numCPU < numCPUs) { newCPU = numCPUs - _pr_numCPU; _pr_numCPU = numCPUs; - } else newCPU = 0; + } else { + newCPU = 0; + } _PR_CPU_LIST_UNLOCK(); for (; newCPU; newCPU--) { cpu = _PR_CreateCPU(); thr = _PR_CreateThread(PR_SYSTEM_THREAD, - _PR_RunCPU, - cpu, - PR_PRIORITY_NORMAL, - PR_GLOBAL_THREAD, - PR_UNJOINABLE_THREAD, - 0, - _PR_IDLE_THREAD); + _PR_RunCPU, + cpu, + PR_PRIORITY_NORMAL, + PR_GLOBAL_THREAD, + PR_UNJOINABLE_THREAD, + 0, + _PR_IDLE_THREAD); } #endif } PR_IMPLEMENT(_PRCPU *) _PR_GetPrimordialCPU(void) { - if (_pr_primordialCPU) + if (_pr_primordialCPU) { return _pr_primordialCPU; - else + } + else { return _PR_MD_CURRENT_CPU(); + } } diff --git a/nsprpub/pr/src/threads/combined/prucv.c b/nsprpub/pr/src/threads/combined/prucv.c index d0bf4c422..801d3d2fd 100644 --- a/nsprpub/pr/src/threads/combined/prucv.c +++ b/nsprpub/pr/src/threads/combined/prucv.c @@ -10,10 +10,10 @@ #if defined(WIN95) /* -** Some local variables report warnings on Win95 because the code paths +** Some local variables report warnings on Win95 because the code paths ** using them are conditioned on HAVE_CUSTOME_USER_THREADS. ** The pragma suppresses the warning. -** +** */ #pragma warning(disable : 4101) #endif @@ -39,24 +39,25 @@ PRBool _PR_NotifyThread (PRThread *thread, PRThread *me) /* The notify and timeout can collide; in which case both may * attempt to delete from the sleepQ; only let one do it. */ - if (thread->flags & (_PR_ON_SLEEPQ|_PR_ON_PAUSEQ)) + if (thread->flags & (_PR_ON_SLEEPQ|_PR_ON_PAUSEQ)) { _PR_DEL_SLEEPQ(thread, PR_TRUE); + } _PR_SLEEPQ_UNLOCK(thread->cpu); - if (thread->flags & _PR_SUSPENDING) { - /* - * set thread state to SUSPENDED; a Resume operation - * on the thread will move it to the runQ - */ - thread->state = _PR_SUSPENDED; - _PR_MISCQ_LOCK(thread->cpu); - _PR_ADD_SUSPENDQ(thread, thread->cpu); - _PR_MISCQ_UNLOCK(thread->cpu); - _PR_THREAD_UNLOCK(thread); - } else { - /* Make thread runnable */ - thread->state = _PR_RUNNABLE; - _PR_THREAD_UNLOCK(thread); + if (thread->flags & _PR_SUSPENDING) { + /* + * set thread state to SUSPENDED; a Resume operation + * on the thread will move it to the runQ + */ + thread->state = _PR_SUSPENDED; + _PR_MISCQ_LOCK(thread->cpu); + _PR_ADD_SUSPENDQ(thread, thread->cpu); + _PR_MISCQ_UNLOCK(thread->cpu); + _PR_THREAD_UNLOCK(thread); + } else { + /* Make thread runnable */ + thread->state = _PR_RUNNABLE; + _PR_THREAD_UNLOCK(thread); _PR_AddThreadToRunQ(me, thread); _PR_MD_WAKEUP_WAITER(thread); @@ -72,29 +73,30 @@ PRBool _PR_NotifyThread (PRThread *thread, PRThread *me) if (thread->wait.cvar) { thread->wait.cvar = NULL; - if (thread->flags & _PR_SUSPENDING) { - /* - * set thread state to SUSPENDED; a Resume operation - * on the thread will enable the thread to run - */ - thread->state = _PR_SUSPENDED; - } else - thread->state = _PR_RUNNING; + if (thread->flags & _PR_SUSPENDING) { + /* + * set thread state to SUSPENDED; a Resume operation + * on the thread will enable the thread to run + */ + thread->state = _PR_SUSPENDED; + } else { + thread->state = _PR_RUNNING; + } _PR_THREAD_UNLOCK(thread); _PR_MD_WAKEUP_WAITER(thread); rv = PR_TRUE; } else { _PR_THREAD_UNLOCK(thread); rv = PR_FALSE; - } - } + } + } return rv; } /* * Notify thread waiting on cvar; called when thread is interrupted - * The thread lock is held on entry and released before return + * The thread lock is held on entry and released before return */ void _PR_NotifyLockedThread (PRThread *thread) { @@ -102,8 +104,9 @@ void _PR_NotifyLockedThread (PRThread *thread) PRCondVar *cvar; PRThreadPriority pri; - if ( !_PR_IS_NATIVE_THREAD(me)) - PR_ASSERT(_PR_MD_GET_INTSOFF() != 0); + if ( !_PR_IS_NATIVE_THREAD(me)) { + PR_ASSERT(_PR_MD_GET_INTSOFF() != 0); + } cvar = thread->wait.cvar; thread->wait.cvar = NULL; @@ -113,36 +116,38 @@ void _PR_NotifyLockedThread (PRThread *thread) _PR_THREAD_LOCK(thread); if (!_PR_IS_NATIVE_THREAD(thread)) { - _PR_SLEEPQ_LOCK(thread->cpu); - /* The notify and timeout can collide; in which case both may - * attempt to delete from the sleepQ; only let one do it. - */ - if (thread->flags & (_PR_ON_SLEEPQ|_PR_ON_PAUSEQ)) - _PR_DEL_SLEEPQ(thread, PR_TRUE); - _PR_SLEEPQ_UNLOCK(thread->cpu); + _PR_SLEEPQ_LOCK(thread->cpu); + /* The notify and timeout can collide; in which case both may + * attempt to delete from the sleepQ; only let one do it. + */ + if (thread->flags & (_PR_ON_SLEEPQ|_PR_ON_PAUSEQ)) { + _PR_DEL_SLEEPQ(thread, PR_TRUE); + } + _PR_SLEEPQ_UNLOCK(thread->cpu); - /* Make thread runnable */ - pri = thread->priority; - thread->state = _PR_RUNNABLE; + /* Make thread runnable */ + pri = thread->priority; + thread->state = _PR_RUNNABLE; - PR_ASSERT(!(thread->flags & _PR_IDLE_THREAD)); + PR_ASSERT(!(thread->flags & _PR_IDLE_THREAD)); - _PR_AddThreadToRunQ(me, thread); - _PR_THREAD_UNLOCK(thread); + _PR_AddThreadToRunQ(me, thread); + _PR_THREAD_UNLOCK(thread); - _PR_MD_WAKEUP_WAITER(thread); + _PR_MD_WAKEUP_WAITER(thread); } else { - if (thread->flags & _PR_SUSPENDING) { - /* - * set thread state to SUSPENDED; a Resume operation - * on the thread will enable the thread to run - */ - thread->state = _PR_SUSPENDED; - } else - thread->state = _PR_RUNNING; - _PR_THREAD_UNLOCK(thread); - _PR_MD_WAKEUP_WAITER(thread); - } + if (thread->flags & _PR_SUSPENDING) { + /* + * set thread state to SUSPENDED; a Resume operation + * on the thread will enable the thread to run + */ + thread->state = _PR_SUSPENDED; + } else { + thread->state = _PR_RUNNING; + } + _PR_THREAD_UNLOCK(thread); + _PR_MD_WAKEUP_WAITER(thread); + } _PR_CVAR_UNLOCK(cvar); return; @@ -181,8 +186,9 @@ PRStatus _PR_WaitCondVar( return PR_SUCCESS; #else /* _PR_GLOBAL_THREADS_ONLY */ - if ( !_PR_IS_NATIVE_THREAD(thread)) - _PR_INTSOFF(is); + if ( !_PR_IS_NATIVE_THREAD(thread)) { + _PR_INTSOFF(is); + } _PR_CVAR_LOCK(cvar); _PR_THREAD_LOCK(thread); @@ -190,10 +196,11 @@ PRStatus _PR_WaitCondVar( if (_PR_PENDING_INTERRUPT(thread)) { PR_SetError(PR_PENDING_INTERRUPT_ERROR, 0); thread->flags &= ~_PR_INTERRUPT; - _PR_CVAR_UNLOCK(cvar); - _PR_THREAD_UNLOCK(thread); - if ( !_PR_IS_NATIVE_THREAD(thread)) - _PR_INTSON(is); + _PR_CVAR_UNLOCK(cvar); + _PR_THREAD_UNLOCK(thread); + if ( !_PR_IS_NATIVE_THREAD(thread)) { + _PR_INTSON(is); + } return PR_FAILURE; } @@ -216,15 +223,15 @@ PRStatus _PR_WaitCondVar( } _PR_CVAR_UNLOCK(cvar); _PR_THREAD_UNLOCK(thread); - - /* - ** Release lock protecting the condition variable and thereby giving time + + /* + ** Release lock protecting the condition variable and thereby giving time ** to the next thread which can potentially notify on the condition variable */ PR_Unlock(lock); PR_LOG(_pr_cvar_lm, PR_LOG_MIN, - ("PR_Wait: cvar=%p waiting for %d", cvar, timeout)); + ("PR_Wait: cvar=%p waiting for %d", cvar, timeout)); rv = _PR_MD_WAIT(thread, timeout); @@ -233,10 +240,11 @@ PRStatus _PR_WaitCondVar( _PR_CVAR_UNLOCK(cvar); PR_LOG(_pr_cvar_lm, PR_LOG_MIN, - ("PR_Wait: cvar=%p done waiting", cvar)); + ("PR_Wait: cvar=%p done waiting", cvar)); - if ( !_PR_IS_NATIVE_THREAD(thread)) - _PR_INTSON(is); + if ( !_PR_IS_NATIVE_THREAD(thread)) { + _PR_INTSON(is); + } /* Acquire lock again that we had just relinquished */ PR_Lock(lock); @@ -260,8 +268,9 @@ void _PR_NotifyCondVar(PRCondVar *cvar, PRThread *me) PRCList *q; PRIntn is; - if ( !_PR_IS_NATIVE_THREAD(me)) - _PR_INTSOFF(is); + if ( !_PR_IS_NATIVE_THREAD(me)) { + _PR_INTSOFF(is); + } PR_ASSERT(_PR_IS_NATIVE_THREAD(me) || _PR_MD_GET_INTSOFF() != 0); _PR_CVAR_LOCK(cvar); @@ -269,15 +278,17 @@ void _PR_NotifyCondVar(PRCondVar *cvar, PRThread *me) while (q != &cvar->condQ) { PR_LOG(_pr_cvar_lm, PR_LOG_MIN, ("_PR_NotifyCondVar: cvar=%p", cvar)); if (_PR_THREAD_CONDQ_PTR(q)->wait.cvar) { - if (_PR_NotifyThread(_PR_THREAD_CONDQ_PTR(q), me) == PR_TRUE) + if (_PR_NotifyThread(_PR_THREAD_CONDQ_PTR(q), me) == PR_TRUE) { break; + } } q = q->next; } _PR_CVAR_UNLOCK(cvar); - if ( !_PR_IS_NATIVE_THREAD(me)) - _PR_INTSON(is); + if ( !_PR_IS_NATIVE_THREAD(me)) { + _PR_INTSON(is); + } #endif /* _PR_GLOBAL_THREADS_ONLY */ } @@ -290,10 +301,10 @@ PRUint32 _PR_CondVarToString(PRCondVar *cvar, char *buf, PRUint32 buflen) PRUint32 nb; if (cvar->lock->owner) { - nb = PR_snprintf(buf, buflen, "[%p] owner=%ld[%p]", - cvar, cvar->lock->owner->id, cvar->lock->owner); + nb = PR_snprintf(buf, buflen, "[%p] owner=%ld[%p]", + cvar, cvar->lock->owner->id, cvar->lock->owner); } else { - nb = PR_snprintf(buf, buflen, "[%p]", cvar); + nb = PR_snprintf(buf, buflen, "[%p]", cvar); } return nb; } @@ -307,7 +318,7 @@ void _PR_ClockInterrupt(void) PRThread *thread, *me = _PR_MD_CURRENT_THREAD(); _PRCPU *cpu = me->cpu; PRIntervalTime elapsed, now; - + PR_ASSERT(_PR_MD_GET_INTSOFF() != 0); /* Figure out how much time elapsed since the last clock tick */ now = PR_IntervalNow(); @@ -315,7 +326,7 @@ void _PR_ClockInterrupt(void) cpu->last_clock = now; PR_LOG(_pr_clock_lm, PR_LOG_MAX, - ("ExpireWaits: elapsed=%lld usec", elapsed)); + ("ExpireWaits: elapsed=%lld usec", elapsed)); while(1) { _PR_SLEEPQ_LOCK(cpu); @@ -370,8 +381,8 @@ void _PR_ClockInterrupt(void) /* Notify the thread waiting on the condition variable */ if (thread->flags & _PR_SUSPENDING) { - PR_ASSERT((thread->state == _PR_IO_WAIT) || - (thread->state == _PR_COND_WAIT)); + PR_ASSERT((thread->state == _PR_IO_WAIT) || + (thread->state == _PR_COND_WAIT)); /* ** Thread is suspended and its condition timeout ** expired. Transfer thread from sleepQ to suspendQ. @@ -398,8 +409,9 @@ void _PR_ClockInterrupt(void) _PR_ADD_RUNQ(thread, cpu, pri); _PR_RUNQ_UNLOCK(cpu); - if (pri > me->priority) + if (pri > me->priority) { _PR_SET_RESCHED_FLAG(); + } thread->wait.cvar = NULL; @@ -411,14 +423,14 @@ void _PR_ClockInterrupt(void) thread->io_suspended = PR_TRUE; #ifdef WINNT - /* - * For NT, record the cpu on which I/O was issued - * I/O cancellation is done on the same cpu - */ + /* + * For NT, record the cpu on which I/O was issued + * I/O cancellation is done on the same cpu + */ thread->md.thr_bound_cpu = cpu; #endif - PR_ASSERT(!(thread->flags & _PR_IDLE_THREAD)); + PR_ASSERT(!(thread->flags & _PR_IDLE_THREAD)); PR_ASSERT(thread->cpu == cpu); thread->state = _PR_RUNNABLE; _PR_RUNQ_LOCK(cpu); @@ -434,7 +446,7 @@ void _PR_ClockInterrupt(void) /* ** Create a new condition variable. -** "lock" is the lock to use with the condition variable. +** "lock" is the lock to use with the condition variable. ** ** Condition variables are synchronization objects that threads can use ** to wait for some condition to occur. @@ -518,11 +530,13 @@ PR_IMPLEMENT(PRStatus) PR_WaitCondVar(PRCondVar *cvar, PRIntervalTime timeout) { PRThread *me = _PR_MD_CURRENT_THREAD(); - PR_ASSERT(cvar->lock->owner == me); - PR_ASSERT(me != suspendAllThread); - if (cvar->lock->owner != me) return PR_FAILURE; + PR_ASSERT(cvar->lock->owner == me); + PR_ASSERT(me != suspendAllThread); + if (cvar->lock->owner != me) { + return PR_FAILURE; + } - return _PR_WaitCondVar(me, cvar, cvar->lock, timeout); + return _PR_WaitCondVar(me, cvar, cvar->lock, timeout); } /* @@ -536,7 +550,9 @@ PR_IMPLEMENT(PRStatus) PR_NotifyCondVar(PRCondVar *cvar) PR_ASSERT(cvar->lock->owner == me); PR_ASSERT(me != suspendAllThread); - if (cvar->lock->owner != me) return PR_FAILURE; + if (cvar->lock->owner != me) { + return PR_FAILURE; + } _PR_NotifyCondVar(cvar, me); return PR_SUCCESS; @@ -554,24 +570,28 @@ PR_IMPLEMENT(PRStatus) PR_NotifyAllCondVar(PRCondVar *cvar) PRThread *me = _PR_MD_CURRENT_THREAD(); PR_ASSERT(cvar->lock->owner == me); - if (cvar->lock->owner != me) return PR_FAILURE; + if (cvar->lock->owner != me) { + return PR_FAILURE; + } #ifdef _PR_GLOBAL_THREADS_ONLY _PR_MD_NOTIFYALL_CV(&cvar->md, &cvar->lock->ilock); return PR_SUCCESS; #else /* _PR_GLOBAL_THREADS_ONLY */ - if ( !_PR_IS_NATIVE_THREAD(me)) - _PR_INTSOFF(is); + if ( !_PR_IS_NATIVE_THREAD(me)) { + _PR_INTSOFF(is); + } _PR_CVAR_LOCK(cvar); q = cvar->condQ.next; while (q != &cvar->condQ) { - PR_LOG(_pr_cvar_lm, PR_LOG_MIN, ("PR_NotifyAll: cvar=%p", cvar)); - _PR_NotifyThread(_PR_THREAD_CONDQ_PTR(q), me); - q = q->next; + PR_LOG(_pr_cvar_lm, PR_LOG_MIN, ("PR_NotifyAll: cvar=%p", cvar)); + _PR_NotifyThread(_PR_THREAD_CONDQ_PTR(q), me); + q = q->next; } _PR_CVAR_UNLOCK(cvar); - if (!_PR_IS_NATIVE_THREAD(me)) - _PR_INTSON(is); + if (!_PR_IS_NATIVE_THREAD(me)) { + _PR_INTSON(is); + } return PR_SUCCESS; #endif /* _PR_GLOBAL_THREADS_ONLY */ @@ -592,13 +612,13 @@ PR_IMPLEMENT(PRCondVar*) PRP_NewNakedCondVar(void) { if (_PR_MD_NEW_LOCK(&(cvar->ilock)) == PR_FAILURE) { - PR_DELETE(cvar); cvar = NULL; - } - else - { - PR_INIT_CLIST(&cvar->condQ); + PR_DELETE(cvar); cvar = NULL; + } + else + { + PR_INIT_CLIST(&cvar->condQ); cvar->lock = _PR_NAKED_CV_LOCK; - } + } } return cvar; @@ -610,16 +630,16 @@ PR_IMPLEMENT(void) PRP_DestroyNakedCondVar(PRCondVar *cvar) PR_ASSERT(_PR_NAKED_CV_LOCK == cvar->lock); _PR_MD_FREE_LOCK(&(cvar->ilock)); - + PR_DELETE(cvar); } PR_IMPLEMENT(PRStatus) PRP_NakedWait( - PRCondVar *cvar, PRLock *lock, PRIntervalTime timeout) + PRCondVar *cvar, PRLock *lock, PRIntervalTime timeout) { PRThread *me = _PR_MD_CURRENT_THREAD(); PR_ASSERT(_PR_NAKED_CV_LOCK == cvar->lock); - return _PR_WaitCondVar(me, cvar, lock, timeout); + return _PR_WaitCondVar(me, cvar, lock, timeout); } /* PRP_NakedWait */ PR_IMPLEMENT(PRStatus) PRP_NakedNotify(PRCondVar *cvar) @@ -639,16 +659,20 @@ PR_IMPLEMENT(PRStatus) PRP_NakedBroadcast(PRCondVar *cvar) PRThread *me = _PR_MD_CURRENT_THREAD(); PR_ASSERT(_PR_NAKED_CV_LOCK == cvar->lock); - if ( !_PR_IS_NATIVE_THREAD(me)) _PR_INTSOFF(is); - _PR_MD_LOCK( &(cvar->ilock) ); + if ( !_PR_IS_NATIVE_THREAD(me)) { + _PR_INTSOFF(is); + } + _PR_MD_LOCK( &(cvar->ilock) ); q = cvar->condQ.next; while (q != &cvar->condQ) { - PR_LOG(_pr_cvar_lm, PR_LOG_MIN, ("PR_NotifyAll: cvar=%p", cvar)); - _PR_NotifyThread(_PR_THREAD_CONDQ_PTR(q), me); - q = q->next; + PR_LOG(_pr_cvar_lm, PR_LOG_MIN, ("PR_NotifyAll: cvar=%p", cvar)); + _PR_NotifyThread(_PR_THREAD_CONDQ_PTR(q), me); + q = q->next; + } + _PR_MD_UNLOCK( &(cvar->ilock) ); + if (!_PR_IS_NATIVE_THREAD(me)) { + _PR_INTSON(is); } - _PR_MD_UNLOCK( &(cvar->ilock) ); - if (!_PR_IS_NATIVE_THREAD(me)) _PR_INTSON(is); return PR_SUCCESS; } /* PRP_NakedBroadcast */ diff --git a/nsprpub/pr/src/threads/combined/prulock.c b/nsprpub/pr/src/threads/combined/prulock.c index 8b2f41eec..69c27d149 100644 --- a/nsprpub/pr/src/threads/combined/prulock.c +++ b/nsprpub/pr/src/threads/combined/prulock.c @@ -7,10 +7,10 @@ #if defined(WIN95) /* -** Some local variables report warnings on Win95 because the code paths +** Some local variables report warnings on Win95 because the code paths ** using them are conditioned on HAVE_CUSTOME_USER_THREADS. ** The pragma suppresses the warning. -** +** */ #pragma warning(disable : 4101) #endif @@ -18,7 +18,7 @@ void _PR_InitLocks(void) { - _PR_MD_INIT_LOCKS(); + _PR_MD_INIT_LOCKS(); } /* @@ -33,7 +33,7 @@ void _PR_IntsOn(_PRCPU *cpu) PR_ASSERT(cpu); /* Global threads don't have CPUs */ PR_ASSERT(_PR_MD_GET_INTSOFF() > 0); - me = _PR_MD_CURRENT_THREAD(); + me = _PR_MD_CURRENT_THREAD(); PR_ASSERT(!(me->flags & _PR_IDLE_THREAD)); /* @@ -69,15 +69,15 @@ void _PR_IntsOn(_PRCPU *cpu) if (cpu->u.missed[3] != 0) { _PRCPU *cpu; - _PR_THREAD_LOCK(me); + _PR_THREAD_LOCK(me); me->state = _PR_RUNNABLE; pri = me->priority; cpu = me->cpu; - _PR_RUNQ_LOCK(cpu); + _PR_RUNQ_LOCK(cpu); _PR_ADD_RUNQ(me, cpu, pri); - _PR_RUNQ_UNLOCK(cpu); - _PR_THREAD_UNLOCK(me); + _PR_RUNQ_UNLOCK(cpu); + _PR_THREAD_UNLOCK(me); _PR_MD_SWITCH_CONTEXT(me); } } @@ -99,11 +99,11 @@ void _PR_UnblockLockWaiter(PRLock *lock) /* Unblock first waiter */ t = _PR_THREAD_CONDQ_PTR(q); - /* - ** We are about to change the thread's state to runnable and for local - ** threads, we are going to assign a cpu to it. So, protect thread's - ** data structure. - */ + /* + ** We are about to change the thread's state to runnable and for local + ** threads, we are going to assign a cpu to it. So, protect thread's + ** data structure. + */ _PR_THREAD_LOCK(t); if (t->flags & _PR_SUSPENDING) { @@ -113,24 +113,24 @@ void _PR_UnblockLockWaiter(PRLock *lock) } /* Found a runnable thread */ - PR_ASSERT(t->state == _PR_LOCK_WAIT); - PR_ASSERT(t->wait.lock == lock); + PR_ASSERT(t->state == _PR_LOCK_WAIT); + PR_ASSERT(t->wait.lock == lock); t->wait.lock = 0; PR_REMOVE_LINK(&t->waitQLinks); /* take it off lock's waitQ */ - /* - ** If this is a native thread, nothing else to do except to wake it - ** up by calling the machine dependent wakeup routine. - ** - ** If this is a local thread, we need to assign it a cpu and - ** put the thread on that cpu's run queue. There are two cases to - ** take care of. If the currently running thread is also a local - ** thread, we just assign our own cpu to that thread and put it on - ** the cpu's run queue. If the the currently running thread is a - ** native thread, we assign the primordial cpu to it (on NT, - ** MD_WAKEUP handles the cpu assignment). - */ - + /* + ** If this is a native thread, nothing else to do except to wake it + ** up by calling the machine dependent wakeup routine. + ** + ** If this is a local thread, we need to assign it a cpu and + ** put the thread on that cpu's run queue. There are two cases to + ** take care of. If the currently running thread is also a local + ** thread, we just assign our own cpu to that thread and put it on + ** the cpu's run queue. If the the currently running thread is a + ** native thread, we assign the primordial cpu to it (on NT, + ** MD_WAKEUP handles the cpu assignment). + */ + if ( !_PR_IS_NATIVE_THREAD(t) ) { t->state = _PR_RUNNABLE; @@ -156,7 +156,9 @@ PR_IMPLEMENT(PRLock*) PR_NewLock(void) { PRLock *lock; - if (!_pr_initialized) _PR_ImplicitInitialization(); + if (!_pr_initialized) { + _PR_ImplicitInitialization(); + } lock = PR_NEWZAP(PRLock); if (lock) { @@ -206,25 +208,26 @@ PR_IMPLEMENT(void) PR_Lock(PRLock *lock) PRThread *t; PRCList *q; - PR_ASSERT(me != suspendAllThread); + PR_ASSERT(me != suspendAllThread); PR_ASSERT(!(me->flags & _PR_IDLE_THREAD)); PR_ASSERT(lock != NULL); -#ifdef _PR_GLOBAL_THREADS_ONLY +#ifdef _PR_GLOBAL_THREADS_ONLY _PR_MD_LOCK(&lock->ilock); PR_ASSERT(lock->owner == 0); lock->owner = me; return; #else /* _PR_GLOBAL_THREADS_ONLY */ - if (_native_threads_only) { - _PR_MD_LOCK(&lock->ilock); - PR_ASSERT(lock->owner == 0); - lock->owner = me; - return; - } + if (_native_threads_only) { + _PR_MD_LOCK(&lock->ilock); + PR_ASSERT(lock->owner == 0); + lock->owner = me; + return; + } - if (!_PR_IS_NATIVE_THREAD(me)) - _PR_INTSOFF(is); + if (!_PR_IS_NATIVE_THREAD(me)) { + _PR_INTSOFF(is); + } PR_ASSERT(_PR_IS_NATIVE_THREAD(me) || _PR_MD_GET_INTSOFF() != 0); @@ -234,11 +237,12 @@ retry: /* Just got the lock */ lock->owner = me; lock->priority = me->priority; - /* Add the granted lock to this owning thread's lock list */ + /* Add the granted lock to this owning thread's lock list */ PR_APPEND_LINK(&lock->links, &me->lockList); _PR_LOCK_UNLOCK(lock); - if (!_PR_IS_NATIVE_THREAD(me)) - _PR_FAST_INTSON(is); + if (!_PR_IS_NATIVE_THREAD(me)) { + _PR_FAST_INTSON(is); + } return; } @@ -258,39 +262,39 @@ retry: } #endif - /* + /* Add this thread to the asked for lock's list of waiting threads. We add this thread thread in the right priority order so when the unlock occurs, the thread with the higher priority will get the lock. */ q = lock->waitQ.next; if (q == &lock->waitQ || _PR_THREAD_CONDQ_PTR(q)->priority == - _PR_THREAD_CONDQ_PTR(lock->waitQ.prev)->priority) { - /* - * If all the threads in the lock waitQ have the same priority, - * then avoid scanning the list: insert the element at the end. - */ - q = &lock->waitQ; + _PR_THREAD_CONDQ_PTR(lock->waitQ.prev)->priority) { + /* + * If all the threads in the lock waitQ have the same priority, + * then avoid scanning the list: insert the element at the end. + */ + q = &lock->waitQ; } else { - /* Sort thread into lock's waitQ at appropriate point */ - /* Now scan the list for where to insert this entry */ - while (q != &lock->waitQ) { - t = _PR_THREAD_CONDQ_PTR(lock->waitQ.next); - if (me->priority > t->priority) { - /* Found a lower priority thread to insert in front of */ - break; - } - q = q->next; - } - } + /* Sort thread into lock's waitQ at appropriate point */ + /* Now scan the list for where to insert this entry */ + while (q != &lock->waitQ) { + t = _PR_THREAD_CONDQ_PTR(lock->waitQ.next); + if (me->priority > t->priority) { + /* Found a lower priority thread to insert in front of */ + break; + } + q = q->next; + } + } PR_INSERT_BEFORE(&me->waitQLinks, q); - /* - Now grab the threadLock since we are about to change the state. We have - to do this since a PR_Suspend or PR_SetThreadPriority type call that takes - a PRThread* as an argument could be changing the state of this thread from - a thread running on a different cpu. - */ + /* + Now grab the threadLock since we are about to change the state. We have + to do this since a PR_Suspend or PR_SetThreadPriority type call that takes + a PRThread* as an argument could be changing the state of this thread from + a thread running on a different cpu. + */ _PR_THREAD_LOCK(me); me->state = _PR_LOCK_WAIT; @@ -300,7 +304,7 @@ retry: _PR_LOCK_UNLOCK(lock); _PR_MD_WAIT(me, PR_INTERVAL_NO_TIMEOUT); - goto retry; + goto retry; #endif /* _PR_GLOBAL_THREADS_ONLY */ } @@ -317,29 +321,30 @@ PR_IMPLEMENT(PRStatus) PR_Unlock(PRLock *lock) PR_ASSERT(lock != NULL); PR_ASSERT(lock->owner == me); - PR_ASSERT(me != suspendAllThread); + PR_ASSERT(me != suspendAllThread); PR_ASSERT(!(me->flags & _PR_IDLE_THREAD)); if (lock->owner != me) { return PR_FAILURE; } -#ifdef _PR_GLOBAL_THREADS_ONLY +#ifdef _PR_GLOBAL_THREADS_ONLY lock->owner = 0; _PR_MD_UNLOCK(&lock->ilock); return PR_SUCCESS; #else /* _PR_GLOBAL_THREADS_ONLY */ - if (_native_threads_only) { - lock->owner = 0; - _PR_MD_UNLOCK(&lock->ilock); - return PR_SUCCESS; - } + if (_native_threads_only) { + lock->owner = 0; + _PR_MD_UNLOCK(&lock->ilock); + return PR_SUCCESS; + } - if (!_PR_IS_NATIVE_THREAD(me)) - _PR_INTSOFF(is); + if (!_PR_IS_NATIVE_THREAD(me)) { + _PR_INTSOFF(is); + } _PR_LOCK_LOCK(lock); - /* Remove the lock from the owning thread's lock list */ + /* Remove the lock from the owning thread's lock list */ PR_REMOVE_LINK(&lock->links); pri = lock->priority; boost = lock->boostPriority; @@ -365,13 +370,15 @@ PR_IMPLEMENT(PRStatus) PR_Unlock(PRLock *lock) /* Unblock the first waiting thread */ q = lock->waitQ.next; - if (q != &lock->waitQ) + if (q != &lock->waitQ) { _PR_UnblockLockWaiter(lock); + } lock->boostPriority = PR_PRIORITY_LOW; lock->owner = 0; _PR_LOCK_UNLOCK(lock); - if (!_PR_IS_NATIVE_THREAD(me)) - _PR_INTSON(is); + if (!_PR_IS_NATIVE_THREAD(me)) { + _PR_INTSON(is); + } return PR_SUCCESS; #endif /* _PR_GLOBAL_THREADS_ONLY */ } @@ -397,7 +404,7 @@ PR_IMPLEMENT(PRBool) PR_TestAndLock(PRLock *lock) PRBool rv = PR_FALSE; PRIntn is; -#ifdef _PR_GLOBAL_THREADS_ONLY +#ifdef _PR_GLOBAL_THREADS_ONLY is = _PR_MD_TEST_AND_LOCK(&lock->ilock); if (is == 0) { lock->owner = me; @@ -407,32 +414,34 @@ PR_IMPLEMENT(PRBool) PR_TestAndLock(PRLock *lock) #else /* _PR_GLOBAL_THREADS_ONLY */ #ifndef _PR_LOCAL_THREADS_ONLY - if (_native_threads_only) { - is = _PR_MD_TEST_AND_LOCK(&lock->ilock); - if (is == 0) { - lock->owner = me; - return PR_TRUE; - } - return PR_FALSE; - } + if (_native_threads_only) { + is = _PR_MD_TEST_AND_LOCK(&lock->ilock); + if (is == 0) { + lock->owner = me; + return PR_TRUE; + } + return PR_FALSE; + } #endif - if (!_PR_IS_NATIVE_THREAD(me)) - _PR_INTSOFF(is); + if (!_PR_IS_NATIVE_THREAD(me)) { + _PR_INTSOFF(is); + } _PR_LOCK_LOCK(lock); if (lock->owner == 0) { /* Just got the lock */ lock->owner = me; lock->priority = me->priority; - /* Add the granted lock to this owning thread's lock list */ + /* Add the granted lock to this owning thread's lock list */ PR_APPEND_LINK(&lock->links, &me->lockList); rv = PR_TRUE; } _PR_LOCK_UNLOCK(lock); - if (!_PR_IS_NATIVE_THREAD(me)) - _PR_INTSON(is); + if (!_PR_IS_NATIVE_THREAD(me)) { + _PR_INTSON(is); + } return rv; #endif /* _PR_GLOBAL_THREADS_ONLY */ } @@ -443,4 +452,6 @@ PR_IMPLEMENT(PRBool) PR_TestAndLock(PRLock *lock) /************************************************************************/ /************************************************************************/ PR_IMPLEMENT(PRStatus) PRP_TryLock(PRLock *lock) - { return (PR_TestAndLock(lock)) ? PR_SUCCESS : PR_FAILURE; } +{ + return (PR_TestAndLock(lock)) ? PR_SUCCESS : PR_FAILURE; +} diff --git a/nsprpub/pr/src/threads/combined/prustack.c b/nsprpub/pr/src/threads/combined/prustack.c index 59562bac4..3f5452c48 100644 --- a/nsprpub/pr/src/threads/combined/prustack.c +++ b/nsprpub/pr/src/threads/combined/prustack.c @@ -19,7 +19,7 @@ PRBool _pr_debugStacks = PR_FALSE; #endif /* How much space to leave between the stacks, at each end */ -#define REDZONE (2 << _pr_pageShift) +#define REDZONE (2 << _pr_pageShift) #define _PR_THREAD_STACK_PTR(_qp) \ ((PRThreadStack*) ((char*) (_qp) - offsetof(PRThreadStack,links))) @@ -54,22 +54,23 @@ PRThreadStack *_PR_NewStack(PRUint32 stackSize) PR_Lock(_pr_stackLock); qp = _pr_freeStacks.prev; while ((_pr_numFreeStacks > _pr_maxFreeStacks) && (qp != &_pr_freeStacks)) { - ts = _PR_THREAD_STACK_PTR(qp); - thr = _PR_THREAD_STACK_TO_PTR(ts); - qp = qp->prev; - /* - * skip stacks which are still being used - */ - if (thr->no_sched) - continue; - PR_REMOVE_LINK(&ts->links); - - /* Give platform OS to clear out the stack for debugging */ - _PR_MD_CLEAR_STACK(ts); - - _pr_numFreeStacks--; - _PR_DestroySegment(ts->seg); - PR_DELETE(ts); + ts = _PR_THREAD_STACK_PTR(qp); + thr = _PR_THREAD_STACK_TO_PTR(ts); + qp = qp->prev; + /* + * skip stacks which are still being used + */ + if (thr->no_sched) { + continue; + } + PR_REMOVE_LINK(&ts->links); + + /* Give platform OS to clear out the stack for debugging */ + _PR_MD_CLEAR_STACK(ts); + + _pr_numFreeStacks--; + _PR_DestroySegment(ts->seg); + PR_DELETE(ts); } /* @@ -79,51 +80,51 @@ PRThreadStack *_PR_NewStack(PRUint32 stackSize) qp = _pr_freeStacks.next; ts = 0; while (qp != &_pr_freeStacks) { - ts = _PR_THREAD_STACK_PTR(qp); - thr = _PR_THREAD_STACK_TO_PTR(ts); - qp = qp->next; - /* - * skip stacks which are still being used - */ - if ((!(thr->no_sched)) && ((ts->allocSize - 2*REDZONE) >= stackSize)) { - /* - ** Found a stack that is not in use and is big enough. Change - ** stackSize to fit it. - */ - stackSize = ts->allocSize - 2*REDZONE; - PR_REMOVE_LINK(&ts->links); - _pr_numFreeStacks--; - ts->links.next = 0; - ts->links.prev = 0; - PR_Unlock(_pr_stackLock); - goto done; - } - ts = 0; + ts = _PR_THREAD_STACK_PTR(qp); + thr = _PR_THREAD_STACK_TO_PTR(ts); + qp = qp->next; + /* + * skip stacks which are still being used + */ + if ((!(thr->no_sched)) && ((ts->allocSize - 2*REDZONE) >= stackSize)) { + /* + ** Found a stack that is not in use and is big enough. Change + ** stackSize to fit it. + */ + stackSize = ts->allocSize - 2*REDZONE; + PR_REMOVE_LINK(&ts->links); + _pr_numFreeStacks--; + ts->links.next = 0; + ts->links.prev = 0; + PR_Unlock(_pr_stackLock); + goto done; + } + ts = 0; } PR_Unlock(_pr_stackLock); if (!ts) { - /* Make a new thread stack object. */ - ts = PR_NEWZAP(PRThreadStack); - if (!ts) { - return NULL; - } - - /* - ** Assign some of the virtual space to the new stack object. We - ** may not get that piece of VM, but if nothing else we will - ** advance the pointer so we don't collide (unless the OS screws - ** up). - */ - ts->allocSize = stackSize + 2*REDZONE; - ts->seg = _PR_NewSegment(ts->allocSize, 0); - if (!ts->seg) { - PR_DELETE(ts); - return NULL; - } - } - - done: + /* Make a new thread stack object. */ + ts = PR_NEWZAP(PRThreadStack); + if (!ts) { + return NULL; + } + + /* + ** Assign some of the virtual space to the new stack object. We + ** may not get that piece of VM, but if nothing else we will + ** advance the pointer so we don't collide (unless the OS screws + ** up). + */ + ts->allocSize = stackSize + 2*REDZONE; + ts->seg = _PR_NewSegment(ts->allocSize, 0); + if (!ts->seg) { + PR_DELETE(ts); + return NULL; + } + } + +done: ts->allocBase = (char*)ts->seg->vaddr; ts->flags = _PR_STACK_MAPPED; ts->stackSize = stackSize; @@ -137,11 +138,11 @@ PRThreadStack *_PR_NewStack(PRUint32 stackSize) #endif PR_LOG(_pr_thread_lm, PR_LOG_NOTICE, - ("thread stack: base=0x%x limit=0x%x bottom=0x%x top=0x%x\n", - ts->allocBase, ts->allocBase + ts->allocSize - 1, - ts->allocBase + REDZONE, - ts->allocBase + REDZONE + stackSize - 1)); - + ("thread stack: base=0x%x limit=0x%x bottom=0x%x top=0x%x\n", + ts->allocBase, ts->allocBase + ts->allocSize - 1, + ts->allocBase + REDZONE, + ts->allocBase + REDZONE + stackSize - 1)); + _PR_MD_INIT_STACK(ts,REDZONE); return ts; @@ -153,11 +154,11 @@ PRThreadStack *_PR_NewStack(PRUint32 stackSize) void _PR_FreeStack(PRThreadStack *ts) { if (!ts) { - return; + return; } if (ts->flags & _PR_STACK_PRIMORDIAL) { - PR_DELETE(ts); - return; + PR_DELETE(ts); + return; } /* diff --git a/nsprpub/pr/src/threads/combined/pruthr.c b/nsprpub/pr/src/threads/combined/pruthr.c index 4625ab246..44a082007 100644 --- a/nsprpub/pr/src/threads/combined/pruthr.c +++ b/nsprpub/pr/src/threads/combined/pruthr.c @@ -7,7 +7,7 @@ #include <signal.h> #include <string.h> -#if defined(WIN95) +#if defined(WIN95) /* ** Some local variables report warnings on Win95 because the code paths ** using them are conditioned on HAVE_CUSTOME_USER_THREADS. @@ -15,7 +15,7 @@ ** */ #pragma warning(disable : 4101) -#endif +#endif /* _pr_activeLock protects the following global variables */ PRLock *_pr_activeLock; @@ -28,7 +28,7 @@ PRInt32 _pr_primordialExitCount; /* In PR_Cleanup(), the primordial thread * If the primordial thread is a system * thread, then _pr_primordialExitCount * is 0. If the primordial thread is - * itself a user thread, then + * itself a user thread, then * _pr_primordialThread is 1. */ PRCondVar *_pr_primordialExitCVar; /* When _pr_userActive is decremented to @@ -60,7 +60,7 @@ static void _PR_InitializeRecycledThread(PRThread *thread); static void _PR_UserRunThread(void); void _PR_InitThreads(PRThreadType type, PRThreadPriority priority, - PRUintn maxPTDs) + PRUintn maxPTDs) { PRThread *thread; PRThreadStack *stack; @@ -74,13 +74,13 @@ void _PR_InitThreads(PRThreadType type, PRThreadPriority priority, stack = PR_NEWZAP(PRThreadStack); #ifdef HAVE_STACK_GROWING_UP stack->stackTop = (char*) ((((PRWord)&type) >> _pr_pageShift) - << _pr_pageShift); + << _pr_pageShift); #else #if defined(SOLARIS) || defined (UNIXWARE) && defined (USR_SVR4_THREADS) stack->stackTop = (char*) &thread; #else stack->stackTop = (char*) ((((PRWord)&type + _pr_pageSize - 1) - >> _pr_pageShift) << _pr_pageShift); + >> _pr_pageShift) << _pr_pageShift); #endif #endif #else @@ -104,11 +104,13 @@ void _PR_InitThreads(PRThreadType type, PRThreadPriority priority, _pr_userActive++; _pr_primordialExitCount = 1; } - thread->no_sched = 1; - _pr_primordialExitCVar = PR_NewCondVar(_pr_activeLock); + thread->no_sched = 1; + _pr_primordialExitCVar = PR_NewCondVar(_pr_activeLock); } - if (!thread) PR_Abort(); + if (!thread) { + PR_Abort(); + } #ifdef _PR_LOCAL_THREADS_ONLY thread->flags |= _PR_PRIMORDIAL; #else @@ -174,13 +176,13 @@ static void _PR_InitializeNativeStack(PRThreadStack *ts) ** Setup stackTop and stackBottom values. */ #ifdef HAVE_STACK_GROWING_UP - ts->allocBase = (char*) ((((PRWord)&ts) >> _pr_pageShift) - << _pr_pageShift); + ts->allocBase = (char*) ((((PRWord)&ts) >> _pr_pageShift) + << _pr_pageShift); ts->stackBottom = ts->allocBase + ts->stackSize; ts->stackTop = ts->allocBase; #else ts->allocBase = (char*) ((((PRWord)&ts + _pr_pageSize - 1) - >> _pr_pageShift) << _pr_pageShift); + >> _pr_pageShift) << _pr_pageShift); ts->stackTop = ts->allocBase; ts->stackBottom = ts->allocBase - ts->stackSize; #endif @@ -195,7 +197,7 @@ void _PR_NotifyJoinWaiters(PRThread *thread) ** Notify on our "termination" condition variable so that joining ** thread will know about our termination. Switch our context and ** come back later on to continue the cleanup. - */ + */ PR_ASSERT(thread == _PR_MD_CURRENT_THREAD()); if (thread->term != NULL) { PR_Lock(_pr_terminationCVLock); @@ -251,19 +253,19 @@ static void _PR_InitializeRecycledThread(PRThread *thread) PRStatus _PR_RecycleThread(PRThread *thread) { if ( _PR_IS_NATIVE_THREAD(thread) && - _PR_NUM_DEADNATIVE < _pr_recycleThreads) { + _PR_NUM_DEADNATIVE < _pr_recycleThreads) { _PR_DEADQ_LOCK; PR_APPEND_LINK(&thread->links, &_PR_DEADNATIVEQ); _PR_INC_DEADNATIVE; _PR_DEADQ_UNLOCK; - return (PR_SUCCESS); + return (PR_SUCCESS); } else if ( !_PR_IS_NATIVE_THREAD(thread) && _PR_NUM_DEADUSER < _pr_recycleThreads) { _PR_DEADQ_LOCK; PR_APPEND_LINK(&thread->links, &_PR_DEADUSERQ); _PR_INC_DEADUSER; _PR_DEADQ_UNLOCK; - return (PR_SUCCESS); + return (PR_SUCCESS); } return (PR_FAILURE); } @@ -433,7 +435,7 @@ void _PR_NativeRunThread(void *arg) thread->state = _PR_DEAD_STATE; if (!_pr_recycleThreads || (_PR_RecycleThread(thread) == - PR_FAILURE)) { + PR_FAILURE)) { /* * thread not recycled * platform-specific thread exit processing @@ -460,8 +462,9 @@ static void _PR_UserRunThread(void) PRThread *thread = _PR_MD_CURRENT_THREAD(); PRIntn is; - if (_MD_LAST_THREAD()) - _MD_LAST_THREAD()->no_sched = 0; + if (_MD_LAST_THREAD()) { + _MD_LAST_THREAD()->no_sched = 0; + } #ifdef HAVE_CUSTOM_USER_THREADS if (thread->stack == NULL) { @@ -472,17 +475,19 @@ static void _PR_UserRunThread(void) while(1) { /* Run thread main */ - if ( !_PR_IS_NATIVE_THREAD(thread)) _PR_MD_SET_INTSOFF(0); + if ( !_PR_IS_NATIVE_THREAD(thread)) { + _PR_MD_SET_INTSOFF(0); + } - /* - * Add to list of active threads - */ - if (!(thread->flags & _PR_IDLE_THREAD)) { - PR_Lock(_pr_activeLock); - PR_APPEND_LINK(&thread->active, &_PR_ACTIVE_LOCAL_THREADQ()); - _pr_local_threads++; - PR_Unlock(_pr_activeLock); - } + /* + * Add to list of active threads + */ + if (!(thread->flags & _PR_IDLE_THREAD)) { + PR_Lock(_pr_activeLock); + PR_APPEND_LINK(&thread->active, &_PR_ACTIVE_LOCAL_THREADQ()); + _pr_local_threads++; + PR_Unlock(_pr_activeLock); + } (*thread->startFunc)(thread->arg); @@ -504,33 +509,33 @@ static void _PR_UserRunThread(void) PR_ASSERT(thread->io_suspended == PR_FALSE); PR_Lock(_pr_activeLock); - /* - * remove thread from list of active threads - */ - if (!(thread->flags & _PR_IDLE_THREAD)) { - PR_REMOVE_LINK(&thread->active); - _pr_local_threads--; - } - PR_Unlock(_pr_activeLock); + /* + * remove thread from list of active threads + */ + if (!(thread->flags & _PR_IDLE_THREAD)) { + PR_REMOVE_LINK(&thread->active); + _pr_local_threads--; + } + PR_Unlock(_pr_activeLock); PR_LOG(_pr_thread_lm, PR_LOG_MIN, ("thread exiting")); /* All done, time to go away */ _PR_CleanupThread(thread); - _PR_INTSOFF(is); + _PR_INTSOFF(is); _PR_NotifyJoinWaiters(thread); - _PR_DecrActiveThreadCount(thread); + _PR_DecrActiveThreadCount(thread); thread->state = _PR_DEAD_STATE; if (!_pr_recycleThreads || (_PR_RecycleThread(thread) == - PR_FAILURE)) { + PR_FAILURE)) { /* ** Destroy the thread resources */ - _PR_UserDestroyThread(thread); + _PR_UserDestroyThread(thread); } /* @@ -557,54 +562,58 @@ void _PR_SetThreadPriority(PRThread *thread, PRThreadPriority newPri) return; } - if (!_PR_IS_NATIVE_THREAD(me)) - _PR_INTSOFF(is); + if (!_PR_IS_NATIVE_THREAD(me)) { + _PR_INTSOFF(is); + } _PR_THREAD_LOCK(thread); if (newPri != thread->priority) { - _PRCPU *cpu = thread->cpu; + _PRCPU *cpu = thread->cpu; - switch (thread->state) { - case _PR_RUNNING: - /* Change my priority */ + switch (thread->state) { + case _PR_RUNNING: + /* Change my priority */ - _PR_RUNQ_LOCK(cpu); - thread->priority = newPri; - if (_PR_RUNQREADYMASK(cpu) >> (newPri + 1)) { - if (!_PR_IS_NATIVE_THREAD(me)) - _PR_SET_RESCHED_FLAG(); - } - _PR_RUNQ_UNLOCK(cpu); - break; + _PR_RUNQ_LOCK(cpu); + thread->priority = newPri; + if (_PR_RUNQREADYMASK(cpu) >> (newPri + 1)) { + if (!_PR_IS_NATIVE_THREAD(me)) { + _PR_SET_RESCHED_FLAG(); + } + } + _PR_RUNQ_UNLOCK(cpu); + break; - case _PR_RUNNABLE: + case _PR_RUNNABLE: - _PR_RUNQ_LOCK(cpu); - /* Move to different runQ */ - _PR_DEL_RUNQ(thread); - thread->priority = newPri; - PR_ASSERT(!(thread->flags & _PR_IDLE_THREAD)); - _PR_ADD_RUNQ(thread, cpu, newPri); - _PR_RUNQ_UNLOCK(cpu); + _PR_RUNQ_LOCK(cpu); + /* Move to different runQ */ + _PR_DEL_RUNQ(thread); + thread->priority = newPri; + PR_ASSERT(!(thread->flags & _PR_IDLE_THREAD)); + _PR_ADD_RUNQ(thread, cpu, newPri); + _PR_RUNQ_UNLOCK(cpu); - if (newPri > me->priority) { - if (!_PR_IS_NATIVE_THREAD(me)) - _PR_SET_RESCHED_FLAG(); - } + if (newPri > me->priority) { + if (!_PR_IS_NATIVE_THREAD(me)) { + _PR_SET_RESCHED_FLAG(); + } + } - break; + break; - case _PR_LOCK_WAIT: - case _PR_COND_WAIT: - case _PR_IO_WAIT: - case _PR_SUSPENDED: + case _PR_LOCK_WAIT: + case _PR_COND_WAIT: + case _PR_IO_WAIT: + case _PR_SUSPENDED: - thread->priority = newPri; - break; - } + thread->priority = newPri; + break; + } } _PR_THREAD_UNLOCK(thread); - if (!_PR_IS_NATIVE_THREAD(me)) - _PR_INTSON(is); + if (!_PR_IS_NATIVE_THREAD(me)) { + _PR_INTSON(is); + } } /* @@ -618,51 +627,53 @@ static void _PR_Suspend(PRThread *thread) PR_ASSERT(thread != me); PR_ASSERT(!_PR_IS_NATIVE_THREAD(thread) || (!thread->cpu)); - if (!_PR_IS_NATIVE_THREAD(me)) + if (!_PR_IS_NATIVE_THREAD(me)) { _PR_INTSOFF(is); + } _PR_THREAD_LOCK(thread); switch (thread->state) { - case _PR_RUNNABLE: - if (!_PR_IS_NATIVE_THREAD(thread)) { - _PR_RUNQ_LOCK(thread->cpu); - _PR_DEL_RUNQ(thread); - _PR_RUNQ_UNLOCK(thread->cpu); + case _PR_RUNNABLE: + if (!_PR_IS_NATIVE_THREAD(thread)) { + _PR_RUNQ_LOCK(thread->cpu); + _PR_DEL_RUNQ(thread); + _PR_RUNQ_UNLOCK(thread->cpu); + + _PR_MISCQ_LOCK(thread->cpu); + _PR_ADD_SUSPENDQ(thread, thread->cpu); + _PR_MISCQ_UNLOCK(thread->cpu); + } else { + /* + * Only LOCAL threads are suspended by _PR_Suspend + */ + PR_ASSERT(0); + } + thread->state = _PR_SUSPENDED; + break; - _PR_MISCQ_LOCK(thread->cpu); - _PR_ADD_SUSPENDQ(thread, thread->cpu); - _PR_MISCQ_UNLOCK(thread->cpu); - } else { + case _PR_RUNNING: /* - * Only LOCAL threads are suspended by _PR_Suspend + * The thread being suspended should be a LOCAL thread with + * _pr_numCPUs == 1. Hence, the thread cannot be in RUNNING state */ - PR_ASSERT(0); - } - thread->state = _PR_SUSPENDED; - break; - - case _PR_RUNNING: - /* - * The thread being suspended should be a LOCAL thread with - * _pr_numCPUs == 1. Hence, the thread cannot be in RUNNING state - */ - PR_ASSERT(0); - break; + PR_ASSERT(0); + break; - case _PR_LOCK_WAIT: - case _PR_IO_WAIT: - case _PR_COND_WAIT: - if (_PR_IS_NATIVE_THREAD(thread)) { - _PR_MD_SUSPEND_THREAD(thread); - } - thread->flags |= _PR_SUSPENDING; - break; + case _PR_LOCK_WAIT: + case _PR_IO_WAIT: + case _PR_COND_WAIT: + if (_PR_IS_NATIVE_THREAD(thread)) { + _PR_MD_SUSPEND_THREAD(thread); + } + thread->flags |= _PR_SUSPENDING; + break; - default: - PR_Abort(); + default: + PR_Abort(); } _PR_THREAD_UNLOCK(thread); - if (!_PR_IS_NATIVE_THREAD(me)) - _PR_INTSON(is); + if (!_PR_IS_NATIVE_THREAD(me)) { + _PR_INTSON(is); + } } static void _PR_Resume(PRThread *thread) @@ -671,72 +682,75 @@ static void _PR_Resume(PRThread *thread) PRIntn is; PRThread *me = _PR_MD_CURRENT_THREAD(); - if (!_PR_IS_NATIVE_THREAD(me)) - _PR_INTSOFF(is); + if (!_PR_IS_NATIVE_THREAD(me)) { + _PR_INTSOFF(is); + } _PR_THREAD_LOCK(thread); switch (thread->state) { - case _PR_SUSPENDED: - thread->state = _PR_RUNNABLE; - thread->flags &= ~_PR_SUSPENDING; - if (!_PR_IS_NATIVE_THREAD(thread)) { - _PR_MISCQ_LOCK(thread->cpu); - _PR_DEL_SUSPENDQ(thread); - _PR_MISCQ_UNLOCK(thread->cpu); + case _PR_SUSPENDED: + thread->state = _PR_RUNNABLE; + thread->flags &= ~_PR_SUSPENDING; + if (!_PR_IS_NATIVE_THREAD(thread)) { + _PR_MISCQ_LOCK(thread->cpu); + _PR_DEL_SUSPENDQ(thread); + _PR_MISCQ_UNLOCK(thread->cpu); + + pri = thread->priority; + + _PR_RUNQ_LOCK(thread->cpu); + _PR_ADD_RUNQ(thread, thread->cpu, pri); + _PR_RUNQ_UNLOCK(thread->cpu); + + if (pri > _PR_MD_CURRENT_THREAD()->priority) { + if (!_PR_IS_NATIVE_THREAD(me)) { + _PR_SET_RESCHED_FLAG(); + } + } + } else { + PR_ASSERT(0); + } + break; - pri = thread->priority; + case _PR_IO_WAIT: + case _PR_COND_WAIT: + thread->flags &= ~_PR_SUSPENDING; + /* PR_ASSERT(thread->wait.monitor->stickyCount == 0); */ + break; - _PR_RUNQ_LOCK(thread->cpu); - _PR_ADD_RUNQ(thread, thread->cpu, pri); - _PR_RUNQ_UNLOCK(thread->cpu); + case _PR_LOCK_WAIT: + { + PRLock *wLock = thread->wait.lock; + + thread->flags &= ~_PR_SUSPENDING; - if (pri > _PR_MD_CURRENT_THREAD()->priority) { - if (!_PR_IS_NATIVE_THREAD(me)) - _PR_SET_RESCHED_FLAG(); + _PR_LOCK_LOCK(wLock); + if (thread->wait.lock->owner == 0) { + _PR_UnblockLockWaiter(thread->wait.lock); } - } else { - PR_ASSERT(0); + _PR_LOCK_UNLOCK(wLock); + break; } - break; - - case _PR_IO_WAIT: - case _PR_COND_WAIT: - thread->flags &= ~_PR_SUSPENDING; -/* PR_ASSERT(thread->wait.monitor->stickyCount == 0); */ - break; - - case _PR_LOCK_WAIT: - { - PRLock *wLock = thread->wait.lock; - - thread->flags &= ~_PR_SUSPENDING; - - _PR_LOCK_LOCK(wLock); - if (thread->wait.lock->owner == 0) { - _PR_UnblockLockWaiter(thread->wait.lock); - } - _PR_LOCK_UNLOCK(wLock); - break; - } - case _PR_RUNNABLE: - break; - case _PR_RUNNING: - /* - * The thread being suspended should be a LOCAL thread with - * _pr_numCPUs == 1. Hence, the thread cannot be in RUNNING state - */ - PR_ASSERT(0); - break; + case _PR_RUNNABLE: + break; + case _PR_RUNNING: + /* + * The thread being suspended should be a LOCAL thread with + * _pr_numCPUs == 1. Hence, the thread cannot be in RUNNING state + */ + PR_ASSERT(0); + break; - default: - /* - * thread should have been in one of the above-listed blocked states - * (_PR_JOIN_WAIT, _PR_IO_WAIT, _PR_UNBORN, _PR_DEAD_STATE) - */ - PR_Abort(); + default: + /* + * thread should have been in one of the above-listed blocked states + * (_PR_JOIN_WAIT, _PR_IO_WAIT, _PR_UNBORN, _PR_DEAD_STATE) + */ + PR_Abort(); } _PR_THREAD_UNLOCK(thread); - if (!_PR_IS_NATIVE_THREAD(me)) + if (!_PR_IS_NATIVE_THREAD(me)) { _PR_INTSON(is); + } } @@ -761,8 +775,8 @@ static PRThread *get_thread(_PRCPU *cpu, PRBool *wakeup_cpus) } thread = NULL; for (pri = priMax; pri >= priMin ; pri-- ) { - if (r & (1 << pri)) { - for (qp = _PR_RUNQ(cpu)[pri].next; + if (r & (1 << pri)) { + for (qp = _PR_RUNQ(cpu)[pri].next; qp != &_PR_RUNQ(cpu)[pri]; qp = qp->next) { thread = _PR_THREAD_PTR(qp); @@ -786,9 +800,6 @@ static PRThread *get_thread(_PRCPU *cpu, PRBool *wakeup_cpus) */ thread = NULL; -#ifdef IRIX - _PR_MD_WAKEUP_PRIMORDIAL_CPU(); -#endif continue; } else if (thread->io_pending == PR_TRUE) { /* @@ -854,16 +865,16 @@ void _PR_Schedule(void) * operation, for example */ if ((thread = suspendAllThread) != 0) { - if ((!(thread->no_sched)) && (thread->state == _PR_RUNNABLE)) { + if ((!(thread->no_sched)) && (thread->state == _PR_RUNNABLE)) { /* Pull thread off of its run queue */ _PR_DEL_RUNQ(thread); _PR_RUNQ_UNLOCK(cpu); goto found_thread; - } else { + } else { thread = NULL; _PR_RUNQ_UNLOCK(cpu); goto idle_thread; - } + } } r = _PR_RUNQREADYMASK(cpu); if (r==0) { @@ -876,8 +887,8 @@ void _PR_Schedule(void) } thread = NULL; for (pri = priMax; pri >= priMin ; pri-- ) { - if (r & (1 << pri)) { - for (qp = _PR_RUNQ(cpu)[pri].next; + if (r & (1 << pri)) { + for (qp = _PR_RUNQ(cpu)[pri].next; qp != &_PR_RUNQ(cpu)[pri]; qp = qp->next) { thread = _PR_THREAD_PTR(qp); @@ -885,7 +896,7 @@ void _PR_Schedule(void) * skip non-schedulable threads */ PR_ASSERT(!(thread->flags & _PR_IDLE_THREAD)); - if ((thread->no_sched) && (me != thread)){ + if ((thread->no_sched) && (me != thread)) { thread = NULL; continue; } else { @@ -907,48 +918,51 @@ void _PR_Schedule(void) for (qp = _PR_CPUQ().next; qp != &_PR_CPUQ(); qp = qp->next) { if (cpu != _PR_CPU_PTR(qp)) { if ((thread = get_thread(_PR_CPU_PTR(qp), &wakeup_cpus)) - != NULL) { + != NULL) { thread->cpu = cpu; _PR_CPU_LIST_UNLOCK(); - if (wakeup_cpus == PR_TRUE) + if (wakeup_cpus == PR_TRUE) { _PR_MD_WAKEUP_CPUS(); + } goto found_thread; } } } _PR_CPU_LIST_UNLOCK(); - if (wakeup_cpus == PR_TRUE) + if (wakeup_cpus == PR_TRUE) { _PR_MD_WAKEUP_CPUS(); + } #endif /* _PR_LOCAL_THREADS_ONLY */ idle_thread: - /* - ** There are no threads to run. Switch to the idle thread - */ + /* + ** There are no threads to run. Switch to the idle thread + */ PR_LOG(_pr_sched_lm, PR_LOG_MAX, ("pausing")); thread = _PR_MD_CURRENT_CPU()->idle_thread; found_thread: PR_ASSERT((me == thread) || ((thread->state == _PR_RUNNABLE) && - (!(thread->no_sched)))); + (!(thread->no_sched)))); /* Resume the thread */ PR_LOG(_pr_sched_lm, PR_LOG_MAX, - ("switching to %d[%p]", thread->id, thread)); + ("switching to %d[%p]", thread->id, thread)); PR_ASSERT(thread->state != _PR_RUNNING); thread->state = _PR_RUNNING; - + /* If we are on the runq, it just means that we went to sleep on some * resource, and by the time we got here another real native thread had - * already given us the resource and put us back on the runqueue + * already given us the resource and put us back on the runqueue */ - PR_ASSERT(thread->cpu == _PR_MD_CURRENT_CPU()); - if (thread != me) + PR_ASSERT(thread->cpu == _PR_MD_CURRENT_CPU()); + if (thread != me) { _PR_MD_RESTORE_CONTEXT(thread); + } #if 0 - /* XXXMB; with setjmp/longjmp it is impossible to land here, but - * it is not with fibers... Is this a bad thing? I believe it is + /* XXXMB; with setjmp/longjmp it is impossible to land here, but + * it is not with fibers... Is this a bad thing? I believe it is * still safe. */ PR_NOT_REACHED("impossible return from schedule"); @@ -956,13 +970,13 @@ found_thread: } /* -** Attaches a thread. -** Does not set the _PR_MD_CURRENT_THREAD. +** Attaches a thread. +** Does not set the _PR_MD_CURRENT_THREAD. ** Does not specify the scope of the thread. */ static PRThread * _PR_AttachThread(PRThreadType type, PRThreadPriority priority, - PRThreadStack *stack) + PRThreadStack *stack) { PRThread *thread; char *mem; @@ -981,9 +995,9 @@ _PR_AttachThread(PRThreadType type, PRThreadPriority priority, thread->state = _PR_RUNNING; PR_INIT_CLIST(&thread->lockList); if (_PR_MD_NEW_LOCK(&thread->threadLock) == PR_FAILURE) { - PR_DELETE(thread); - return 0; - } + PR_DELETE(thread); + return 0; + } return thread; } @@ -992,15 +1006,15 @@ _PR_AttachThread(PRThreadType type, PRThreadPriority priority, -PR_IMPLEMENT(PRThread*) +PR_IMPLEMENT(PRThread*) _PR_NativeCreateThread(PRThreadType type, - void (*start)(void *arg), - void *arg, - PRThreadPriority priority, - PRThreadScope scope, - PRThreadState state, - PRUint32 stackSize, - PRUint32 flags) + void (*start)(void *arg), + void *arg, + PRThreadPriority priority, + PRThreadScope scope, + PRThreadState state, + PRUint32 stackSize, + PRUint32 flags) { PRThread *thread; @@ -1028,33 +1042,33 @@ _PR_NativeCreateThread(PRThreadType type, thread->startFunc = start; thread->arg = arg; - /* + /* Set thread flags related to scope and joinable state. If joinable thread, allocate a "termination" conidition variable. */ if (state == PR_JOINABLE_THREAD) { thread->term = PR_NewCondVar(_pr_terminationCVLock); - if (thread->term == NULL) { - PR_DELETE(thread->stack); - goto done; - } + if (thread->term == NULL) { + PR_DELETE(thread->stack); + goto done; + } } - thread->state = _PR_RUNNING; + thread->state = _PR_RUNNING; if (_PR_MD_CREATE_THREAD(thread, _PR_NativeRunThread, priority, - scope,state,stackSize) == PR_SUCCESS) { + scope,state,stackSize) == PR_SUCCESS) { return thread; } if (thread->term) { PR_DestroyCondVar(thread->term); thread->term = NULL; } - PR_DELETE(thread->stack); + PR_DELETE(thread->stack); } done: if (thread) { - _PR_DecrActiveThreadCount(thread); + _PR_DecrActiveThreadCount(thread); _PR_DestroyThread(thread); } return NULL; @@ -1063,13 +1077,13 @@ done: /************************************************************************/ PR_IMPLEMENT(PRThread*) _PR_CreateThread(PRThreadType type, - void (*start)(void *arg), - void *arg, - PRThreadPriority priority, - PRThreadScope scope, - PRThreadState state, - PRUint32 stackSize, - PRUint32 flags) + void (*start)(void *arg), + void *arg, + PRThreadPriority priority, + PRThreadScope scope, + PRThreadState state, + PRUint32 stackSize, + PRUint32 flags) { PRThread *me; PRThread *thread = NULL; @@ -1080,7 +1094,7 @@ PR_IMPLEMENT(PRThread*) _PR_CreateThread(PRThreadType type, PRIntn useRecycled = 0; PRBool status; - /* + /* First, pin down the priority. Not all compilers catch passing out of range enum here. If we let bad values thru, priority queues won't work. */ @@ -1089,34 +1103,39 @@ PR_IMPLEMENT(PRThread*) _PR_CreateThread(PRThreadType type, } else if (priority < PR_PRIORITY_FIRST) { priority = PR_PRIORITY_FIRST; } - - if (!_pr_initialized) _PR_ImplicitInitialization(); - if (! (flags & _PR_IDLE_THREAD)) + if (!_pr_initialized) { + _PR_ImplicitInitialization(); + } + + if (! (flags & _PR_IDLE_THREAD)) { me = _PR_MD_CURRENT_THREAD(); + } #if defined(_PR_GLOBAL_THREADS_ONLY) - /* - * can create global threads only - */ - if (scope == PR_LOCAL_THREAD) - scope = PR_GLOBAL_THREAD; + /* + * can create global threads only + */ + if (scope == PR_LOCAL_THREAD) { + scope = PR_GLOBAL_THREAD; + } #endif - if (_native_threads_only) - scope = PR_GLOBAL_THREAD; + if (_native_threads_only) { + scope = PR_GLOBAL_THREAD; + } native = (((scope == PR_GLOBAL_THREAD)|| (scope == PR_GLOBAL_BOUND_THREAD)) - && _PR_IS_NATIVE_THREAD_SUPPORTED()); + && _PR_IS_NATIVE_THREAD_SUPPORTED()); _PR_ADJUST_STACKSIZE(stackSize); if (native) { - /* - * clear the IDLE_THREAD flag which applies to LOCAL - * threads only - */ - flags &= ~_PR_IDLE_THREAD; + /* + * clear the IDLE_THREAD flag which applies to LOCAL + * threads only + */ + flags &= ~_PR_IDLE_THREAD; flags |= _PR_GLOBAL_SCOPE; if (_PR_NUM_DEADNATIVE > 0) { _PR_DEADQ_LOCK; @@ -1132,35 +1151,38 @@ PR_IMPLEMENT(PRThread*) _PR_CreateThread(PRThreadType type, _PR_InitializeRecycledThread(thread); thread->startFunc = start; thread->arg = arg; - thread->flags = (flags | _PR_GLOBAL_SCOPE); - if (type == PR_SYSTEM_THREAD) - { - thread->flags |= _PR_SYSTEM; - PR_ATOMIC_INCREMENT(&_pr_systemActive); - } - else PR_ATOMIC_INCREMENT(&_pr_userActive); + thread->flags = (flags | _PR_GLOBAL_SCOPE); + if (type == PR_SYSTEM_THREAD) + { + thread->flags |= _PR_SYSTEM; + PR_ATOMIC_INCREMENT(&_pr_systemActive); + } + else { + PR_ATOMIC_INCREMENT(&_pr_userActive); + } - if (state == PR_JOINABLE_THREAD) { - if (!thread->term) - thread->term = PR_NewCondVar(_pr_terminationCVLock); - } - else { - if(thread->term) { - PR_DestroyCondVar(thread->term); + if (state == PR_JOINABLE_THREAD) { + if (!thread->term) { + thread->term = PR_NewCondVar(_pr_terminationCVLock); + } + } + else { + if(thread->term) { + PR_DestroyCondVar(thread->term); thread->term = 0; - } - } + } + } thread->priority = priority; - _PR_MD_SET_PRIORITY(&(thread->md), priority); - /* XXX what about stackSize? */ - thread->state = _PR_RUNNING; + _PR_MD_SET_PRIORITY(&(thread->md), priority); + /* XXX what about stackSize? */ + thread->state = _PR_RUNNING; _PR_MD_WAKEUP_WAITER(thread); - return thread; + return thread; } } - thread = _PR_NativeCreateThread(type, start, arg, priority, - scope, state, stackSize, flags); + thread = _PR_NativeCreateThread(type, start, arg, priority, + scope, state, stackSize, flags); } else { if (_PR_NUM_DEADUSER > 0) { _PR_DEADQ_LOCK; @@ -1170,14 +1192,14 @@ PR_IMPLEMENT(PRThread*) _PR_CreateThread(PRThreadType type, } else { PRCList *ptr; - /* Go down list checking for a recycled thread with a + /* Go down list checking for a recycled thread with a * large enough stack. XXXMB - this has a bad degenerate case. */ ptr = _PR_DEADUSERQ.next; while( ptr != &_PR_DEADUSERQ ) { thread = _PR_THREAD_PTR(ptr); if ((thread->stack->stackSize >= stackSize) && - (!thread->no_sched)) { + (!thread->no_sched)) { PR_REMOVE_LINK(&thread->links); _PR_DEC_DEADUSER; break; @@ -1185,28 +1207,29 @@ PR_IMPLEMENT(PRThread*) _PR_CreateThread(PRThreadType type, ptr = ptr->next; thread = NULL; } - } + } _PR_DEADQ_UNLOCK; - if (thread) { + if (thread) { _PR_InitializeRecycledThread(thread); thread->startFunc = start; thread->arg = arg; thread->priority = priority; - if (state == PR_JOINABLE_THREAD) { - if (!thread->term) - thread->term = PR_NewCondVar(_pr_terminationCVLock); - } else { - if(thread->term) { - PR_DestroyCondVar(thread->term); - thread->term = 0; - } - } + if (state == PR_JOINABLE_THREAD) { + if (!thread->term) { + thread->term = PR_NewCondVar(_pr_terminationCVLock); + } + } else { + if(thread->term) { + PR_DestroyCondVar(thread->term); + thread->term = 0; + } + } useRecycled++; } } - } + } if (thread == NULL) { #ifndef HAVE_CUSTOM_USER_THREADS stack = _PR_NewStack(stackSize); @@ -1260,8 +1283,9 @@ PR_IMPLEMENT(PRThread*) _PR_CreateThread(PRThreadType type, PR_INIT_CLIST(&thread->lockList); if (_PR_MD_INIT_THREAD(thread) == PR_FAILURE) { - if (thread->threadAllocatedOnStack == 1) + if (thread->threadAllocatedOnStack == 1) { _PR_FreeStack(thread->stack); + } else { PR_DELETE(thread); } @@ -1270,8 +1294,9 @@ PR_IMPLEMENT(PRThread*) _PR_CreateThread(PRThreadType type, } if (_PR_MD_NEW_LOCK(&thread->threadLock) == PR_FAILURE) { - if (thread->threadAllocatedOnStack == 1) + if (thread->threadAllocatedOnStack == 1) { _PR_FreeStack(thread->stack); + } else { PR_DELETE(thread->privateData); PR_DELETE(thread); @@ -1284,8 +1309,9 @@ PR_IMPLEMENT(PRThread*) _PR_CreateThread(PRThreadType type, if (status == PR_FALSE) { _PR_MD_FREE_LOCK(&thread->threadLock); - if (thread->threadAllocatedOnStack == 1) + if (thread->threadAllocatedOnStack == 1) { _PR_FreeStack(thread->stack); + } else { PR_DELETE(thread->privateData); PR_DELETE(thread); @@ -1293,7 +1319,7 @@ PR_IMPLEMENT(PRThread*) _PR_CreateThread(PRThreadType type, return NULL; } - /* + /* Set thread flags related to scope and joinable state. If joinable thread, allocate a "termination" condition variable. */ @@ -1301,8 +1327,9 @@ PR_IMPLEMENT(PRThread*) _PR_CreateThread(PRThreadType type, thread->term = PR_NewCondVar(_pr_terminationCVLock); if (thread->term == NULL) { _PR_MD_FREE_LOCK(&thread->threadLock); - if (thread->threadAllocatedOnStack == 1) + if (thread->threadAllocatedOnStack == 1) { _PR_FreeStack(thread->stack); + } else { PR_DELETE(thread->privateData); PR_DELETE(thread); @@ -1310,9 +1337,9 @@ PR_IMPLEMENT(PRThread*) _PR_CreateThread(PRThreadType type, return NULL; } } - + } - + /* Update thread type counter */ PR_Lock(_pr_activeLock); thread->flags = flags; @@ -1326,15 +1353,17 @@ PR_IMPLEMENT(PRThread*) _PR_CreateThread(PRThreadType type, /* Make thread runnable */ thread->state = _PR_RUNNABLE; - /* - * Add to list of active threads - */ + /* + * Add to list of active threads + */ PR_Unlock(_pr_activeLock); - if ((! (thread->flags & _PR_IDLE_THREAD)) && _PR_IS_NATIVE_THREAD(me) ) + if ((! (thread->flags & _PR_IDLE_THREAD)) && _PR_IS_NATIVE_THREAD(me) ) { thread->cpu = _PR_GetPrimordialCPU(); - else + } + else { thread->cpu = _PR_MD_CURRENT_CPU(); + } PR_ASSERT(!_PR_IS_NATIVE_THREAD(thread)); @@ -1350,28 +1379,29 @@ PR_IMPLEMENT(PRThread*) _PR_CreateThread(PRThreadType type, ** If the creating thread is a kernel thread, we need to ** awaken the user thread idle thread somehow; potentially ** it could be sleeping in its idle loop, and we need to poke - ** it. To do so, wake the idle thread... + ** it. To do so, wake the idle thread... */ _PR_MD_WAKEUP_WAITER(NULL); } else if (_PR_IS_NATIVE_THREAD(me)) { _PR_MD_WAKEUP_WAITER(thread); } - if ((! (thread->flags & _PR_IDLE_THREAD)) && !_PR_IS_NATIVE_THREAD(me) ) + if ((! (thread->flags & _PR_IDLE_THREAD)) && !_PR_IS_NATIVE_THREAD(me) ) { _PR_INTSON(is); + } } return thread; } PR_IMPLEMENT(PRThread*) PR_CreateThread(PRThreadType type, - void (*start)(void *arg), - void *arg, - PRThreadPriority priority, - PRThreadScope scope, - PRThreadState state, - PRUint32 stackSize) + void (*start)(void *arg), + void *arg, + PRThreadPriority priority, + PRThreadScope scope, + PRThreadState state, + PRUint32 stackSize) { - return _PR_CreateThread(type, start, arg, priority, scope, state, + return _PR_CreateThread(type, start, arg, priority, scope, state, stackSize, 0); } @@ -1388,7 +1418,7 @@ PR_IMPLEMENT(PRThread*) PR_CreateThread(PRThreadType type, ** thread. PR_Init does this automatically for the primordial thread. */ PRThread* _PRI_AttachThread(PRThreadType type, - PRThreadPriority priority, PRThreadStack *stack, PRUint32 flags) + PRThreadPriority priority, PRThreadStack *stack, PRUint32 flags) { PRThread *thread; @@ -1419,9 +1449,9 @@ PRThread* _PRI_AttachThread(PRThreadType type, PR_INIT_CLIST(&thread->links); if (_PR_MD_INIT_ATTACHED_THREAD(thread) == PR_FAILURE) { - PR_DELETE(thread->stack); - _PR_DestroyThread(thread); - return NULL; + PR_DELETE(thread->stack); + _PR_DestroyThread(thread); + return NULL; } _PR_MD_SET_CURRENT_CPU(NULL); @@ -1445,7 +1475,7 @@ PRThread* _PRI_AttachThread(PRThreadType type, } PR_IMPLEMENT(PRThread*) PR_AttachThread(PRThreadType type, - PRThreadPriority priority, PRThreadStack *stack) + PRThreadPriority priority, PRThreadStack *stack) { return PR_GetCurrentThread(); } @@ -1453,16 +1483,17 @@ PR_IMPLEMENT(PRThread*) PR_AttachThread(PRThreadType type, PR_IMPLEMENT(void) PR_DetachThread(void) { /* - * On IRIX, Solaris, and Windows, foreign threads are detached when + * On Solaris, and Windows, foreign threads are detached when * they terminate. */ -#if !defined(IRIX) && !defined(WIN32) \ +#if !defined(WIN32) \ && !(defined(SOLARIS) && defined(_PR_GLOBAL_THREADS_ONLY)) PRThread *me; if (_pr_initialized) { me = _PR_MD_GET_ATTACHED_THREAD(); - if ((me != NULL) && (me->flags & _PR_ATTACHED)) + if ((me != NULL) && (me->flags & _PR_ATTACHED)) { _PRI_DetachThread(); + } } #endif } @@ -1471,12 +1502,12 @@ void _PRI_DetachThread(void) { PRThread *me = _PR_MD_CURRENT_THREAD(); - if (me->flags & _PR_PRIMORDIAL) { - /* - * ignore, if primordial thread - */ - return; - } + if (me->flags & _PR_PRIMORDIAL) { + /* + * ignore, if primordial thread + */ + return; + } PR_ASSERT(me->flags & _PR_ATTACHED); PR_ASSERT(_PR_IS_NATIVE_THREAD(me)); _PR_CleanupThread(me); @@ -1486,17 +1517,18 @@ void _PRI_DetachThread(void) _PR_MD_CLEAN_THREAD(me); _PR_MD_SET_CURRENT_THREAD(NULL); - if (!me->threadAllocatedOnStack) + if (!me->threadAllocatedOnStack) { PR_DELETE(me->stack); + } _PR_MD_FREE_LOCK(&me->threadLock); PR_DELETE(me); } /* ** Wait for thread termination: -** "thread" is the target thread +** "thread" is the target thread ** -** This can return PR_FAILURE if no joinable thread could be found +** This can return PR_FAILURE if no joinable thread could be found ** corresponding to the specified target thread. ** ** The calling thread is suspended until the target thread completes. @@ -1511,8 +1543,9 @@ PR_IMPLEMENT(PRStatus) PR_JoinThread(PRThread *thread) PRCondVar *term; PRThread *me = _PR_MD_CURRENT_THREAD(); - if (!_PR_IS_NATIVE_THREAD(me)) + if (!_PR_IS_NATIVE_THREAD(me)) { _PR_INTSOFF(is); + } term = thread->term; /* can't join a non-joinable thread */ if (term == NULL) { @@ -1524,8 +1557,9 @@ PR_IMPLEMENT(PRStatus) PR_JoinThread(PRThread *thread) if (term->condQ.next != &term->condQ) { goto ErrorExit; } - if (!_PR_IS_NATIVE_THREAD(me)) + if (!_PR_IS_NATIVE_THREAD(me)) { _PR_INTSON(is); + } /* wait for the target thread's termination cv invariant */ PR_Lock (_pr_terminationCVLock); @@ -1533,14 +1567,15 @@ PR_IMPLEMENT(PRStatus) PR_JoinThread(PRThread *thread) (void) PR_WaitCondVar(term, PR_INTERVAL_NO_TIMEOUT); } (void) PR_Unlock (_pr_terminationCVLock); - - /* + + /* Remove target thread from global waiting to join Q; make it runnable again and put it back on its run Q. When it gets scheduled later in _PR_RunThread code, it will clean up its stack. - */ - if (!_PR_IS_NATIVE_THREAD(me)) + */ + if (!_PR_IS_NATIVE_THREAD(me)) { _PR_INTSOFF(is); + } thread->state = _PR_RUNNABLE; if ( !_PR_IS_NATIVE_THREAD(thread) ) { _PR_THREAD_LOCK(thread); @@ -1552,23 +1587,26 @@ PR_IMPLEMENT(PRStatus) PR_JoinThread(PRThread *thread) _PR_AddThreadToRunQ(me, thread); _PR_THREAD_UNLOCK(thread); } - if (!_PR_IS_NATIVE_THREAD(me)) + if (!_PR_IS_NATIVE_THREAD(me)) { _PR_INTSON(is); + } _PR_MD_WAKEUP_WAITER(thread); return PR_SUCCESS; ErrorExit: - if ( !_PR_IS_NATIVE_THREAD(me)) _PR_INTSON(is); - return PR_FAILURE; + if ( !_PR_IS_NATIVE_THREAD(me)) { + _PR_INTSON(is); + } + return PR_FAILURE; } PR_IMPLEMENT(void) PR_SetThreadPriority(PRThread *thread, - PRThreadPriority newPri) + PRThreadPriority newPri) { - /* + /* First, pin down the priority. Not all compilers catch passing out of range enum here. If we let bad values thru, priority queues won't work. */ @@ -1577,11 +1615,13 @@ PR_IMPLEMENT(void) PR_SetThreadPriority(PRThread *thread, } else if ((PRIntn)newPri < (PRIntn)PR_PRIORITY_FIRST) { newPri = PR_PRIORITY_FIRST; } - + if ( _PR_IS_NATIVE_THREAD(thread) ) { thread->priority = newPri; _PR_MD_SET_PRIORITY(&(thread->md), newPri); - } else _PR_SetThreadPriority(thread, newPri); + } else { + _PR_SetThreadPriority(thread, newPri); + } } PR_IMPLEMENT(PRStatus) PR_SetCurrentThreadName(const char *name) @@ -1595,14 +1635,16 @@ PR_IMPLEMENT(PRStatus) PR_SetCurrentThreadName(const char *name) } thread = PR_GetCurrentThread(); - if (!thread) + if (!thread) { return PR_FAILURE; + } PR_Free(thread->name); nameLen = strlen(name); thread->name = (char *)PR_Malloc(nameLen + 1); - if (!thread->name) + if (!thread->name) { return PR_FAILURE; + } memcpy(thread->name, name, nameLen + 1); _PR_MD_SET_CURRENT_THREAD_NAME(thread->name); return PR_SUCCESS; @@ -1610,14 +1652,15 @@ PR_IMPLEMENT(PRStatus) PR_SetCurrentThreadName(const char *name) PR_IMPLEMENT(const char *) PR_GetThreadName(const PRThread *thread) { - if (!thread) + if (!thread) { return NULL; + } return thread->name; } /* -** This routine prevents all other threads from running. This call is needed by +** This routine prevents all other threads from running. This call is needed by ** the garbage collector. */ PR_IMPLEMENT(void) PR_SuspendAll(void) @@ -1633,25 +1676,27 @@ PR_IMPLEMENT(void) PR_SuspendAll(void) suspendAllThread = _PR_MD_CURRENT_THREAD(); _PR_MD_BEGIN_SUSPEND_ALL(); for (qp = _PR_ACTIVE_LOCAL_THREADQ().next; - qp != &_PR_ACTIVE_LOCAL_THREADQ(); qp = qp->next) { - if ((me != _PR_ACTIVE_THREAD_PTR(qp)) && + qp != &_PR_ACTIVE_LOCAL_THREADQ(); qp = qp->next) { + if ((me != _PR_ACTIVE_THREAD_PTR(qp)) && _PR_IS_GCABLE_THREAD(_PR_ACTIVE_THREAD_PTR(qp))) { _PR_Suspend(_PR_ACTIVE_THREAD_PTR(qp)); - PR_ASSERT((_PR_ACTIVE_THREAD_PTR(qp))->state != _PR_RUNNING); - } + PR_ASSERT((_PR_ACTIVE_THREAD_PTR(qp))->state != _PR_RUNNING); + } } for (qp = _PR_ACTIVE_GLOBAL_THREADQ().next; - qp != &_PR_ACTIVE_GLOBAL_THREADQ(); qp = qp->next) { + qp != &_PR_ACTIVE_GLOBAL_THREADQ(); qp = qp->next) { if ((me != _PR_ACTIVE_THREAD_PTR(qp)) && _PR_IS_GCABLE_THREAD(_PR_ACTIVE_THREAD_PTR(qp))) /* PR_Suspend(_PR_ACTIVE_THREAD_PTR(qp)); */ - _PR_MD_SUSPEND_THREAD(_PR_ACTIVE_THREAD_PTR(qp)); + { + _PR_MD_SUSPEND_THREAD(_PR_ACTIVE_THREAD_PTR(qp)); + } } _PR_MD_END_SUSPEND_ALL(); } /* -** This routine unblocks all other threads that were suspended from running by +** This routine unblocks all other threads that were suspended from running by ** PR_SuspendAll(). This call is needed by the garbage collector. */ PR_IMPLEMENT(void) PR_ResumeAll(void) @@ -1664,16 +1709,18 @@ PR_IMPLEMENT(void) PR_ResumeAll(void) */ _PR_MD_BEGIN_RESUME_ALL(); for (qp = _PR_ACTIVE_LOCAL_THREADQ().next; - qp != &_PR_ACTIVE_LOCAL_THREADQ(); qp = qp->next) { - if ((me != _PR_ACTIVE_THREAD_PTR(qp)) && - _PR_IS_GCABLE_THREAD(_PR_ACTIVE_THREAD_PTR(qp))) + qp != &_PR_ACTIVE_LOCAL_THREADQ(); qp = qp->next) { + if ((me != _PR_ACTIVE_THREAD_PTR(qp)) && + _PR_IS_GCABLE_THREAD(_PR_ACTIVE_THREAD_PTR(qp))) { _PR_Resume(_PR_ACTIVE_THREAD_PTR(qp)); + } } for (qp = _PR_ACTIVE_GLOBAL_THREADQ().next; - qp != &_PR_ACTIVE_GLOBAL_THREADQ(); qp = qp->next) { + qp != &_PR_ACTIVE_GLOBAL_THREADQ(); qp = qp->next) { if ((me != _PR_ACTIVE_THREAD_PTR(qp)) && - _PR_IS_GCABLE_THREAD(_PR_ACTIVE_THREAD_PTR(qp))) - _PR_MD_RESUME_THREAD(_PR_ACTIVE_THREAD_PTR(qp)); + _PR_IS_GCABLE_THREAD(_PR_ACTIVE_THREAD_PTR(qp))) { + _PR_MD_RESUME_THREAD(_PR_ACTIVE_THREAD_PTR(qp)); + } } _PR_MD_END_RESUME_ALL(); suspendAllThread = NULL; @@ -1715,8 +1762,9 @@ PR_IMPLEMENT(PRStatus) PR_EnumerateThreads(PREnumerator func, void *arg) if (_PR_IS_GCABLE_THREAD(t)) { rv = (*func)(t, i, arg); - if (rv != PR_SUCCESS) + if (rv != PR_SUCCESS) { return rv; + } i++; } } @@ -1728,8 +1776,9 @@ PR_IMPLEMENT(PRStatus) PR_EnumerateThreads(PREnumerator func, void *arg) if (_PR_IS_GCABLE_THREAD(t)) { rv = (*func)(t, i, arg); - if (rv != PR_SUCCESS) + if (rv != PR_SUCCESS) { return rv; + } i++; } } @@ -1787,7 +1836,7 @@ _PR_AddSleepQ(PRThread *thread, PRIntervalTime timeout) ** must be one) so that they remain relative to us. */ PR_ASSERT (thread->links.next != &_PR_SLEEPQ(cpu)); - + t = _PR_THREAD_PTR(thread->links.next); PR_ASSERT(_PR_THREAD_PTR(t->links.prev) == thread); t->sleep -= sleep; @@ -1821,24 +1870,28 @@ _PR_DelSleepQ(PRThread *thread, PRBool propogate_time) if (propogate_time == PR_TRUE) { PRThread *after = _PR_THREAD_PTR(q); after->sleep += thread->sleep; - } else + } else { _PR_SLEEPQMAX(cpu) -= thread->sleep; + } } else { /* Check if prev is the beggining of the list; if so, - * we are the only element on the list. + * we are the only element on the list. */ - if (thread->links.prev != &_PR_SLEEPQ(cpu)) + if (thread->links.prev != &_PR_SLEEPQ(cpu)) { _PR_SLEEPQMAX(cpu) -= thread->sleep; - else + } + else { _PR_SLEEPQMAX(cpu) = 0; + } } thread->flags &= ~_PR_ON_SLEEPQ; } else { thread->flags &= ~_PR_ON_PAUSEQ; } PR_REMOVE_LINK(&thread->links); - } else + } else { PR_ASSERT(0); + } } void @@ -1861,17 +1914,17 @@ _PR_AddThreadToRunQ( * "post" the awakened thread to the IO completion port * for the next idle CPU to execute (this is done in * _PR_MD_WAKEUP_WAITER). - * Threads with a suspended I/O operation remain bound to - * the same cpu until I/O is cancelled + * Threads with a suspended I/O operation remain bound to + * the same cpu until I/O is cancelled * * NOTE: the boolean expression below must be the exact * opposite of the corresponding boolean expression in * _PR_MD_WAKEUP_WAITER. */ if ((!_PR_IS_NATIVE_THREAD(me) && (cpu == me->cpu)) || - (thread->md.thr_bound_cpu)) { - PR_ASSERT(!thread->md.thr_bound_cpu || - (thread->md.thr_bound_cpu == cpu)); + (thread->md.thr_bound_cpu)) { + PR_ASSERT(!thread->md.thr_bound_cpu || + (thread->md.thr_bound_cpu == cpu)); _PR_RUNQ_LOCK(cpu); _PR_ADD_RUNQ(thread, cpu, pri); _PR_RUNQ_UNLOCK(cpu); |