// Copyright (c) 2007-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\include\nkernsmp\nk_priv.h

// 

// WARNING: This file contains some APIs which are internal and are subject

//          to change without notice. Such APIs should therefore not be used

//          outside the Kernel and Hardware Services package.

//

#ifndef __NK_PRIV_H__

#define __NK_PRIV_H__

#include <cpudefs.h>

#include <nkern.h>

#define __USE_BTRACE_LOCK__

class Monitor;

const TInt KNumPriClasses = 4;

extern const TUint8 KClassFromPriority[KNumPriorities];

#ifndef __LOAD_BALANCE_INFO_DEFINED__

/**

@internalComponent

*/

struct SLbInfo

	{

	TUint64		i__Dummy;

	};

#endif

/********************************************

 * Schedulable = thread or thread group

 ********************************************/

/**

@publishedPartner

@prototype

Base class for a nanokernel thread or group

*/

class NThreadGroup;

class NSchedulable : public TPriListLink

	{

public:

	/**

	@internalComponent

	*/

	enum

		{

		EReadyGroup=1,

		EReadyCpuMask=0x1f,

		EReadyCpuSticky=0x40,

		EReadyOffset=0x80,

		};

	/**

	@internalComponent

	*/

	enum NReadyFlags

		{

		ENewTimeslice=1,

		EPreferSameCpu=2,

		EUnPause=4,

		};

	/**

	@internalComponent

	*/

	enum NEventState

		{

		EEventCountShift=16u,

		EEventCountMask=0xffff0000u,

		EEventCountInc=0x10000u,

		EEventCpuShift=0u,

		EEventCpuMask=0x1fu,

		EThreadCpuShift=8u,

		EThreadCpuMask=0x1f00u,

		EDeferredReady=0x4000u,

		EEventParent=0x8000u,

		};

	/**

	@internalComponent

	*/

	enum NLbState

		{

		ELbState_Inactive	= 0x00u,	// not currently involved in load balancing

		ELbState_Global		= 0x01u,	// flag indicating this is on global load balance list

		ELbState_Temp		= 0x02u,	// flag indicating this is on a temporary load balance list

		ELbState_CpuMask	= 0x1Fu,	// mask of bits indicating CPU if on per-CPU list

		ELbState_PerCpu		= 0x20u,	// flag indicating this is on per-CPU load balance list

		ELbState_ExtraRef	= 0x40u,	// flag indicating extra reference has been taken after thread/group died

		ELbState_Generation	= 0x80u,	// 1 bit generation number

		};

	/**

	@internalComponent

	*/

	enum NCpuStatsSelect

		{

		E_RunTime=0x01u,

		E_RunTimeDelta=0x02u,

		E_ActiveTime=0x04u,

		E_ActiveTimeDelta=0x08u,

		E_LastRunTime=0x10u,

		E_LastActiveTime=0x20u,

		E_AllStats = 0x3fu

		};

	/**

	@internalComponent

	*/

	struct SCpuStats

		{

		TUint64		iRunTime;			// total run time

		TUint64		iRunTimeDelta;		// run time since we last asked

		TUint64		iActiveTime;		// total active time

		TUint64		iActiveTimeDelta;	// active time since we last asked

		TUint64		iLastRunTime;		// how long ago this last ran

		TUint64		iLastActiveTime;	// how long ago this was last active

		};

public:

	NSchedulable();								/**< @internalComponent */

	void AcqSLock();							/**< @internalComponent */

	void RelSLock();							/**< @internalComponent */

	void LAcqSLock();							/**< @internalComponent */

	void RelSLockU();							/**< @internalComponent */

	void ReadyT(TUint aMode);					/**< @internalComponent */ // make ready, assumes lock held

	TInt BeginTiedEvent();						/**< @internalComponent */

	void EndTiedEvent();						/**< @internalComponent */

	TInt AddTiedEvent(NEventHandler* aEvent);	/**< @internalComponent */

	TBool TiedEventReadyInterlock(TInt aCpu);	/**< @internalComponent */

	void UnPauseT();							/**< @internalComponent */ // decrement pause count and make ready if necessary

	static void DeferredReadyIDfcFn(TAny*);		/**< @internalComponent */

	void DetachTiedEvents();					/**< @internalComponent */

	TBool TakeRef();							/**< @internalComponent */

	TBool DropRef();							/**< @internalComponent */

	void LbUnlink();							/**< @internalComponent */

	void LbTransfer(SDblQue& aDestQ);			/**< @internalComponent */

	void RemoveFromEnumerateList();				/**< @internalComponent */

	void GetCpuStats(TUint aMask, SCpuStats& aOut);		/**< @internalComponent */

	void GetCpuStatsT(TUint aMask, SCpuStats& aOut);	/**< @internalComponent */

	void GetLbStats(TUint64 aTime);				/**< @internalComponent */

	void LbDone(TUint aFlags);					/**< @internalComponent */

	TUint32 SetCpuAffinityT(TUint32 aAffinity);	/**< @internalComponent */

	TBool ShouldMigrate(TInt aCpu);				/**< @internalComponent */

	void InitLbInfo();							/**< @internalComponent */

	void NominalPriorityChanged();				/**< @internalComponent */

	void AddToEnumerateList();					/**< @internalComponent */

	void SetEventCpu();							/**< @internalComponent */

public:

	static TUint32 PreprocessCpuAffinity(TUint32 aAffinity);			/**< @internalComponent */

	inline TBool IsGroup()			{return !iParent;}					/**< @internalComponent */

	inline TBool IsLoneThread()		{return iParent==this;}				/**< @internalComponent */

	inline TBool IsGroupThread()	{return iParent && iParent!=this;}	/**< @internalComponent */

public:

//	TUint8				iReady;					/**< @internalComponent */	// flag indicating thread on ready list = cpu number | EReadyOffset

//	TUint8				iCurrent;				/**< @internalComponent */	// flag indicating thread is running

//	TUint8				iLastCpu;				/**< @internalComponent */	// CPU on which this thread last ran

	TUint8				iPauseCount;			/**< @internalComponent */	// count of externally requested pauses extending a voluntary wait

	TUint8				iSuspended;				/**< @internalComponent */	// flag indicating active external suspend (Not used for groups)

	TUint8				iACount;				/**< @internalComponent */	// access count

	TUint8				iPreferredCpu;			/**< @internalComponent */

	TInt				iActiveState;			/**< @internalComponent */

	TUint8				i_NSchedulable_Spare2;	/**< @internalComponent */

	TUint8				iForcedCpu;				/**< @internalComponent */

	TUint8				iTransientCpu;			/**< @internalComponent */

	TUint8				iLbState;				/**< @internalComponent */

	TUint8				iCpuChange;				/**< @internalComponent */	// flag showing CPU migration outstanding

	TUint8				iStopping;				/**< @internalComponent */	// thread is exiting, thread group is being destroyed

	TUint16				iFreezeCpu;				/**< @internalComponent */	// flag set if CPU frozen - count for groups

	NSchedulable*		iParent;				/**< @internalComponent */	// Pointer to group containing thread, =this for normal thread, =0 for group

	TUint32				iCpuAffinity;			/**< @internalComponent */

	volatile TUint32	iEventState;			/**< @internalComponent */	// bits 16-31=count, 0-4=event CPU, 5-9=thread CPU, 10=defer, 11=parent

	TSpinLock			iSSpinLock;				/**< @internalComponent */

	SDblQue				iEvents;				/**< @internalComponent */	// doubly-linked list of tied events

	TUint32				i_IDfcMem[sizeof(TDfc)/sizeof(TUint32)];	/**< @internalComponent */	// IDFC used to make thread ready after last tied event completes

//	TDfc				iDeferredReadyIDfc;		/**< @internalComponent */	// IDFC used to make thread ready after last tied event completes

	union {

		TUint64HL		iRunCount;				/**< @internalComponent */	// number of times this thread has run

		TUint64HL		iLastStartTime;			/**< @internalComponent */	// last start time for groups

		};

	TUint64HL			iLastRunTime;			/**< @internalComponent */	// time when this thread last ran

	TUint64HL			iTotalCpuTime;			/**< @internalComponent */	// total CPU time used by this thread

	TUint64HL			iLastActivationTime;	/**< @internalComponent */	// time when this thread last became active

	TUint64HL			iTotalActiveTime;		/**< @internalComponent */	// total time this thread has been active

	TUint64HL			iSavedCpuTime;			/**< @internalComponent */	// Total CPU time used at last check

	TUint64HL			iSavedActiveTime;		/**< @internalComponent */	// Total active time at last check

	SDblQueLink			iLbLink;				/**< @internalComponent */	// Link into queue of tasks requiring load balancing

	SIterDQLink			iEnumerateLink;			/**< @internalComponent */

	enum {EMaxLbInfoSize = 48};					/**< @internalComponent */

	union	{

		TUint64			i__Dummy[EMaxLbInfoSize/sizeof(TUint64)];	/**< @internalComponent */

		SLbInfo			iLbInfo;				/**< @internalComponent */

		};

	};

