windows-xp/Source/XPSP1/NT/base/fs/utils/dfrg/priority.c

#include "stdafx.h"
#include <windows.h>



/* 
 * Priority.c
 * 
 * This module contains the following routines
 *      IsBelowNormalBasePriority : Checks is the current process is executing below Normal Base priority
 *      ResetToNormalPriority : Resets current process to Normal priority
 *      Main : Calling routine to test above 2 routines. 
 *
 * Here is some MSDN data on the base priority of a process.
 *
 * Thread Priority
 * ===============
 * Base Priority
 * 
 * The priority level of a thread is determined by both the priority class of 
 * its process and its priority level. The priority class and priority level are 
 * combined to form the base priority of each thread. The following table shows the 
 * base priority levels for combinations of priority class and priority value. 
 * 
 *   Process Priority Class				Thread Priority Level 
 * 1 IDLE_PRIORITY_CLASS				THREAD_PRIORITY_IDLE 
 * 1 BELOW_NORMAL_PRIORITY_CLASS		THREAD_PRIORITY_IDLE 
 * 1 NORMAL_PRIORITY_CLASS				THREAD_PRIORITY_IDLE 
 * 1 ABOVE_NORMAL_PRIORITY_CLASS		THREAD_PRIORITY_IDLE 
 * 1 HIGH_PRIORITY_CLASS				THREAD_PRIORITY_IDLE 
 * 2 IDLE_PRIORITY_CLASS				THREAD_PRIORITY_LOWEST 
 * 3 IDLE_PRIORITY_CLASS				THREAD_PRIORITY_BELOW_NORMAL 
 * 4 IDLE_PRIORITY_CLASS				THREAD_PRIORITY_NORMAL 
 * 4 BELOW_NORMAL_PRIORITY_CLASS		THREAD_PRIORITY_LOWEST 
 * 5 IDLE_PRIORITY_CLASS				THREAD_PRIORITY_ABOVE_NORMAL 
 * 5 BELOW_NORMAL_PRIORITY_CLASS		THREAD_PRIORITY_BELOW_NORMAL 
 * 5 Background NORMAL_PRIORITY_CLASS	THREAD_PRIORITY_LOWEST 
 * 6 IDLE_PRIORITY_CLASS				THREAD_PRIORITY_HIGHEST 
 * 6 BELOW_NORMAL_PRIORITY_CLASS		THREAD_PRIORITY_NORMAL 
 * 6 Background NORMAL_PRIORITY_CLASS	THREAD_PRIORITY_BELOW_NORMAL 
 * 7 BELOW_NORMAL_PRIORITY_CLASS		THREAD_PRIORITY_ABOVE_NORMAL 
 * 7 Background NORMAL_PRIORITY_CLASS	THREAD_PRIORITY_NORMAL 
 * 7 Foreground NORMAL_PRIORITY_CLASS	THREAD_PRIORITY_LOWEST 
 * 8 BELOW_NORMAL_PRIORITY_CLASS		THREAD_PRIORITY_HIGHEST 
 * 8 NORMAL_PRIORITY_CLASS				THREAD_PRIORITY_ABOVE_NORMAL 
 * 8 Foreground NORMAL_PRIORITY_CLASS	THREAD_PRIORITY_BELOW_NORMAL 
 * 8 ABOVE_NORMAL_PRIORITY_CLASS		THREAD_PRIORITY_LOWEST 
 * 9 NORMAL_PRIORITY_CLASS				THREAD_PRIORITY_HIGHEST 
 * 9 Foreground NORMAL_PRIORITY_CLASS	THREAD_PRIORITY_NORMAL 
 * 9 ABOVE_NORMAL_PRIORITY_CLASS		THREAD_PRIORITY_BELOW_NORMAL 
 * 10 Foreground NORMAL_PRIORITY_CLASS	THREAD_PRIORITY_ABOVE_NORMAL 
 * 10 ABOVE_NORMAL_PRIORITY_CLASS		THREAD_PRIORITY_NORMAL 
 * 11 Foreground NORMAL_PRIORITY_CLASS	THREAD_PRIORITY_HIGHEST 
 * 11 ABOVE_NORMAL_PRIORITY_CLASS		THREAD_PRIORITY_ABOVE_NORMAL 
 * 11 HIGH_PRIORITY_CLASS				THREAD_PRIORITY_LOWEST 
 * 12 ABOVE_NORMAL_PRIORITY_CLASS		THREAD_PRIORITY_HIGHEST 
 * 12 HIGH_PRIORITY_CLASS				THREAD_PRIORITY_BELOW_NORMAL 
 * 13 HIGH_PRIORITY_CLASS				THREAD_PRIORITY_NORMAL 
 * 14 HIGH_PRIORITY_CLASS				THREAD_PRIORITY_ABOVE_NORMAL 
 * 15 HIGH_PRIORITY_CLASS				THREAD_PRIORITY_HIGHEST 
 * 15 HIGH_PRIORITY_CLASS				THREAD_PRIORITY_TIME_CRITICAL 
 * 15 IDLE_PRIORITY_CLASS				THREAD_PRIORITY_TIME_CRITICAL  
 * 15 BELOW_NORMAL_PRIORITY_CLASS		THREAD_PRIORITY_TIME_CRITICAL 
 * 15 NORMAL_PRIORITY_CLASS				THREAD_PRIORITY_TIME_CRITICAL 
 * 15 ABOVE_NORMAL_PRIORITY_CLASS		THREAD_PRIORITY_TIME_CRITICAL 
 * 16 REALTIME_PRIORITY_CLASS			THREAD_PRIORITY_IDLE 
 * 22 REALTIME_PRIORITY_CLASS			THREAD_PRIORITY_LOWEST 
 * 23 REALTIME_PRIORITY_CLASS			THREAD_PRIORITY_BELOW_NORMAL 
 * 24 REALTIME_PRIORITY_CLASS			THREAD_PRIORITY_NORMAL 
 * 25 REALTIME_PRIORITY_CLASS			THREAD_PRIORITY_ABOVE_NORMAL 
 * 26 REALTIME_PRIORITY_CLASS			THREAD_PRIORITY_HIGHEST 
 * 31 REALTIME_PRIORITY_CLASS			THREAD_PRIORITY_TIME_CRITICAL 
 *
 */


