Annotation of /trunk/kernel26-magellan/patches-2.6.16-r12/0011-2.6.16-sched-idleprio-1.2.patch
Parent Directory | Revision Log
Revision 72 -
(hide annotations)
(download)
Mon Jun 5 09:25:38 2006 UTC (18 years, 3 months ago) by niro
File size: 6218 byte(s)
Mon Jun 5 09:25:38 2006 UTC (18 years, 3 months ago) by niro
File size: 6218 byte(s)
ver bump to 2.6.16-r12: - updated to linux-2.6.16.19 - updated to ck11
1 | niro | 72 | include/linux/init_task.h | 4 +-- |
2 | include/linux/sched.h | 6 +++- | ||
3 | kernel/sched.c | 57 ++++++++++++++++++++++++++++++++++++++-------- | ||
4 | 3 files changed, 54 insertions(+), 13 deletions(-) | ||
5 | |||
6 | Index: linux-2.6.16-ck1/include/linux/init_task.h | ||
7 | =================================================================== | ||
8 | --- linux-2.6.16-ck1.orig/include/linux/init_task.h 2006-03-20 20:46:25.000000000 +1100 | ||
9 | +++ linux-2.6.16-ck1/include/linux/init_task.h 2006-03-20 20:46:51.000000000 +1100 | ||
10 | @@ -83,8 +83,8 @@ extern struct group_info init_groups; | ||
11 | .usage = ATOMIC_INIT(2), \ | ||
12 | .flags = 0, \ | ||
13 | .lock_depth = -1, \ | ||
14 | - .prio = MAX_PRIO-20, \ | ||
15 | - .static_prio = MAX_PRIO-20, \ | ||
16 | + .prio = MAX_PRIO-21, \ | ||
17 | + .static_prio = MAX_PRIO-21, \ | ||
18 | .policy = SCHED_NORMAL, \ | ||
19 | .cpus_allowed = CPU_MASK_ALL, \ | ||
20 | .mm = NULL, \ | ||
21 | Index: linux-2.6.16-ck1/include/linux/sched.h | ||
22 | =================================================================== | ||
23 | --- linux-2.6.16-ck1.orig/include/linux/sched.h 2006-03-20 20:46:50.000000000 +1100 | ||
24 | +++ linux-2.6.16-ck1/include/linux/sched.h 2006-03-20 20:46:51.000000000 +1100 | ||
25 | @@ -163,9 +163,10 @@ extern unsigned long weighted_cpuload(co | ||
26 | #define SCHED_RR 2 | ||
27 | #define SCHED_BATCH 3 | ||
28 | #define SCHED_ISO 4 | ||
29 | +#define SCHED_IDLEPRIO 5 | ||
30 | |||
31 | #define SCHED_MIN 0 | ||
32 | -#define SCHED_MAX 4 | ||
33 | +#define SCHED_MAX 5 | ||
34 | |||
35 | #define SCHED_RANGE(policy) ((policy) >= SCHED_MIN && \ | ||
36 | (policy) <= SCHED_MAX) | ||
37 | @@ -497,10 +498,11 @@ struct signal_struct { | ||
38 | #define MAX_USER_RT_PRIO 100 | ||
39 | #define MAX_RT_PRIO MAX_USER_RT_PRIO | ||
40 | |||
41 | -#define MAX_PRIO (MAX_RT_PRIO + 40) | ||
42 | +#define MAX_PRIO (MAX_RT_PRIO + 41) | ||
43 | |||
44 | #define rt_task(p) (unlikely(SCHED_RT((p)->policy))) | ||
45 | #define iso_task(p) ((p)->policy == SCHED_ISO) | ||
46 | +#define idleprio_task(p) ((p)->policy == SCHED_IDLEPRIO) | ||
47 | |||
48 | /* | ||
49 | * Some day this will be a full-fledged user tracking system.. | ||
50 | Index: linux-2.6.16-ck1/kernel/sched.c | ||
51 | =================================================================== | ||
52 | --- linux-2.6.16-ck1.orig/kernel/sched.c 2006-03-20 20:46:50.000000000 +1100 | ||
53 | +++ linux-2.6.16-ck1/kernel/sched.c 2006-03-20 20:46:51.000000000 +1100 | ||
54 | @@ -710,7 +710,7 @@ int sched_interactive __read_mostly = 1; | ||
55 | * As the bonus increases the initial priority starts at a higher "stair" or | ||
56 | * priority for longer. | ||
57 | */ | ||
58 | -static int effective_prio(const task_t *p) | ||
59 | +static int effective_prio(task_t *p) | ||
60 | { | ||
61 | int prio; | ||
62 | unsigned int full_slice, used_slice = 0; | ||
63 | @@ -730,6 +730,20 @@ static int effective_prio(const task_t * | ||
64 | return MAX_RT_PRIO - 1; | ||
65 | } | ||
66 | |||
67 | + if (idleprio_task(p)) { | ||
68 | + if (unlikely(p->flags & (PF_NONSLEEP | PF_FREEZE))) { | ||
69 | + /* | ||
70 | + * If idleprio is waking up from in kernel activity | ||
71 | + * or being frozen, reschedule at a normal priority | ||
72 | + * to begin with. | ||
73 | + */ | ||
74 | + p->time_slice = p->slice % RR_INTERVAL() ? : | ||
75 | + RR_INTERVAL(); | ||
76 | + return MAX_PRIO - 2; | ||
77 | + } | ||
78 | + return MAX_PRIO - 1; | ||
79 | + } | ||
80 | + | ||
81 | full_slice = slice(p); | ||
82 | if (full_slice > p->slice) | ||
83 | used_slice = full_slice - p->slice; | ||
84 | @@ -741,8 +755,8 @@ static int effective_prio(const task_t * | ||
85 | |||
86 | rr = rr_interval(p); | ||
87 | prio += used_slice / rr; | ||
88 | - if (prio > MAX_PRIO - 1) | ||
89 | - prio = MAX_PRIO - 1; | ||
90 | + if (prio > MAX_PRIO - 2) | ||
91 | + prio = MAX_PRIO - 2; | ||
92 | return prio; | ||
93 | } | ||
94 | |||
95 | @@ -2470,7 +2484,7 @@ void account_user_time(struct task_struc | ||
96 | |||
97 | /* Add user time to cpustat. */ | ||
98 | tmp = cputime_to_cputime64(cputime); | ||
99 | - if (TASK_NICE(p) > 0) | ||
100 | + if (TASK_NICE(p) > 0 || idleprio_task(p)) | ||
101 | cpustat->nice = cputime64_add(cpustat->nice, tmp); | ||
102 | else | ||
103 | cpustat->user = cputime64_add(cpustat->user, tmp); | ||
104 | @@ -2766,11 +2780,22 @@ static int dependent_sleeper(const int t | ||
105 | if ((jiffies % DEF_TIMESLICE) > | ||
106 | (sd->per_cpu_gain * DEF_TIMESLICE / 100)) | ||
107 | ret = 1; | ||
108 | - } else | ||
109 | + else if (idleprio_task(p)) | ||
110 | + ret = 1; | ||
111 | + } else { | ||
112 | if (smt_curr->static_prio < p->static_prio && | ||
113 | !TASK_PREEMPTS_CURR(p, smt_rq) && | ||
114 | smt_slice(smt_curr, sd) > slice(p)) | ||
115 | ret = 1; | ||
116 | + else if (idleprio_task(p) && !idleprio_task(smt_curr) && | ||
117 | + smt_curr->slice * sd->per_cpu_gain > | ||
118 | + slice(smt_curr)) | ||
119 | + /* | ||
120 | + * With batch tasks they run just the last | ||
121 | + * per_cpu_gain percent of the smt task's slice. | ||
122 | + */ | ||
123 | + ret = 1; | ||
124 | + } | ||
125 | |||
126 | check_smt_task: | ||
127 | if ((!smt_curr->mm && smt_curr != smt_rq->idle) || | ||
128 | @@ -2790,10 +2815,15 @@ check_smt_task: | ||
129 | if ((jiffies % DEF_TIMESLICE) > | ||
130 | (sd->per_cpu_gain * DEF_TIMESLICE / 100)) | ||
131 | resched_task(smt_curr); | ||
132 | + else if (idleprio_task(smt_curr)) | ||
133 | + resched_task(smt_curr); | ||
134 | } else { | ||
135 | if (TASK_PREEMPTS_CURR(p, smt_rq) && | ||
136 | smt_slice(p, sd) > slice(smt_curr)) | ||
137 | resched_task(smt_curr); | ||
138 | + else if (idleprio_task(smt_curr) && !idleprio_task(p) && | ||
139 | + p->slice * sd->per_cpu_gain > slice(p)) | ||
140 | + resched_task(smt_curr); | ||
141 | else | ||
142 | wakeup_busy_runqueue(smt_rq); | ||
143 | } | ||
144 | @@ -3436,8 +3466,9 @@ void set_user_nice(task_t *p, const long | ||
145 | * If the task increased its priority or is running and | ||
146 | * lowered its priority, then reschedule its CPU: | ||
147 | */ | ||
148 | - if (delta < 0 || (delta > 0 && task_running(rq, p))) | ||
149 | - resched_task(rq->curr); | ||
150 | + if (delta < 0 || ((delta > 0 || idleprio_task(p)) && | ||
151 | + task_running(rq, p))) | ||
152 | + resched_task(rq->curr); | ||
153 | } | ||
154 | out_unlock: | ||
155 | task_rq_unlock(rq, &flags); | ||
156 | @@ -3630,6 +3661,12 @@ recheck: | ||
157 | return -EPERM; | ||
158 | } | ||
159 | |||
160 | + if (!(p->mm) && policy == SCHED_IDLEPRIO) | ||
161 | + /* | ||
162 | + * Don't allow kernel threads to be SCHED_IDLEPRIO. | ||
163 | + */ | ||
164 | + return -EINVAL; | ||
165 | + | ||
166 | retval = security_task_setscheduler(p, policy, param); | ||
167 | if (retval) | ||
168 | return retval; | ||
169 | @@ -3931,8 +3968,8 @@ asmlinkage long sys_sched_yield(void) | ||
170 | schedstat_inc(rq, yld_cnt); | ||
171 | current->slice = slice(current); | ||
172 | current->time_slice = rr_interval(current); | ||
173 | - if (likely(!rt_task(current))) | ||
174 | - newprio = MAX_PRIO - 1; | ||
175 | + if (likely(!rt_task(current) && !idleprio_task(current))) | ||
176 | + newprio = MAX_PRIO - 2; | ||
177 | |||
178 | if (newprio != current->prio) { | ||
179 | dequeue_task(current, rq); | ||
180 | @@ -4091,6 +4128,7 @@ asmlinkage long sys_sched_get_priority_m | ||
181 | case SCHED_NORMAL: | ||
182 | case SCHED_BATCH: | ||
183 | case SCHED_ISO: | ||
184 | + case SCHED_IDLEPRIO: | ||
185 | ret = 0; | ||
186 | break; | ||
187 | } | ||
188 | @@ -4116,6 +4154,7 @@ asmlinkage long sys_sched_get_priority_m | ||
189 | case SCHED_NORMAL: | ||
190 | case SCHED_BATCH: | ||
191 | case SCHED_ISO: | ||
192 | + case SCHED_IDLEPRIO: | ||
193 | ret = 0; | ||
194 | } | ||
195 | return ret; |