__ASSERT_COMPILE(!(_FOFF(NSchedulable,iSSpinLock)&7));

__ASSERT_COMPILE(!(_FOFF(NSchedulable,iRunCount)&7));

__ASSERT_COMPILE(!(_FOFF(NSchedulable,iTotalCpuTime)&7));

__ASSERT_COMPILE(!(_FOFF(NSchedulable,iLbInfo)&7));

__ASSERT_COMPILE(sizeof(SLbInfo) <= NSchedulable::EMaxLbInfoSize);

__ASSERT_COMPILE(!(sizeof(NSchedulable)&7));

/**

@internalComponent

*/

inline TBool TDfc::IsValid()

	{

	if (iHType < KNumDfcPriorities)

		return TRUE;

	if (iHType != EEventHandlerIDFC)

		return FALSE;

	return !iTied || !iTied->iStopping;

	}

/********************************************

 * Thread

 ********************************************/

/**

@internalComponent

*/

class NThreadWaitState

	{

private:

	enum TWtStFlags

		{

		EWtStWaitPending		=0x01u,		// thread is about to wait

		EWtStWaitActive			=0x02u,		// thread is actually blocked

		EWtStTimeout			=0x04u,		// timeout is active on this wait

		EWtStObstructed			=0x08u,		// wait is due to obstruction (e.g. mutex) rather than lack of work to do

		EWtStDead				=0x80u,		// thread is dead

		};

private:

	NThreadWaitState();

	void SetUpWait(TUint aType, TUint aFlags, TAny* aWaitObj);

	void SetUpWait(TUint aType, TUint aFlags, TAny* aWaitObj, TUint32 aTimeout);

	void SetDead(TDfc* aKillDfc);

	void CancelWait();

	TInt DoWait();

	static void TimerExpired(TAny*);

	TInt UnBlockT(TUint aType, TAny* aWaitObj, TInt aReturnValue);

	TUint32 ReleaseT(TAny*& aWaitObj, TInt aReturnValue);

	void CancelTimerT();

private:

	inline NThreadBase* Thread();

	inline TBool WaitPending()

		{ return iWtC.iWtStFlags & (EWtStWaitPending|EWtStDead); }

	inline TBool ThreadIsBlocked()

		{ return iWtC.iWtStFlags & (EWtStWaitActive|EWtStDead); }

	inline TBool ThreadIsDead()

		{ return iWtC.iWtStFlags & EWtStDead; }

private:

	struct S

		{

		volatile TUint8			iWtStFlags;

		volatile TUint8			iWtObjType;

		volatile TUint8			iWtStSpare1;

		volatile TUint8			iWtStSpare2;

		union

			{

			TAny* volatile		iWtObj;

			volatile TInt		iRetVal;

			TDfc* volatile		iKillDfc;

			};

		};

	union

		{

		S						iWtC;

		volatile TUint32		iWtSt32[2];

		volatile TUint64		iWtSt64;

		};

	NTimer						iTimer;

private:

	friend class NSchedulable;

	friend class NThreadBase;

	friend class NThread;

	friend class TScheduler;

	friend class TSubScheduler;

	friend class TDfc;

	friend class TDfcQue;

	friend class NFastSemaphore;

	friend class NFastMutex;

	friend class NTimer;

	friend class NTimerQ;

	friend class NKern;

	friend class Monitor;

	friend class NKTest;

	};

