上層排程，linux排程的核心函式為schedule，schedule函式封裝了核心排程的框架。細節實現上呼叫具體的排程類中的函式實現。schedule函式主要流程為：

1，將當前程序從相應的執行佇列中刪除；

2，計算和更新排程實體和程序的相關排程資訊；

3，將當前進重新插入到排程執行佇列中，對於CFS排程，根據具體的執行時間進行插入而對於實時排程插入到對應優先順序佇列的隊尾；

4，從執行佇列中選擇執行的下一個程序；

5，程序排程資訊和上下文切換；

當程序上下文切換後（關於程序切換在前面的文章中有介紹），排程就基本上完成了，當前執行的程序就是切換過來的程序了。

/*核心和其他部分用於呼叫程序排程器的入口，選擇
 哪個程序可以執行，何時將其投入執行。schedule通常
 都需要和一個具體的排程類相關聯，也就是說，他
 會找到一個最高優先順序的排程類，後者需要有自己的
 可執行佇列，然後問後者誰才是下一個該執行的程序
 該函式唯一重要的事情是，他回撥用pick_next_task*/
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();
	rq = cpu_rq(cpu);/*得到特定cpu的rq*/
	rcu_sched_qs(cpu);
	prev = rq->curr;/*當前的執行程序*/
	switch_count = &prev->nivcsw;/*程序切換計數*/

	release_kernel_lock(prev);
need_resched_nonpreemptible:

	schedule_debug(prev);

	if (sched_feat(HRTICK))
		hrtick_clear(rq);

	spin_lock_irq(&rq->lock);
	update_rq_clock(rq);/*更新rq的clock屬性*/
	clear_tsk_need_resched(prev);/*清楚prev程序的排程位*/

	if (prev->state && !(preempt_count() & PREEMPT_ACTIVE)) {
		if (unlikely(signal_pending_state(prev->state, prev)))
			prev->state = TASK_RUNNING;
		else/*從執行佇列中刪除prev程序,根據排程類的
			不同，實現不同*/
			deactivate_task(rq, prev, 1);
		switch_count = &prev->nvcsw;
	}
	/*現只對實時程序有用*/
	pre_schedule(rq, prev);

	if (unlikely(!rq->nr_running))
		idle_balance(cpu, rq);
	/*將當前程序，也就是被切換出去的程序重新
	插入到各自的執行佇列中，對於CFS演算法插入
	到合適的位置上，對於實時排程插入到同一個
	優先順序佇列的連結串列尾部*/
	put_prev_task(rq, prev);
	/*從各自的執行佇列中選擇下一個程序來執行*/
	next = pick_next_task(rq);

	if (likely(prev != next)) {
		/*更新切換出去和進來程序以及對應rq的相關變數*/
		sched_info_switch(prev, next);
		perf_event_task_sched_out(prev, next, cpu);

		rq->nr_switches++;/*切換記錄*/
		rq->curr = next;
		++*switch_count;
		/*上下文切換，在程序切換已經介紹*/
		context_switch(rq, prev, next); /* unlocks the rq */
		/*
		 * the context switch might have flipped the stack from under
		 * us, hence refresh the local variables.
		 */
		cpu = smp_processor_id();
		rq = cpu_rq(cpu);
	} else
		spin_unlock_irq(&rq->lock);
	/*對於實時程序有用到*/
	post_schedule(rq);

	if (unlikely(reacquire_kernel_lock(current) < 0))
		goto need_resched_nonpreemptible;

	preempt_enable_no_resched();
	if (need_resched())
		goto need_resched;
}
 

對於cpu_rq函式

/*通過向上加偏移的方式得到rq，這裡可以看出
runqueues為一個rq結構的陣列，cpu為陣列下標*/
#define cpu_rq(cpu)		(&per_cpu(runqueues, (cpu)))

deactivate_task函式實現

/*
 * deactivate_task - remove a task from the runqueue.
 */
static void deactivate_task(struct rq *rq, struct task_struct *p, int sleep)
{
	if (task_contributes_to_load(p))
		rq->nr_uninterruptible++;
	/*具體操作*/
	dequeue_task(rq, p, sleep);
	dec_nr_running(rq);/*rq中當前程序的執行數減一*/
}
 

我們看具體的操作

