// 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()

		iIdleSpinLock(TSpinLock::EOrderIdleDFCList),

	{

	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()

		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

	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)

			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

				}

				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;

		}

		{

		cpu = g->iLastCpu;

		}

		cpu = g->iCpuAffinity;

		cpu = ss0.iCpuNum;

	if (cpu < 0)

		{

		// pick a cpu

				{

				}

			}

		}

cpu_ok:

	__NK_ASSERT_ALWAYS(cpu>=0);

	if (g->TiedEventReadyInterlock(cpu))

		{

		__KTRACE_OPT(KSCHED2,DEBUGPRINT("ReadyT->CPU %dD",cpu));

		++g->iPauseCount;

		}

		{

		}

	}

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

				{

				ot->iCpuChange = FALSE;

				ot->iParent->iCpuChange = FALSE;

				}

			}

			{

			ot->iCpuChange = FALSE;

			ot->iParent->iCpuChange = FALSE;

			}

		}

no_ot:

	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)

				{