kernel26-alx/patches-2.6.17-r6/0009-2.6.17-sched-idleprio-1.9.patch

Add the SCHED_IDLEPRIO scheduling policy. Tasks set to this policy are only
given cpu time if no other tasks at all wish to have cpu time thus running
effectively at idle priority. If semaphores or mutexes are held, or the
system is going into suspend, schedule them as SCHED_NORMAL nice 19.

Signed-off-by: Con Kolivas <kernel@kolivas.org>

 include/linux/init_task.h |    4 +-
 include/linux/sched.h     |    9 +++--
 kernel/sched.c            |   75 +++++++++++++++++++++++++++++++++++++++-------
 3 files changed, 72 insertions(+), 16 deletions(-)

Index: linux-ck-dev/include/linux/init_task.h
===================================================================
--- linux-ck-dev.orig/include/linux/init_task.h	2006-06-18 15:23:44.000000000 +1000
+++ linux-ck-dev/include/linux/init_task.h	2006-06-18 15:23:46.000000000 +1000
@@ -85,8 +85,8 @@ extern struct group_info init_groups;
 	.usage		= ATOMIC_INIT(2),				\
 	.flags		= 0,						\
 	.lock_depth	= -1,						\
-	.prio		= MAX_PRIO-20,					\
-	.static_prio	= MAX_PRIO-20,					\
+	.prio		= MAX_PRIO-21,					\
+	.static_prio	= MAX_PRIO-21,					\
 	.policy		= SCHED_NORMAL,					\
 	.cpus_allowed	= CPU_MASK_ALL,					\
 	.mm		= NULL,						\
Index: linux-ck-dev/include/linux/sched.h
===================================================================
--- linux-ck-dev.orig/include/linux/sched.h	2006-06-18 15:23:44.000000000 +1000
+++ linux-ck-dev/include/linux/sched.h	2006-06-18 15:23:46.000000000 +1000
@@ -165,9 +165,10 @@ extern unsigned long weighted_cpuload(co
 #define SCHED_RR		2
 #define SCHED_BATCH		3
 #define SCHED_ISO		4
+#define SCHED_IDLEPRIO		5
 
 #define SCHED_MIN		0
-#define SCHED_MAX		4
+#define SCHED_MAX		5
 
 #define SCHED_RANGE(policy)	((policy) <= SCHED_MAX)
 #define SCHED_RT(policy)	((policy) == SCHED_FIFO || \
@@ -492,12 +493,14 @@ struct signal_struct {
 #define MAX_RT_PRIO		MAX_USER_RT_PRIO
 #define ISO_PRIO		(MAX_RT_PRIO - 1)
 
-#define MAX_PRIO		(MAX_RT_PRIO + 40)
-#define MIN_USER_PRIO		(MAX_PRIO - 1)
+#define MAX_PRIO		(MAX_RT_PRIO + 41)
+#define MIN_USER_PRIO		(MAX_PRIO - 2)
+#define IDLEPRIO_PRIO		(MAX_PRIO - 1)
 
 #define rt_task(p)		(unlikely(SCHED_RT((p)->policy)))
 #define batch_task(p)		(unlikely((p)->policy == SCHED_BATCH))
 #define iso_task(p)		(unlikely((p)->policy == SCHED_ISO))
+#define idleprio_task(p)	(unlikely((p)->policy == SCHED_IDLEPRIO))
 
 /*
  * Some day this will be a full-fledged user tracking system..
Index: linux-ck-dev/kernel/sched.c
===================================================================
--- linux-ck-dev.orig/kernel/sched.c	2006-06-18 15:23:38.000000000 +1000
+++ linux-ck-dev/kernel/sched.c	2006-06-18 15:23:46.000000000 +1000
@@ -627,6 +627,12 @@ static void set_load_weight(task_t *p)
 		else
 #endif
 			p->load_weight = RTPRIO_TO_LOAD_WEIGHT(p->rt_priority);
+	} else if (idleprio_task(p)) {
+		/*
+		 * We want idleprio_tasks to have a presence on weighting but
+		 * as small as possible
+		 */
+		p->load_weight = 1;
 	} else
 		p->load_weight = TASK_LOAD_WEIGHT(p);
 }
