//

#include <emulator.h>

#ifdef	__EMI_SUPPORT__

// This should be essentially the same as the EPOC32 version!

#ifdef	_DEBUG

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

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

#endif	// _DEBUG

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

		/*

		*/

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

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

		/*

		*/

// From here on it's all emulator (i.e. Win32) specific; there isn't any EPOC32 equivalent for most of it.

// The emulator uses one Win32 thread for each Symbian thread; these are the ones scheduled by the Symbian

// nanokernel in the algorithm above. Only one such thread will be running at a time; the others will be

// waiting on their individual scheduler locks, thus simulating a single-threaded architecture.

// In addition, there are some more Win32 threads used to handle timers, interrupts and the like. These

// are not under control of the Symbian scheduler. They are given higher priority than the Symbian threads,

// so they can run preemptively under control of the Win32 scheduler. However, they must call functions

// from the Win32Interrupt class before using any Symbian OS calls, so that the current Symbian thread can

// be suspended during the 'virtual interrupt'.

static DWORD TlsIndex = TLS_OUT_OF_INDEXES;

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 whether 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);

	Win32FindNonPreemptibleFunctions();

	Interrupt.Init();

	}

void SchedulerRegister(NThread& aSelf)

	{

	TlsSetValue(TlsIndex, &aSelf);

	}

inline NThread* RunningThread()

// Returns the NThread actually running

	{

	if (TlsIndex == TLS_OUT_OF_INDEXES)

		return NULL;				// not yet initialised

	else

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

	}

inline TBool IsScheduledThread()

// True if the NThread actually running is the scheduled one (not an interrupt thread or similar)

	{

	return RunningThread() == TheScheduler.iCurrentThread;

	}

inline NThread& CheckedCurrentThread()

// Returns the NThread actually running, checking that it's the scheduled one (not an interrupt thread or similar)

	{

	NThread* t = RunningThread();

	__NK_ASSERT_ALWAYS(t == TheScheduler.iCurrentThread);

	return *t;

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

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

#ifdef	MONITOR_THREAD_CPU_TIME

	{

	{

#endif	// MONITOR_THREAD_CPU_TIME

	__NK_ASSERT_ALWAYS(InterruptsStatus(ETrue));

		{

		// Yes, this is reachable!

		}

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

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

		CheckedSignalObjectAndWait(aNext.iScheduleLock, aCurrent.iScheduleLock);

		}

	else if (aNext.WakeUp())

		{

		// We didn't wake the target thread; instead we need to re-reschedule in this thread

		__NK_ASSERT_ALWAYS(InterruptsStatus(EFalse));

		return;

		// Target thread woken, now wait to be rescheduled

		CheckedWaitForSingleObject(aCurrent.iScheduleLock);

	__NK_ASSERT_ALWAYS(InterruptsStatus(ETrue));

	}

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

		// Exit from this loop when further rescheduling is no longer needed

		if (!TheScheduler.iRescheduleNeededFlag)

			break;

		// Choose the next thread to run, using the Symbian scheduler

		TheScheduler.iRescheduleNeededFlag = FALSE;

		NKern::EnableAllInterrupts();

		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() can return immediately, if it turns out that another reschedule is

		// necessary; otherwise, this thread will be descheduled in favour of the one selected

		// above, and SwitchThreads() will only return when this thread is next selected

		SwitchThreads(me, *t);

		// When we start again, we should check for being forced to exit; otherwise go round the

		// loop again to see whether another reschedule is called for (e.g. if there are new DFCs).

		NThread::TDivert divertToExit = me.iDivertFn;

		me.iDivertFn = NULL;

		if (divertToExit)

			divertToExit();

		}

	// interrupts are disabled, the kernel is still locked

	if (TheScheduler.iProcessHandler)

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

	__NK_ASSERT_ALWAYS(TheScheduler.iKernCSLocked == 1);

	TheScheduler.iKernCSLocked = 0;

TBool NThread::WakeUp()

//

// Wake up the thread. What to do depends on whether it was preempted or voluntarily

// rescheduled.

//

// On entry, the kernel is locked, and interrupts may be enabled or disabled.

// The return value is TRUE if the caller should immediately reschedule again because we

// needed to unlock the kernel in order to resume the thread but there were DFCs pending.

// In this case, the thread is not woken, the kernel remains locked, and the return is

// made with interrupts disabled (whether or not they were on entry).

//

// Otherise, the target thread is woken up (in any of several different ways), and the

// the return value is FALSE. In that case the interrupt status is unchanged; and the

// kernel may or not still be locked.

	__NK_ASSERT_ALWAYS(TheScheduler.iKernCSLocked > 0);

	__NK_ASSERT_ALWAYS(RunningThread() != this);		// Can't wake self!

	switch (iWakeup)

	default:

		FAULT();

	case EIdle:

		// The thread is waiting on its scheduler lock, in Idle()

		__NK_ASSERT_ALWAYS(TheScheduler.iCurrentThread == this);

		CheckedSetEvent(iScheduleLock);

		break;

	case ERelease:

		// The thread is waiting on its scheduler lock

		TheScheduler.iCurrentThread = this;

		CheckedSetEvent(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 it; OTOH it will need to have its static data updated ...

		//

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

		iWakeup = ERelease;

		TheScheduler.iCurrentThread = this;

		if (TheScheduler.iProcessHandler)

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

		CheckedResumeThread(iWinThread);

		break;

	case EResumeDiverted:

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

		//

		// It does not need the kernel unlocked, but does have a diversion pending. We

		// know it's safe to 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;

		TheScheduler.iCurrentThread = this;

		ApplyDiversion();

		CheckedResumeThread(iWinThread, ETrue);

		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. Before doing so, we have to check whether there are DFCs

		// or a reschedule pending; if so, we don't unlock the kernel or wake the target

		// thread, but instead return TRUE, so that our caller (usually SwitchThreads()

		// above) knows to return and go round the TScheduler::Reschedule() loop again.

		//

		TInt irq = NKern::DisableAllInterrupts();

		if (TheScheduler.iRescheduleNeededFlag || TheScheduler.iDfcPendingFlag)

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

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

			return TRUE;

		// Otherwise we mark the thread as not-preempted, unlock the kernel, restore

		// interrupts, and resume the thread.

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

		iWakeup = ERelease;

		TheScheduler.iCurrentThread = this;

		if (TheScheduler.iProcessHandler)

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

		TheScheduler.iKernCSLocked = 0;

		// If there are callbacks waiting, and the thread is in user mode, divert it to

		// pick up its callbacks (we know this is safe because we called IsSafeToPreempt()

		// when we suspended it - otherwise the diversion could get lost.

		if (iUserModeCallbacks != NULL && !iInKernel)

			{

			TheScheduler.iKernCSLocked = 1;					// prevent further pre-emption

			ApplyDiversion();

			}

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

		//

		NKern::RestoreInterrupts(irq);

		CheckedResumeThread(iWinThread);

		break;

	return FALSE;

	CheckedWaitForSingleObject(me.iScheduleLock);

void EnterKernel(TBool aDiversion)

	NThread& t = CheckedCurrentThread();

	volatile TInt& inKernel = t.iInKernel;

	__NK_ASSERT_DEBUG(inKernel >= 0);

	// This code has to be re-entrant, because a thread that's in the process

	// of entering the kernel may be preempted; then if it isn't yet marked

	// as 'in the kernel' it can be diverted through EnterKernel()/LeaveKernel()

	// in order to execute user-mode callbacks.  However this is all in the