//
//   ------------------------------
//  |  IsBelowNormalBasePriority() |
//   ------------------------------
//
// COPYRIGHT� 2001 Microsoft Corporation and Executive Software International, Inc.
//
//  Description:
//    Determine whether the current thread running below the normal priority or not.
// 
//    Caller must have a PROCESS_QUERY_INFORMATION access to the process/ thread.
//
//    PDL
//
//		This routine taking normal base priority as "Base Priority level 7". ie
//		combination of NORMAL_PRIORITY_CLASS and THREAD_PRIORITY_NORMAL (background)
//
//		These are the conditions that we can use to determine whether the 
//		thread running at >= NORMAL priority or not. 
//
//		1) All the thread running under IDLE_PRIORITY_CLASS has got base priority of 1 except
//		the thread which has the priority of THREAD_PRIORITY_TIME_CRITICAL.
//
//		2) The thread belongs to a BELOW_NORMAL_PRIORITY_CLASS process should run at  
//		THREAD_PRIORITY_ABOVE_NORMAL or higher priority to get the NORMAL base priority.
//
//		3) All the Threads, which are running at THRED_PRIORITY_IDLE has a base priority of less than 7 
//		except those threads are in the REALTIME_PRIORITY_CLASS process.
//
//		4) If the process running at NORMAL_PRIORITY_CLASS then the thread should run  at 
//		THREAD_PRIORITY_NORMAL or above.
//  
//  Calling Sequence:
//		None.
//
//  Inputs:
//		None.
//
//  Outputs:
//		None.
//		Return TRUE if the current thread's Base priority is below normal.
//		otherwise return FALSE
//
//  Error Handling:
//		Error not handled, returns FALSE on error
//		
//
//  Global Effects:
//    None
BOOL
IsBelowNormalBasePriority()
{
	DWORD   PriorityClass, ThreadPriority;
	BOOL	bBelowNormal  = FALSE;


	do {
		//
		// get the Process Priority class and the thread priority
		//
		PriorityClass  = GetPriorityClass(GetCurrentProcess());
		if (!PriorityClass ) break;

		ThreadPriority = GetThreadPriority(GetCurrentThread());
		if (THREAD_PRIORITY_ERROR_RETURN == ThreadPriority) break;


		bBelowNormal = TRUE;

        //
        // Check for the 4 cases of running below Normal base priority
        //

        //
        // 1) Check for threads running under IDLE_PRIORITY_CLASS has got base priority of 1 except
        //	  the thread which has the priority of THREAD_PRIORITY_TIME_CRITICAL.
		if (IDLE_PRIORITY_CLASS				== PriorityClass &&
			THREAD_PRIORITY_TIME_CRITICAL   != ThreadPriority ) break;
        //
        // 2) Check threads that belongs to a BELOW_NORMAL_PRIORITY_CLASS process should run at  
        //    THREAD_PRIORITY_ABOVE_NORMAL or higher priority to get the NORMAL base priority.
		if (BELOW_NORMAL_PRIORITY_CLASS		== PriorityClass &&
			THREAD_PRIORITY_NORMAL			>= ThreadPriority ) break;
        //
        // 3) Check all the Threads, which are running at THREAD_PRIORITY_IDLE has a base priority of less than 7 
        //    except those threads are in the REALTIME_PRIORITY_CLASS process.
		if (THREAD_PRIORITY_IDLE			== ThreadPriority &&
			REALTIME_PRIORITY_CLASS			!= PriorityClass ) break;
        //
        // 4) Check if the process is running at NORMAL_PRIORITY_CLASS then the thread should run  at 
        //    THREAD_PRIORITY_NORMAL or above.
		if (NORMAL_PRIORITY_CLASS			== PriorityClass &&
			THREAD_PRIORITY_NORMAL			>= ThreadPriority ) break;

        // 
        // If it did not meet the above criteria, then it must be running at Normal base priority or above
		bBelowNormal = FALSE;

	}while(0);


	return bBelowNormal;
}


