--655623-882628228-1025483202=:11969
Content-Type: TEXT/PLAIN; charset=US-ASCII
the attached patch adds a feature that was pretty high on the scheduler
features wishlist: it implements the functionality of SCHED_IDLE, in a
safe way. Another desired scheduler feature was batch scheduling, the
cache-friendly handling of lowprio, batch-like, CPU-bound, 100%
noninteractive tasks. The new SCHED_BATCH scheduler policy implements both
features.
the existing SCHED_IDLE patches floating around, despite their simplicity,
had one major flaw that prevented their integration into the scheduler: if
an unpriviledged SCHED_IDLE process uses normal kernel functionality,
which happens to grab a critical kernel resource such as the root
directory's semaphore, and schedules away still holding the semaphore,
then there is no guarantee that the task will run again in any
deterministic amount of time - keeping the critical resource potentially
forever - deadlocking every other process that attempts to use that
critical resource. This property, while being a source for soft lockups
even during ordinary use, also makes SCHED_IDLE an easy DoS exploit.
as the size of the patch suggests, the safe solution is not simple. The
basic concept is the identification of user-space preemption via a special
scheduler upcall: one safe point to delay a task's execution indefinitely
is when the task is preempted in pure user-space mode - if this happens
then the lowlevel kernel entry code calls the schedule_userspace()
function, instead of schedule(). In every other case the task needs to
stay in the 'normal' scheduler queues, to guarantee prompt processing of
kernelspace code. Furthermore, such batch-mode tasks need to be scheduled
if they get a signal delivered - otherwise it would not be possible to eg.
kill them.
other properties: SCHED_BATCH also triggers much longer, batch-like
timeslices - the default SCHED_BATCH timeslice is 1.5 seconds. Nice values
still have a meaning for SCHED_BATCH processes as well - they determine
the relative percentage of idle CPU time allocated to SCHED_BATCH
processes. If the SCHED_BATCH process is in kernel-mode then the nice
value is used as the normal priority when preempting (or not preempting)
other, non-SCHED_BATCH processes.
put in another way: whenever a SCHED_BATCH process is in kernel-mode, it's
"elevated" into the SCHED_NORMAL priority domain - which guarantees timely
execution of kernel-space code. When the SCHED_BATCH process is executing
user-space code then it can be put into the batch-queue, and can be
delayed indefinitely.
Timeslice distribution is a modified/simplified version of SCHED_NORMAL
scheduling: SCHED_BATCH processes are scheduled in a roundrobin way,
timeslices are distributed based on the nice value. SCHED_BATCH tasks that
use up their timeslices get suspended until all other SCHED_BATCH tasks on
that CPU exhaust their timeslices - at which point a new turn begins.
SCHED_NORMAL, SCHED_RR and SCHED_FIFO tasks preempt SCHED_BATCH processes
immediately. All this functionality is implemented in an O(1) way. (The
interactivity estimator is active for SCHED_BATCH processes as well - this
has an effect if the task is in kernelspace mode. This also makes sure
that no artificial priority boost can be achieved by switching in/out of
SCHED_BATCH mode.)
on SMP there are per-CPU batch queues - which enables the use of hundreds
or thousands of SCHED_BATCH processes, if desired. A new, independent
load-balancer is used to distribute SCHED_BATCH processes: SCHED_BATCH
processes will populate CPUs depending on the CPU's "10 seconds history of
idleness". The more idle a CPU, the more SCHED_BATCH processes it will
handle. The weighting is done in a way to make the global distribution of
SCHED_BATCH timeslices fair. The load-balancer also honors caching
properties and tries to reduce unnecessery bouncing of SCHED_BATCH
processes. (The balancing, like in the SCHED_NORMAL case, is not intended
to be 100% 'sharp' - some statistical fuzziness is allowed to keep
overhead and complexity down.)
(to see the SMP SCHED_BATCH load-balancer in action, start up multiple
SCHED_BATCH processes on an SMP box - they populate all available CPUs
evenly. Then start up a single CPU-intensive, non-SCHED_BATCH process -
after a few seconds all SCHED_BATCH processes will migrate off to the
remaining CPUs, and the SCHED_NORMAL task will get 100% CPU time of a
single CPU.)
(design sidenote: initially i tried to integrate SCHED_BATCH scheduling
into the existing scheduler and SCHED_NORMAL balancer somehow, but gave up
on this idea. While that worked for RT scheduling, SCHED_BATCH scheduling
is quite different, and is 100% orthogonal to all the other scheduling
domains. Eg. the balancing of non-SCHED_BATCH processes *must not* be
influenced by the way SCHED_BATCH processes are distributed amongst CPUs.
The distribution of timeslices must be completely separated as well. So
since all the queues and state has to be separate, they can as well be in
separate (and simplified) data structures.)
i've also attached setbatch.c, which is a simple utility to change a given
PID's scheduling policy to SCHED_BATCH. One straightforward way of using
it is to change one shell to be SCHED_BATCH:
./setbatch $$
and start various commands from this SCHED_BATCH shell - all forked
children inherit the SCHED_BATCH setting.
the load generated by multiple SCHED_BATCH processes does not show up in
the load average - this is the straightforward solution to not confuse
load-average-sensitive applications such as sendmail.
the runtime performance impact of SCHED_BATCH is fairly minimal. There is
a (pretty light) branch and function call cost in the entry.S preemption
codepath. Otherwise the SCHED_BATCH code triggers in slowpaths only: eg.
when we would otherwise switch to the idle thread.
the patch was tested on x86 systems. non-x86 systems should still work
with the patch applied, but no SCHED_BATCH process will in fact be
suspended. For batch-suspension to work the architecture needs to call
schedule_userspace() instead of schedule(), when pure userspace code is
preempted.
the attached patch is against 2.5.24, it was tested on SMP and UP systems
as well, but keep in mind that this is the first version of this patch, so
some rough edges might be present. The patch can also be downloaded from
my scheduler patches homepage:
http://redhat.com/~mingo/O(1)-scheduler/batch-sched-2.5.24-A0
bug reports, success reports, comments, suggestions are welcome,
Ingo
--655623-882628228-1025483202=:11969
Content-Type: TEXT/PLAIN; charset=US-ASCII; name="batch-sched-2.5.24-A0"
Content-Transfer-Encoding: BASE64
Content-ID: <Pine.LNX.4.44.0207010226420.11969@e2>
Content-Description:
Content-Disposition: attachment; filename="batch-sched-2.5.24-A0"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--655623-882628228-1025483202=:11969
Content-Type: TEXT/PLAIN; charset=US-ASCII; name="setbatch.c"
Content-Transfer-Encoding: BASE64
Content-ID: <Pine.LNX.4.44.0207010226421.11969@e2>
Content-Description:
Content-Disposition: attachment; filename="setbatch.c"
DQovKg0KICogU2V0IGEgZ2l2ZW4gUElEIHRvIGJlIGEgU0NIRURfQkFUQ0gg
cHJvY2Vzcy4NCiAqIA0KICogQ29weXJpZ2h0IChDKSAyMDAyIEluZ28gTW9s
bmFyDQogKi8NCiNpbmNsdWRlIDx0aW1lLmg+DQojaW5jbHVkZSA8c3RkaW8u
aD4NCiNpbmNsdWRlIDxzY2hlZC5oPg0KI2luY2x1ZGUgPHN0ZGxpYi5oPg0K
I2luY2x1ZGUgPHN5cy90eXBlcy5oPg0KI2luY2x1ZGUgPGxpbnV4L3VuaXN0
ZC5oPg0KDQppbnQgbWFpbiAoaW50IGFyZ2MsIGNoYXIgKiphcmd2KQ0Kew0K
CWludCBwaWQsIHJldDsNCglzdHJ1Y3Qgc2NoZWRfcGFyYW0gcDsNCg0KCXAu
c2NoZWRfcHJpb3JpdHkgPSAwOw0KDQoJaWYgKGFyZ2MgIT0gMikgew0KCQlw
cmludGYoInVzYWdlOiBzZXRiYXRjaCA8cGlkPlxuIik7DQoJCWV4aXQoLTEp
Ow0KCX0NCglwaWQgPSBhdG9sKGFyZ3ZbMV0pOw0KDQoJcmV0ID0gc2NoZWRf
c2V0c2NoZWR1bGVyKHBpZCwgMywgJnApOw0KDQoJaWYgKHJldCkgew0KCQlw
cmludGYoImNvdWxkIG5vdCBzZXQgcGlkICVkIHRvIFNDSEVEX0JBVENIOiBl
cnIgJWQuXG4iLCBwaWQsIHJldCk7DQoJCXJldHVybiAtMTsNCgl9DQoJcHJp
bnRmKCJwaWQgJWQgaXMgU0NIRURfQkFUQ0ggZnJvbSBub3cgb24uXG4iLCBw
aWQpOw0KCXJldHVybiAwOw0KfQ0K
--655623-882628228-1025483202=:11969--
-
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/