进程调度1【进程的优先级】

静态优先级
动态优先级 100 ~ 139
基本时间片
平均睡眠时间
惩罚值
运行队列
实时进程优先级 0 ~ 99
普通进程优先级 100 ~ 139

• 基本时间片

/*
	宏						描述			值
	DEF_TIMESLICE			默认时间片		100毫秒(HZ=1000)
	MIN_TIMESLICE			最小时间片		5毫秒(HZ=1000)
	
*/
#define MIN_TIMESLICE		max(5 * HZ / 1000, 1)
#define DEF_TIMESLICE		(100 * HZ / 1000)
#define NICE_TO_PRIO(nice)	(MAX_RT_PRIO + (nice) + 20)
#define SCALE_PRIO(x, prio) \
	max(x * (MAX_PRIO - prio) / (MAX_USER_PRIO/2), MIN_TIMESLICE)
  //max(x * (140      - prio) / (40/2),  5)	
  
/*
	时间片 = (140 - 静态优先级) * 20   静态优先级 <  120
	时间片 = (140 - 静态优先级) * 5    静态优先级 >= 120
*/
static unsigned int task_timeslice(task_t *p)
{
	if (p->static_prio < NICE_TO_PRIO(0))
		return SCALE_PRIO(DEF_TIMESLICE*4, p->static_prio);
	else
		return SCALE_PRIO(DEF_TIMESLICE, p->static_prio);
}

• 进程优先级

/*
    宏					描述					值
	MAX_PRIO			最大优先级				140		
	MAX_RT_PRIO			最大实时进程优先级		100
	MAX_USER_RT_PRIO	最大实时进程优先级		100
	USER_PRIO			用户优先级				p - 100
	MAX_USER_PRIO		最大用户优先级		    40
	TASK_USER_PRIO		用户进程优先级			静态优先级 - 100
*/
#define USER_PRIO(p)		((p)-MAX_RT_PRIO)
#define TASK_USER_PRIO(p)	USER_PRIO((p)->static_prio)
#define MAX_USER_PRIO		(USER_PRIO(MAX_PRIO))
#define MAX_USER_RT_PRIO	100              //实时进程优先级范围 0 ~ 99
#define MAX_RT_PRIO		MAX_USER_RT_PRIO	 //最大实时进程优先级
#define MAX_PRIO		(MAX_RT_PRIO + 40)	 //普通进程的优先级范围  100 ~ 139
#define rt_task(p)		(unlikely((p)->prio < MAX_RT_PRIO))  //判断是否是实时进程

惩罚值:

/*
    宏						描述			值
	MAX_BONUS				最大惩罚值		10
	CURRENT_BONUS			进程当前惩罚值	平均睡眠时间(单位:毫秒) * 10 / 100
	PRIO_BONUS_RATIO	 					25
	DEF_TIMESLICE			默认时间片		100毫秒(HZ=1000)
	MAX_SLEEP_AVG			最大平均睡眠时间	1000毫秒(HZ=1000)
*/
#define NS_TO_JIFFIES(TIME)	((TIME) / (1000000000 / HZ))
#define JIFFIES_TO_NS(TIME)	((TIME) * (1000000000 / HZ))
#define DEF_TIMESLICE		(100 * HZ / 1000)			// 默认时间片 100毫秒(HZ=1000)		
#define MAX_SLEEP_AVG		(DEF_TIMESLICE * MAX_BONUS)	//最大平均睡眠时间 1000毫秒(HZ=1000)
#define PRIO_BONUS_RATIO	 25
#define MAX_BONUS		(MAX_USER_PRIO * PRIO_BONUS_RATIO / 100)    	//最大惩罚值 10
#define CURRENT_BONUS(p) \												
	(NS_TO_JIFFIES((p)->sleep_avg) * MAX_BONUS / \
		MAX_SLEEP_AVG)

动态优先级:

static int effective_prio(task_t *p)
{
	int bonus, prio;

	if (rt_task(p))
		return p->prio;

	bonus = CURRENT_BONUS(p) - MAX_BONUS / 2;

	prio = p->static_prio - bonus;	// 动态优先级 = 静态优先级 - 惩罚值
	if (prio < MAX_RT_PRIO)			// 动态优先级最小值 100
		prio = MAX_RT_PRIO;
	if (prio > MAX_PRIO-1)			// 动态优先级最大值 139
		prio = MAX_PRIO-1;
	return prio;
}