进程(四)进程调度及切换

进程(四)进程调度及切换 2013-07-15 15:21:18

分类： LINUX

1. 一、调度策略
   
2. 每个linux进程总是按照下边的调度类型被调度：
   
3. SCHED_FIFO：先进先出的实时进程。适用于时间性要求比较强，但每次运行所需的时间比较短的进程，实时的应用大都具有这样的特点。
   
4. SCHED_RR：时间片轮流的实时进程。轮流，适合比较大，每次运行需时较长的进程。
   
5. SCHED_OTHER：普通的分时进程。传统的调度政策，适合于交互式分时应用。
   
6. 
   
7. Linux 根据policy从整体上区分实时进程和普通进程，因为实时进程和普通进程度调度是不同的，它们两者之间，实时进程应该先于普通进程而运行，然后，对于同一类型的不同进程，采用不同的标准来选择进程：
   
8. 1.普通进程调度
   
9. (1)静态优先级
   
10. 每个普通进程都有它自己的静态优先级。内核从100~139表示。
    
11. 静态优先级本质上决定了进程的基本时间片，即进程用完了以前的时间片时，系统分配给进程的时间片长度。
    
12. 不随时间而改变，只能由用户进行修改。它指明了在被迫和其他进程竞争CPU之前，该进程所应该被允许的时间片的最大值。
    
13. 若静态优先级<120:基本时间片（ms）=（140-静态优先级）*20
    
14. 若静态优先级>=120:基本时间片（ms）=（140-静态优先级）*5
    
15. (2)动态优先级
    
16. 普通进程除了静态优先级还有动态优先级，范围是100~139.    
    
17. 动态优先级是调度程序在选择新程序来运行的时候选择的数。只要进程拥有CPU，它就随着时间不断减小；当它小于0时，标记进程重新调度。它指明了在这个时间片中所剩余的时间量。    
    
18. 动态优先级=max(100,min(静态优先级-bonus+5,139))    
    
19.     
    
20. 2.实时进程的调度
    
21. 每个实时进程都与一个实时优先级相关，范围从1~99表示。
    
22. 与普通进程相反，实时进程总是被当成活动进程。    
    
23. 调度程序总是让优先级高的进程运行，发生以下情况实时进程才会被另外一个进程取代：
    
24. (1)进程被另外一个具有更高实时优先级的实时进程抢占。
    
25. (2)进程执行了阻塞操作并进入睡眠。
    
26. (3)进程停止或被杀死。
    
27. (4)进程通过系统调用自动放弃CPU。
    
28. (5)进程是基于时间片轮转的实时进程(SCHED_RR)，而且用完了时间片。
    
29.     
    
30. 二、调度程序使用的数据结构
    
31. 数据结构runqueue是linux2.6调度程序最重要的数据结构。
    
32. 系统中每个cpu都有它自己的运行队列，所有的runqueue结构存放在runqueues每cpu变量中。
    
33. struct runqueue {
    
34.     spinlock_t lock;//自旋锁，用于锁定运行队列
    
35.     unsigned long nr_running;//可运行的的任务数目
    
36.     unsigned long cpu_load[3];//基于运行队列中进程的平均数量的cpu负载因子
    
37.     unsigned long long nr_switches;//上下文切换数目
    
38.     unsigned long nr_uninterruptible;//处于不可中断或者睡眠状态的任务数目
    
39.     unsigned long expired_timestamp;//队列最后被换出的时间
    
40.     unsigned long long timestamp_last_tick;//最后一个调度程序的节拍
    
41.     task_t *curr, *idle;//当前运行的任务和空闲的任务
    
42.     struct mm_struct *prev_mm;//最后运行任务的mm_struct结构体。
    
43.     prio_array_t *active, *expired, arrays[2];//1.活动优先级队列2.超时优先级队列，3.实际优先级数组
    
44.     int best_expired_prio;//最适宜换出的优先级队列
    
45.     atomic_t nr_iowait;//等待I/O操作的任务数目
    
46.     
    
47.     struct sched_domain *sd;//多处理器相关
    
48.     int active_balance;//活动的需要负载平衡进程个数
    
49.     int push_cpu;//哪个CPU需要进行负载平衡？
    
50.     task_t *migration_thread;//换出任务
    
51.     struct list_head migration_queue;//换出队列
    
52.     /* latency stats */
    
53.     struct sched_info rq_sched_info;
    
54.     /* sys_sched_yield() stats */
    
55.     unsigned long yld_exp_empty;
    
56.     unsigned long yld_act_empty;
    
57.     unsigned long yld_both_empty;
    
58.     unsigned long yld_cnt;
    
59.     /* schedule() stats */
    
60.     unsigned long sched_switch;
    
61.     unsigned long sched_cnt;
    
62.     unsigned long sched_goidle;
    
63.     /* try_to_wake_up() stats */
    
64.     unsigned long ttwu_cnt;
    
65.     unsigned long ttwu_local;
    
66. };
    
