// Copyright (c) 1998-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\nkern\win32\ncsched.cpp

// 

//

// NThreadBase member data

#define __INCLUDE_NTHREADBASE_DEFINES__

#include <e32cmn.h>

#include <e32cmn_private.h>

#include "nk_priv.h"

#ifdef __EMI_SUPPORT__

extern void EMI_AddTaskSwitchEvent(TAny* aPrevious, TAny* aNext);

extern void EMI_CheckDfcTag(TAny* aNext);

#endif

typedef void (*ProcessHandler)(TAny* aAddressSpace);

static DWORD TlsIndex = TLS_OUT_OF_INDEXES;

static NThreadBase* SelectThread(TScheduler& aS)

//

// Select the next thread to run.

// This is the heart of the rescheduling algorithm.

//

	{

	NThreadBase* t = static_cast<NThreadBase*>(aS.First());

	__NK_ASSERT_DEBUG(t);

#ifdef _DEBUG

	if (t->iHeldFastMutex)

		{

		__KTRACE_OPT(KSCHED2,DEBUGPRINT("Resched init->%T, Holding %M",t,t->iHeldFastMutex));

		}

	else

		{

		__KTRACE_OPT(KSCHED2,DEBUGPRINT("Resched init->%T",t));

		}

#endif

	if (t->iTime == 0 && !t->Alone())

		{

		// round robin

		// get here if thread's timeslice has expired and there is another

		// thread ready at the same priority

		if (t->iHeldFastMutex)

			{

			// round-robin deferred due to fast mutex held

			t->iHeldFastMutex->iWaiting = 1;

			return t;

			}

		t->iTime = t->iTimeslice;		// reset old thread time slice

		t = static_cast<NThreadBase*>(t->iNext);					// next thread

		aS.iQueue[t->iPriority] = t;		// make it first in list

		__KTRACE_OPT(KSCHED2,DEBUGPRINT("RoundRobin->%T",t));

		}

	if (t->iHeldFastMutex)

		{

		if (t->iHeldFastMutex == &aS.iLock)

			{

			// thread holds system lock: use it

			return t;

			}

		if ((t->i_ThrdAttr & KThreadAttImplicitSystemLock) != 0 && aS.iLock.iHoldingThread)

			t->iHeldFastMutex->iWaiting = 1;

		__NK_ASSERT_DEBUG((t->i_ThrdAttr & KThreadAttAddressSpace) == 0);

/*

		Check for an address space change. Not implemented for Win32, but useful as

		documentaiton of the algorithm.

		if ((t->i_ThrdAttr & KThreadAttAddressSpace) != 0 && t->iAddressSpace != aS.iAddressSpace)

			t->iHeldFastMutex->iWaiting = 1;

*/

		}

	else if (t->iWaitFastMutex && t->iWaitFastMutex->iHoldingThread)

		{

		__KTRACE_OPT(KSCHED2,DEBUGPRINT("Resched inter->%T, Blocked on %M",t->iWaitFastMutex->iHoldingThread,t->iWaitFastMutex));

		t = t->iWaitFastMutex->iHoldingThread;

		}

	else if (t->i_ThrdAttr & KThreadAttImplicitSystemLock)

		{

		// implicit system lock required

		if (aS.iLock.iHoldingThread)

			{

			// system lock held, switch to that thread

			t = aS.iLock.iHoldingThread;

			__KTRACE_OPT(KSCHED2,DEBUGPRINT("Resched inter->%T (IMP SYS)",t));

			t->iHeldFastMutex->iWaiting = 1;	// aS.iLock.iWaiting = 1;

			return t;

			}

		__NK_ASSERT_DEBUG((t->i_ThrdAttr & KThreadAttAddressSpace) == 0);

/*

		Check for an address space change. Not implemented for Win32, but useful as

		documentaiton of the algorithm.

		if ((t->i_ThrdAttr & KThreadAttAddressSpace) != 0 || t->iAddressSpace != aS.iAddressSpace)

			{

			// what do we do now?

			__NK_ASSERT_DEBUG(FALSE);

			}

*/

		}

	return t;

	}