@@ -734,13 +740,24 @@ static inline void slice_overrun(struct 
 	} while (unlikely(p->totalrun > ns_slice));
 }
 
+static inline int idleprio_suitable(const struct task_struct *p)
+{
+	return (!p->mutexes_held &&
+		!(p->flags & (PF_FREEZE | PF_NONSLEEP)));
+}
+
+static inline int idleprio(const struct task_struct *p)
+{
+	return (p->prio == IDLEPRIO_PRIO);
+}
+
 /*
  * effective_prio - dynamic priority dependent on bonus.
  * The priority normally decreases by one each RR_INTERVAL.
  * As the bonus increases the initial priority starts at a higher "stair" or
  * priority for longer.
  */
-static int effective_prio(const task_t *p)
+static int effective_prio(task_t *p)
 {
 	int prio;
 	unsigned int full_slice, used_slice = 0;
@@ -760,6 +777,18 @@ static int effective_prio(const task_t *
 			return ISO_PRIO;
 	}
 
+	if (idleprio_task(p)) {
+		if (unlikely(!idleprio_suitable(p))) {
+			/*
+			 * If idleprio tasks are holding a semaphore, mutex,
+			 * or being frozen, schedule at a normal priority.
+			 */
+			p->time_slice = p->slice % RR_INTERVAL ? : RR_INTERVAL;
+			return MIN_USER_PRIO;
+		}
+		return IDLEPRIO_PRIO;
+	}
+
 	full_slice = slice(p);
 	if (full_slice > p->slice)
 		used_slice = full_slice - p->slice;
@@ -2582,7 +2611,7 @@ void account_user_time(struct task_struc
 
 	/* Add user time to cpustat. */
 	tmp = cputime_to_cputime64(cputime);
-	if (TASK_NICE(p) > 0)
+	if (TASK_NICE(p) > 0 || idleprio_task(p))
 		cpustat->nice = cputime64_add(cpustat->nice, tmp);
 	else
 		cpustat->user = cputime64_add(cpustat->user, tmp);
@@ -2710,11 +2739,14 @@ void scheduler_tick(void)
 			}
 		} else
 			p->flags &= ~PF_ISOREF;
-	} else
-		/* SCHED_FIFO tasks never run out of timeslice. */
-		if (unlikely(p->policy == SCHED_FIFO))
-			goto out_unlock;
-
+	} else {
+		if (idleprio_task(p) && !idleprio(p) && idleprio_suitable(p))
+			set_tsk_need_resched(p);
+		else
+			/* SCHED_FIFO tasks never run out of timeslice. */
+			if (unlikely(p->policy == SCHED_FIFO))
+				goto out_unlock;
+	}
 
 	debit = ns_diff(rq->timestamp_last_tick, p->timestamp);
 	p->ns_debit += debit;
@@ -2855,11 +2887,24 @@ static int dependent_sleeper(int this_cp
 			if ((jiffies % DEF_TIMESLICE) >
 				(sd->per_cpu_gain * DEF_TIMESLICE / 100))
 					ret = 1;
-		} else
+			else if (idleprio(p))
+				ret = 1;
+		} else {
 			if (smt_curr->static_prio < p->static_prio &&
 				!TASK_PREEMPTS_CURR(p, smt_rq) &&
 				smt_slice(smt_curr, sd) > slice(p))
 					ret = 1;
+			else if (idleprio(p) && !idleprio_task(smt_curr) &&
+				smt_curr->slice * sd->per_cpu_gain >
+				slice(smt_curr)) {
+				/*
+				 * With idleprio tasks they run just the last
+				 * per_cpu_gain percent of the smt task's
+				 * slice.
+				 */
+				ret = 1;
+			}
+		}
 
 unlock:
 		spin_unlock(&smt_rq->lock);
@@ -3479,8 +3524,9 @@ void set_user_nice(task_t *p, long nice)
 		 * If the task increased its priority or is running and
 		 * lowered its priority, then reschedule its CPU:
 		 */
