调度程序schedule()注释

78 阅读 0 评论 52 点赞

我是靠谱客的博主冷傲绿茶，最近开发中收集的这篇文章主要介绍调度程序schedule()注释，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

调度时机：

　　1、进程终止、睡眠，这些通常是进程自身行为，当然也有运行异常；

　　2、时间片用完时，而时间片更新是在时钟中断驱动下完成的；

　　3、设备驱动程序；

　　4、进程从异常、中断、及系统调用返回的时候会进行need_resched()检测，会触发调度。

问题：多cpu下，时钟中断如何处理的？时钟中断应该是只被一个cpu捕获并处理，那么其他cpu靠什么来驱动时间片更新？怎么触发调度？

调度具体实现

  1 asmlinkage void schedule(void)
  2 {
  3     struct schedule_data * sched_data;
  4     struct task_struct *prev, *next, *p;
  5     struct list_head *tmp;
  6     int this_cpu, c;
  7 
  8 
  9     spin_lock_prefetch(&runqueue_lock);                                    //锁运行队列
 10 
 11     if (!current->active_mm) BUG();                                        //内核线程没有mm空间，但其active_mm会借用当前进程
 12 need_resched_back:                                                        //的mm，保持与用户线程处理的统一性
 13     prev = current;                                                        //当前进程即将被调度出去，current也比较巧妙，task
 14                                                                         //_struct与内核堆栈共用一个8kB的union体，其中task
 15                                                                         //_struct占用低位的1kB左右，堆栈占用高位约7KB空间
 16                                                                         //通过对堆栈指针esp&0xffffe0000即可
 17     this_cpu = prev->processor;                                            //取得进程运行的cpu
 18 
 19     if (unlikely(in_interrupt())) {                                        //unlikely用于gcc>=2.96之后的编译优化，表示if内代
 20                                                                         //码运行的可能性比较低，这样编译器就可以将else里
 21                                                                         //面的代码提前，cpu在进行指令预取方面有性能提高
 22                                                                         //反之，likely则是if内代码运行可能性高
 23         printk("Scheduling in interruptn");                            //如果在中断中进行调度，有问题
 24         BUG();
 25     }
 26 
 27     release_kernel_lock(prev, this_cpu);                                //如果prev占用了全局内核锁，释放；如果当前cpu占
 28                                                                         //用了全局中断锁，释放；开当前cpu中断线
 29 
 30     /*
 31     * 'sched_data' is protected by the fact that we can run
 32     * only one process per CPU.
 33     */
 34     sched_data = &aligned_data[this_cpu].schedule_data;                    //这个也不大懂，schedule_data里面有64位的last_sch
 35                                                                         //edule信息，不知道smp中用这个干什么    
 36     spin_lock_irq(&runqueue_lock);                                        //锁运行队列，关中断
 37 
 38     /* move an exhausted RR process to be last.. */
 39     if (unlikely(prev->policy == SCHED_RR))                                //如果是实时进程
 40         if (!prev->counter) {                                            //时间片已经用完
 41             prev->counter = NICE_TO_TICKS(prev->nice);                    //将nice转换为时间片，nice为UNIX时期沿用的负向优
 42                                                                         //向优先级，取值-20~19，值越大越谦让，值越小，优
 43                                                                         //先级越高
 44             move_last_runqueue(prev);                                    //将其移动到运行队列尾部
 45         }
 46 
 47     switch (prev->state) {                                                //获取进程状态
 48     case TASK_INTERRUPTIBLE:                                            //可被信号唤醒的中断
 49         if (signal_pending(prev)) {                                        //如果有信号到来，就让其进入TASK_RUNNING状态
 50             prev->state = TASK_RUNNING;
 51             break;
 52         }
 53     default:
 54         del_from_runqueue(prev);                                        //TASK_STOPED,TASK_ZOMBE,TASK_UNINNTERRUPTIBLE状
 55                                                                         //态，比如调用exit(),wait4()等
 56     case TASK_RUNNING:;
 57     }
 58     prev->need_resched = 0;                                                //清空need_resched
 59 
 60     /*
 61     * this is the scheduler proper:
 62     */
 63 
 64 repeat_schedule:
 65     /*
 66     * Default process to select..
 67     */
 68     next = idle_task(this_cpu);                                            //获得空闲进程
 69     c = -1000;                                                            //找最大值的常用初始化
 70     list_for_each(tmp, &runqueue_head) {                                //遍历运行队列
 71         p = list_entry(tmp, struct task_struct, run_list);                
 72         if (can_schedule(p, this_cpu)) {                                //如果程序可以在cpu上跑，并且允许在这颗cpu上跑
 73             int weight = goodness(p, this_cpu, prev->active_mm);        //获取调度权重
 74             if (weight > c)
 75                 c = weight, next = p;                                    //更新最大权重与选中进程
 76         }
 77     }
 78 
 79     /* Do we need to re-calculate counters? */
 80     if (unlikely(!c)) {                                                    //c==0？说明所有进程时间片用完了，可能性很小
 81         struct task_struct *p;
 82 
 83         spin_unlock_irq(&runqueue_lock);                                //开运行队列锁，开中断
 84         read_lock(&tasklist_lock);                                        //锁住进程双向链表
 85         for_each_task(p)                                                
 86             p->counter = (p->counter >> 1) + NICE_TO_TICKS(p->nice);    //更新每个进程的时间片
 87         read_unlock(&tasklist_lock);                                    //开进程双向链表
 88         spin_lock_irq(&runqueue_lock);                                    //锁运行队列，开中断
 89         goto repeat_schedule;                                            //再次寻找最值得调度的进程
 90     }
 91 
 92     /*
 93     * from this point on nothing can prevent us from
 94     * switching to the next task, save this fact in
 95     * sched_data.
 96     */
 97     sched_data->curr = next;                                            //cpu的正在运行进程指向新进程
 98     task_set_cpu(next, this_cpu);                                        //将task_struct的processor与cpus_runnable更新
 99     spin_unlock_irq(&runqueue_lock);                                    //解锁运行队列，开中断
100 
101     if (unlikely(prev == next)) {                                        //如果选择到的进程仍为之前的进程
102         /* We won't go through the normal tail, so do this by hand */
103         prev->policy &= ~SCHED_YIELD;                                    //那就不再客气了
104         goto same_process;
105     }
106 
107 #ifdef CONFIG_SMP
108     /*
109     * maintain the per-process 'last schedule' value.
110     * (this has to be recalculated even if we reschedule to
111     * the same process) Currently this is only used on SMP,
112     * and it's approximate, so we do not have to maintain
113     * it while holding the runqueue spinlock.
114     */
115     sched_data->last_schedule = get_cycles();                            //更新调度进程时的时钟，用于smp中另外一个cpu调度参考
116 
117     /*
118     * We drop the scheduler lock early (it's a global spinlock),
119     * thus we have to lock the previous process from getting
120     * rescheduled during switch_to().
121     */
122 
123 #endif /* CONFIG_SMP */
124 
125     kstat.context_swtch++;                                                //记录调度次数
126     /*
127     * there are 3 processes which are affected by a context switch:
128     *
129     * prev == .... ==> (last => next)
130     *
131     * It's the 'much more previous' 'prev' that is on next's stack,
132     * but prev is set to (the just run) 'last' process by switch_to().
133     * This might sound slightly confusing but makes tons of sense.
134     */
135     prepare_to_switch();
136     {
137         struct mm_struct *mm = next->mm;                                //新进程的运行空间
138         struct mm_struct *oldmm = prev->active_mm;                        //原进程的运行空间
139         if (!mm) {                                                        //如果新进程没有运行空间，则是内核进程
140             if (next->active_mm) BUG();                                    //内核进程在调度出去的时候会释放其借用的运行空间，如
141                                                                         //果此处仍然存在，则有问题
142             next->active_mm = oldmm;                                    //借用原进程的运行空间
143             atomic_inc(&oldmm->mm_count);                                //原进程运行空间计数加1，用于内存交换信息
144             enter_lazy_tlb(oldmm, next, this_cpu);                        //tlb采用lazy刷新方式
145         }
146         else {                                                            //如果是用户进程
147             if (next->active_mm != mm) BUG();                            //用户进程的两个运行空间应该相同
148             switch_mm(oldmm, mm, next, this_cpu);                        //切换用户空间
149         }
150 
151         if (!prev->mm) {                                                //如果原进程是内核进程
152             prev->active_mm = NULL;                                        //释放其引用的运行空间
153             mmdrop(oldmm);                                                //运行空间计数-1
154         }
155     }
156 
157     /*
158     * This just switches the register state and the
159     * stack.
160     */
161     switch_to(prev, next, prev);                                        //切换寄存器状态与堆栈
162     __schedule_tail(prev);                                                //原进程放入运行队列尾部
163 
164 same_process:
165     reacquire_kernel_lock(current);                                        //针对smp，要将当前进程的内核深度清0
166     if (current->need_resched)                                            //再次调度
167         goto need_resched_back;
168     return;
169 }