MCL/sf/os/kernelhwsrv: comparison kernel/eka/include/nkernsmp/nkern.h

equal deleted inserted replaced

-:a179b74831c9
+:c1f20ce4abcf
 extern "C" {
 /** @internalComponent */
 IMPORT_C void NKFault(const char* file, TInt line);
 /** @internalComponent */
-void NKIdle(TInt aStage);
+void NKIdle(TUint32 aStage);
 }
 /**
 @publishedPartner
 @released
 		EOrderReadyList			=0x88u,		// Per-CPU ready list lock
 		EOrderThreadGroup		=0x90u,		// Thread group locks
 		EOrderThread			=0x91u,		// Thread locks
 		EOrderFastMutex			=0x98u,		// Fast mutex locks
 		EOrderEventHandlerTied	=0x9Cu,		// Event handler tied lock
+		EOrderEnumerate			=0x9Du,		// Thread/Group enumeration lists
 		EOrderGenericPreHigh0	=0x9Eu,		// Device driver spin locks, high range
 		EOrderGenericPreHigh1	=0x9Fu,		// Device driver spin locks, high range
 		EOrderNone				=0xFFu		// No order check required (e.g. for dynamic ordering)
 		};
 	TLinAddr iPreprocessHandler;	// used for handle lookups
 	SSlowExecEntry iEntries[1];		// first entry is for call number 0
 	};
 // Thread iAttributes Constants
-const TUint8 KThreadAttImplicitSystemLock=1;	/**< @internalComponent */
+const TUint8 KThreadAttImplicitSystemLock=1;		/**< @internalComponent */
-const TUint8 KThreadAttAddressSpace=2;			/**< @internalComponent */
+const TUint8 KThreadAttAddressSpace=2;				/**< @internalComponent */
-const TUint8 KThreadAttLoggable=4;				/**< @internalComponent */
+const TUint8 KThreadAttLoggable=4;					/**< @internalComponent */
 // Thread CPU
-const TUint32 KCpuAffinityAny=0xffffffffu;		/**< @internalComponent */
+const TUint32 KCpuAffinityAny=0xffffffffu;			/**< @internalComponent */
+const TUint32 KCpuAffinityPref=0x40000000u;			/**< @internalComponent */
+const TUint32 KCpuAffinityTransient=0x20000000u;	/**< @internalComponent */
 /** Information needed for creating a nanothread.
 	@publishedPartner
 	@prototype
 	@prototype
 */
 struct SNThreadGroupCreateInfo
 	{
 	TUint32 iCpuAffinity;
+	TDfc* iDestructionDfc;
 	};
 /**	Constant for use with NKern:: functions which release a fast mutex as well
 	as performing some other operations.
 	@publishedPartner
 	@released
 */
 #define	SYSTEM_LOCK		(NFastMutex*)0
 /** Idle handler function
 	Pointer to a function which is called whenever a CPU goes idle
 	@param	aPtr	The iPtr stored in the SCpuIdleHandler structure
-	@param	aStage	If positive, the number of processors still active
+	@param	aStage	Bits 0-7 give a bitmask of CPUs now active, i.e. 0 means all processors now idle
-					If zero, indicates all processors are now idle
+					Bit 31 set indicates that the current core can now be powered down
-					-1 indicates that postamble processing is required after waking up
+					Bit 30 set indicates that other cores still remain to be retired
+					Bit 29 set indicates that postamble processing is required after waking up
-	@publishedPartner
+	@param	aU		Points to some per-CPU uncached memory used for handshaking during power down/power up
-	@prototype
-*/
+	@internalComponent
-typedef void (*TCpuIdleHandlerFn)(TAny* aPtr, TInt aStage);
+*/
+typedef void (*TCpuIdleHandlerFn)(TAny* aPtr, TUint32 aStage, volatile TAny* aU);
 /** Idle handler structure
-	@publishedPartner
+	@internalComponent
-	@prototype
 */
 struct SCpuIdleHandler
 	{
+	/**
+	Defined flag bits in aStage parameter
+	*/
+	enum
+		{
+		EActiveCpuMask=0xFFu,
+		EPostamble=1u<<29,		// postamble needed
+		EMore=1u<<30,			// more cores still to be retired
+		ERetire=1u<<31,			// this core can now be retired
+		};
 	TCpuIdleHandlerFn	iHandler;
 	TAny*				iPtr;
 	volatile TBool		iPostambleRequired;
 	};
 	IMPORT_C static TBool ThreadForceResume(NThread* aThread, NFastMutex* aMutex);
 	IMPORT_C static void ThreadRelease(NThread* aThread, TInt aReturnValue);
 	IMPORT_C static void ThreadRelease(NThread* aThread, TInt aReturnValue, NFastMutex* aMutex);
 	IMPORT_C static void ThreadSetPriority(NThread* aThread, TInt aPriority);
 	IMPORT_C static void ThreadSetPriority(NThread* aThread, TInt aPriority, NFastMutex* aMutex);