67. 
    
68. 三、实际代码分析
    
69. //schedule只能由进程在内核中主动调用，或者在当前进程从系统空间返回到用户空间的前夕被动的调用。而不能在一个中断服务程序中调用
    
70. asmlinkage void schedule(void)
    
71. {
    
72.     struct schedule_data * sched_data;
    
73.     struct task_struct *prev, *next, *p;
    
74.     struct list_head *tmp;
    
75.     int this_cpu, c;
    
76.     
    
77.     if (!current->active_mm) BUG();//内存描述符不为空
    
78. need_resched_back:
    
79.     prev = current;
    
80.     this_cpu = prev->processor;//当前进程所在的处理器
    
81.     
    
82.     if (in_interrupt())//调度不能发生在中断服务程序中
    
83.         goto scheduling_in_interrupt;
    
84.     
    
85.     release_kernel_lock(prev, this_cpu);//空语句
    
86.     //检查是否有内核软中断服务请求在等待
    
87.     if (softirq_active(this_cpu) & softirq_mask(this_cpu))
    
88.         goto handle_softirq;//有就转去执行软中断服务请求
    
89. handle_softirq_back:
    
90.     //将当前cpu的schedule_data信息保存
    
91.     sched_data = & aligned_data[this_cpu].schedule_data;
    
92.     //锁住队列
    
93.     spin_lock_irq(&runqueue_lock);
    
94.     
    
95.     if (prev->policy == SCHED_RR)//若调度政策为SCHED_RR，即轮流政策
    
96.         goto move_rr_last;//转去检查时间配额是否为0，为0就重新分配，然后再跳转回来
    
97. move_rr_back:
    
98.     switch (prev->state) {//查询当前进程状态
    
99.         case TASK_INTERRUPTIBLE://可中断的睡眠状态
    
100.             if (signal_pending(prev)) {//有信号到来
     
101.                 prev->state = TASK_RUNNING;//设置为可运行状态
     
102.                 break;
     
103.             }
     
104.             default://深度睡眠
     
105.                 del_from_runqueue(prev);//将当前进程从可执行队列中删除
     
106.             case TASK_RUNNING:
     
107.     }
     
108.     prev->need_resched = 0;//调度标志清0
     
109. 
     
110. repeat_schedule://挑选一个进程来运行
     
111.     next = idle_task(this_cpu);//从0号进程开始
     
112.     c = -1000;//权值设为-1000
     
113.     if (prev->state == TASK_RUNNING)//当前进程状态为可运行状态
     
114.         goto still_running;//转去计算当前进程的权值，并把最优进程设置为当前进程，然后跳转回来接着往下找是否还有更优的进程
     
115.     
     
116. still_running_back:
     
117.     list_for_each(tmp, &runqueue_head) {//遍历可执行队列中的所有进程
     
118.         p = list_entry(tmp, struct task_struct, run_list);//从队列中依次取出进程的task_struct结构
     
119.         if (can_schedule(p, this_cpu)) {//取出的进程是否允许调度
     
120.             int weight = goodness(p, this_cpu, prev->active_mm);//计算出取出进程的权值
     
121.             if (weight > c)//是否大于C
     
122.                 c = weight, next = p;//最优进程next改成权值最大的进程
     
123.         }
     
124.     }
     
125.     if (!c)//若c为0，表明可运行队列中的所有进程的权值都是0，且都是SCHED_OTHER的进程
     
126.         goto recalculate;//转去重新计算各个进程的时间配额
     
127.     sched_data->curr = next;
     
128. #ifdef CONFIG_SMP
     
129.     next->has_cpu = 1;//表明已经在某一个cpu上开始运行
     
130.     next->processor = this_cpu;//最优进程运行的处理器号
     
131. #endif
     
132.     spin_unlock_irq(&runqueue_lock);
     
133.     
     
134.     if (prev == next)//若挑选出来的进程和当前进程一致
     
135.         goto same_process;//不需切换，退出
     
136.     
     
137.     kstat.context_swtch++;
     
138.     prepare_to_switch();//空语句
     
139.     struct mm_struct *mm = next->mm;
     
140.     struct mm_struct *oldmm = prev->active_mm;
     
141.     if (!mm) {//最优进程若是内核线程，不需要切换进程的虚拟空间，
     
142.         if (next->active_mm) BUG();
     
143.             next->active_mm = oldmm;//内核线程使用当前进程的内核空间
     
144.         atomic_inc(&oldmm->mm_count);//当前进程的内核空间使用计数递加
     
145.         enter_lazy_tlb(oldmm, next, this_cpu);
     
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);//递减共享计数
     
154.      }
     