-		if (delta < 0 || (delta > 0 && task_running(rq, p)))
-			resched_task(rq->curr);
+		if (delta < 0 || ((delta > 0 || idleprio_task(p)) &&
+			task_running(rq, p)))
+				resched_task(rq->curr);
 	}
 out_unlock:
 	task_rq_unlock(rq, &flags);
@@ -3673,6 +3719,11 @@ recheck:
 			return -EPERM;
 	}
 
+	if (!(p->mm) && policy == SCHED_IDLEPRIO) {
+		/* Don't allow kernel threads to be SCHED_IDLEPRIO. */
+		return -EINVAL;
+	}
+
 	retval = security_task_setscheduler(p, policy, param);
 	if (retval)
 		return retval;
@@ -3971,7 +4022,7 @@ asmlinkage long sys_sched_yield(void)
 	schedstat_inc(rq, yld_cnt);
 	current->slice = slice(current);
 	current->time_slice = rr_interval(current);
-	if (likely(!rt_task(current)))
+	if (likely(!rt_task(current) && !idleprio(current)))
 		newprio = MIN_USER_PRIO;
 
 	requeue_task(current, rq, newprio);
@@ -4126,6 +4177,7 @@ asmlinkage long sys_sched_get_priority_m
 	case SCHED_NORMAL:
 	case SCHED_BATCH:
 	case SCHED_ISO:
+	case SCHED_IDLEPRIO:
 		ret = 0;
 		break;
 	}
@@ -4151,6 +4203,7 @@ asmlinkage long sys_sched_get_priority_m
 	case SCHED_NORMAL:
 	case SCHED_BATCH:
 	case SCHED_ISO:
+	case SCHED_IDLEPRIO:
 		ret = 0;
 	}
 	return ret;