/**

@publishedPartner

@prototype

Base class for a nanokernel thread.

*/

class TSubScheduler;

class NThreadBase : public NSchedulable

	{

public:

    /**

    Defines the possible types of wait object

    */

	enum NThreadWaitType

		{

		EWaitNone,

		EWaitFastSemaphore,

		EWaitFastMutex,

		EWaitSleep,

		EWaitBlocked,

		EWaitDfc,

		ENumWaitTypes

		};

	/**

	@internalComponent

	*/

	enum NThreadCSFunction

		{

		ECSExitPending=-1,

		ECSExitInProgress=-2,

		ECSDivertPending=-3,

		};

	/**

	@internalComponent

	*/

	enum NThreadTimeoutOp

		{

		ETimeoutPreamble=0,

		ETimeoutPostamble=1,

		ETimeoutSpurious=2,

		};

public:

	NThreadBase();

	TInt Create(SNThreadCreateInfo& anInfo,	TBool aInitial);	/**< @internalComponent */

	void UnReadyT();										/**< @internalComponent */

	TBool SuspendOrKill(TInt aCount);						/**< @internalComponent */

	TBool DoSuspendOrKillT(TInt aCount, TSubScheduler* aS);	/**< @internalComponent */

	TBool CancelTimerT();									/**< @internalComponent */

	void DoReleaseT(TInt aReturnCode, TUint aMode);			/**< @internalComponent */

	TBool CheckFastMutexDefer();							/**< @internalComponent */

	void DoCsFunctionT();									/**< @internalComponent */

	TBool Resume(TBool aForce);								/**< @internalComponent */

	IMPORT_C TBool Suspend(TInt aCount);					/**< @internalComponent */

	IMPORT_C TBool Resume();								/**< @internalComponent */

	IMPORT_C TBool ForceResume();							/**< @internalComponent */

	IMPORT_C void Release(TInt aReturnCode, TUint aMode);	/**< @internalComponent */

	IMPORT_C void RequestSignal();							/**< @internalComponent */

	IMPORT_C void SetPriority(TInt aPriority);				/**< @internalComponent */

	void SetNominalPriority(TInt aPriority);				/**< @internalComponent */

	void SetMutexPriority(NFastMutex* aMutex);				/**< @internalComponent */

	void LoseInheritedPriorityT();							/**< @internalComponent */

	void ChangeReadyThreadPriority();						/**< @internalComponent */

	TBool TiedEventLeaveInterlock();						/**< @internalComponent */

	TBool TiedEventJoinInterlock();							/**< @internalComponent */

	IMPORT_C void Kill();									/**< @internalComponent */

	void Exit();											/**< @internalComponent */

	// hooks for platform-specific code

	void OnKill();											/**< @internalComponent */

	void OnExit();											/**< @internalComponent */

public:

	static void TimerExpired(TAny* aPtr);					/**< @internalComponent */

	/** @internalComponent */

	inline void UnknownState(TInt aOp, TInt aParam)

		{ (*iHandlers->iStateHandler)((NThread*)this,aOp,aParam); }

	/** @internalComponent */

	inline TUint8 Attributes()

		{ return i_ThrdAttr; }

	/** @internalComponent */

	inline TUint8 SetAttributes(TUint8 aNewAtt)

		{ return __e32_atomic_swp_ord8(&i_ThrdAttr, aNewAtt); }

	/** @internalComponent */

	inline TUint8 ModifyAttributes(TUint8 aClearMask, TUint8 aSetMask)

		{ return __e32_atomic_axo_ord8(&i_ThrdAttr, (TUint8)~(aClearMask|aSetMask), aSetMask); }

	/** @internalComponent */

	inline void SetAddressSpace(TAny* a)

		{ iAddressSpace=a; }

	/** @internalComponent */

	inline void SetExtraContext(TAny* a, TInt aSize)

		{ iExtraContext = a; iExtraContextSize = aSize; }

	/** @internalTechnology */

	inline TBool IsDead()

		{ return iWaitState.ThreadIsDead(); }

public:

	TPriListLink		iWaitLink;				/**< @internalComponent */	// used to link thread into a wait queue

//	TUint8				iBasePri;				/**< @internalComponent */	// priority with no fast mutex held

//	TUint8				iMutexPri;				/**< @internalComponent */	// priority from held fast mutex

//	TUint8				iNominalPri;			/**< @internalComponent */	// nominal priority of thread (excluding effect of higher level inheritance)

	TUint8				iLinkedObjType;

	TUint8				i_ThrdAttr;				/**< @internalComponent */

	TUint8				iInitial;				/**< @internalComponent */	// TRUE if this is an initial thread

	TUint8				iFastMutexDefer;		/**< @internalComponent */

	NFastSemaphore		iRequestSemaphore;		/**< @internalComponent */

	TInt				iTime;					/**< @internalComponent */	// time remaining, 0 if expired

	TInt				iTimeslice;				/**< @internalComponent */	// timeslice for this thread, -ve = no timeslicing

	TLinAddr			iSavedSP;				/**< @internalComponent */

	TAny*				iAddressSpace;			/**< @internalComponent */

	NFastMutex* volatile iHeldFastMutex;		/**< @internalComponent */	// fast mutex held by this thread

	TUserModeCallback* volatile iUserModeCallbacks;	/**< @internalComponent */	// Head of singly-linked list of callbacks

	TAny* volatile		iLinkedObj;				/**< @internalComponent */	// object to which this thread is linked

	NThreadGroup*		iNewParent;				/**< @internalComponent */	// group to join

	const SFastExecTable* iFastExecTable;		/**< @internalComponent */

	const SSlowExecEntry* iSlowExecTable;		/**< @internalComponent */	// points to first entry iEntries[0]

	volatile TInt		iCsCount;				/**< @internalComponent */	// critical section count

	volatile TInt		iCsFunction;			/**< @internalComponent */	// what to do on leaving CS: +n=suspend n times, 0=nothing, -1=exit

	NThreadWaitState	iWaitState;				/**< @internalComponent */

	const SNThreadHandlers* iHandlers;			/**< @internalComponent */	// additional thread event handlers

	TInt				iSuspendCount;			/**< @internalComponent */	// -how many times we have been suspended

	TLinAddr			iStackBase;				/**< @internalComponent */

	TInt				iStackSize;				/**< @internalComponent */

	TAny*				iExtraContext;			/**< @internalComponent */	// parent FPSCR value (iExtraContextSize == -1), coprocessor context (iExtraContextSize > 0) or NULL

	TInt				iExtraContextSize;		/**< @internalComponent */	// +ve=dynamically allocated, 0=none, -1=iExtraContext stores parent FPSCR value

	TUint8				iCoreCycling;			/**< @internalComponent */	// this thread is currently cycling through all active cores

	TUint8				iRebalanceAttr;			/**< @internalComponent */	// behaviour of load balancing wrt this thread

	TUint8				iNThreadBaseSpare4c;	/**< @internalComponent */	// spare to allow growth while preserving BC

	TUint8				iNThreadBaseSpare4d;	/**< @internalComponent */	// spare to allow growth while preserving BC

	TUint32				iNThreadBaseSpare5;		/**< @internalComponent */	// spare to allow growth while preserving BC

	TUint32				iNThreadBaseSpare6;		/**< @internalComponent */	// spare to allow growth while preserving BC

	TUint32				iNThreadBaseSpare7;		/**< @internalComponent */	// spare to allow growth while preserving BC

	TUint32				iNThreadBaseSpare8;		/**< @internalComponent */	// spare to allow growth while preserving BC

	TUint32				iNThreadBaseSpare9;		/**< @internalComponent */	// spare to allow growth while preserving BC

	};