155.     
     
156.     switch_to(prev, next, prev);//进程的切换，主要是堆栈的切换
     
157.     __schedule_tail(prev);//将当前进程的SCHED_YIELD标志清0
     
158. 650
     
159. same_process:
     
160.     reacquire_kernel_lock(current);
     
161.     if (current->need_resched)//调度标志又为1
     
162.         goto need_resched_back;//转回重新调度
     
163.     
     
164.     return;//成功返回
     
165.     
     
166. recalculate:
     
167.     {
     
168.         struct task_struct *p;
     
169.         spin_unlock_irq(&runqueue_lock);
     
170.         read_lock(&tasklist_lock);
     
171.         for_each_task(p)//遍历所有进程
     
172.             p->counter = (p->counter >> 1) + NICE_TO_TICKS(p->nice);//根据静态优先级nice重新分配时间配额
     
173.         read_unlock(&tasklist_lock);
     
174.         spin_lock_irq(&runqueue_lock);
     
175.     }
     
176.     goto repeat_schedule;
     
177.     
     
178. still_running:
     
179.     c = goodness(prev, this_cpu, prev->active_mm);//计算出当前进程的权值
     
180.     next = prev;//将当前进程暂时设置为最优进程，也就是说下边的查找会以当前进程的权值做起点
     
181.     goto still_running_back;
     
182.     
     
183. handle_softirq:
     
184.     do_softirq();//处理软中断请求
     
185.     goto handle_softirq_back;
     
186. move_rr_last:
     
187.     if (!prev->counter) {//当前进程的时间配额为0
     
188.         prev->counter = NICE_TO_TICKS(prev->nice);//重新分配时间按配额
     
189.         move_last_runqueue(prev);//加入到可执行进程队列末尾
     
190.     }
     
191.     goto move_rr_back;
     
192.     
     
193. scheduling_in_interrupt:
     
194.     printk("Scheduling in interrupt\n");
     
195.     BUG();
     
196.     return;
     
197. }
     
198. 
     
199. #if HZ < 200
     
200.     #define TICK_SCALE(x) ((x) >> 2)
     
201. #elif HZ < 400
     
202.     #define TICK_SCALE(x) ((x) >> 1)
     
203. #elif HZ < 800
     
204.     #define TICK_SCALE(x) (x)
     
205. #elif HZ < 1600
     
206.     #define TICK_SCALE(x) ((x) << 1)
     
207. #else
     
208.     #define TICK_SCALE(x) ((x) << 2)
     
209. #endif
     
210.     
     
211. #define NICE_TO_TICKS(nice) (TICK_SCALE(20-(nice))+1)
     
212. 
     
213. static inline int goodness(struct task_struct * p, int this_cpu, struct mm_struct *this_mm)
     
214. {
     
215.     int weight;
     
216.     weight = -1;
     
217.     if (p->policy & SCHED_YIELD)//若进程设置了”礼让“，则权值设为weight = -1返回
     
218.         goto out;
     
219.     
     
220.     if (p->policy == SCHED_OTHER) {//对于没有实时要求的进程
     
221.         weight = p->counter;//权值设为剩下的时间配额
     
222.         if (!weight)//若剩下的时间配额为0，则权值weight = 0返回
     
223.             goto out;
     
224. 
     
225. #ifdef CONFIG_SMP
     
226.     if (p->processor == this_cpu)
     
227.         weight += PROC_CHANGE_PENALTY;
     
228. #endif
     
229.     if (p->mm == this_mm || !p->mm)//若是内核线程且其用户空间与当前进程相同，无需切换用户空间
     
230.         weight += 1;//得到一点奖励
     
231.         weight += 20-p->nice;//20-p->nice范围为1-40，nice为谦让程度，nice为非实时进程的静态优先级
     
232.         goto out;//返回weight
     
233.     }
     
234.     //对于有实时要求的进程，即调度政策为SCHED_FIFO 或者SCHED_RR的进程
     
235.     weight = 1000 + p->rt_priority;//加上实时优先级（动态优先级）
     
236. out:
     
237.     return weight;
     
238. }
     