//
//   --------------------------
//  |  ResetToNormalPriority() |
//   --------------------------
//
// COPYRIGHT� 2001 Microsoft Corporation and Executive Software International, Inc.
//
//  Description:
//    Sets Current Thread's Base priority to Normal
//
//	  Caller should have PROCESS_SET_INFORMATION and THREAD_SET_INFORMATION access right
//    for the current process / current thread..
//
//    PDL
//
//		Resetting base priority by setting Priority Class and Thread Priority 
//		to NORMAL.
//  
//  Calling Sequence:
//		None.
//
//  Inputs:
//		None.
//
//  Outputs:
//		None.
//		returns FALSE on error. return TRUE on success
//
//  Error Handling:
//    return FALSE on error
//
//  Global Effects:
//    The process priority will reset to NORMAL_PRIORITY_CLASS 
//    and current thread's  priority to THREAD_PRIORITY_NORMAL.
//
BOOL
ResetToNormalPriority()
{
	if (!SetPriorityClass(GetCurrentProcess(),NORMAL_PRIORITY_CLASS)) return FALSE;
	if (!SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_NORMAL)) return FALSE;
	return TRUE;
}





#ifdef TEST_PRIORITY_MODULE

int
main()
{
	for (;;) {
		Sleep(4000);
		if (IsBelowNormalBasePriority()) {
			ResetToNormalPriority();
		}
	}
	return 0;
}

#endif