// 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;