239. 
     
240. static inline void switch_mm(struct mm_struct *prev, struct mm_struct *next, struct task_struct *tsk,unsigned cpu)
     
241. {
     
242.     if (prev != next) {
     
243.         clear_bit(cpu, &prev->cpu_vm_mask);
     
244.         if (prev->context.segments != next->context.segments)
     
245.             load_LDT(next);
     
246. #ifdef CONFIG_SMP
     
247.         cpu_tlbstate[cpu].state = TLBSTATE_OK;
     
248.         cpu_tlbstate[cpu].active_mm = next;
     
249. #endif
     
250.         set_bit(cpu, &next->cpu_vm_mask);
     
251.         //将新进程的页面目录的起始地址装入cr3中
     
252.         asm volatile("movl %0,%%cr3": :"r" (__pa(next->pgd)));
     
253.     }
     
254. }
     
255. 
     
256. #define switch_to(prev,next,last) do { \
     
257. 16    asm volatile("pushl %%esi\n\t" \//当前进程prev的寄存器入栈
     
258. 17    "pushl %%edi\n\t" \
     
259. 18    "pushl %%ebp\n\t" \
     
260. 19    "movl %%esp,%0\n\t" /* save ESP */ \//将当前进程prev系统空间堆栈指针存入prev->thread.esp
     
261. 20    "movl %3,%%esp\n\t" /* restore ESP */ \//将新受到调度要进入运行的进程next的系统空间堆栈指针next->thread.esp存入ESP
     
262.                                           //从21行开始，已经切换了堆栈，现在使用的是next进程的堆栈
     
263. 21    "movl $1f,%1\n\t" /* save EIP */ \//将25行pop指令所在的地址保存在prev->thread.eip
     
264. 22    "pushl %4\n\t" /* restore EIP */ \//将next->thread.eip压入堆栈，next->thread.eip正是进程next在上一次被调离时在21行保存的，指向1
     
265. 23    "jmp __switch_to\n" \//从__switch_to返回时，执行那里的ret指令，由于是jmp指令转过去的，最后进入堆栈的
     
266.                         //next->thread.eip变成了返回地址，也就是标号1所在的地址，也就是25行指令所在的地址
     
267. 24    "1:\t" \
     
268. 25    "popl %%ebp\n\t" \//恢复新切入的进程next在上一次被调离时push进堆栈的内容，前边堆栈已经切换了
     
269. 26    "popl %%edi\n\t" \
     
270. 27    "popl %%esi\n\t" \
     
271. 28    :"=m" (prev->thread.esp),"=m" (prev->thread.eip), \
     
272. 29    "=b" (last) \
     
273. 30    :"m" (next->thread.esp),"m" (next->thread.eip), \
     
274. 31    "a" (prev), "d" (next), \
     
275. 32    "b" (prev)); \
     
276. } while (0)
     
277. 
     
278. void __switch_to(struct task_struct *prev_p, struct task_struct *next_p)
     
279. {
     
280.     struct thread_struct *prev = &prev_p->thread,
     
281.     *next = &next_p->thread;
     
282.     struct tss_struct *tss = init_tss + smp_processor_id();
     
283.     
     
284.     unlazy_fpu(prev_p);
     
285.     
     
286.     tss->esp0 = next->esp0;//TSS内核的内核空间堆栈指针设为要调度运行的进程的堆栈指针
     
287.     
     
288.     asm volatile("movl %%fs,%0":"=m" (*(int *)&prev->fs));
     
289.     asm volatile("movl %%gs,%0":"=m" (*(int *)&prev->gs));
     
290.     
     
291.     loadsegment(fs, next->fs);
     
292.     loadsegment(gs, next->gs);
     
293.     
     
294.     if (next->debugreg[7]){
     
295.         loaddebug(next, 0);
     
296.         loaddebug(next, 1);
     
297.         loaddebug(next, 2);
     
298.         loaddebug(next, 3);
     
299.         loaddebug(next, 6);
     
300.         loaddebug(next, 7);
     
301.     }
     
302.     
     
303.     if (prev->ioperm || next->ioperm) {//有I/O位图
     
304.         if (next->ioperm) {
     
305.             memcpy(tss->io_bitmap, next->io_bitmap,IO_BITMAP_SIZE*sizeof(unsigned long));//拷贝要调度运行的进程的IO位位图
     
306.             tss->bitmap = IO_BITMAP_OFFSET;
     
307.         } else
     
308.             tss->bitmap = INVALID_IO_BITMAP_OFFSET;
     
309.     }
     
310. }
     