// from NThread

#undef i_ThrdAttr

TBool NThread::WakeUp()

//

// Wake up the thread. What to do depends on whether we were preempted or voluntarily

// rescheduled.

//

// Return TRUE if we need to immediately reschedule again because we had to unlock

// the kernel but there are DFCs pending. In this case, the thread does not wake up.

//

// NB. kernel is locked

//

	{

	switch (iWakeup)

		{

	default:

		FAULT();

	case EIdle:

		__NK_ASSERT_ALWAYS(TheScheduler.iCurrentThread == this);

		__NK_ASSERT_ALWAYS(SetEvent(iScheduleLock));

		break;

	case ERelease:

		TheScheduler.iCurrentThread = this;

		__NK_ASSERT_ALWAYS(SetEvent(iScheduleLock));

		break;

	case EResumeLocked:

		// The thread is Win32 suspended and must be resumed.

		//

		// A newly created thread does not need the kernel unlocked so we can

		// just resume the suspended thread

		//

		__KTRACE_OPT(KSCHED,DEBUGPRINT("Win32Resume->%T",this));

		iWakeup = ERelease;

		TheScheduler.iCurrentThread = this;

		if (TheScheduler.iProcessHandler)

			(*ProcessHandler(TheScheduler.iProcessHandler))(iAddressSpace); // new thread will need to have its static data updated

		__NK_ASSERT_ALWAYS(TInt(ResumeThread(iWinThread)) > 0);	// check thread was previously suspended

		break;

	case EResumeDiverted:

		// The thread is Win32 suspended and must be resumed.

		//

		// The thread needs to be diverted, and does not need the kernel

		// unlocked.

		//

		// It's safe the divert the thread here because we called

		// IsSafeToPreempt() when we suspended it - otherwise the diversion

		// could get lost.

		//

		__KTRACE_OPT(KSCHED,DEBUGPRINT("Win32Resume->%T (Resuming diverted thread)",this));

		iWakeup = ERelease;

		ApplyDiversion();

		TheScheduler.iCurrentThread = this;

		__NK_ASSERT_ALWAYS(TInt(ResumeThread(iWinThread)) == 1);

		break;

	case EResume:

		// The thread is Win32 suspended and must be resumed.

		//

		// the complication here is that we have to unlock the kernel on behalf of the

		// pre-empted thread. This means that we have to check to see if there are more DFCs

		// pending or a reschedule required, as we unlock the kernel. That check is

		// carried out with interrupts disabled.

		//

		// If so, we go back around the loop in this thread context

		//

		// Otherwise, we unlock the kernel (having marked us as not-preempted),

		// enable interrupts and then resume the thread. If pre-emption occurs before the thread

		// is resumed, it is the new thread that is pre-empted, not the running thread, so we are guaranteed

		// to be able to call ResumeThread. If pre-emption occurs, and we are rescheduled to run before

		// that occurs, we will once again be running with the kernel locked and the other thread will

		// have been re-suspended by Win32: so all is well.

		//		

		{

		__KTRACE_OPT(KSCHED,DEBUGPRINT("Win32Resume->%T",this));

		TInt irq = NKern::DisableAllInterrupts();

		if (TheScheduler.iDfcPendingFlag || TheScheduler.iRescheduleNeededFlag)

			{

			// we were interrrupted... back to the top

			TheScheduler.iRescheduleNeededFlag = TRUE;	// ensure we do the reschedule

			return TRUE;

			}

		iWakeup = ERelease;

		TheScheduler.iCurrentThread = this;

		if (TheScheduler.iProcessHandler)

			(*ProcessHandler(TheScheduler.iProcessHandler))(iAddressSpace); // threads resumed after interrupt or locks need to have static data updated

		if (iInKernel == 0 && iUserModeCallbacks != NULL)

			ApplyDiversion();

		else 

			TheScheduler.iKernCSLocked = 0;		// have to unlock the kernel on behalf of the new thread

		TheScheduler.iCurrentThread = this;

		NKern::RestoreInterrupts(irq);

		__NK_ASSERT_ALWAYS(TInt(ResumeThread(iWinThread)) > 0);	// check thread was previously suspended

		}

		break;

		}

	return FALSE;

	}

