进程睡眠时其分配到的时间片剩余时钟节拍数会减少吗？

Mr__key

进程睡眠时其分配到的时间片剩余时钟节拍数会减少吗？

瀚海书香

回复 1# Mr__key
这个应该不会吧。

看过原理，没有看过具体的这块代码，抽时间看看。

   

Mr__key

回复 2# 瀚海书香
进程睡眠后相当于自动放弃了cpu资源，再接下来的进程管理调度会根据该进程其优先级及平均睡眠时间重新分配其时间片。

   

瀚海书香

回复 3# Mr__key

进程睡眠后相当于自动放弃了cpu资源，再接下来的进程管理调度会根据该进程其优先级及平均睡眠时间重新分配其时间片。

不知道你看的那个版本的代码？？？

刚才看了一下2.6.32的内核代码：
如果进程在还有时间片的情况下调用sleep，那么对应的在内核通过alarm系统调用，将当前进程放到等待队列上，调用schedule()。
当睡眠时间到了以后，timer触发default_wake_function，最后对应的函数是try_to_wake_up（）。
try_to_wake_up函数

1. /***
   
2. * try_to_wake_up - wake up a thread
   
3. * @p: the to-be-woken-up thread
   
4. * @state: the mask of task states that can be woken
   
5. * @sync: do a synchronous wakeup?
   
6. *
   
7. * Put it on the run-queue if it's not already there. The "current"
   
8. * thread is always on the run-queue (except when the actual
   
9. * re-schedule is in progress), and as such you're allowed to do
   
10. * the simpler "current->state = TASK_RUNNING" to mark yourself
    
11. * runnable without the overhead of this.
    
12. *
    
13. * returns failure only if the task is already active.
    
14. */
    
15. static int try_to_wake_up(struct task_struct *p, unsigned int state,
    
16.                           int wake_flags)
    
17. {
    
18.         int cpu, orig_cpu, this_cpu, success = 0;
    
19.         unsigned long flags;
    
20.         struct rq *rq, *orig_rq;
    
21. 
    
22.         if (!sched_feat(SYNC_WAKEUPS))
    
23.                 wake_flags &= ~WF_SYNC;
    
24. 
    
25.         this_cpu = get_cpu();
    
26. 
    
27.         smp_wmb();
    
28.         rq = orig_rq = task_rq_lock(p, &flags);
    
29.         update_rq_clock(rq);
    
30.         if (!(p->state & state))
    
31.                 goto out;
    
32. 
    
33.         if (p->se.on_rq)
    
34.                 goto out_running;
    
35. 
    
36.         cpu = task_cpu(p);
    
37.         orig_cpu = cpu;
    
38. 
    
39. #ifdef CONFIG_SMP
    
40.         if (unlikely(task_running(rq, p)))
    
41.                 goto out_activate;
    
42. 
    
43.         /*
    
44.          * In order to handle concurrent wakeups and release the rq->lock
    
45.          * we put the task in TASK_WAKING state.
    
46.          *
    
47.          * First fix up the nr_uninterruptible count:
    
48.          */
    
49.         if (task_contributes_to_load(p))
    
50.                 rq->nr_uninterruptible--;
    
51.         p->state = TASK_WAKING;
    
52.         task_rq_unlock(rq, &flags);
    
53. 
    
54.         cpu = p->sched_class->select_task_rq(p, SD_BALANCE_WAKE, wake_flags);
    
55.         if (cpu != orig_cpu)
    
56.                 set_task_cpu(p, cpu);
    
57. 
    
58.         rq = task_rq_lock(p, &flags);
    
59. 
    
60.         if (rq != orig_rq)
    
61.                 update_rq_clock(rq);
    
62. 
    
63.         WARN_ON(p->state != TASK_WAKING);
    
64.         cpu = task_cpu(p);
    
65. 
    
66. #ifdef CONFIG_SCHEDSTATS
    
67.         schedstat_inc(rq, ttwu_count);
    
68.         if (cpu == this_cpu)
    
69.                 schedstat_inc(rq, ttwu_local);
    
70.         else {
    
71.                 struct sched_domain *sd;
    
72.                 for_each_domain(this_cpu, sd) {
    
73.                         if (cpumask_test_cpu(cpu, sched_domain_span(sd))) {
    
74.                                 schedstat_inc(sd, ttwu_wake_remote);
    
75.                                 break;
    
76.                         }
    
77.                 }
    
78.         }
    
79. #endif /* CONFIG_SCHEDSTATS */
    
80. 
    
81. out_activate:
    
82. #endif /* CONFIG_SMP */
    
83.         schedstat_inc(p, se.nr_wakeups);
    
84.         if (wake_flags & WF_SYNC)
    
85.                 schedstat_inc(p, se.nr_wakeups_sync);
    
86.         if (orig_cpu != cpu)
    
87.                 schedstat_inc(p, se.nr_wakeups_migrate);
    
88.         if (cpu == this_cpu)
    
89.                 schedstat_inc(p, se.nr_wakeups_local);
    
90.         else
    
91.                 schedstat_inc(p, se.nr_wakeups_remote);
    
92.         activate_task(rq, p, 1);
    
93.         success = 1;
    
94. 
    
95.         /*
    
96.          * Only attribute actual wakeups done by this task.
    
97.          */
    
98.         if (!in_interrupt()) {
    
99.                 struct sched_entity *se = &current->se;
    
100.                 u64 sample = se->sum_exec_runtime;
     
101. 
     
102.                 if (se->last_wakeup)
     
103.                         sample -= se->last_wakeup;
     
104.                 else
     
105.                         sample -= se->start_runtime;
     
106.                 update_avg(&se->avg_wakeup, sample);
     
107. 
     
108.                 se->last_wakeup = se->sum_exec_runtime;
     
109.         }
     
110. 
     
111. out_running:
     
112.         trace_sched_wakeup(rq, p, success);
     
113.         check_preempt_curr(rq, p, wake_flags);
     
114. 
     
115.         p->state = TASK_RUNNING;
     
116. #ifdef CONFIG_SMP
     
117.         if (p->sched_class->task_wake_up)
     
118.                 p->sched_class->task_wake_up(rq, p);
     
119. 
     
120.         if (unlikely(rq->idle_stamp)) {
     
121.                 u64 delta = rq->clock - rq->idle_stamp;
     
122.                 u64 max = 2*sysctl_sched_migration_cost;
     
123. 
     
124.                 if (delta > max)
     
125.                         rq->avg_idle = max;
     
126.                 else
     
127.                         update_avg(&rq->avg_idle, delta);
     
128.                 rq->idle_stamp = 0;
     
129.         }
     
130. #endif
     
131. out:
     
132.         task_rq_unlock(rq, &flags);
     
133.         put_cpu();
     
134. 
     
135.         return success;
     
136. }
     

复制代码

该函数将进程的状态设置为TASK_RUNNING，并将进程插入本地CPU队列，不会修改时间片，顶多会根据平均睡眠时间修改优先级。
   

Mr__key

回复 4# 瀚海书香


    嗯，你说的不错，进程的时间片都只会在时间片用完后调用task_timeslice来重填其时间片，

睡眠进程唤醒后，会继续使用睡眠前剩余的时间片！