311. 
     
312. 
     
313. //////////////////////////////////////////////////////////////////////////////////////////////
     
314. /*************************************强制性调度*********************************************/
     
315. //内核中的强制性调度，也就是非自愿的、被动的剥夺式的调度，主要是由时间引起的，这种调度发生在
     
316. //进程从系统空间返回到用户空间的前夕。如下三种情况：
     
317. //1.在时钟中断的服务程序中，发现当前进程运行时间过长
     
318. //2.当唤醒一个睡眠中的进程时，发现被唤醒的进程比当前进程更有资格运行。
     
319. //3.一个进程通过系统调用改变调度政策或礼让。
     
320. 
     
321. //第一种情况：
     
322. [do_timer_interrupt()>do_timer()>update_process_times()]
     
323. void update_process_times(int user_tick)//调整当前进程与时间有关的一些参数
     
324. {
     
325. 581 struct task_struct *p = current;
     
326. 582 int cpu = smp_processor_id(), system = user_tick ^ 1;
     
327. 583
     
328. 584 update_one_process(p, user_tick, system, cpu);//统计信息
     
329. 585 if (p->pid) {//0号进程，时间配额不能递减
     
330. 586 if (--p->counter <= 0) {//时间配额减为0或小于0
     
331. 587 p->counter = 0;//设为0
     
332. 588 p->need_resched = 1;//设置调度标志
     
333. 589 }
     
334. 590 if (p->nice > 0)
     
335. 591 kstat.per_cpu_nice[cpu] += user_tick;
     
336. 592 else
     
337. 593 kstat.per_cpu_user[cpu] += user_tick;
     
338. 594 kstat.per_cpu_system[cpu] += system;
     
339. 595 } else if (local_bh_count(cpu) || local_irq_count(cpu) > 1)
     
340. 596 kstat.per_cpu_system[cpu] += system;
     
341. }
     
342. 
     
343. //第二种情况：
     
344. inline void wake_up_process(struct task_struct * p)
     
345. {
     
346. 331 unsigned long flags;
     
347. 332
     
348. 336 spin_lock_irqsave(&runqueue_lock, flags);
     
349. 337 p->state = TASK_RUNNING;
     
350. 338 if (task_on_runqueue(p))//当前唤醒进程是否已经在cpu的可运行队列runqueue
     
351. 339 goto out;
     
352. 340 add_to_runqueue(p);//挂入cpu的可运行队列runqueue
     
353. 341 reschedule_idle(p);
     
354. out:
     
355. 343 spin_unlock_irqrestore(&runqueue_lock, flags);
     
356. }
     
357. 
     
358. static void reschedule_idle(struct task_struct * p)
     
359. {
     
360. #ifdef CONFIG_SMP
     
361. 
     
362. #else /* UP */
     
363. 287 int this_cpu = smp_processor_id();
     
364. 288 struct task_struct *tsk;
     
365. 289 //#define cpu_curr(cpu) aligned_data[(cpu)].schedule_data.curr
     
366. 290 tsk = cpu_curr(this_cpu);
     
367. 291 if (preemption_goodness(tsk, p, this_cpu) > 1)//将当前运行进程和唤醒进程比较
     
368. 292 tsk->need_resched = 1;//唤醒的进程权值高，就设置调度标志
     
369. #endif
     
370. }
     
371. 
     
372. static inline int preemption_goodness(struct task_struct * prev, struct task_struct * p, int cpu)
     
373. {
     
374.     return goodness(p, cpu, prev->active_mm)-goodness(prev, cpu, prev->active_mm);
     
375. }
     
376. 
     
377. //第三种情况：自愿让出
     
