FCL/sf/os/kernelhwsrv: comparison kernel/eka/nkernsmp/nkern.cpp

equal deleted inserted replaced

-:c1f20ce4abcf
+:3e88ff8f41d5
 			// this forces priority changes to wait for the mutex lock
 			pC->iLinkedObjType = NThreadBase::EWaitFastMutex;
 			pC->iLinkedObj = this;
 			pC->iWaitState.SetUpWait(NThreadBase::EWaitFastMutex, NThreadWaitState::EWtStObstructed, this);
 			pC->iWaitLink.iPriority = pC->iPriority;
-			if (waited)
+			iWaitQ.Add(&pC->iWaitLink);
-				iWaitQ.AddHead(&pC->iWaitLink);	// we were next at this priority
-			else
-				iWaitQ.Add(&pC->iWaitLink);
 			pC->RelSLock();
 			if (pH)
 				pH->SetMutexPriority(this);
 do_pause:
 			iMutexLock.UnlockOnly();
 	else
 		{
 		iCsFunction = ECSDivertPending;
 		iSuspendCount = 0;
 		iSuspended = 0;
-		// If thread is killed before first resumption, set iACount=1
-		__e32_atomic_tau_ord8(&iACount, 1, 0, 1);
 		if (aS)
 			aS->iReadyListLock.UnlockOnly();
 		DoReleaseT(KErrDied,0);
 		if (!iReady && !iPauseCount)
 			ReadyT(0);
 // If aCount>=0 suspend the thread aCount times
 // If aCount<0 kill the thread
 TBool NThreadBase::SuspendOrKill(TInt aCount)
 	{
 	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T nSuspendOrKill %d", this, aCount));
-	if (aCount==0 || i_NThread_Initial)
+	if (aCount==0)
 		return FALSE;
 	TBool result = FALSE;
 	TBool concurrent = FALSE;
 	TSubScheduler* ss = 0;
 	AcqSLock();
 			--iSuspendCount;
 		if (!iSuspendCount)
 			{
 			result = TRUE;
 			iSuspended = 0;
-			// On first resumption set iACount=1
-			// From then on the thread must be killed before being deleted
-			__e32_atomic_tau_ord8(&iACount, 1, 0, 1);
 			if (!iPauseCount && !iReady && !iWaitState.iWtC.iWtStFlags)
 				ReadyT(0);
 			}
 		}
 	TDfc* pD = NULL;
 	NThreadExitHandler xh = iHandlers->iExitHandler;
 	if (xh)
 		pD = (*xh)((NThread*)this);		// call exit handler
-	// if CPU freeze still active, remove it
-	NKern::EndFreezeCpu(0);
 	// detach any tied events
 	DetachTiedEvents();
 	NKern::LeaveGroup();	// detach from group if exit handler didn't do it
 	@param	The number of the CPU to which this thread should be locked, or
 			KCpuAny if it should be able to run on any CPU.
 	@return The previous affinity mask.
 */
-TUint32 NSchedulable::SetCpuAffinityT(TUint32 aAffinity)
+TUint32 NThreadBase::SetCpuAffinity(TUint32 aAffinity)
 	{
 	// check aAffinity is valid
-	NThreadBase* t = 0;
+	AcqSLock();
-	NThreadGroup* g = 0;
+	TUint32 old_aff = iParent->iCpuAffinity;
-	NSchedulable* p = iParent;
+	TBool migrate = FALSE;
-	if (!p)
-		g = (NThreadGroup*)this, p=g;
-	else
-		t = (NThreadBase*)this;
-	if (iParent && iParent!=this)
-		g = (NThreadGroup*)iParent;
-	TUint32 old_aff = p->iCpuAffinity;
 	TBool make_ready = FALSE;
 	TSubScheduler* ss0 = &SubScheduler();
 	TSubScheduler* ss = 0;
-#ifdef KNKERN
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T nSetCpu %08x->%08x, F:%d R:%02x PR:%02x",this,iParent->iCpuAffinity,aAffinity,iParent->iFreezeCpu,iReady,iParent->iReady));
-	if (iParent)
+	if (i_NThread_Initial)
-		{
-		__KTRACE_OPT(KNKERN,DEBUGPRINT("%T nSetCpu %08x->%08x, F:%d R:%02x PR:%02x",this,iParent->iCpuAffinity,aAffinity,iParent->iFreezeCpu,iReady,iParent->iReady));
-		}
-	else
-		{
-		__KTRACE_OPT(KNKERN,DEBUGPRINT("%G nSetCpu %08x->%08x, F:%d R:%02x",this,iCpuAffinity,aAffinity,iFreezeCpu,iReady));
-		}
-#endif
-	if (t && t->i_NThread_Initial)
 		goto done;	// can't change affinity of initial thread
-	if (aAffinity == NTHREADBASE_CPU_AFFINITY_MASK)
+	iParent->iCpuAffinity = aAffinity;		// set new affinity, might not take effect yet
-		{
+	if (!iParent->iReady)
-		p->iTransientCpu = 0;
-		}
-	else if ( (aAffinity & (KCpuAffinityPref|NTHREADBASE_CPU_AFFINITY_MASK)) == KCpuAffinityPref)
-		{
-		p->iTransientCpu = 0;
-		p->iPreferredCpu = TUint8((aAffinity & (EReadyCpuMask|EReadyCpuSticky)) | EReadyOffset);
-		}
-	else if ( (aAffinity & (KCpuAffinityTransient|KCpuAffinityPref|NTHREADBASE_CPU_AFFINITY_MASK)) == KCpuAffinityTransient)
-		{
-		p->iTransientCpu = TUint8(aAffinity & EReadyCpuMask) | EReadyOffset;
-		}
-	else
-		p->iCpuAffinity = NSchedulable::PreprocessCpuAffinity(aAffinity);		// set new affinity, might not take effect yet
-	if (!p->iReady)
 		goto done;	// thread/group not currently on a ready list so can just change affinity
+	migrate = !CheckCpuAgainstAffinity(iParent->iReady & EReadyCpuMask, aAffinity);	// TRUE if thread's current CPU is incompatible with the new affinity
-	// Check if the thread needs to migrate or can stay where it is
+	if (!migrate)
-	if (!p->ShouldMigrate(p->iReady & EReadyCpuMask))
 		goto done;	// don't need to move thread, so just change affinity
-	ss = TheSubSchedulers + (p->iReady & EReadyCpuMask);
+	ss = TheSubSchedulers + (iParent->iReady & EReadyCpuMask);
 	ss->iReadyListLock.LockOnly();
-	if (p->iCurrent)
+	if (iParent->iCurrent)
 		{
-		p->iCpuChange = TRUE;			// mark CPU change pending
+		iParent->iCpuChange = TRUE;			// mark CPU change pending
 		if (ss == ss0)
 			RescheduleNeeded();
 		else
 			// kick other CPU now so migration happens before acquisition of fast mutex
-			send_resched_ipi_and_wait(p->iReady & EReadyCpuMask);
+			send_resched_ipi_and_wait(iParent->iReady & EReadyCpuMask);
 		}
 	else
 		{
 		// Note: Need to know here if any thread in group would return TRUE from CheckFastMutexDefer()
 		// This is handled by the scheduler - when a thread belonging to a group is context switched
 		// out while holding a fast mutex its iFastMutexDefer is set to 1 and the group's iFreezeCpu
 		// is incremented.
-		if (p->iFreezeCpu || (iParent==this && t->CheckFastMutexDefer()))
+		if (iParent->iFreezeCpu || (iParent==this && CheckFastMutexDefer()))
-			p->iCpuChange = TRUE;	// CPU frozen or fast mutex held so just mark deferred CPU migration
+			iParent->iCpuChange = TRUE;	// CPU frozen or fast mutex held so just mark deferred CPU migration
 		else
 			{
-			ss->SSRemoveEntry(p);
+			ss->Remove(iParent);
-			p->iReady = 0;
+			iParent->iReady = 0;
 			make_ready = TRUE;
 			}
 		}
 	ss->iReadyListLock.UnlockOnly();
 	if (make_ready)
-		p->ReadyT(0);
+		iParent->ReadyT(0);
 done:
+	RelSLock();
 	return old_aff;
-	}
-/** Force the current thread onto a particular CPU
-	@pre	Kernel must not be locked.
-	@pre	Call in a thread context.
-	@pre	Current thread must not be in a group
-	@pre	Current thread must not hold a fast mutex
-	@pre	Current thread must have an active CPU freeze
-	@pre	Current thread must not be an initial thread
-	@param	The number of the CPU to which this thread should be moved
-*/
-void NKern::JumpTo(TInt aCpu)
-	{
-	// check aAffinity is valid
-	NThreadBase* t = NKern::CurrentThread();
-	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T NJumpTo %d", t, aCpu));
-	if (NKern::HeldFastMutex())
-		__crash();
-	t->LAcqSLock();
-	if (t->iParent!=t)
-		__crash();
-	if (!t->iFreezeCpu)
-		__crash();
-	if (t->i_NThread_Initial)
-		__crash();
-	if (TUint(aCpu) >= (TUint)NKern::NumberOfCpus())
-		__crash();
-	TUint8 fc = (TUint8)(aCpu | NSchedulable::EReadyOffset);
-	if (t->iCurrent != fc)
-		{
-		t->iForcedCpu = fc;
-		t->iCpuChange = TRUE;
-		RescheduleNeeded();
-		}
-	t->RelSLockU();		// reschedules and jumps to new CPU
-	}
-TBool NSchedulable::ShouldMigrate(TInt aCpu)
-	{
-	// Check if the thread's current CPU is compatible with the new affinity
-	TUint32 active = TheScheduler.iThreadAcceptCpus;
-	// If it can't stay where it is, migrate
-	if (!CheckCpuAgainstAffinity(aCpu, iCpuAffinity, active))
-		return TRUE;
-	TInt cpu = iTransientCpu ? iTransientCpu : iPreferredCpu;
-	// No preferred or transient CPU, so can stay where it is
-	if (!cpu)
-		return FALSE;
-	// If thread isn't on preferred CPU but could be, migrate
-	cpu &= EReadyCpuMask;
-	if (cpu!=aCpu && CheckCpuAgainstAffinity(cpu, iCpuAffinity, active))
-		return TRUE;
-	return FALSE;
 	}
 /******************************************************************************
 * Thread wait state
 		CancelTimerT();
 	if (oldws64 & EWtStWaitActive)
 		{
 		NThreadBase* t = Thread();
 		if (!t->iPauseCount && !t->iSuspended)
-			t->ReadyT(oldws64 & EWtStObstructed);
+			t->ReadyT(0);
 		}
 	return KErrNone;
 	}
 TUint32 NThreadWaitState::ReleaseT(TAny*& aWaitObj, TInt aReturnValue)
 	aMutex->Signal();
 	NKern::Unlock();
 	}
-/** Changes the nominal priority of a thread.
-	This function is intended to be used by the EPOC layer and personality layers.
-	Do not use this function directly on a Symbian OS thread - use Kern::ThreadSetPriority().
-@param aThread Thread to receive the new priority.
-@param aPriority New inherited priority for aThread.
-	@see Kern::SetThreadPriority()
-*/
-void NKern::ThreadSetNominalPriority(NThread* aThread, TInt aPriority)
-	{
-	NKern::Lock();
-	aThread->SetNominalPriority(aPriority);
-	NKern::Unlock();
-	}
 /** Atomically signals the request semaphore of a nanothread and a fast mutex.
 	This function is intended to be used by the EPOC layer and personality
 	layers.  Device drivers should use Kern::RequestComplete instead.
 		{
 		NKern::Unlock();
 		return 1;
 		}
 	pC->iFreezeCpu = 1;
-	__e32_atomic_add_rlx32(&ss.iDeferShutdown, 1);
 	if (pC->iParent != pC)
 		{
 		pC->AcqSLock();
 		++pC->iParent->iFreezeCpu;
 		pC->RelSLock();
 				RescheduleNeeded();
 			pC->RelSLock();
 			}
 		else if (pC->iCpuChange)		// deferred CPU change?
 			RescheduleNeeded();
-		__e32_atomic_add_rlx32(&ss.iDeferShutdown, TUint32(-1));
 		}
 	NKern::Unlock();
 	}
 	@param	The new CPU affinity mask
 	@return The old affinity mask
 */
 EXPORT_C TUint32 NKern::ThreadSetCpuAffinity(NThread* aThread, TUint32 aAffinity)
 	{
-	aThread->LAcqSLock();
+	NKern::Lock();
-	TUint32 r = aThread->SetCpuAffinityT(aAffinity);
+	TUint32 r = aThread->SetCpuAffinity(aAffinity);
-	aThread->RelSLockU();
+	NKern::Unlock();
 	return r;
 	}
 /** Modify a thread's timeslice
 		pC->AcqSLock();
 		ss.iReadyListLock.LockOnly();
 		pC->UnReadyT();
 		pC->iParent = pC;
 		g->iCurrent = 0;	// since current thread is no longer in g
-		TUint64 now = NKern::Timestamp();
+		ss.AddHead(pC);
-		g->iLastRunTime.i64 = now;
-		g->iTotalCpuTime.i64 += (now - g->iLastStartTime.i64);
-		if (--g->iActiveState == 0)
-			{
-			// group no longer active
-			g->iTotalActiveTime.i64 += (now - g->iLastActivationTime.i64);
-			}
-		ss.SSAddEntryHead(pC);
 		pC->iReady = TUint8(ss.iCpuNum | NSchedulable::EReadyOffset);
 		pC->iCpuAffinity = g->iCpuAffinity;	// keep same CPU affinity
 		// if we're frozen, the group's freeze count was incremented
 		if (pC->iFreezeCpu)
 			--g->iFreezeCpu;
 				// we were the last thread in the group stopping it from moving
 				// but there may be no other threads left after UnReadyT'ing this one
 				g->iCpuChange = FALSE;
 				if (g->iReady)
 					{
-					ss.SSRemoveEntry(g);
+					ss.Remove(g);
 					g->iReady = 0;
 					make_group_ready = TRUE;
 					}
 				}
 			}
 	__ASSERT_WITH_MESSAGE_DEBUG(!pC->i_NThread_Initial, "Not idle thread", "NKern::JoinGroup");
 	__NK_ASSERT_ALWAYS(pC->iParent==pC && !pC->iFreezeCpu);
 	__KTRACE_OPT(KNKERN,DEBUGPRINT("NJoinGroup %T->%G",pC,aGroup));
 	pC->AcqSLock();
 	aGroup->AcqSLock();
+	TBool migrate = !CheckCpuAgainstAffinity(ss.iCpuNum, aGroup->iCpuAffinity);	// TRUE if thread's current CPU is incompatible with the group's affinity
-	// Check if current CPU is compatible with group's affinity
-	TBool migrate = !CheckCpuAgainstAffinity(ss.iCpuNum, aGroup->iCpuAffinity);
 	if (!aGroup->iReady || aGroup->iReady==pC->iReady)
 		{
 		// group not ready or ready on this CPU
 		if (!migrate)
 			{
 			pC->iParent = aGroup;
 			aGroup->iNThreadList.AddHead(pC);
 			if (!aGroup->iReady)
 				{
 				aGroup->iPriority = pC->iPriority;
-				ss.SSAddEntryHead(aGroup);
+				ss.AddHead(aGroup);
 				aGroup->iReady = TUint8(ss.iCpuNum | NSchedulable::EReadyOffset);
 				}
 			else if (pC->iPriority > aGroup->iPriority)
-				ss.SSChgEntryP(aGroup, pC->iPriority);
+				{
+				ss.ChangePriority(aGroup, pC->iPriority);
+				}
 			pC->iReady = NSchedulable::EReadyGroup;
 			aGroup->iCurrent = aGroup->iReady;
 			ss.iReadyListLock.UnlockOnly();
 			++aGroup->iThreadCount;
-			TUint64 now = NKern::Timestamp();
-			aGroup->iLastStartTime.i64 = now;
-			if (++aGroup->iActiveState == 1)
-				aGroup->iLastActivationTime.i64 = now;
 			goto done;
 			}
 		}
 	// this thread needs to migrate to another CPU
 	pC->iNewParent = aGroup;
 	NKern::Unlock();
 	}
 /******************************************************************************
-* Iterable Doubly Linked List
-******************************************************************************/
-TInt SIterDQIterator::Step(SIterDQLink*& aObj, TInt aMaxSteps)
-	{
-	if (aMaxSteps <= 0)
-		aMaxSteps = KMaxCpus + 3;
-	SIterDQLink* p = Next();
-	SIterDQLink* q = p;
-	__NK_ASSERT_DEBUG(p!=0);
-	for(; p->IsIterator() && --aMaxSteps>0; p=p->Next())
-		{}
-	if (p->IsObject())
-		{
-		// found object
-		Deque();
-		InsertAfter(p);
-		aObj = p;
-		return KErrNone;
-		}
-	if (p->IsAnchor())
-		{
-		// reached end of list
-		if (p != q)
-			{
-			Deque();
-			InsertBefore(p);	// put at the end
-			}
-		aObj = 0;
-		return KErrEof;
-		}
-	// Maximum allowed number of other iterators skipped
-	Deque();
-	InsertAfter(p);
-	aObj = 0;
-	return KErrGeneral;
-	}
-/******************************************************************************
 * Priority Lists
 ******************************************************************************/
 #ifndef __PRI_LIST_MACHINE_CODED__
 /** Returns the priority of the highest priority item present on a priority list.
 	@return	The highest priority present or -1 if the list is empty.
 */
 EXPORT_C TInt TPriListBase::HighestPriority()
 	{
+//	TUint64 present = MAKE_TUINT64(iPresent[1], iPresent[0]);
+//	return __e32_find_ms1_64(present);
 	return __e32_find_ms1_64(iPresent64);
 	}
 /** Finds the highest priority item present on a priority list.
 /******************************************************************************
 * Generic IPIs
 ******************************************************************************/
+TGenIPIList::TGenIPIList()
+	:	iGenIPILock(TSpinLock::EOrderGenericIPIList)
+	{
+	}
+TGenIPIList GenIPIList;
 extern "C" {
 extern void send_generic_ipis(TUint32);
 void generic_ipi_isr(TSubScheduler* aS)
 	{
-	TScheduler& s = TheScheduler;
 	TGenericIPI* ipi = aS->iNextIPI;
 	if (!ipi)
 		return;
 	TUint32 m = aS->iCpuMask;
-	SDblQueLink* anchor = &s.iGenIPIList.iA;
+	SDblQueLink* anchor = &GenIPIList.iA;
 	while (ipi != anchor)
 		{
 		__e32_atomic_and_acq32(&ipi->iCpusIn, ~m);
 		(*ipi->iFunc)(ipi);
-		TInt irq = s.iGenIPILock.LockIrqSave();
+		TInt irq = GenIPIList.iGenIPILock.LockIrqSave();
 		TGenericIPI* n = (TGenericIPI*)ipi->iNext;
 		ipi->iCpusOut &= ~m;
 		if (ipi->iCpusOut == 0)
 			{
 			ipi->Deque();
 		ipi = n;
 		while (ipi!=anchor && !(ipi->iCpusIn & m))
 			ipi = (TGenericIPI*)ipi->iNext;
 		if (ipi == anchor)
 			aS->iNextIPI = 0;
-		s.iGenIPILock.UnlockIrqRestore(irq);
+		GenIPIList.iGenIPILock.UnlockIrqRestore(irq);
 		}
 	}
 }
 void TGenericIPI::Queue(TGenericIPIFn aFunc, TUint32 aCpuMask)
 	__KTRACE_OPT(KSCHED2,DEBUGPRINT("GenIPI F=%08x M=%08x", aFunc, aCpuMask));
 	iFunc = aFunc;
 	TScheduler& s = TheScheduler;
 	TInt i;
 	TUint32 ipis = 0;
-	TInt irq = s.iGenIPILock.LockIrqSave();
+	TInt irq = GenIPIList.iGenIPILock.LockIrqSave();
 	if (aCpuMask & 0x80000000u)
 		{
 		if (aCpuMask==0xffffffffu)
-			aCpuMask = s.iIpiAcceptCpus;
+			aCpuMask = s.iActiveCpus2;
 		else if (aCpuMask==0xfffffffeu)
-			aCpuMask = s.iIpiAcceptCpus &~ SubScheduler().iCpuMask;
+			aCpuMask = s.iActiveCpus2 &~ SubScheduler().iCpuMask;
 		else
 			aCpuMask = 0;
 		}
 	iCpusIn = aCpuMask;
 	iCpusOut = aCpuMask;
 	if (!aCpuMask)
 		{
-		s.iGenIPILock.UnlockIrqRestore(irq);
+		GenIPIList.iGenIPILock.UnlockIrqRestore(irq);
 		iNext = 0;
 		return;
 		}
-	s.iGenIPIList.Add(this);
+	GenIPIList.Add(this);
 	for (i=0; i<s.iNumCpus; ++i)
 		{
 		if (!(aCpuMask & (1<<i)))
 			continue;
 		TSubScheduler& ss = *s.iSub[i];
 			ss.iNextIPI = this;
 			ipis |= (1<<i);
 			}
 		}
 	send_generic_ipis(ipis);
-	s.iGenIPILock.UnlockIrqRestore(irq);
+	GenIPIList.iGenIPILock.UnlockIrqRestore(irq);
 	__KTRACE_OPT(KSCHED2,DEBUGPRINT("GenIPI ipis=%08x", ipis));
 	}
 void TGenericIPI::QueueAll(TGenericIPIFn aFunc)
 	{
 	mb();
 	}
 /**	Stop all other CPUs
-Call with kernel unlocked, returns with kernel locked.
+	Call with kernel locked
-Returns mask of CPUs halted plus current CPU.
+*/
-*/
+void TStopIPI::StopCPUs()
-TUint32 TStopIPI::StopCPUs()
+	{
-	{
-	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"TStopIPI::StopCPUs()");
-	TScheduler& s = TheScheduler;
 	iFlag = 0;
-	NKern::ThreadEnterCS();
-	// Stop any cores powering up or down for now
-	// A core already on the way down will stop just before the transition to SHUTDOWN_FINAL
-	// A core already on the way up will carry on powering up
-	TInt irq = s.iGenIPILock.LockIrqSave();
-	++s.iCCDeferCount;	// stops bits in iIpiAcceptCpus being cleared, but doesn't stop them being set
-						// but iIpiAcceptCpus | s.iCpusComingUp is constant
-	TUint32 act2 = s.iIpiAcceptCpus;		// CPUs still accepting IPIs
-	TUint32 cu = s.iCpusComingUp;			// CPUs powering up
-	s.iGenIPILock.UnlockIrqRestore(irq);
-	TUint32 cores = act2 | cu;
-	if (cu)
-		{
-		// wait for CPUs coming up to start accepting IPIs
-		while (cores & ~s.iIpiAcceptCpus)
-			{
-			__snooze();	// snooze until cores have come up
-			}
-		}
-	NKern::Lock();
 	QueueAllOther(&Isr);	// send IPIs to all other CPUs
 	WaitEntry();			// wait for other CPUs to reach the ISR
-	return cores;
+	}
-	}
-/**	Release the stopped CPUs
-Call with kernel locked, returns with kernel unlocked.
-*/
 void TStopIPI::ReleaseCPUs()
 	{
-	__e32_atomic_store_rel32(&iFlag, 1);	// allow other CPUs to proceed
+	iFlag = 1;				// allow other CPUs to proceed
 	WaitCompletion();		// wait for them to finish with this IPI
-	NKern::Unlock();
-	TheScheduler.CCUnDefer();
-	NKern::ThreadLeaveCS();
 	}
 void TStopIPI::Isr(TGenericIPI* a)
 	{
 	TStopIPI* s = (TStopIPI*)a;
-	while (!__e32_atomic_load_acq32(&s->iFlag))
+	while (!s->iFlag)
 		{
 		__chill();
 		}
-	__e32_io_completion_barrier();
+	}
-	}
-/******************************************************************************
-* TCoreCycler - general method to execute something on all active cores
-******************************************************************************/
-TCoreCycler::TCoreCycler()
-	{
-	iCores = 0;
-	iG = 0;
-	}
-void TCoreCycler::Init()
-	{
-	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"TCoreCycler::Init()");
-	TScheduler& s = TheScheduler;
-	NKern::ThreadEnterCS();
-	iG = NKern::LeaveGroup();
-	NThread* t = NKern::CurrentThread();
-	if (t->iCoreCycling)
-		{
-		__crash();
-		}
-	t->iCoreCycling = TRUE;
-	// Stop any cores powering up or down for now
-	// A core already on the way down will stop just before the transition to SHUTDOWN_FINAL
-	// A core already on the way up will carry on powering up
-	TInt irq = s.iGenIPILock.LockIrqSave();
-	++s.iCCDeferCount;	// stops bits in iIpiAcceptCpus being cleared, but doesn't stop them being set
-						// but iIpiAcceptCpus | s.iCpusComingUp is constant
-	TUint32 act2 = s.iIpiAcceptCpus;		// CPUs still accepting IPIs
-	TUint32 cu = s.iCpusComingUp;			// CPUs powering up
-	TUint32 gd = s.iCpusGoingDown;			// CPUs no longer accepting IPIs on the way down
-	s.iGenIPILock.UnlockIrqRestore(irq);
-	if (gd)
-		{
-		// wait for CPUs going down to reach INACTIVE state
-		TUint32 remain = gd;
-		FOREVER
-			{
-			TInt i;
-			for (i=0; i<KMaxCpus; ++i)
-				{
-				if (remain & (1u<<i))
-					{
-					// platform specific function returns TRUE when core has detached from SMP cluster
-					if (s.iSub[i]->Detached())
-						remain &= ~(1u<<i);	// core is now down
-					}
-				}
-			if (!remain)
-				break;		// all done
-			else
-				{
-				__snooze();	// snooze until cores have gone down
-				}
-			}
-		}
-	iCores = act2 | cu;
-	if (cu)
-		{
-		// wait for CPUs coming up to start accepting IPIs
-		while (iCores & ~s.iIpiAcceptCpus)
-			{
-			__snooze();	// snooze until cores have come up
-			}
-		}
-	iFrz = NKern::FreezeCpu();
-	if (iFrz)
-		__crash();	// already frozen so won't be able to migrate :-(
-	iInitialCpu = NKern::CurrentCpu();
-	iCurrentCpu = iInitialCpu;
-	iRemain = iCores;
-	}
-TInt TCoreCycler::Next()
-	{
-	NThread* t = NKern::CurrentThread();
-	if (iCores == 0)
-		{
-		Init();
-		return KErrNone;
-		}
-	if (NKern::CurrentCpu() != iCurrentCpu)
-		__crash();
-	iRemain &= ~(1u<<iCurrentCpu);
-	TInt nextCpu = iRemain ? __e32_find_ms1_32(iRemain) : iInitialCpu;
-	if (nextCpu != iCurrentCpu)
-		{
-		NKern::JumpTo(nextCpu);
-		iCurrentCpu = nextCpu;
-		if (NKern::CurrentCpu() != iCurrentCpu)
-			__crash();
-		}
-	if (iRemain)
-		{
-		return KErrNone;
-		}
-	NKern::EndFreezeCpu(iFrz);
-	iCores = 0;
-	TScheduler& s = TheScheduler;
-	s.CCUnDefer();
-	t->iCoreCycling = FALSE;
-	if (iG)
-		NKern::JoinGroup(iG);
-	NKern::ThreadLeaveCS();
-	return KErrEof;
-	}

branch	RCL_3
changeset 257	3e88ff8f41d5
parent 256	c1f20ce4abcf