+	static void ThreadSetNominalPriority(NThread* aThread, TInt aPriority);
 	IMPORT_C static void ThreadRequestSignal(NThread* aThread);
 	IMPORT_C static void ThreadRequestSignal(NThread* aThread, NFastMutex* aMutex);
 	IMPORT_C static void ThreadRequestSignal(NThread* aThread, TInt aCount);
 	IMPORT_C static void ThreadKill(NThread* aThread);
 	IMPORT_C static void ThreadKill(NThread* aThread, NFastMutex* aMutex);
 	IMPORT_C static TUint64 ThreadCpuTime(NThread* aThread);							/**< @internalComponent */
 	IMPORT_C static TUint32 CpuTimeMeasFreq();											/**< @internalComponent */
 	static TInt QueueUserModeCallback(NThreadBase* aThread, TUserModeCallback* aCallback);	/**< @internalComponent */
 	static void MoveUserModeCallbacks(NThreadBase* aSrcThread, NThreadBase* aDestThread);	/**< @internalComponent */
 	static void CancelUserModeCallbacks();												/**< @internalComponent */
+	static void JumpTo(TInt aCpu);														/**< @internalComponent */
 	// Thread Groups
 	IMPORT_C static TInt GroupCreate(NThreadGroup* aGroup, SNThreadGroupCreateInfo& aInfo);
 	IMPORT_C static void GroupDestroy(NThreadGroup* aGroup);
 	IMPORT_C static NThreadGroup* CurrentGroup();
 	// Miscellaneous
 	IMPORT_C static NThread* CurrentThread();
 	IMPORT_C static TInt CurrentCpu();										/**< @internalComponent */
 	IMPORT_C static TInt NumberOfCpus();									/**< @internalComponent */
+	IMPORT_C static void SetNumberOfActiveCpus(TInt aNumber);
 	IMPORT_C static void LockSystem();
 	IMPORT_C static void UnlockSystem();
 	IMPORT_C static TBool FlashSystem();
 	IMPORT_C static void WaitForAnyRequest();
 	IMPORT_C static void Sleep(TUint32 aTime);
 	static void Init0(TAny* aVariantData);
 	static void Init(NThread* aThread, SNThreadCreateInfo& aInfo);
 	static TInt BootAP(volatile SAPBootInfo* aInfo);
 	IMPORT_C static TBool KernelLocked(TInt aCount=0);						/**< @internalTechnology */
 	IMPORT_C static NFastMutex* HeldFastMutex();							/**< @internalTechnology */
 	static void Idle();
+	static void DoIdle();
 	IMPORT_C static SCpuIdleHandler* CpuIdleHandler();						/**< @internalTechnology */
 	static void NotifyCrash(const TAny* a0, TInt a1);						/**< @internalTechnology */
 	IMPORT_C static TBool Crashed();
 	static TUint32 IdleGenerationCount();
 @internalComponent
 */
 class TStopIPI : public TGenericIPI
 	{
 public:
-	void StopCPUs();
+	TUint32 StopCPUs();
 	void ReleaseCPUs();
 	static void Isr(TGenericIPI*);
 public:
 	volatile TInt iFlag;
 	};
+/**
+@internalComponent
+*/
+class TCoreCycler
+	{
+public:
+	TCoreCycler();
+	TInt Next();
+private:
+	void Init();
+private:
+	TUint32			iCores;
+	TUint32			iRemain;
+	TInt			iInitialCpu;
+	TInt			iCurrentCpu;
+	NThreadGroup*	iG;
+	TInt			iFrz;
+	};
 #include <ncern.h>
 #endif

branch	RCL_3
changeset 43	c1f20ce4abcf
parent 0	a41df078684a
child 44	3e88ff8f41d5