static void ThreadExit(NThread& aCurrent, NThread& aNext)

//

// The final context switch of a thread.

// Wake up the next thread and then destroy this one's Win32 resources.

//

// Return without terminating if we need to immediately reschedule again because

// we had to unlock the kernel but there are DFCs pending.

//

	{

	// the thread is dead

	// extract win32 handles from dying NThread object before rescheduling

	HANDLE sl = aCurrent.iScheduleLock;

	HANDLE th = aCurrent.iWinThread;

	// wake up the next thread

	if (aNext.WakeUp())

		return;			// need to re-reschedule in this thread

	// we are now a vanilla win32 thread, nKern no longer knows about us

	// release resources and exit cleanly

	CloseHandle(sl);

	CloseHandle(th);

	ExitThread(0);		// does not return

	}

#ifdef MONITOR_THREAD_CPU_TIME

static inline void UpdateThreadCpuTime(NThread& aCurrent, NThread& aNext)

	{	

	TUint32 timestamp = NKern::FastCounter();

	if (aCurrent.iLastStartTime)

		aCurrent.iTotalCpuTime += timestamp - aCurrent.iLastStartTime;

	aNext.iLastStartTime = timestamp;

	}

#else

static inline void UpdateThreadCpuTime(NThread& /*aCurrent*/, NThread& /*aNext*/)

	{	

	}

#endif

static void SwitchThreads(NThread& aCurrent, NThread& aNext)

//

// The fundamental context switch - wake up the next thread and wait for reschedule

// trivially is aNext.WakeUp(), Wait(aCurrent.iScheduleLock), but we may be able to

// optimise the signal-and-wait

//

	{

	UpdateThreadCpuTime(aCurrent, aNext);

	if (aCurrent.iNState == NThread::EDead)

		ThreadExit(aCurrent, aNext);

	else if (Win32AtomicSOAW && aNext.iWakeup==NThread::ERelease)

		{

		// special case optimization for normally blocked threads using atomic Win32 primitive

		TheScheduler.iCurrentThread = &aNext;

		DWORD result=SignalObjectAndWait(aNext.iScheduleLock,aCurrent.iScheduleLock, INFINITE, FALSE);

		if (result != WAIT_OBJECT_0)

			{

			__NK_ASSERT_ALWAYS(result == 0xFFFFFFFF);

			KPrintf("SignalObjectAndWait() failed with %d (%T->%T)",GetLastError(),&aCurrent,&aNext);

			FAULT();

			}

		}

	else

		{

		if (aNext.WakeUp())

			return;			// need to re-reschedule in this thread

		__NK_ASSERT_ALWAYS(WaitForSingleObject(aCurrent.iScheduleLock, INFINITE) == WAIT_OBJECT_0);

		}

	}

void TScheduler::YieldTo(NThreadBase*)

//

// Directed context switch to the nominated thread.

// Enter with kernel locked, exit with kernel unlocked but interrupts disabled.

//

	{

	RescheduleNeeded();

	TScheduler::Reschedule();

	}

void TScheduler::Reschedule()

//

// Enter with kernel locked, exit with kernel unlocked, interrupts disabled.

// If the thread is dead do not return, but terminate the thread.

