调度子系统2_核心调度器

//	核心调度器
//		当进程决定让出cpu时调用
//	函数任务：
//		1.禁止内核抢占
//		2.获取本cpu的rq
//		3.取消为当前进程运行的hrtimer
//		4.获取队列锁
//		5.更新队列时钟
//		6.清除当前进程need resched标志
//		7.如果当前进程为非运行状态，并且当前非内核抢占路径
//			7.1 如果当前进程有信号待处理，设置当前进程为就绪状态
//			7.2 否则进程出队rq
//		8.如果当前rq没有可运行进程
//			8.1 通过load balance从其他进程搬进程
//		9.通知调度器类用另一个进程代替当前进程
//		10.通知调度器类选择下一个可运行进程
//		11.如果下一个运行的进程非当前进程
//			11.1 执行进程切换
//		12.否则释放队列锁
//		13.开启内核抢占
//		14.如果当前进程被设置need resched，重复1 
1.1 asmlinkage void __sched schedule(void)
{
	struct task_struct *prev, *next;
	unsigned long *switch_count;
	struct rq *rq;
	int cpu;

need_resched:
	//禁止抢占
	preempt_disable();
	cpu = smp_processor_id();
	//本cpu的rq
	rq = cpu_rq(cpu);
	//当前rq上正在运行的进程
	prev = rq->curr;
	//进程被切换的次数
	switch_count = &prev->nivcsw;

	//取消为当前进程运行的hrtimer
	if (sched_feat(HRTICK))
		hrtick_clear(rq);
	//获取队列锁
	raw_spin_lock_irq(&rq->lock);
	//更新队列时钟
	update_rq_clock(rq);
	//清除当前进程need resched标志
	clear_tsk_need_resched(prev);
	//当前进程非运行状态，并且非内核抢占
	if (prev->state && !(preempt_count() & PREEMPT_ACTIVE)) {
		//当前进程有信号待处理，设置进程为运行态
		if (unlikely(signal_pending_state(prev->state, prev)))
		{
			prev->state = TASK_RUNNING;
		}
		else
		{	//进程出队rq
			deactivate_task(rq, prev, 1);
		}
			
		switch_count = &prev->nvcsw;
	}
	//通知调度器类，即将发生进程切换
	pre_schedule(rq, prev);
	//当前rq没有可运行进程，通过loadbalance从其他cpu的rq搬进程过来
	if (unlikely(!rq->nr_running))
		idle_balance(cpu, rq);
	//通知调度器类用另一个进程代替当前进程
	put_prev_task(rq, prev);
	//通知调度器类选择下一个可运行进程
	next = pick_next_task(rq);
	//切换当前进程
	if (likely(prev != next)) {	
		//统计rq切换次数
		rq->nr_switches++;
		rq->curr = next;
		++*switch_count;
		//切换进程上下文
		context_switch(rq, prev, next); 
		//现在已经是另一个进程在运行
		cpu = smp_processor_id();
		rq = cpu_rq(cpu);
	} else
		raw_spin_unlock_irq(&rq->lock);
	//通知调度器类，完成了进程切换
	post_schedule(rq);
	//开启内核抢占
	preempt_enable_no_resched();
	//如果当前进程需要切换，则再次切换
	if (need_resched())
		goto need_resched;
}

//	通知调度器类，即将进程切换
2.1 static inline void pre_schedule(struct rq *rq, struct task_struct *prev)
{
	if (prev->sched_class->pre_schedule)
		prev->sched_class->pre_schedule(rq, prev);
}

//	通知调度器，完成了进程切换
2.2 static inline void post_schedule(struct rq *rq)
{
	if (rq->post_schedule) {
		unsigned long flags;
		//获取队列锁
		raw_spin_lock_irqsave(&rq->lock, flags);
		if (rq->curr->sched_class->post_schedule)
			rq->curr->sched_class->post_schedule(rq);
		raw_spin_unlock_irqrestore(&rq->lock, flags);
		rq->post_schedule = 0;
	}
}

//	通知调度器类，用另一个进程替换当前进程
3.1 static void put_prev_task(struct rq *rq, struct task_struct *prev)
{
	....
	prev->sched_class->put_prev_task(rq, prev);
}


//	通知调度器类，选择下一个运行的进程
4.1 static inline struct task_struct *pick_next_task(struct rq *rq)
{
	const struct sched_class *class;
	struct task_struct *p;

	//如果rq中进程数等于cfs中进程数，说明没有rt进程，由cfs选出下一个运行的进程
	if (likely(rq->nr_running == rq->cfs.nr_running)) {
		p = fair_sched_class.pick_next_task(rq);
		if (likely(p))
			return p;
	}
	//否则由最高优先级的调度类
	class = sched_class_highest;
	for ( ; ; ) {
		//选择下一个运行进程
		p = class->pick_next_task(rq);
		if (p)
			return p;
		//下一个优先级的调度类
		class = class->next;
	}
}
//	最高优先级调度器类
4.2 #define sched_class_highest (&rt_sched_class)