static void dequeue_task(struct rq *rq, struct task_struct *p, int sleep)
{
	if (sleep) {/*如果sleep不為0，更新se中相關變數*/
		if (p->se.last_wakeup) {
			update_avg(&p->se.avg_overlap,
				p->se.sum_exec_runtime - p->se.last_wakeup);
			p->se.last_wakeup = 0;
		} else {
			update_avg(&p->se.avg_wakeup,
				sysctl_sched_wakeup_granularity);
		}
	}
	/*更新程序的sched_info資料結構中相關屬性*/
	sched_info_dequeued(p);
	/*呼叫具體排程類的函式從他的執行佇列中刪除*/
	p->sched_class->dequeue_task(rq, p, sleep);
	p->se.on_rq = 0;
}
 

可見，呼叫了具體執行佇列的刪除函式，我們看最關鍵的選擇下一個程序的方式。

/*
 * Pick up the highest-prio task:
 */
 /*以優先順序為序，從高到低，一次檢查每個排程類
 並且從高優先順序的排程類中，選擇最高優先順序的程序
 */
static inline struct task_struct *
pick_next_task(struct rq *rq)
{
	const struct sched_class *class;
	struct task_struct *p;

	/*
	 * Optimization: we know that if all tasks are in
	 * the fair class we can call that function directly:
	 */
	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);/*呼叫該排程類中的函式，找出下一個task*/
		if (p)
			return p;
		/*
		 * Will never be NULL as the idle class always
		 * returns a non-NULL p:
		 */
		 /*訪問下一個排程類*/
		class = class->next;
	}
}

可見，對於排程類的選擇，同樣以優先順序進行。

對於程序排程資訊的切換最終會呼叫__sched_info_switch

/*
 * Called when tasks are switched involuntarily due, typically, to expiring
 * their time slice.  (This may also be called when switching to or from
 * the idle task.)  We are only called when prev != next.
 */
static inline void
__sched_info_switch(struct task_struct *prev, struct task_struct *next)
{
	struct rq *rq = task_rq(prev);

	/*
	 * prev now departs the cpu.  It's not interesting to record
	 * stats about how efficient we were at scheduling the idle
	 * process, however.
	 */
	if (prev != rq->idle)/*如果被切換出去的程序不是idle程序*/
		sched_info_depart(prev);/*更新prev程序和他對應rq的相關變數*/

	if (next != rq->idle)/*如果切換進來的程序不是idle程序*/
		sched_info_arrive(next);/*更新next程序和對應佇列的相關變數*/
}

/*
 * Called when a process ceases being the active-running process, either
 * voluntarily or involuntarily.  Now we can calculate how long we ran.
 * Also, if the process is still in the TASK_RUNNING state, call
 * sched_info_queued() to mark that it has now again started waiting on
 * the runqueue.
 */
static inline void sched_info_depart(struct task_struct *t)
{
	/*計算在程序在rq中執行的時間長度*/
	unsigned long long delta = task_rq(t)->clock -
					t->sched_info.last_arrival;
	/*更新RunQueue中的Task所得到CPU執行
	時間的累加值.*/
	rq_sched_info_depart(task_rq(t), delta);
	
	/*如果被切換出去程序的狀態是執行狀態
	那麼將程序sched_info.last_queued設定為rq的clock
	last_queued為最後一次排隊等待執行的時間*/
	if (t->state == TASK_RUNNING)
		sched_info_queued(t);
}

/*
 * Called when a task finally hits the cpu.  We can now calculate how
 * long it was waiting to run.  We also note when it began so that we
 * can keep stats on how long its timeslice is.
 */
static void sched_info_arrive(struct task_struct *t)
{
	unsigned long long now = task_rq(t)->clock, delta = 0;

	if (t->sched_info.last_queued)/*如果被切換進來前在執行程序中排隊*/
		delta = now - t->sched_info.last_queued;/*計算排隊等待的時間長度*/
	sched_info_reset_dequeued(t);/*因為程序將被切換進來執行，設定last_queued為0*/
	t->sched_info.run_delay += delta;/*更新程序在執行佇列裡面等待的時間*/
	t->sched_info.last_arrival = now;/*更新最後一次執行的時間*/
	t->sched_info.pcount++;/*cpu上執行的次數加一*/
	/*更新rq中rq_sched_info中的對應的變數*/
	rq_sched_info_arrive(task_rq(t), delta);
}

對於schedule排程函式框架的分析基本是這樣了，對於具體的CFS和實時排程的實現在後面分析。