//

	{

	__NK_ASSERT_ALWAYS(TheScheduler.iKernCSLocked == 1);

	NThread& me = *static_cast<NThread*>(TheScheduler.iCurrentThread);

	for (;;)

		{

		NKern::DisableAllInterrupts();

		if (TheScheduler.iDfcPendingFlag)

			TheScheduler.QueueDfcs();

		if (!TheScheduler.iRescheduleNeededFlag)

			break;

		NKern::EnableAllInterrupts();

		TheScheduler.iRescheduleNeededFlag = FALSE;

		NThread* t = static_cast<NThread*>(SelectThread(TheScheduler));

		__KTRACE_OPT(KSCHED,DEBUGPRINT("Reschedule->%T (%08x%08x)",t,TheScheduler.iPresent[1],TheScheduler.iPresent[0]));

#ifdef __EMI_SUPPORT__

		EMI_AddTaskSwitchEvent(&me,t);

		EMI_CheckDfcTag(t);

#endif

#ifdef BTRACE_CPU_USAGE

		if(TheScheduler.iCpuUsageFilter)

			TheScheduler.iBTraceHandler(BTRACE_HEADER_C(4,BTrace::ECpuUsage,BTrace::ENewThreadContext),0,(TUint32)t,0,0,0,0,0);

#endif

		SwitchThreads(me, *t);

		// we have just been scheduled to run... check for diversion/new Dfcs

		NThread::TDivert divert = me.iDivert;

		if (divert)

			{

			// diversion (e.g. force exit)

			me.iDivert = NULL;

			divert();						// does not return

			}

		}

	if (TheScheduler.iProcessHandler)

		(*ProcessHandler(TheScheduler.iProcessHandler))(me.iAddressSpace);

	// interrrupts are disabled, the kernel is still locked

	TheScheduler.iKernCSLocked = 0;

	}

/**	Put the emulator into 'idle'.

	This is called by the idle thread when there is nothing else to do.

	@internalTechnology

 */

EXPORT_C void NThread::Idle()

//

// Rather than spin, we go to sleep on the schedule lock. Preemption detects

// this state (Win32Idling) and pokes the event rather than diverting the thread.

//

// enter and exit with kernel locked

//

	{

	NThread& me = *static_cast<NThread*>(TheScheduler.iCurrentThread);

	me.iWakeup = EIdle;

	__NK_ASSERT_ALWAYS(WaitForSingleObject(me.iScheduleLock, INFINITE) == WAIT_OBJECT_0);

	// something happened, and we've been prodded by an interrupt

	// the kernel was locked by the interrupt, and now reschedule

	me.iWakeup = ERelease;

	TScheduler::Reschedule();

	NKern::EnableAllInterrupts();

	}

void SchedulerInit(NThread& aInit)

//

// Initialise the win32 nKern scheduler

//

	{

	DWORD procaffin,sysaffin;

	if (GetProcessAffinityMask(GetCurrentProcess(),&procaffin,&sysaffin))

		{

		DWORD cpu;

		switch (Win32SingleCpu)

			{

		default:

			// bind the emulator to a nominated CPU on the host PC

			cpu = (1<<Win32SingleCpu);

			if (!(sysaffin & cpu))

				cpu = procaffin;	// CPU selection invalid

			break;

		case NThread::ECpuSingle:

			// bind the emulator to a single CPU on the host PC, pick one

			cpu = procaffin ^ (procaffin & (procaffin-1));

			break;

		case NThread::ECpuAll:

			// run the emulator on all CPUs on the host PC

			cpu=sysaffin;

			break;

			}

		SetProcessAffinityMask(GetCurrentProcess(), cpu);

		}

	// identify if we can use the atomic SignalObjectAndWait API in Win32 for rescheduling

	Win32AtomicSOAW = (SignalObjectAndWait(aInit.iScheduleLock, aInit.iScheduleLock, INFINITE, FALSE) == WAIT_OBJECT_0);

	//

	// allocate the TLS used for thread identification, and set it for the init thread

	TlsIndex = TlsAlloc();

	__NK_ASSERT_ALWAYS(TlsIndex != TLS_OUT_OF_INDEXES);

	SchedulerRegister(aInit);

	//

	Interrupt.Init();

	Win32FindNonPreemptibleFunctions();

	}

void SchedulerRegister(NThread& aSelf)

	{

	TlsSetValue(TlsIndex,&aSelf);

	}

NThread* SchedulerThread()

	{

	if (TlsIndex != TLS_OUT_OF_INDEXES)

		return static_cast<NThread*>(TlsGetValue(TlsIndex));

	else

		return NULL;  // not yet initialised

	}