378. asmlinkage long sys_sched_setscheduler(pid_t pid, int policy,struct sched_param *param)
     
379. {
     
380.     return setscheduler(pid, policy, param);
     
381. }
     
382. 
     
383. asmlinkage long sys_sched_setparam(pid_t pid, struct sched_param *param)
     
384. {
     
385.     return setscheduler(pid, -1,param);
     
386. }
     
387. //改变进程的调度政策
     
388. static int setscheduler(pid_t pid, int policy,struct sched_param *param)
     
389. {
     
390. 890 struct sched_param lp;
     
391. 891 struct task_struct *p;
     
392. 892 int retval;
     
393. 893
     
394. 894 retval = -EINVAL;
     
395. 895 if (!param || pid < 0)//检查参数和PID
     
396. 896 goto out_nounlock;
     
397. 897
     
398. 898 retval = -EFAULT;
     
399. 899 if (copy_from_user(&lp, param, sizeof(struct sched_param)))//从用户空间拷贝到内核
     
400. 900 goto out_nounlock;
     
401. 901
     
402. 905 read_lock_irq(&tasklist_lock);
     
403. 906 spin_lock(&runqueue_lock);
     
404. 907 //根据PID找到进程的task_struct结构
     
405. 908 p = find_process_by_pid(pid);
     
406. 909
     
407. 910 retval = -ESRCH;
     
408. 911 if (!p)
     
409. 912 goto out_unlock;
     
410. 913
     
411. 914 if (policy < 0)
     
412. 915 policy = p->policy;
     
413. 916 else {
     
414. 917 retval = -EINVAL;
     
415. 918 if (policy != SCHED_FIFO && policy != SCHED_RR &&policy != SCHED_OTHER)//调度政策必须为这三种
     
416. 920 goto out_unlock;
     
417. 921 }
     
418. 922
     
419. 927 retval = -EINVAL;
     
420. 928 if (lp.sched_priority < 0 || lp.sched_priority > 99)
     
421. 929 goto out_unlock;
     
422. 930 if ((policy == SCHED_OTHER) != (lp.sched_priority == 0))
     
423. 931 goto out_unlock;
     
424. 932
     
425. 933 retval = -EPERM;
     
426. 934 if ((policy == SCHED_FIFO || policy == SCHED_RR) &&!capable(CAP_SYS_NICE))//是否有权限
     
427. 936 goto out_unlock;
     
428. 937 if ((current->euid != p->euid) && (current->euid != p->uid) &&!capable(CAP_SYS_NICE))
     
429. 939 goto out_unlock;
     
430. 940
     
431. 941 retval = 0;
     
432. 942 p->policy = policy;//设置新的调度政策
     
433. 943 p->rt_priority = lp.sched_priority;
     
434. 944 if (task_on_runqueue(p))//检查是否在可运行队列中
     
435. 945 move_first_runqueue(p);//在队列中的话，移到队列前部
     
436. 946
     
437. 947 current->need_resched = 1;//重新设置调度标志
     
438. 948
     
439. out_unlock:
     
440. 950 spin_unlock(&runqueue_lock);
     
441. 951 read_unlock_irq(&tasklist_lock);
     
442. 952
     
443. out_nounlock:
     
444. 954 return retval;
     
445. }
     
446. //为其它进程让路，但并不进入睡眠
     
447. asmlinkage long sys_sched_yield(void)
     
448. {
     
449. 1028
     
450. 1029 int nr_pending = nr_running;//正在等待运行的进程数量
     
451. 1030
     
452. #if CONFIG_SMP
     
453. 1032 int i;
     
454. 1035 for (i = 0; i < smp_num_cpus; i++)
     
455. 1036 if (aligned_data[i].schedule_data.curr != idle_task(i))
     
456. 1037 nr_pending--;
     
457. #else
     
458. 1040 nr_pending--;
     
459. #endif
     
460. 1042 if (nr_pending) {//若还有等待运行的进程
     
461. 1047 if (current->policy == SCHED_OTHER)
     
462. 1048 current->policy |= SCHED_YIELD;//调度政策设为“自动礼让”
     
463. 1049 current->need_resched = 1;//重新设置调度标志
     
464. 1050 }
     
465. 1051 return 0;
     
466. }

阅读(1025) | 评论(2) | 转发(3) |

0

上一篇：进程(三):进程睡眠

下一篇：软中断机制