__ASSERT_COMPILE(!(_FOFF(NThreadBase,iWaitLink)&7));

__ASSERT_COMPILE(!(sizeof(NThreadBase)&7));

#ifdef __INCLUDE_NTHREADBASE_DEFINES__

#define	iReady				iSpare1				/**< @internalComponent */

#define	iCurrent			iSpare2				/**< @internalComponent */

#define	iLastCpu			iSpare3				/**< @internalComponent */

#define iBasePri			iWaitLink.iSpare1	/**< @internalComponent */

#define	iMutexPri			iWaitLink.iSpare2	/**< @internalComponent */

#define	iNominalPri			iWaitLink.iSpare3	/**< @internalComponent */

#define	i_NThread_Initial	iInitial			/**< @internalComponent */

#endif

/** @internalComponent */

#define	i_NThread_BasePri		iWaitLink.iSpare1

#define	i_NThread_NominalPri	iWaitLink.iSpare3

/** @internalComponent */

#define	NTHREADBASE_CPU_AFFINITY_MASK	0x80000000

/** @internalComponent */

inline NThreadBase* NThreadWaitState::Thread()

	{ return _LOFF(this, NThreadBase, iWaitState); }

/********************************************

 * Thread group

 ********************************************/

/**

@publishedPartner

@prototype

Base class for a nanokernel thread or group

*/

class NThreadGroup : public NSchedulable

	{

public:

	NThreadGroup();

public:

	TInt iThreadCount;										/**< @internalComponent */

	TDfc* iDestructionDfc;									/**< @internalComponent */

	TPriList<NThreadBase, KNumPriorities> iNThreadList;		/**< @internalComponent */

	};

/********************************************