inline TBool IsScheduledThread()

	{

	return SchedulerThread() == TheScheduler.iCurrentThread;

	}

NThread& CheckedCurrentThread()

	{

	NThread* t = SchedulerThread();

	__NK_ASSERT_ALWAYS(t == TheScheduler.iCurrentThread);

	return *t;

	}

/**	Disable normal 'interrupts'.

	@param	aLevel Ignored

	@return	Cookie to be passed into RestoreInterrupts()

 */

EXPORT_C TInt NKern::DisableInterrupts(TInt /*aLevel*/)

	{

	return Interrupt.Mask();

	}

/**	Disable all maskable 'interrupts'.

	@return	Cookie to be passed into RestoreInterrupts()

 */

EXPORT_C TInt NKern::DisableAllInterrupts()

	{

	return Interrupt.Mask();

	}

/**	Enable all maskable 'interrupts'

	@internalComponent

 */

EXPORT_C void NKern::EnableAllInterrupts()

	{

	Interrupt.Restore(0);

	}

/** Restore interrupt mask to state preceding a DisableInterrupts() call

	@param	aLevel Cookie returned by Disable(All)Interrupts()

 */

EXPORT_C void NKern::RestoreInterrupts(TInt aLevel)

	{

	Interrupt.Restore(aLevel);

	}

/**	Unlocks the kernel.

	Decrements iKernCSLocked; if it becomes zero and IDFCs or a reschedule are

	pending, calls the scheduler to process them.

    @pre    Call either in a thread or an IDFC context.

    @pre    Do not call from an ISR.

	@pre	Do not call from bare Win32 threads.

 */

EXPORT_C void NKern::Unlock()

//

// using this coding sequence it is possible to call Reschedule unnecessarily

// if we are preempted after testing the flags (lock is zero at this point).

// However, in the common case this is much faster because 'disabling interrupts'

// can be very expensive.

//

	{

	CHECK_PRECONDITIONS(MASK_NOT_ISR,"NKern::Unlock");	

	__ASSERT_WITH_MESSAGE_DEBUG(IsScheduledThread(),"Do not call from bare Win32 threads","NKern::Unlock");	// check that we are a scheduled thread

	__NK_ASSERT_ALWAYS(TheScheduler.iKernCSLocked > 0);	// Can't unlock if it isn't locked!

	if (--TheScheduler.iKernCSLocked == 0)

		{

		if (TheScheduler.iRescheduleNeededFlag || TheScheduler.iDfcPendingFlag)

			{

			TheScheduler.iKernCSLocked = 1;

			TScheduler::Reschedule();

			NKern::EnableAllInterrupts();

			}

		}

	}

/**	Locks the kernel.

	Increments iKernCSLocked, thereby deferring IDFCs and preemption.

    @pre    Call either in a thread or an IDFC context.

    @pre    Do not call from an ISR.

	@pre	Do not call from bare Win32 threads.

 */

EXPORT_C void NKern::Lock()

	{

	CHECK_PRECONDITIONS(MASK_NOT_ISR,"NKern::Lock");		

	__ASSERT_WITH_MESSAGE_ALWAYS(IsScheduledThread(),"Do not call from bare Win32 threads","NKern::Lock");	// check that we are a scheduled thread

	++TheScheduler.iKernCSLocked;

	}

/**	Locks the kernel and returns a pointer to the current thread

	Increments iKernCSLocked, thereby deferring IDFCs and preemption.

    @pre    Call either in a thread or an IDFC context.

    @pre    Do not call from an ISR.

	@pre	Do not call from bare Win32 threads.

 */

EXPORT_C NThread* NKern::LockC()

	{

	CHECK_PRECONDITIONS(MASK_NOT_ISR,"NKern::Lock");		

	__ASSERT_WITH_MESSAGE_ALWAYS(IsScheduledThread(),"Do not call from bare Win32 threads","NKern::Lock");	// check that we are a scheduled thread