1	Add the SCHED_IDLEPRIO scheduling policy. Tasks set to this policy are only
2	given cpu time if no other tasks at all wish to have cpu time thus running
3	effectively at idle priority. If semaphores or mutexes are held, or the
4	system is going into suspend, schedule them as SCHED_NORMAL nice 19.
5
6	Signed-off-by: Con Kolivas <kernel@kolivas.org>
7
8	include/linux/init_task.h \| 4 +-
9	include/linux/sched.h \| 9 +++--
10	kernel/sched.c \| 75 +++++++++++++++++++++++++++++++++++++++-------
11	3 files changed, 72 insertions(+), 16 deletions(-)
12
13	Index: linux-ck-dev/include/linux/init_task.h
14	===================================================================
15	--- linux-ck-dev.orig/include/linux/init_task.h 2006-06-18 15:23:44.000000000 +1000
16	+++ linux-ck-dev/include/linux/init_task.h 2006-06-18 15:23:46.000000000 +1000
17	@@ -85,8 +85,8 @@ extern struct group_info init_groups;
18	.usage = ATOMIC_INIT(2), \
19	.flags = 0, \
20	.lock_depth = -1, \
21	- .prio = MAX_PRIO-20, \
22	- .static_prio = MAX_PRIO-20, \
23	+ .prio = MAX_PRIO-21, \
24	+ .static_prio = MAX_PRIO-21, \
25	.policy = SCHED_NORMAL, \
26	.cpus_allowed = CPU_MASK_ALL, \
27	.mm = NULL, \
28	Index: linux-ck-dev/include/linux/sched.h
29	===================================================================
30	--- linux-ck-dev.orig/include/linux/sched.h 2006-06-18 15:23:44.000000000 +1000
31	+++ linux-ck-dev/include/linux/sched.h 2006-06-18 15:23:46.000000000 +1000
32	@@ -165,9 +165,10 @@ extern unsigned long weighted_cpuload(co
33	#define SCHED_RR 2
34	#define SCHED_BATCH 3
35	#define SCHED_ISO 4
36	+#define SCHED_IDLEPRIO 5
37
38	#define SCHED_MIN 0
39	-#define SCHED_MAX 4
40	+#define SCHED_MAX 5
41
42	#define SCHED_RANGE(policy) ((policy) <= SCHED_MAX)
43	#define SCHED_RT(policy) ((policy) == SCHED_FIFO \|\| \
44	@@ -492,12 +493,14 @@ struct signal_struct {
45	#define MAX_RT_PRIO MAX_USER_RT_PRIO
46	#define ISO_PRIO (MAX_RT_PRIO - 1)
47
48	-#define MAX_PRIO (MAX_RT_PRIO + 40)
49	-#define MIN_USER_PRIO (MAX_PRIO - 1)
50	+#define MAX_PRIO (MAX_RT_PRIO + 41)
51	+#define MIN_USER_PRIO (MAX_PRIO - 2)
52	+#define IDLEPRIO_PRIO (MAX_PRIO - 1)
53
54	#define rt_task(p) (unlikely(SCHED_RT((p)->policy)))
55	#define batch_task(p) (unlikely((p)->policy == SCHED_BATCH))
56	#define iso_task(p) (unlikely((p)->policy == SCHED_ISO))
57	+#define idleprio_task(p) (unlikely((p)->policy == SCHED_IDLEPRIO))
58
59	/*
60	* Some day this will be a full-fledged user tracking system..
61	Index: linux-ck-dev/kernel/sched.c
62	===================================================================
63	--- linux-ck-dev.orig/kernel/sched.c 2006-06-18 15:23:38.000000000 +1000
64	+++ linux-ck-dev/kernel/sched.c 2006-06-18 15:23:46.000000000 +1000
65	@@ -627,6 +627,12 @@ static void set_load_weight(task_t *p)
66	else
67	#endif
68	p->load_weight = RTPRIO_TO_LOAD_WEIGHT(p->rt_priority);
69	+ } else if (idleprio_task(p)) {
70	+ /*
71	+ * We want idleprio_tasks to have a presence on weighting but
72	+ * as small as possible
73	+ */
74	+ p->load_weight = 1;
75	} else
76	p->load_weight = TASK_LOAD_WEIGHT(p);
77	}
78	@@ -734,13 +740,24 @@ static inline void slice_overrun(struct
79	} while (unlikely(p->totalrun > ns_slice));
80	}
81
82	+static inline int idleprio_suitable(const struct task_struct *p)
83	+{
84	+ return (!p->mutexes_held &&
85	+ !(p->flags & (PF_FREEZE \| PF_NONSLEEP)));
86	+}
87	+
88	+static inline int idleprio(const struct task_struct *p)
89	+{
90	+ return (p->prio == IDLEPRIO_PRIO);
91	+}
92	+
93	/*
94	* effective_prio - dynamic priority dependent on bonus.
95	* The priority normally decreases by one each RR_INTERVAL.
96	* As the bonus increases the initial priority starts at a higher "stair" or
97	* priority for longer.
98	*/
99	-static int effective_prio(const task_t *p)
100	+static int effective_prio(task_t *p)
101	{
102	int prio;
103	unsigned int full_slice, used_slice = 0;
104	@@ -760,6 +777,18 @@ static int effective_prio(const task_t *
105	return ISO_PRIO;
106	}
107
108	+ if (idleprio_task(p)) {
109	+ if (unlikely(!idleprio_suitable(p))) {
110	+ /*
111	+ * If idleprio tasks are holding a semaphore, mutex,
112	+ * or being frozen, schedule at a normal priority.
113	+ */
114	+ p->time_slice = p->slice % RR_INTERVAL ? : RR_INTERVAL;
115	+ return MIN_USER_PRIO;
116	+ }
117	+ return IDLEPRIO_PRIO;
118	+ }
119	+
120	full_slice = slice(p);
121	if (full_slice > p->slice)
122	used_slice = full_slice - p->slice;
123	@@ -2582,7 +2611,7 @@ void account_user_time(struct task_struc
124
125	/* Add user time to cpustat. */
126	tmp = cputime_to_cputime64(cputime);
127	- if (TASK_NICE(p) > 0)
128	+ if (TASK_NICE(p) > 0 \|\| idleprio_task(p))
129	cpustat->nice = cputime64_add(cpustat->nice, tmp);
130	else
131	cpustat->user = cputime64_add(cpustat->user, tmp);
132	@@ -2710,11 +2739,14 @@ void scheduler_tick(void)
133	}
134	} else
135	p->flags &= ~PF_ISOREF;
136	- } else
137	- /* SCHED_FIFO tasks never run out of timeslice. */
138	- if (unlikely(p->policy == SCHED_FIFO))
139	- goto out_unlock;
140	-
141	+ } else {
142	+ if (idleprio_task(p) && !idleprio(p) && idleprio_suitable(p))
143	+ set_tsk_need_resched(p);
144	+ else
145	+ /* SCHED_FIFO tasks never run out of timeslice. */
146	+ if (unlikely(p->policy == SCHED_FIFO))
147	+ goto out_unlock;
148	+ }
149
150	debit = ns_diff(rq->timestamp_last_tick, p->timestamp);
151	p->ns_debit += debit;
152	@@ -2855,11 +2887,24 @@ static int dependent_sleeper(int this_cp
153	if ((jiffies % DEF_TIMESLICE) >
154	(sd->per_cpu_gain * DEF_TIMESLICE / 100))
155	ret = 1;
156	- } else
157	+ else if (idleprio(p))
158	+ ret = 1;
159	+ } else {
160	if (smt_curr->static_prio < p->static_prio &&
161	!TASK_PREEMPTS_CURR(p, smt_rq) &&
162	smt_slice(smt_curr, sd) > slice(p))
163	ret = 1;
164	+ else if (idleprio(p) && !idleprio_task(smt_curr) &&
165	+ smt_curr->slice * sd->per_cpu_gain >
166	+ slice(smt_curr)) {
167	+ /*
168	+ * With idleprio tasks they run just the last
169	+ * per_cpu_gain percent of the smt task's
170	+ * slice.
171	+ */
172	+ ret = 1;
173	+ }
174	+ }
175
176	unlock:
177	spin_unlock(&smt_rq->lock);
178	@@ -3479,8 +3524,9 @@ void set_user_nice(task_t *p, long nice)
179	* If the task increased its priority or is running and
180	* lowered its priority, then reschedule its CPU:
181	*/
182	- if (delta < 0 \|\| (delta > 0 && task_running(rq, p)))
183	- resched_task(rq->curr);
184	+ if (delta < 0 \|\| ((delta > 0 \|\| idleprio_task(p)) &&
185	+ task_running(rq, p)))
186	+ resched_task(rq->curr);
187	}
188	out_unlock:
189	task_rq_unlock(rq, &flags);
190	@@ -3673,6 +3719,11 @@ recheck:
191	return -EPERM;
192	}
193
194	+ if (!(p->mm) && policy == SCHED_IDLEPRIO) {
195	+ /* Don't allow kernel threads to be SCHED_IDLEPRIO. */
196	+ return -EINVAL;
197	+ }
198	+
199	retval = security_task_setscheduler(p, policy, param);
200	if (retval)
201	return retval;
202	@@ -3971,7 +4022,7 @@ asmlinkage long sys_sched_yield(void)
203	schedstat_inc(rq, yld_cnt);
204	current->slice = slice(current);
205	current->time_slice = rr_interval(current);
206	- if (likely(!rt_task(current)))
207	+ if (likely(!rt_task(current) && !idleprio(current)))
208	newprio = MIN_USER_PRIO;
209
210	requeue_task(current, rq, newprio);
211	@@ -4126,6 +4177,7 @@ asmlinkage long sys_sched_get_priority_m
212	case SCHED_NORMAL:
213	case SCHED_BATCH:
214	case SCHED_ISO:
215	+ case SCHED_IDLEPRIO:
216	ret = 0;
217	break;
218	}
219	@@ -4151,6 +4203,7 @@ asmlinkage long sys_sched_get_priority_m
220	case SCHED_NORMAL:
221	case SCHED_BATCH:
222	case SCHED_ISO:
223	+ case SCHED_IDLEPRIO:
224	ret = 0;
225	}
226	return ret;