My first commit on the Symbian Hg repository. Testng how branches are working.
// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// e32\nkernsmp\sched.cpp
//
//
// NThreadBase member data
#define __INCLUDE_NTHREADBASE_DEFINES__
// TDfc member data
#define __INCLUDE_TDFC_DEFINES__
#include "nk_priv.h"
#include <nk_irq.h>
TSpinLock NEventHandler::TiedLock(TSpinLock::EOrderEventHandlerTied);
/******************************************************************************
* TScheduler
******************************************************************************/
// TScheduler resides in .bss so other fields are zero-initialised
TScheduler::TScheduler()
: iActiveCpus1(1), // only boot CPU for now
iActiveCpus2(1), // only boot CPU for now
iIdleSpinLock(TSpinLock::EOrderIdleDFCList),
iCpusNotIdle(1) // only boot CPU for now
{
TInt i;
for (i=0; i<KMaxCpus; ++i)
{
TSubScheduler* s = TheSubSchedulers + i;
iSub[i] = s;
s->iScheduler = this;
s->iCpuNum = TUint32(i);
s->iCpuMask = 1u<<i;
}
}
/** Return a pointer to the scheduler
Intended for use by the crash debugger, not for general device driver use.
@return Pointer to the scheduler object
@internalTechnology
*/
EXPORT_C TScheduler* TScheduler::Ptr()
{
return &TheScheduler;
}
/******************************************************************************
* TSubScheduler
******************************************************************************/
// TSubScheduler resides in .bss so other fields are zero-initialised
TSubScheduler::TSubScheduler()
: TPriListBase(KNumPriorities),
iExIDfcLock(TSpinLock::EOrderExIDfcQ),
iReadyListLock(TSpinLock::EOrderReadyList),
iKernLockCount(1),
iEventHandlerLock(TSpinLock::EOrderEventHandlerList)
{
}
/******************************************************************************
* NSchedulable
******************************************************************************/
void NSchedulable::AcqSLock()
{
iSSpinLock.LockOnly();
if (iParent!=this && iParent)
iParent->AcqSLock();
}
void NSchedulable::RelSLock()
{
if (iParent!=this && iParent)
iParent->RelSLock();
iSSpinLock.UnlockOnly();
}
void NSchedulable::LAcqSLock()
{
NKern::Lock();
AcqSLock();
}
void NSchedulable::RelSLockU()
{
RelSLock();
NKern::Unlock();
}
void NSchedulable::UnPauseT()
{
CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NSchedulable::UnPauseT");
__KTRACE_OPT(KNKERN,DEBUGPRINT("%T nUnPauseT",this));
__NK_ASSERT_DEBUG(iPauseCount);
if (--iPauseCount || iReady || iSuspended || (iParent && ((NThread*)this)->iWaitState.ThreadIsBlocked()))
return;
ReadyT(EUnPause);
}
void NSchedulable::DeferredReadyIDfcFn(TAny* aPtr)
{
NSchedulable* a = (NSchedulable*)aPtr;
a->AcqSLock();
TUint32 evs = __e32_atomic_and_acq32(&a->iEventState, ~EDeferredReady);
if (evs & EDeferredReady)
{
if (a->iParent)
{
// thread
a->UnPauseT();
}
else
{
// thread group
NThreadGroup* g = (NThreadGroup*)a;
__KTRACE_OPT(KNKERN,DEBUGPRINT("%G nDeferredReady",g));
__NK_ASSERT_DEBUG(g->iPauseCount);
if (--g->iPauseCount && g->iNThreadList.NonEmpty())
g->ReadyT(EUnPause);
}
}
a->RelSLock();
}
TInt NSchedulable::AddTiedEvent(NEventHandler* aEvent)
{
__KTRACE_OPT(KNKERN,DEBUGPRINT("%T AddEv %08x",this,aEvent));
TInt r = KErrGeneral;
NEventHandler::TiedLock.LockOnly();
AcqSLock();
if (iStopping)
r = KErrDied;
else if (!aEvent->iTied)
{
aEvent->iTied = this;
iEvents.Add(&aEvent->iTiedLink);
r = KErrNone;
}
RelSLock();
NEventHandler::TiedLock.UnlockOnly();
return r;
}
void ipi_dummy(TGenericIPI*)
{
}
/** Detach and cancel any tied events attached to this thread/group
Call in a thread context with interrupts and preemption enabled.
Calling thread in critical section.
@internalComponent
*/
void NSchedulable::DetachTiedEvents()
{
__KTRACE_OPT(KNKERN,DEBUGPRINT("%T DetTiedEv",this));
NKern::Lock();
NEventHandler::TiedLock.LockOnly();
AcqSLock();
iStopping = TRUE;
if (!iParent)
{
// can't destroy a group until all threads have detached from it
NThreadGroup* g = (NThreadGroup*)this;
__NK_ASSERT_ALWAYS(g->iThreadCount==0 && g->iNThreadList.IsEmpty());
}
RelSLock();
NEventHandler::TiedLock.UnlockOnly();
// send IPI to all processors to synchronise
// after this, any tied IDFCs can only proceed to completion
// they can't be queued again
TGenericIPI ipi;
ipi.QueueAllOther(&ipi_dummy);
NKern::Unlock();
ipi.WaitCompletion();
FOREVER
{
NKern::Lock();
NEventHandler::TiedLock.LockOnly();
AcqSLock();
NEventHandler* h = 0;
TInt type = -1;
if (!iEvents.IsEmpty())
{
h = _LOFF(iEvents.First()->Deque(), NEventHandler, iTiedLink);
h->iTiedLink.iNext = 0;
type = h->iHType;
}
RelSLock();
if (type == NEventHandler::EEventHandlerNTimer)
{
// everything's easy for a timer since we can just cancel it here
NTimer* tmr = (NTimer*)h;
tmr->DoCancel(NTimer::ECancelDestroy);
tmr->iTied = 0;
}
else if (type == NEventHandler::EEventHandlerIDFC)
{
// can just cancel the IDFC with TiedLock held
// EndTiedEvent() may be delayed, but we wait for that further down
// iTied will have been captured before the IDFC state is reset
// Cancel() waits for the state to be reset
TDfc* d = (TDfc*)h;
d->Cancel();
d->iHType = (TUint8)NEventHandler::EEventHandlerDummy;
d->iTied = 0;
}
NEventHandler::TiedLock.UnlockOnly();
NKern::Unlock();
if (!h)
break;
switch (type)
{
case NEventHandler::EEventHandlerIrq:
{
NIrqHandler* pH = (NIrqHandler*)h;
// pH can't have been freed since we dequeued it but left iTied set
pH->Unbind(pH->iHandle, this);
break;
}
case NEventHandler::EEventHandlerNTimer:
case NEventHandler::EEventHandlerIDFC:
case NEventHandler::EEventHandlerDummy:
// nothing left to do
break;
default:
__NK_ASSERT_ALWAYS(0);
break;
}
}
// Wait for any remaining tied event handlers to complete
while (iEventState & EEventCountMask)
{
__chill();
}
}
/******************************************************************************
* NThreadGroup
******************************************************************************/
/******************************************************************************
* NThreadBase
******************************************************************************/
/** Makes a nanothread ready.
For use by RTOS personality layers.
@pre Kernel must be locked.
@pre Call either in a thread or an IDFC context.
@pre The thread being made ready must not be explicitly suspended
@post Kernel is locked.
*/
void NSchedulable::ReadyT(TUint aMode)
{
CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NSchedulable::ReadyT");
__KTRACE_OPT(KNKERN,DEBUGPRINT("%T nReadyT(%x)",this,aMode));
NThreadBase* t = (NThreadBase*)this;
#ifdef _DEBUG
if (!iParent)
t = (NThreadBase*)0xface0fff;
#endif
__NK_ASSERT_DEBUG(!iReady && (!iParent || (!t->iWaitState.iWtC.iWtStFlags && !t->iPauseCount && !t->iSuspended)));
TSubScheduler& ss0 = SubScheduler();
NSchedulable* g = this;
if (iParent != this && iParent)
{
NThreadGroup* tg = (NThreadGroup*)iParent;
iReady = EReadyGroup;
if (tg->iReady)
{
// extra thread added to group - change priority if necessary
tg->iNThreadList.Add(this);
TInt gp = tg->iPriority;
TSubScheduler& ss = TheSubSchedulers[tg->iReady & EReadyCpuMask];
ss.iReadyListLock.LockOnly();
TInt hp = ss.HighestPriority();
if (iPriority>gp)
ss.ChangePriority(tg, iPriority);
if (iPriority>hp || (iPriority==hp && ss.iCurrentThread && ss.iCurrentThread->iTime==0))
{
if (&ss == &ss0)
RescheduleNeeded(); // reschedule on this processor
else
ss0.iReschedIPIs |= ss.iCpuMask; // will kick the other CPU when this CPU reenables preemption
}
if ((aMode & ENewTimeslice) && t->iTime==0 && (iNext!=this || ss.iQueue[iPriority]))
t->iTime = t->iTimeslice;
ss.iReadyListLock.UnlockOnly();
return;
}
tg->iNThreadList.Add(this);
tg->iPriority = iPriority; // first in group
g = tg; // fall through to add group to subscheduler
}
TInt cpu = -1;
if (aMode & EUnPause)
{
cpu = (g->iEventState & EThreadCpuMask)>>EThreadCpuShift;
if (CheckCpuAgainstAffinity(cpu, g->iCpuAffinity))
goto cpu_ok;
}
else if (g->iFreezeCpu)
{
cpu = g->iLastCpu;
if (!CheckCpuAgainstAffinity(cpu, g->iCpuAffinity))
g->iCpuChange = TRUE;
}
else if (!(g->iCpuAffinity & NTHREADBASE_CPU_AFFINITY_MASK))
cpu = g->iCpuAffinity;
else if ((aMode & EPreferSameCpu) && (g->iCpuAffinity & ss0.iCpuMask))
cpu = ss0.iCpuNum;
if (cpu < 0)
{
// pick a cpu
TScheduler& s = TheScheduler;
TUint32 m = g->iCpuAffinity & s.iActiveCpus1;
TInt i;
TInt lowest_p = KMaxTInt;
for (i=0; i<s.iNumCpus; ++i)
{
TSubScheduler& ss = *s.iSub[i];
if (!(m & ss.iCpuMask))
continue;
TInt hp = ss.HighestPriority();
if (hp < lowest_p)
{
lowest_p = hp;
cpu = i;
continue;
}
if (hp > lowest_p)
continue;
if (cpu>=0 && g->iLastCpu!=i)
continue;
lowest_p = hp;
cpu = i;
}
}
cpu_ok:
__NK_ASSERT_ALWAYS(cpu>=0);
if (g->TiedEventReadyInterlock(cpu))
{
__KTRACE_OPT(KSCHED2,DEBUGPRINT("ReadyT->CPU %dD",cpu));
++g->iPauseCount;
// ((TDfc*)g->i_IDfcMem)->Add();
return;
}
__KTRACE_OPT(KSCHED2,DEBUGPRINT("ReadyT->CPU %d",cpu));
TSubScheduler& ss = TheSubSchedulers[cpu];
ss.iReadyListLock.LockOnly();
TInt hp = ss.HighestPriority();
if (g->iPriority>hp || (g->iPriority==hp && ss.iCurrentThread && ss.iCurrentThread->iTime==0))
{
if (&ss == &ss0)
RescheduleNeeded(); // reschedule on this processor
else
ss0.iReschedIPIs |= ss.iCpuMask; // will kick the other CPU when this CPU reenables preemption
}
ss.Add(g);
g->iReady = TUint8(cpu | EReadyOffset);
if ((aMode & ENewTimeslice) && iParent && t->iTime==0 && g->iNext!=g)
t->iTime = t->iTimeslice;
ss.iReadyListLock.UnlockOnly();
}
NThread* TSubScheduler::SelectNextThread()
{
NThread* ot = iCurrentThread;
NThread* t = 0;
TBool migrate = FALSE;
TBool gmigrate = FALSE;
TBool fmd_done = FALSE;
TBool fmd_res = FALSE;
if (!ot)
{
iReadyListLock.LockOnly();
iRescheduleNeededFlag = FALSE;
goto no_ot;
}
ot->AcqSLock();
if (ot->iNewParent)
ot->iNewParent->AcqSLock();
SaveTimesliceTimer(ot); // remember how much of current thread's timeslice remains
if (ot->iCsFunction==NThreadBase::ECSDivertPending && ot->iWaitState.iWtC.iWtStFlags)
{
// thread about to exit so cancel outstanding wait
ot->DoReleaseT(KErrDied,0);
}
if (ot->iWaitState.iWtC.iWtStFlags==0)
{
// ASSUMPTION: If iNewParent set, ot can't hold a fast mutex (assertion in JoinGroup)
TBool pfmd = (ot->iParent!=ot && !ot->iFastMutexDefer);
if (ot->iTime==0 || pfmd)
{
// ot's timeslice has expired
fmd_res = ot->CheckFastMutexDefer();
fmd_done = TRUE;
if (fmd_res)
{
if (ot->iTime == 0)
ot->iTime = 0x80000000; // mark deferred timeslice expiry
if (pfmd)
{
ot->iFastMutexDefer = 1;
++ot->iParent->iFreezeCpu;
}
}
}
}
iReadyListLock.LockOnly();
iRescheduleNeededFlag = FALSE;
// process outstanding suspend/kill/CPU change on ot
__NK_ASSERT_DEBUG(!(ot->iWaitState.iWtC.iWtStFlags & NThreadWaitState::EWtStWaitActive));
if (ot->iWaitState.iWtC.iWtStFlags || ot->iPauseCount || ot->iSuspended)
{
// ot is no longer ready to run
__KTRACE_OPT(KSCHED2,DEBUGPRINT("Rschd<-%T WS: %02x %02x (%08x) P:%02x S:%1x", ot,
ot->iWaitState.iWtC.iWtStFlags, ot->iWaitState.iWtC.iWtObjType, ot->iWaitState.iWtC.iWtObj, ot->iPauseCount, ot->iSuspended));
TInt wtst = ot->iWaitState.DoWait();
if (wtst>=0 && wtst!=NThread::EWaitFastMutex)
ot->iTime = ot->iTimeslice;
ot->UnReadyT();
if (ot->iNewParent)
{
ot->iParent = ot->iNewParent, ++((NThreadGroup*)ot->iParent)->iThreadCount;
wmb(); // must make sure iParent is updated before iNewParent is cleared
ot->iNewParent = 0;
}
ot->iCpuChange = FALSE;
}
else if (ot->iNewParent)
{
__NK_ASSERT_ALWAYS(ot->iParent==ot && !ot->iHeldFastMutex && !ot->iFreezeCpu);
ot->UnReadyT();
migrate = TRUE;
ot->iParent = ot->iNewParent;
ot->iCpuChange = FALSE;
++((NThreadGroup*)ot->iParent)->iThreadCount;
wmb(); // must make sure iParent is updated before iNewParent is cleared
ot->iNewParent = 0;
}
else if (ot->iParent->iCpuChange && !ot->iParent->iFreezeCpu)
{
if (!CheckCpuAgainstAffinity(iCpuNum, ot->iParent->iCpuAffinity))
{
if (ot->iParent==ot)
{
if (!fmd_done)
fmd_res = ot->CheckFastMutexDefer(), fmd_done = TRUE;
if (!fmd_res)
{
__KTRACE_OPT(KSCHED2,DEBUGPRINT("Rschd<-%T A:%08x",ot,ot->iParent->iCpuAffinity));
ot->UnReadyT();
migrate = TRUE;
ot->iCpuChange = FALSE;
}
}
else
{
__KTRACE_OPT(KSCHED2,DEBUGPRINT("Rschd<-%T GA:%08x",ot,ot->iParent->iCpuAffinity));
Remove(ot->iParent);
ot->iParent->iReady = 0;
gmigrate = TRUE;
ot->iCpuChange = FALSE;
ot->iParent->iCpuChange = FALSE;
}
}
else
{
ot->iCpuChange = FALSE;
ot->iParent->iCpuChange = FALSE;
}
}
no_ot:
NSchedulable* g = (NSchedulable*)First();
TBool rrcg = FALSE;
if (g && g->IsGroup())
{
t = (NThread*)((NThreadGroup*)g)->iNThreadList.First();
if (g->iNext!=g)
rrcg = TRUE;
}
else
t = (NThread*)g;
TBool rrct = (t && t->iNext!=t);
if (t && t->iTime==0 && (rrcg || rrct))
{
// candidate thread's timeslice has expired and there is another at the same priority
if (t==ot)
{
if (ot->iParent!=ot)
{
((NThreadGroup*)ot->iParent)->iNThreadList.iQueue[ot->iPriority] = ot->iNext;
iQueue[ot->iParent->iPriority] = ot->iParent->iNext;
}
else
iQueue[ot->iPriority] = ot->iNext;
ot->iTime = ot->iTimeslice;
NSchedulable* g2 = (NSchedulable*)First();
if (g2->IsGroup())
t = (NThread*)((NThreadGroup*)g2)->iNThreadList.First();
else
t = (NThread*)g2;
if (t->iTime==0)
{
// loop again since we need to lock t before round robining it
__KTRACE_OPT(KSCHED2,DEBUGPRINT("Rschd<-%T RRL",ot));
iRescheduleNeededFlag = TRUE;
}
else
{
__KTRACE_OPT(KSCHED2,DEBUGPRINT("Rschd<-%T RR",ot));
}
/* if (ot->iCpuAffinity & NTHREADBASE_CPU_AFFINITY_MASK)
{
ot->UnReadyT();
migrate = TRUE;
}
else
ot->iTime = ot->iTimeslice;
*/
}
else // loop again since we need to lock t before round robining it
{
__KTRACE_OPT(KSCHED2,DEBUGPRINT("Rschd<-%T LL",ot));
iRescheduleNeededFlag = TRUE;
}
}
if (t != ot)
{
if (ot)
{
ot->iCurrent = 0;
ot->iParent->iCurrent = 0;
ot->CompleteContextSave();
}
if (t)
{
t->iLastCpu = iCpuNum;
t->iParent->iLastCpu = iCpuNum;
t->iCurrent = TUint8(iCpuNum | NSchedulable::EReadyOffset);
t->iParent->iCurrent = t->iCurrent;
}
iCurrentThread = t;
}
UpdateThreadTimes(ot,t); // update ot's run time and set up the timeslice timer for t
iReadyListLock.UnlockOnly();
if (migrate)
ot->ReadyT(NThreadBase::ENewTimeslice); // new timeslice if it's queued behind another thread at same priority
if (gmigrate)
ot->iParent->ReadyT(0); // new timeslice if it's queued behind another thread at same priority
if (ot)
{
ot->RelSLock();
// DFC to signal thread is now dead
if (ot->iWaitState.ThreadIsDead() && ot->iWaitState.iWtC.iKillDfc)
ot->iWaitState.iWtC.iKillDfc->DoEnque();
}
__KTRACE_OPT(KSCHED,DEBUGPRINT("Rschd->%T",t));
__NK_ASSERT_ALWAYS(!t || t->iParent); // must be a thread not a group
return t; // could return NULL
}
void NThreadBase::UnReadyT()
{
if (iParent!=this)
{
NThreadGroup& g = *(NThreadGroup*)iParent;
TPriListBase& l = g.iNThreadList;
l.Remove(this);
if (g.iReady)
{
TSubScheduler& ss = TheSubSchedulers[g.iReady & EReadyCpuMask];
if (l.IsEmpty())
{
// __KTRACE_OPT(KNKERN,DEBUGPRINT("%T UnReadyT (G=%G-)",this,&g));
ss.Remove(&g);
g.iReady = 0;
g.iPriority = 0;
}
else
{
// __KTRACE_OPT(KNKERN,DEBUGPRINT("%T UnReadyT (G=%G)",this,&g));
ss.ChangePriority(&g, l.HighestPriority());
}
}
}
else
{
// __KTRACE_OPT(KNKERN,DEBUGPRINT("%T UnReadyT",this));
TheSubSchedulers[iReady & EReadyCpuMask].Remove(this);
}
iReady = 0;
}
void NThreadBase::ChangeReadyThreadPriority()
{
TInt newp = iMutexPri>iBasePri ? iMutexPri : iBasePri;
TInt oldp = iPriority;
TSubScheduler* ss0 = &SubScheduler();
TSubScheduler* ss = 0;
if (iParent->iReady)
{
ss = TheSubSchedulers + (iParent->iReady & EReadyCpuMask);
ss->iReadyListLock.LockOnly();
}
TBool resched = FALSE;
NSchedulable* g = iParent;
if (g!=this)
{
NThreadGroup* tg = (NThreadGroup*)g;
tg->iNThreadList.ChangePriority(this, newp);
if (ss)
{
TInt ngp = tg->iNThreadList.HighestPriority();
if (ngp!=tg->iPriority)
ss->ChangePriority(tg, ngp);
}
}
else
ss->ChangePriority(this, newp);
if (iCurrent) // can't be current if parent not ready
{
TInt nhp = ss->HighestPriority();
if (newp<oldp && (newp<nhp || (newp==nhp && iTime==0)))
resched = TRUE;
}
else if (ss)
{
NThreadBase* ct = ss->iCurrentThread;
TInt cp = ct ? ct->iPriority : -1;
if (newp>cp || (newp==cp && ct->iTime==0))
resched = TRUE;
}
if (resched)
{
if (ss == ss0)
RescheduleNeeded();
else
ss0->iReschedIPIs |= ss->iCpuMask; // will kick the other CPU when this CPU reenables preemption
}
if (ss)
ss->iReadyListLock.UnlockOnly();
}
/** Changes the priority of a nanokernel thread.
For use by RTOS personality layers.
Do not use this function directly on a Symbian OS thread.
The thread's unknown state handler will be invoked with function EChangePriority
and parameter newp if the current NState is not recognised and the new priority
is not equal to the original priority.
@param newp The new nanokernel priority (0 <= newp < KNumPriorities).
@pre Kernel must be locked.
@pre Call in a thread context.
@post Kernel is locked.
*/
EXPORT_C void NThreadBase::SetPriority(TInt newp)
{
CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_IDFC|MASK_NOT_ISR,"NThreadBase::SetPriority");
AcqSLock();
__KTRACE_OPT(KNKERN,DEBUGPRINT("%T nSetPri %d(%d)->%d(%d)",this,iPriority,iBasePri,newp,iMutexPri));
iBasePri = TUint8(newp);
if (iMutexPri > iBasePri)
newp = iMutexPri;
TInt oldp = iPriority;
if (newp == oldp)
{
RelSLock();
return;
}
NFastMutex* wfm = 0;
if (iLinkedObj && iLinkedObjType==EWaitFastMutex)
wfm = (NFastMutex*)iLinkedObj;
if (wfm)
{
// if thread is attached to/waiting on a fast mutex, need to acquire mutex lock
++iPauseCount;
RelSLock();
wfm->iMutexLock.LockOnly();
AcqSLock();
UnPauseT();
wfm->iWaitQ.ChangePriority(&iWaitLink, newp); // change position of this thread on mutex wait queue
}
if (iReady)
{
ChangeReadyThreadPriority();
RelSLock();
if (wfm && newp<=wfm->iWaitQ.HighestPriority())
{
// this thread was contending for the mutex but they may be other waiting threads
// with higher or equal priority, so wake up the first thread on the list.
NThreadBase* pT = _LOFF(wfm->iWaitQ.First(), NThreadBase, iWaitLink);
pT->AcqSLock();
// if thread is still blocked on this fast mutex, release it but leave it on the wait queue
// NOTE: it can't be suspended
pT->iWaitState.UnBlockT(NThreadBase::EWaitFastMutex, wfm, KErrNone);
pT->RelSLock();
}
}
else
{
iPriority = (TUint8)newp;
if (wfm && newp>oldp)
{
NThreadBase* pT = _LOFF(wfm->iWaitQ.First(), NThreadBase, iWaitLink); // highest priority waiting thread
if (pT==this)
{
// this is now highest priority waiting thread so wake it up
iWaitState.UnBlockT(NThreadBase::EWaitFastMutex, wfm, KErrNone);
}
}
RelSLock();
}
if (wfm)
{
NThreadBase* t = (NThreadBase*)(TLinAddr(wfm->iHoldingThread)&~3);
if (t)
t->SetMutexPriority(wfm);
wfm->iMutexLock.UnlockOnly();
}
}
/** Set the inherited priority of a nanokernel thread.
@pre Kernel must be locked.
@pre Call in a thread context.
@pre The thread holds a fast mutex
@post Kernel is locked.
*/
void NThreadBase::SetMutexPriority(NFastMutex* aM)
{
TInt newp = aM->iWaitQ.HighestPriority();
if (newp<0)
newp = 0;
AcqSLock();
__KTRACE_OPT(KNKERN,DEBUGPRINT("%T nSetMPri %d->%d Base %d (mutex %08x)",this,iMutexPri,newp,iBasePri,aM));
iMutexPri = TUint8(newp);
if (iMutexPri < iBasePri)
newp = iBasePri;
TInt oldp = iPriority;
if (newp == oldp)
{
RelSLock();
return;
}
if (iReady)
ChangeReadyThreadPriority();
else
iPriority = (TUint8)newp;
RelSLock();
}
void NThreadBase::LoseInheritedPriorityT()
{
__KTRACE_OPT(KNKERN,DEBUGPRINT("%T nLoseInhPri %d->%d",this,iPriority,iBasePri));
TSubScheduler* ss = &SubScheduler();
TInt newp = iBasePri;
NSchedulable* g = iParent;
ss->iReadyListLock.LockOnly();
if (g!=this)
{
NThreadGroup* tg = (NThreadGroup*)g;
tg->iNThreadList.ChangePriority(this, newp);
TInt hp = tg->iNThreadList.HighestPriority();
if (hp == tg->iPriority)
{
if (newp <= hp)
RescheduleNeeded();
goto out;
}
newp = hp;
g = tg;
}
if (newp <= ss->HighestPriority())
RescheduleNeeded();
ss->ChangePriority(g, newp);
out:
ss->iReadyListLock.UnlockOnly();
}